# 2

src/Calculator/MathLib/Functions/Advanced/Factorial.cs

@@ -3,14 +3,27 @@
 
 namespace MathLib.Functions.Advanced
 {
+    /// <summary>
+    /// Represents factorial operation
+    /// </summary>
     public class Factorial : IAdvancedMethod
     {
+        /// <summary>
+        /// Calculate factorial by recursive method.
+        /// Max value for calculation is 69 to prevent stack od double overflow.
+        /// </summary>
+        /// <param name="operand">input value</param>
+        /// <returns>factorial of input value</returns>
         public double Calculate(double operand)
         {
             if (operand.Equals(0))
             {
                 return 1;
             }
+            if (operand > 69)
+            {
+                return Double.NaN;
+            }
 
             return operand * Calculate(operand - 1);
         }

src/Calculator/MathLib/Functions/Advanced/Logarithm.cs

@@ -3,6 +3,9 @@
 
 namespace MathLib.Functions.Advanced
 {
+    /// <summary>
+    /// Represents logarithm operation.
+    /// </summary>
     public class Logarithm : IAdvancedMethod
     {
         /// <summary>

src/Calculator/MathLib/Functions/Advanced/Negation.cs

@@ -3,8 +3,16 @@
 
 namespace MathLib.Functions.Advanced
 {
+    /// <summary>
+    /// Represents negation of number
+    /// </summary>
     public class Negation : IAdvancedMethod
     {
+        /// <summary>
+        /// Number negation
+        /// </summary>
+        /// <param name="operand">value for negation</param>
+        /// <returns>-1* value</returns>
         public double Calculate(double operand)
         {
             return operand = -1 * operand;

src/Calculator/MathLib/Functions/Advanced/Power.cs

@@ -3,13 +3,26 @@
 
 namespace MathLib.Functions.Advanced
 {
+    /// <summary>
+    /// Provides methods for second or n-th power.
+    /// </summary>
     public class Power : IAdvancedMethod
     {
+        /// <summary>
+        /// calculate second power.
+        /// </summary>
+        /// <param name="operand">operand</param>
+        /// <returns>power of operand</returns>
         public double Calculate(double operand)
         {
             return operand * operand;
         }
-
+        /// <summary>
+        /// calculate n-th power of operand
+        /// </summary>
+        /// <param name="operand">operand</param>
+        /// <param name="exponent">exponent of power</param>
+        /// <returns></returns>
         public double Calculate(double operand, double exponent)
         {
             return Math.Pow(operand, exponent);

src/Calculator/MathLib/Functions/Advanced/Root.cs

@@ -3,13 +3,26 @@
 
 namespace MathLib.Functions.Advanced
 {
+    /// <summary>
+    /// Provides methods for square or general root.
+    /// </summary>
     public class Root : IAdvancedMethod
     {
+        /// <summary>
+        /// Calculate square root of specified number.
+        /// </summary>
+        /// <param name="operand"></param>
+        /// <returns>square root of specified number</returns>
         public double Calculate(double operand)
         {
             return Math.Sqrt(operand);
         }
-
+        /// <summary>
+        /// Calculate n-th root of specified number.
+        /// </summary>
+        /// <param name="operand">root of this value will be computed</param>
+        /// <param name="exponent">n</param>
+        /// <returns></returns>
         public double Calculate(double operand, int exponent)
         {
             return Math.Pow(operand, (1.0 / exponent));

src/Calculator/MathLib/Functions/Basic/Addition.cs

@@ -4,6 +4,9 @@
 
 namespace MathLib.Functions.Basic
 {
+    /// <summary>
+    /// Represents addition
+    /// </summary>
     public class Addition : ISimpleMethod
     {
         private readonly List<double> operands;
@@ -12,7 +15,10 @@ public Addition()
         {
             operands = new List<double>();
         }
-
+        ///<summary>
+        /// sum all mambers of operands
+        ///</summary>
+        /// <returns>result of sumation</returns>
         public double Calculate()
         {
             if (operands.Count == 0)
@@ -22,17 +28,31 @@ public double Calculate()
 
             return sum(operands);
         }
-
+        /// <summary>
+        /// Add first and second operand.
+        /// </summary>
+        /// <param name="firstOperand">first operand of addition</param>
+        /// <param name="secondOperand">second operand of addition</param>
+        /// <returns>result of addition</returns>
         public double Calculate(double firstOperand, double secondOperand)
         {
             return firstOperand + secondOperand;
         }
-
+        /// <summary>
+        /// Add operand for addition.
+        /// After all operand will be added, you can sum them by calling 
+        /// calculate mathod.
+        /// </summary>
+        /// <param name="operand">value</param>
         public void AddOperand(double operand)
         {
             operands.Add(operand);
         }
-
+        /// <summary>
+        /// sum all mambers of operands
+        /// </summary>
+        /// <param name="operands">values for addition</param>
+        /// <returns></returns>
         private double sum(List<double> operands)
         {
             double result = 0;

src/Calculator/MathLib/Functions/Basic/Division.cs

@@ -5,6 +5,9 @@
 
 namespace MathLib.Functions.Basic
 {
+    /// <summary>
+    /// Represents division
+    /// </summary>
     public class Division : ISimpleMethod
     {
         private List<double> operands;
@@ -13,6 +16,10 @@ public Division()
         {
             operands = new List<double>();
         }
+        /// <summary>
+        /// divide all mambers of operands
+        /// </summary>
+        /// <returns>result of division</returns>
         public double Calculate()
         {
             if (!operands.Any())
@@ -39,7 +46,12 @@ public double Calculate()
 
             return result;
         }
-
+        /// <summary>
+        /// Divide first operad by second operand.
+        /// </summary>
+        /// <param name="firstOperand">first operand of division</param>
+        /// <param name="secondOperand">second operand of division</param>
+        /// <returns>result of division</returns>
         public double Calculate(double firstOperand, double secondOperand)
         {
             if (isDoubleZero(secondOperand))
@@ -49,12 +61,21 @@ public double Calculate(double firstOperand, double secondOperand)
 
             return firstOperand / secondOperand;
         }
-
+        /// <summary>
+        /// Add operand for division.
+        /// After all operand will be added, you can divide them by calling 
+        /// calculate mathod.
+        /// </summary>
+        /// <param name="operand">value</param>
         public void AddOperand(double operand)
         {
             operands.Add(operand);
         }
-
+        /// <summary>
+        /// Determinate if given number is zero.
+        /// </summary>
+        /// <param name="num">value</param>
+        /// <returns></returns>
         private bool isDoubleZero(double num)
         {
             return (Math.Abs(num) < double.Epsilon);

src/Calculator/MathLib/Functions/Basic/Multiplication.cs

@@ -1,5 +1,4 @@
-using System;
-using MathLib.Interfaces;
+using MathLib.Interfaces;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -8,12 +7,17 @@ namespace MathLib.Functions.Basic
     public class Multiplication : ISimpleMethod
     {
         private List<double> operands;
-
+        /// <summary>
+        /// Represents multiplication
+        /// </summary>
         public Multiplication()
         {
             operands = new List<double>();
         }
-
+        /// <summary>
+        /// multiply all mambers of operands
+        /// </summary>
+        /// <returns>result of multipication</returns>
         public double Calculate()
         {
             if (!operands.Any())
@@ -30,12 +34,22 @@ public double Calculate()
 
             return result;
         }
-
+        /// <summary>
+        /// Multiplay first and second operand.
+        /// </summary>
+        /// <param name="firstOperand">first operand of multiplication</param>
+        /// <param name="secondOperand">second operand of multiplication</param>
+        /// <returns>result of multipication</returns>
         public double Calculate(double firstOperand, double secondOperand)
         {
             return firstOperand * secondOperand;
         }
-
+        /// <summary>
+        /// Add operand for multipication.
+        /// After all operand will be added, you can multiply them by calling 
+        /// calculate mathod.
+        /// </summary>
+        /// <param name="operand">value</param>
         public void AddOperand(double operand)
         {
             operands.Add(operand);

src/Calculator/MathLib/Functions/Basic/Substraction.cs

@@ -3,17 +3,23 @@
 using MathLib.Exception;
 using MathLib.Interfaces;
 
+
 namespace MathLib.Functions.Basic
 {
+    /// <summary>
+    /// Represents substraction.
+    /// </summary>
     public class Substraction : ISimpleMethod
     {
         private readonly List<double> operands;
-
         public Substraction()
         {
             operands = new List<double>();
         }
-
+        /// <summary>
+        /// Substract all mambers of operands
+        /// </summary>
+        /// <returns>result of substraction</returns>
         public double Calculate()
         {
             if (!operands.Any())
@@ -30,12 +36,22 @@ public double Calculate()
 
             return result;
         }
-
+        /// <summary>
+        /// Substract secondOperand from firstOperand
+        /// </summary>
+        /// <param name="firstOperand">first operand of substraction</param>
+        /// <param name="secondOperand">second operand of substraction</param>
+        /// <returns>result of substraction</returns>
         public double Calculate(double firstOperand, double secondOperand)
         {
             return firstOperand - secondOperand;
         }
-
+        /// <summary>
+        /// Add operand for substraction.
+        /// After all operand will be added, you can substract them by calling 
+        /// calculate mathod.
+        /// </summary>
+        /// <param name="operand">value</param>
         public void AddOperand(double operand)
         {
             operands.Add(operand);