def calluser():
availableOperations = []
tokenString = ''
equationTokens = []
self.resultOut = True
if name == 'addition':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = addition(
self.tokens, True)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = additionEquation(
self.lTokens, self.rTokens, True)
elif name == 'subtraction':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = subtraction(
self.tokens, True)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = subtractionEquation(
self.lTokens, self.rTokens, True)
elif name == 'multiplication':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = multiplication(
self.tokens, True)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = multiplicationEquation(
self.lTokens, self.rTokens, True)
elif name == 'division':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = division(
self.tokens, True)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = divisionEquation(
self.lTokens, self.rTokens, True)
elif name == 'simplify':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = simplify(
self.tokens)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = simplifyEquation(
self.lTokens, self.rTokens)
elif name == 'factorize':
self.tokens, availableOperations, tokenString, equationTokens, comments = factorize(
self.tokens)
elif name == 'find roots':
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = quadraticRoots(
self.lTokens, self.rTokens)
elif name == 'solve':
lhs, rhs = getLHSandRHS(self.tokens)
variables = getVariables(lhs, rhs)
self.wrtVariableButtons(variables, name)
self.resultOut = False
elif name == 'integrate':
lhs, rhs = getLHSandRHS(self.tokens)
variables = getVariables(lhs, rhs)
self.wrtVariableButtons(variables, name)
self.resultOut = False
elif name == 'differentiate':
lhs, rhs = getLHSandRHS(self.tokens)
variables = getVariables(lhs, rhs)
self.wrtVariableButtons(variables, name)
self.resultOut = False
if self.resultOut:
self.eqToks = equationTokens
self.output = resultLatex(name, equationTokens, comments)
if len(availableOperations) == 0:
self.clearButtons()
else:
self.refreshButtons(availableOperations)
if self.mode == 'normal':
self.textedit.setText(tokenString)
elif self.mode == 'interaction':
cursor = self.textedit.textCursor()
cursor.insertText(tokenString)
if self.showStepByStep is True:
showSteps(self)
if self.showPlotter is True:
plot(self)
def simplifyEquation(lToks, rToks):
"""Simplifies given equation tokens
Arguments:
lToks {list} -- LHS tokens list
rToks {list} -- RHS tokens list
Returns:
lTokens {list} -- LHS tokens list
rTokens {list} -- RHS tokens list
availableOperations {list} -- list of operations
token_string {string} -- simplified result in string
animation {list} -- list of equation simplification progress
comments {list} -- list of solution steps
"""
lTokens = copy.deepcopy(lToks)
rTokens = copy.deepcopy(rToks)
animation = []
comments = [[]]
lVariables = []
lVariables.extend(getLevelVariables(lTokens))
rVariables = []
rVariables.extend(getLevelVariables(rTokens))
animBuilder = lToks
lenToks = len(lToks)
equalTo = Binary()
equalTo.scope = [lenToks]
equalTo.value = '='
animBuilder.append(equalTo)
if len(rToks) == 0:
zero = Zero()
zero.scope = [lenToks + 1]
animBuilder.append(zero)
else:
animBuilder.extend(rToks)
animation.append(copy.deepcopy(animBuilder))
availableOperations = getOperationsEquation(lVariables, lTokens,
rVariables, rTokens)
while len(availableOperations) > 0:
if '/' in availableOperations:
lTokens, rTokens, availableOperations, token_string, anim, com = divisionEquation(
lTokens, rTokens)
animation.pop(len(animation) - 1)
animation.extend(anim)
comments.extend(com)
elif '*' in availableOperations:
lTokens, rTokens, availableOperations, token_string, anim, com = multiplicationEquation(
lTokens, rTokens)
animation.pop(len(animation) - 1)
animation.extend(anim)
comments.extend(com)
elif '+' in availableOperations:
lTokens, rTokens, availableOperations, token_string, anim, com = additionEquation(
lTokens, rTokens)
animation.pop(len(animation) - 1)
animation.extend(anim)
comments.extend(com)
elif '-' in availableOperations:
lTokens, rTokens, availableOperations, token_string, anim, com = subtractionEquation(
lTokens, rTokens)
animation.pop(len(animation) - 1)
animation.extend(anim)
comments.extend(com)
lVariables = getLevelVariables(lTokens)
rVariables = getLevelVariables(rTokens)
availableOperations = getOperationsEquation(lVariables, lTokens,
rVariables, rTokens)
moved = False
if len(rTokens) > 0:
moved = True
lTokens, rTokens = moveRTokensToLTokens(lTokens, rTokens)
tokenToStringBuilder = copy.deepcopy(lTokens)
lenToks = len(lTokens)
equalTo = Binary()
equalTo.scope = [lenToks]
equalTo.value = '='
tokenToStringBuilder.append(equalTo)
if len(rTokens) == 0:
zero = Zero()
zero.scope = [lenToks + 1]
tokenToStringBuilder.append(zero)
else:
tokenToStringBuilder.extend(rTokens)
if moved:
animation.append(copy.deepcopy(tokenToStringBuilder))
comments.append(['Moving the rest of variables/constants to LHS'])
token_string = tokensToString(tokenToStringBuilder)
return lTokens, rTokens, availableOperations, token_string, animation, comments
def calluser():
availableOperations = []
tokenString = ''
equationTokens = []
self.resultOut = True
if not self.matrix:
"""
This part handles the cases when VisMa is NOT dealing with matrices.
Boolean flags used in code below:
simul -- {True} when VisMa is dealing with simultaneous equations & {False} in all other cases
"""
if name == 'addition':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = addition(
self.tokens, True)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = additionEquation(
self.lTokens, self.rTokens, True)
elif name == 'subtraction':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = subtraction(
self.tokens, True)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = subtractionEquation(
self.lTokens, self.rTokens, True)
elif name == 'multiplication':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = multiplication(
self.tokens, True)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = multiplicationEquation(
self.lTokens, self.rTokens, True)
elif name == 'division':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = division(
self.tokens, True)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = divisionEquation(
self.lTokens, self.rTokens, True)
elif name == 'simplify':
if self.solutionType == 'expression':
self.tokens, availableOperations, tokenString, equationTokens, comments = simplify(self.tokens)
else:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = simplifyEquation(self.lTokens, self.rTokens)
elif name == 'factorize':
self.tokens, availableOperations, tokenString, equationTokens, comments = factorize(self.tokens)
elif name == 'find roots':
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = rootFinder(self.lTokens, self.rTokens)
elif name == 'solve':
if not self.simul:
lhs, rhs = getLHSandRHS(self.tokens)
variables = getVariables(lhs, rhs)
else:
variables = getVariableSim(self.tokens)
self.wrtVariableButtons(variables, name)
self.resultOut = False
elif name == 'factorial':
self.tokens, availableOperations, tokenString, equationTokens, comments = factorial(self.tokens)
elif name == 'combination':
nTokens = self.tokens[0]
rTokens = self.tokens[1]
self.tokens, _, _, equationTokens, comments = combination(nTokens, rTokens)
elif name == 'permutation':
nTokens = self.tokens[0]
rTokens = self.tokens[1]
self.tokens, _, _, equationTokens, comments = permutation(nTokens, rTokens)
elif name == 'integrate':
lhs, rhs = getLHSandRHS(self.tokens)
variables = getVariables(lhs, rhs)
self.wrtVariableButtons(variables, name)
self.resultOut = False
elif name == 'differentiate':
lhs, rhs = getLHSandRHS(self.tokens)
variables = getVariables(lhs, rhs)
self.wrtVariableButtons(variables, name)
self.resultOut = False
else:
"""
This part handles the cases when VisMa is dealing with matrices.
Boolean flags used in code below:
dualOperand -- {True} when the matrix operations require two operands (used in operations like addition, subtraction etc)
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)
else:
Matrix0_copy = copy.deepcopy(self.Matrix0)
if name == 'Addition':
MatrixResult = addMatrix(self.Matrix1, self.Matrix2)
elif name == 'Subtraction':
MatrixResult = subMatrix(self.Matrix1, self.Matrix2)
elif name == 'Multiply':
MatrixResult = multiplyMatrix(self.Matrix1, self.Matrix2)
elif name == 'Simplify':
MatrixResult = simplifyMatrix(self.Matrix0)
elif name == 'Trace':
sqMatrix = SquareMat()
sqMatrix.value = self.Matrix0.value
result = sqMatrix.traceMat()
elif name == 'Determinant':
sqMatrix = SquareMat()
sqMatrix.value = self.Matrix0.value
result = sqMatrix.determinant()
elif name == 'Inverse':
sqMatrix = SquareMat()
sqMatrix.value = self.Matrix0.value
MatrixResult = SquareMat()
MatrixResult = sqMatrix.inverse()
if name in ['Addition', 'Subtraction', 'Multiply']:
self.dualOperandMatrix = True
else:
self.dualOperandMatrix = False
if name in ['Determinant', 'Trace']:
self.nonMatrixResult = True
else:
self.nonMatrixResult = False
if self.resultOut:
if not self.matrix:
self.eqToks = equationTokens
self.output = resultLatex(equationTokens, name, comments, self.solutionType)
if (mathError(self.eqToks[-1])):
self.output += 'Math Error: LHS not equal to RHS' + '\n'
if len(availableOperations) == 0:
self.clearButtons()
else:
self.refreshButtons(availableOperations)
if self.mode == 'normal':
self.textedit.setText(tokenString)
elif self.mode == 'interaction':
cursor = self.textedit.textCursor()
cursor.insertText(tokenString)
if self.showStepByStep is True:
showSteps(self)
if self.showPlotter is True:
plot(self)
else:
if self.dualOperandMatrix:
if not self.scalarOperationsMatrix:
self.output = resultMatrixStringLatex(operation=name, operand1=Matrix1_copy, operand2=Matrix2_copy, result=MatrixResult)
else:
# TODO: Implement Scalar Matrices operations.
pass
# finalCLIstring = resultMatrix_Latex(operation=name, operand1=scalarTokens_copy, operand2=Matrix2_copy, result=MatrixResult)
else:
if self.nonMatrixResult:
self.output = resultMatrixStringLatex(operation=name, operand1=Matrix0_copy, nonMatrixResult=True, result=result)
else:
self.output = resultMatrixStringLatex(operation=name, operand1=Matrix0_copy, result=MatrixResult)
if self.mode == 'normal':
self.textedit.setText(tokenString)
elif self.mode == 'interaction':
cursor = self.textedit.textCursor()
cursor.insertText(tokenString)
if self.showStepByStep is True:
showSteps(self)
def commandExec(command):
operation = command.split('(', 1)[0]
inputEquation = command.split('(', 1)[1][:-1]
if ',' in inputEquation:
varName = inputEquation.split(',')[1]
inputEquation = inputEquation.split(',')[0]
lhs = []
rhs = []
solutionType = ''
lTokens = []
rTokens = []
equationTokens = []
comments = []
tokens = tokenizer(inputEquation)
lhs, rhs = getLHSandRHS(tokens)
lTokens = lhs
rTokens = rhs
_, solutionType = checkTypes(lhs, rhs)
if operation == 'simplify':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = simplify(tokens)
else:
lTokens, rTokens, _, _, equationTokens, comments = simplifyEquation(
lTokens, rTokens)
elif operation == 'addition':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = addition(tokens, True)
else:
lTokens, rTokens, _, _, equationTokens, comments = additionEquation(
lTokens, rTokens, True)
elif operation == 'subtraction':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = subtraction(tokens, True)
else:
lTokens, rTokens, _, _, equationTokens, comments = subtractionEquation(
lTokens, rTokens, True)
elif operation == 'multiplication':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = multiplication(
tokens, True)
else:
lTokens, rTokens, _, _, equationTokens, comments = multiplicationEquation(
lTokens, rTokens, True)
elif operation == 'division':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = division(tokens, True)
else:
lTokens, rTokens, _, _, equationTokens, comments = divisionEquation(
lTokens, rTokens, True)
elif operation == 'simplify':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = simplify(tokens)
else:
lTokens, rTokens, _, _, equationTokens, comments = simplifyEquation(
lTokens, rTokens)
elif operation == 'factorize':
tokens, _, _, equationTokens, comments = factorize(tokens)
elif operation == 'find-roots':
lTokens, rTokens, _, _, equationTokens, comments = quadraticRoots(
lTokens, rTokens)
elif operation == 'solve':
lhs, rhs = getLHSandRHS(tokens)
lTokens, rTokens, _, _, equationTokens, comments = solveFor(
lTokens, rTokens, varName)
elif operation == 'integrate':
lhs, rhs = getLHSandRHS(tokens)
lTokens, _, _, equationTokens, comments = integrate(lTokens, varName)
elif operation == 'differentiate':
lhs, rhs = getLHSandRHS(tokens)
lTokens, _, _, equationTokens, comments = differentiate(
lTokens, varName)
printOnCLI(equationTokens, operation, comments)
def commandExec(command):
operation = command.split('(', 1)[0]
inputEquation = command.split('(', 1)[1][:-1]
matrix = False # True when matrices operations are present in the code.
if operation[0:4] == 'mat_':
matrix = True
if not matrix:
"""
This part handles the cases when VisMa is NOT dealing with matrices.
Boolean flags used in code below:
simul -- {True} when VisMa is dealing with simultaneous equations & {False} in all other cases
"""
varName = None
if ',' in inputEquation:
varName = inputEquation.split(',')[1]
varName = "".join(varName.split())
inputEquation = inputEquation.split(',')[0]
simul = False # True when simultaneous equation is present
if (inputEquation.count(';') == 2) and (operation == 'solve'):
simul = True
afterSplit = inputEquation.split(';')
eqStr1 = afterSplit[0]
eqStr2 = afterSplit[1]
eqStr3 = afterSplit[2]
lhs = []
rhs = []
solutionType = ''
lTokens = []
rTokens = []
equationTokens = []
comments = []
if simul:
tokens = [tokenizer(eqStr1), tokenizer(eqStr2), tokenizer(eqStr3)]
else:
tokens = tokenizer(inputEquation)
if '=' in inputEquation:
lhs, rhs = getLHSandRHS(tokens)
lTokens = lhs
rTokens = rhs
_, solutionType = checkTypes(lhs, rhs)
else:
solutionType = 'expression'
lhs, rhs = getLHSandRHS(tokens)
lTokens = lhs
rTokens = rhs
if operation == 'plot':
app = QApplication(sys.argv)
App(tokens)
sys.exit(app.exec_())
elif operation == 'simplify':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = simplify(tokens)
else:
lTokens, rTokens, _, _, equationTokens, comments = simplifyEquation(
lTokens, rTokens)
elif operation == 'addition':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = addition(tokens, True)
else:
lTokens, rTokens, _, _, equationTokens, comments = additionEquation(
lTokens, rTokens, True)
elif operation == 'subtraction':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = subtraction(
tokens, True)
else:
lTokens, rTokens, _, _, equationTokens, comments = subtractionEquation(
lTokens, rTokens, True)
elif operation == 'multiplication':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = multiplication(
tokens, True)
else:
lTokens, rTokens, _, _, equationTokens, comments = multiplicationEquation(
lTokens, rTokens, True)
elif operation == 'division':
if solutionType == 'expression':
tokens, _, _, equationTokens, comments = division(tokens, True)
else:
lTokens, rTokens, _, _, equationTokens, comments = divisionEquation(
lTokens, rTokens, True)
elif operation == 'factorize':
tokens, _, _, equationTokens, comments = factorize(tokens)
elif operation == 'find-roots':
lTokens, rTokens, _, _, equationTokens, comments = rootFinder(
lTokens, rTokens)
elif operation == 'solve':
if simul:
if varName is not None:
_, equationTokens, comments = simulSolver(
tokens[0], tokens[1], tokens[2], varName)
else:
_, equationTokens, comments = simulSolver(
tokens[0], tokens[1], tokens[2])
solutionType = equationTokens
else:
lhs, rhs = getLHSandRHS(tokens)
lTokens, rTokens, _, _, equationTokens, comments = solveFor(
lTokens, rTokens, varName)
elif operation == 'factorial':
tokens, _, _, equationTokens, comments = factorial(tokens)
elif operation == 'combination':
n = tokenizer(inputEquation)
r = tokenizer(varName)
tokens, _, _, equationTokens, comments = combination(n, r)
elif operation == 'permutation':
n = tokenizer(inputEquation)
r = tokenizer(varName)
tokens, _, _, equationTokens, comments = permutation(n, r)
elif operation == 'integrate':
lhs, rhs = getLHSandRHS(tokens)
lTokens, _, _, equationTokens, comments = integrate(
lTokens, varName)
elif operation == 'differentiate':
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:
"""
This part handles the cases when VisMa is dealing with matrices.
Boolean flags used in code below:
dualOperand -- {True} when the matrix operations require two operands (used in operations like addition, subtraction etc)
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.)
"""
operation = operation[4:]
dualOperand = False
nonMatrixResult = False
scalarOperations = False
if ', ' in inputEquation:
dualOperand = True
[inputEquation1, inputEquation2] = inputEquation.split(', ')
if '[' in inputEquation1:
inputEquation1 = inputEquation1[1:][:-1]
inputEquation1 = inputEquation1.split('; ')
matrixOperand1 = []
for row in inputEquation1:
row1 = row.split(' ')
for i, _ in enumerate(row1):
row1[i] = tokenizer(row1[i])
matrixOperand1.append(row1)
Matrix1 = Matrix()
Matrix1.value = matrixOperand1
inputEquation2 = inputEquation2[1:][:-1]
inputEquation2 = inputEquation2.split('; ')
matrixOperand2 = []
for row in inputEquation2:
row1 = row.split(' ')
for i, _ in enumerate(row1):
row1[i] = tokenizer(row1[i])
matrixOperand2.append(row1)
Matrix2 = Matrix()
Matrix2.value = matrixOperand2
Matrix1_copy = copy.deepcopy(Matrix1)
Matrix2_copy = copy.deepcopy(Matrix2)
else:
scalarOperations = True
scalar = inputEquation1
scalarTokens = scalar
# scalarTokens = tokenizer(scalar)
inputEquation2 = inputEquation2[1:][:-1]
inputEquation2 = inputEquation2.split('; ')
matrixOperand2 = []
for row in inputEquation2:
row1 = row.split(' ')
for i, _ in enumerate(row1):
row1[i] = tokenizer(row1[i])
matrixOperand2.append(row1)
Matrix2 = Matrix()
Matrix2.value = matrixOperand2
scalarTokens_copy = copy.deepcopy(scalarTokens)
Matrix2_copy = copy.deepcopy(Matrix2)
else:
inputEquation = inputEquation[1:][:-1]
inputEquation = inputEquation.split('; ')
matrixOperand = []
for row in inputEquation:
row1 = row.split(' ')
for i, _ in enumerate(row1):
row1[i] = tokenizer(row1[i])
matrixOperand.append(row1)
Matrix0 = Matrix()
Matrix0.value = matrixOperand
Matrix0_copy = copy.deepcopy(Matrix0)
if operation == 'simplify':
MatrixResult = simplifyMatrix(Matrix0)
elif operation == 'add':
MatrixResult = addMatrix(Matrix1, Matrix2)
elif operation == 'sub':
MatrixResult = subMatrix(Matrix1, Matrix2)
elif operation == 'mult':
MatrixResult = multiplyMatrix(Matrix1, Matrix2)
elif operation == 'determinant':
nonMatrixResult = True
sqMatrix = SquareMat()
sqMatrix.value = Matrix0.value
result = sqMatrix.determinant()
elif operation == 'trace':
nonMatrixResult = True
sqMatrix = SquareMat()
sqMatrix.value = Matrix0.value
result = sqMatrix.traceMat()
elif operation == 'inverse':
sqMatrix = SquareMat()
sqMatrix.value = Matrix0.value
MatrixResult = SquareMat()
MatrixResult = sqMatrix.inverse()
finalCLIstring = ''
if dualOperand:
if not scalarOperations:
finalCLIstring = resultMatrixString(operation=operation,
operand1=Matrix1_copy,
operand2=Matrix2_copy,
result=MatrixResult)
else:
finalCLIstring = resultMatrixString(operation=operation,
operand1=scalarTokens_copy,
operand2=Matrix2_copy,
result=MatrixResult)
else:
if nonMatrixResult:
finalCLIstring = resultMatrixString(operation=operation,
operand1=Matrix0_copy,
nonMatrixResult=True,
result=result)
else:
finalCLIstring = resultMatrixString(operation=operation,
operand1=Matrix0_copy,
result=MatrixResult)
print(finalCLIstring)