def calluser():
availableOperations = []
tokenString = ''
equationTokens = []
if varName == 'Back':
self.input = str(self.textedit.toPlainText())
self.tokens = tokenizer(self.input)
# print(self.tokens)
lhs, rhs = getLHSandRHS(self.tokens)
operations, self.solutionType = checkTypes(lhs, rhs)
self.refreshButtons(operations)
elif operation == 'solve':
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = solveFor(
self.lTokens, self.rTokens, varName)
elif operation == 'integrate':
self.lTokens, availableOperations, tokenString, equationTokens, comments = integrate(
self.lTokens, varName)
elif operation == 'differentiate':
self.lTokens, availableOperations, tokenString, equationTokens, comments = differentiate(
self.lTokens, varName)
self.eqToks = equationTokens
self.output = resultLatex(operation, equationTokens, comments,
varName)
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 calluser():
availableOperations = []
tokenString = ''
equationTokens = []
self.input = str(self.textedit.toPlainText())
if varName == 'back':
if self.input[0:4] == 'mat_':
self.input = self.input[4:]
self.input = self.input[0:-1]
self.input = self.input[1:]
if ';' in self.input:
self.simul = True
if (self.input.count(';') == 2):
afterSplit = self.input.split(';')
eqStr1 = afterSplit[0]
eqStr2 = afterSplit[1]
eqStr3 = afterSplit[2]
elif (self.input.count(';') == 1):
afterSplit = self.input.split(';')
eqStr1 = afterSplit[0]
eqStr2 = afterSplit[1]
eqStr3 = ''
if self.simul:
self.tokens = [tokenizer(eqStr1), tokenizer(eqStr2), tokenizer(eqStr3)]
else:
self.tokens = tokenizer(self.input)
# DBP: print(self.tokens)
self.addEquation()
lhs, rhs = getLHSandRHS(self.tokens)
self.lTokens = lhs
self.rTokens = rhs
operations, self.solutionType = checkTypes(lhs, rhs)
self.refreshButtons(operations)
else:
if operation == 'solve':
if not self.simul:
self.lTokens, self.rTokens, availableOperations, tokenString, equationTokens, comments = solveFor(self.lTokens, self.rTokens, varName)
else:
tokenString, equationTokens, comments = simulSolver(self.tokens[0], self.tokens[1], self.tokens[2], varName)
elif operation == 'integrate':
self.lTokens, availableOperations, tokenString, equationTokens, comments = integrate(self.lTokens, varName)
elif operation == 'differentiate':
self.lTokens, availableOperations, tokenString, equationTokens, comments = differentiate(self.lTokens, varName)
self.eqToks = equationTokens
renderQuickSol(self, tokenString, self.showQSolver)
self.output = resultLatex(equationTokens, operation, comments, self.solutionType, self.simul, varName)
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 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)