Merge 7be838e into 3532df2

visma/discreteMaths/boolean.py

@@ -2,9 +2,22 @@
 from visma.functions.constant import Constant
 from visma.io.tokenize import tokenizer
 
+# TODO: Test cases.
+# TODO: Implement GUI/CLI.
+
 
 def logicalAND(token1, token2):
-    # TODO: Comments, animations & test cases.
+    """Implements Bitwise AND
+    Arguments:
+        token1 -- {list} -- List of tokens of a constant number
+        token2 -- {list} -- List of tokens of a constant number
+
+    Returns:
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
+
     comments = []
     animations = []
     token1, _, _, _, _ = simplify(token1)
@@ -30,7 +43,17 @@ def logicalAND(token1, token2):
 
 
 def logicalOR(token1, token2):
-    # TODO: Comments, animations & test cases.
+    """Implements Bitwise OR
+    Arguments:
+        token1 -- {list} -- List of tokens of a constant number
+        token2 -- {list} -- List of tokens of a constant number
+
+    Returns:
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
+
     comments = []
     animations = []
     token1, _, _, _, _ = simplify(token1)
@@ -56,7 +79,16 @@ def logicalOR(token1, token2):
 
 
 def logicalNOT(token1):
-    # TODO: Test cases.
+    """Implements Bitwise NOT
+    Arguments:
+        token1 -- {list} -- List of tokens of a constant number
+
+    Returns:
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
+
     comments = []
     animations = []
     token1, _, _, _, _ = simplify(token1)

visma/discreteMaths/probability.py

@@ -2,6 +2,18 @@
 
 
 def simpleProbability(sampleSpace, requiredEvent=None):
+    """Implements simple probability
+
+    Arguments:
+        sampleSpace -- {visma.discreteMaths.statistics.ArithemeticMean}
+        requiredEvent -- {Event whose probability is to be calculated}
+
+    Returns:
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
+
     animations = []
     comments = []
     events = []

visma/discreteMaths/statistics.py

@@ -4,8 +4,12 @@
 from visma.io.parser import tokensToString
 from visma.functions.constant import Constant
 
+# TODO: Implement this module in GUI/CLI
+
 
 class sampleSpace(object):
+    """Class used to represent sample space of a data.
+    """
     values = []
     size = 0
 
@@ -16,6 +20,16 @@ def __init__(self, values):
 
 
 def ArithemeticMean(sampleSpace):
+    """Implements arithemetic mean
+
+    Arguments:
+        sampleSpace -- {visma.discreteMaths.statistics.ArithemeticMean}
+
+    Returns:
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
     animations = []
     comments = []
     if sampleSpace.values is not []:
@@ -40,6 +54,17 @@ def ArithemeticMean(sampleSpace):
 
 
 def Mode(sampleSpace):
+    """Implements Mode
+
+    Arguments:
+        sampleSpace -- {visma.discreteMaths.statistics.ArithemeticMean}
+
+    Returns:
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
+
     animations = []
     comments = []
     token_string = ''
@@ -56,6 +81,17 @@ def Mode(sampleSpace):
 
 
 def Median(sampleSpace):
+    """Implements Median
+
+    Arguments:
+        sampleSpace -- {visma.discreteMaths.statistics.ArithemeticMean}
+
+    Returns:
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
+
     animations = []
     comments = []
     token_string = ''

visma/gui/cli.py

@@ -48,7 +48,7 @@ def __init__(self, parent, tokens):
 def commandExec(command):
     operation = command.split('(', 1)[0]
     inputEquation = command.split('(', 1)[1][:-1]
-    matrix = False
+    matrix = False      # True when matrices operations are present in the code.
     if operation[0:4] == 'mat_':
         matrix = True
 
@@ -65,7 +65,7 @@ def commandExec(command):
             varName = "".join(varName.split())
             inputEquation = inputEquation.split(',')[0]
 
-        simul = False
+        simul = False   # True when simultaneous equation is present
         if (inputEquation.count(';') == 2) and (operation == 'solve'):
             simul = True
             afterSplit = inputEquation.split(';')
@@ -155,6 +155,7 @@ def commandExec(command):
             lhs, rhs = getLHSandRHS(tokens)
             lTokens, _, _, equationTokens, comments = differentiate(lTokens, varName)
         if operation != 'plot':
+            # FIXME: when either plotting window or GUI window is opened from CLI and after it is closed entire CLI exits, it would be better if it is avoided
             final_string = resultStringCLI(equationTokens, operation, comments, solutionType, simul)
             print(final_string)
     else:

visma/gui/window.py

@@ -770,6 +770,7 @@ def calluser():
                 nonMatrixResult -- {True} when the result after performing operations on the Matrix is not a Matrix (in operations like Determinant, Trace etc.)
                 scalarOperations -- {True} when one of the operand in a scalar (used in operations like Scalar Addition, Scalar Subtraction etc.)
                 """
+                #   TODO: use latex tools like /amsmath for displaying matrices
                 if self.dualOperandMatrix:
                     Matrix1_copy = copy.deepcopy(self.Matrix1)
                     Matrix2_copy = copy.deepcopy(self.Matrix2)
@@ -828,7 +829,7 @@ def calluser():
                         if not self.scalarOperationsMatrix:
                             self.output = resultMatrixStringLatex(operation=name, operand1=Matrix1_copy, operand2=Matrix2_copy, result=MatrixResult)
                         else:
-                            # TODO: Scalar Matrix Operation
+                            # TODO: Implement Scalar Matrices operations.
                             pass
                             # finalCLIstring = resultMatrix_Latex(operation=name, operand1=scalarTokens_copy, operand2=Matrix2_copy, result=MatrixResult)
                     else:

visma/simplify/addsub.py

@@ -13,6 +13,19 @@
 
 
 def addition(tokens, direct=False):
+    """Function deals with addition related operations (driver function in addition module)
+
+    Arguments:
+        tokens {list} -- list of tokens
+        direct {bool} -- True when we are only concerned about multiplications terms in the input
+
+    Returns:
+        tokens {list} -- list of tokens
+        availableOperations {list} -- list of operations which can be performed on a equation token
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
 
     animation = [copy.deepcopy(tokens)]
     variables = []
@@ -37,6 +50,21 @@ def addition(tokens, direct=False):
 
 
 def additionEquation(lToks, rToks, direct=False):
+    """Function deals with multiplication related operations FOR EQUATIONS (driver function in multiplication module)
+
+    Arguments:
+        rtoks {list} -- list of right tokens
+        ltoks {list} -- list of left tokens
+        direct {bool} -- True when we are only concerned about multiplications terms in the input
+
+    Returns:
+        rtoks {list} -- list of right tokens
+        ltoks {list} -- list of left tokens
+        availableOperations {list} -- list of operations which can be performed on a equation token
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
 
     lTokens = copy.deepcopy(lToks)
     rTokens = copy.deepcopy(rToks)
@@ -146,6 +174,18 @@ def additionEquation(lToks, rToks, direct=False):
 
 
 def expressionAddition(variables, tokens):
+    """Function deals with addition related operations of two terms (called from driver function)
+
+    Arguments:
+        variables {list} -- list of LevelVariables
+        tokens {list} -- list of tokens
+
+    Returns:
+        variables {list} -- list of LevelVariables
+        tokens {list} -- list of tokens
+        removeScopes {list} -- indices of those tokens (/terms) which are removed as two terms in the equations get multiplied
+        comments {list} -- list of comments in equation solving process
+    """
 
     removeScopes = []
     change = []
@@ -522,6 +562,19 @@ def equationAddition(lVariables, lTokens, rVariables, rTokens):
 
 
 def subtraction(tokens, direct=False):
+    """Function deals with subtraction related operations (driver function in subtraction module)
+
+    Arguments:
+        tokens {list} -- list of tokens
+        direct {bool} -- True when we are only concerned about multiplications terms in the input
+
+    Returns:
+        tokens {list} -- list of tokens
+        availableOperations {list} -- list of operations which can be performed on a equation token
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
 
     animation = [copy.deepcopy(tokens)]
     comments = []
@@ -544,6 +597,21 @@ def subtraction(tokens, direct=False):
 
 
 def subtractionEquation(lToks, rToks, direct=False):
+    """Function deals with multiplication related operations FOR EQUATIONS (driver function in multiplication module)
+
+    Arguments:
+        rtoks {list} -- list of right tokens
+        ltoks {list} -- list of left tokens
+        direct {bool} -- True when we are only concerned about multiplications terms in the input
+
+    Returns:
+        rtoks {list} -- list of right tokens
+        ltoks {list} -- list of left tokens
+        availableOperations {list} -- list of operations which can be performed on a equation token
+        token_string {string} -- final result stored in a string
+        animation {list} -- list of equation solving process
+        comments {list} -- list of comments in equation solving process
+    """
 
     lTokens = copy.deepcopy(lToks)
     rTokens = copy.deepcopy(rToks)
@@ -655,6 +723,18 @@ def subtractionEquation(lToks, rToks, direct=False):
 
 
 def expressionSubtraction(variables, tokens):
+    """Function deals with multiplication related operations of two terms (called from driver function)
+
+    Arguments:
+        variables {list} -- list of LevelVariables
+        tokens {list} -- list of tokens
+
+    Returns:
+        variables {list} -- list of LevelVariables
+        tokens {list} -- list of tokens
+        removeScopes {list} -- indices of those tokens (/terms) which are removed as two terms in the equations get multiplied
+        comments {list} -- list of comments in equation solving process
+    """
 
     removeScopes = []
     change = []