def graphPlot(workspace, again):
"""Function for plotting graphs in 2D and 3D space
2D graphs are plotted for expression in one variable and equations in two variables. 3D graphs are plotted for expressions in two variables and equations in three variables.
Arguments:
workspace {QtWidgets.QWidget} -- main layout
Returns:
graphVars {list} -- variables to be plotted on the graph
func {numpy.array(2D)/function(3D)} -- equation converted to compatible data type for plotting
variables {list} -- variables in given equation
again {bool} -- True when an equation can be plotted in 2D and 3D both else False
Note:
The func obtained from graphPlot() function is of different type for 2D and 3D plots. For 2D, func is a numpy array, and for 3D, func is a function.
"""
tokens = workspace.eqToks[-1]
axisRange = workspace.axisRange
eqType = getTokensType(tokens)
LHStok, RHStok = getLHSandRHS(tokens)
variables = sorted(getVariables(LHStok, RHStok))
dim = len(variables)
if (dim == 1 and eqType == "expression") or ((dim == 2)
and eqType == "equation"):
if again:
variables.append('f(' + variables[0] + ')')
graphVars, func = plotIn3D(LHStok, RHStok, variables, axisRange)
else:
graphVars, func = plotIn2D(LHStok, RHStok, variables, axisRange)
if dim == 1:
variables.append('f(' + variables[0] + ')')
elif (dim == 2 and eqType == "expression") or ((dim == 3)
and eqType == "equation"):
graphVars, func = plotIn3D(LHStok, RHStok, variables, axisRange)
if dim == 2:
variables.append('f(' + variables[0] + ',' + variables[1] + ')')
else:
return [], None, None
return graphVars, func, variables
def plot(workspace):
"""When called from window.py it initiates rendering of equations.
Arguments:
workspace {QtWidgets.QWidget} -- main layout
"""
workspace.figure2D.clear()
workspace.figure3D.clear()
tokens = workspace.eqToks[-1]
eqType = getTokensType(tokens)
LHStok, RHStok = getLHSandRHS(tokens)
variables = sorted(getVariables(LHStok, RHStok))
dim = len(variables)
graphVars, func, variables = graphPlot(workspace, False)
renderPlot(workspace, graphVars, func, variables)
# Handles case when a equation (like x^2 + y^2 = 5) can be rendered in 2D as well as 3D.
if ((dim == 2) and eqType == "equation"):
graphVars, func, variables = graphPlot(workspace, True)
renderPlot(workspace, graphVars, func, variables)
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 quickTest(inp, operation, wrtVar=None):
if operation.__name__ not in ['ArithemeticMean', 'Mode', 'Median']:
if (inp.count(';') == 2):
afterSplit = inp.split(';')
eqStr1 = afterSplit[0]
eqStr2 = afterSplit[1]
eqStr3 = afterSplit[2]
tokens = [tokenizer(eqStr1), tokenizer(eqStr2), tokenizer(eqStr3)]
token_string, _, _ = operation(tokens[0], tokens[1], tokens[2],
wrtVar)
return removeSpaces(token_string)
elif (inp.count(';') == 1):
afterSplit = inp.split(';')
eqStr1 = afterSplit[0]
eqStr2 = afterSplit[1]
tokens = [tokenizer(eqStr1), tokenizer(eqStr2)]
_, _, token_string, _, _ = operation(tokens[0], tokens[1])
return removeSpaces(token_string)
else:
lhs, rhs = getLHSandRHS(tokenizer(inp))
_, inpType = checkTypes(lhs, rhs)
if inpType == "equation":
if wrtVar is not None:
_, _, _, token_string, _, _ = operation(lhs, rhs, wrtVar)
else:
_, _, _, token_string, _, _ = operation(lhs, rhs)
elif inpType == "expression":
if wrtVar is not None:
_, _, token_string, _, _ = operation(lhs, wrtVar)
else:
_, _, token_string, _, _ = operation(lhs)
else:
sampleSpaceObject = sampleSpace(inp)
token_string, _, _ = operation(sampleSpaceObject)
output = removeSpaces(token_string)
return output
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 interactionMode(self):
self.enableQSolver = False
showQSolve(self, self.enableQSolver)
cursor = self.textedit.textCursor()
interactionText = cursor.selectedText()
if str(interactionText) == '':
self.mode = 'normal'
self.input = str(self.textedit.toPlainText())
else:
self.input = str(interactionText)
self.mode = 'interaction'
showbuttons = True
if len(self.input) == 0:
self.input = '0'
QMessageBox.information(
self, "Message",
"No input is given. please enter some expression.")
showbuttons = False
self.tokens = tokenizer(self.input)
self.addEquation()
lhs, rhs = getLHSandRHS(self.tokens)
self.lTokens = lhs
self.rTokens = rhs
operations, self.solutionType = checkTypes(lhs, rhs)
if isinstance(operations, list) and showbuttons:
opButtons = []
if len(operations) > 0:
if len(operations) == 1:
if operations[0] not in [
'integrate', 'differentiate', 'find roots',
'factorize'
]:
opButtons = ['simplify']
else:
opButtons = ['simplify']
for operation in operations:
if operation == '+':
opButtons.append("addition")
elif operation == '-':
opButtons.append("subtraction")
elif operation == '*':
opButtons.append("multiplication")
elif operation == '/':
opButtons.append("division")
else:
opButtons.append(operation)
if self.buttonSet:
for i in reversed(range(self.solutionOptionsBox.count())):
self.solutionOptionsBox.itemAt(i).widget().setParent(None)
for i in range(int(len(opButtons) / 2) + 1):
for j in range(2):
if len(opButtons) > (i * 2 + j):
self.solutionButtons[(i,
j)] = QtWidgets.QPushButton(
opButtons[i * 2 + j])
self.solutionButtons[(i, j)].resize(100, 100)
self.solutionButtons[(i, j)].clicked.connect(
self.onSolvePress(opButtons[i * 2 + j]))
self.solutionOptionsBox.addWidget(
self.solutionButtons[(i, j)], i, j)
else:
self.bottomButton.setParent(None)
self.solutionWidget = QWidget()
for i in range(int(len(opButtons) / 2) + 1):
for j in range(2):
if len(opButtons) > (i * 2 + j):
self.solutionButtons[(i,
j)] = QtWidgets.QPushButton(
opButtons[i * 2 + j])
self.solutionButtons[(i, j)].resize(100, 100)
self.solutionButtons[(i, j)].clicked.connect(
self.onSolvePress(opButtons[i * 2 + j]))
self.solutionOptionsBox.addWidget(
self.solutionButtons[(i, j)], i, j)
self.solutionWidget.setLayout(self.solutionOptionsBox)
self.buttonSplitter.addWidget(self.solutionWidget)
self.buttonSet = True
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 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 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 interactionMode(self):
if not self.matrix:
self.enableQSolver = False
renderQuickSol(self, self.qSol, self.enableQSolver)
cursor = self.textedit.textCursor()
interactionText = cursor.selectedText()
if str(interactionText) == '':
self.mode = 'normal'
self.input = str(self.textedit.toPlainText())
else:
self.input = str(interactionText)
self.mode = 'interaction'
showbuttons = True
if len(self.input) == 0:
return self.warning("No input given!")
self.simul = False
self.combi = False
self.matrix = False
self.dualOperandMatrix = False
self.scalarOperationsMatrix = False
self.nonMatrixResult = False
if self.input[0:4] == 'mat_':
self.input = self.input[4:]
self.input = self.input[0:-1]
self.input = self.input[1:]
self.matrix = True
if not self.matrix:
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):
self.combi = True
afterSplit = self.input.split(';')
eqStr1 = afterSplit[0]
eqStr2 = afterSplit[1]
eqStr3 = ''
if self.simul:
self.tokens = [tokenizer(eqStr1), tokenizer(eqStr2), tokenizer(eqStr3)]
self.addEquation()
operations = ['solve']
if self.combi:
operations.extend(['combination', 'permutation'])
self.solutionType = 'equation'
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)
if isinstance(operations, list) and showbuttons:
opButtons = []
if len(operations) > 0:
if len(operations) == 1:
if (operations[0] not in ['integrate', 'differentiate', 'find roots', 'factorize']) and (not self.simul):
opButtons = ['simplify']
else:
opButtons = ['simplify']
for operation in operations:
if operation == '+':
opButtons.append("addition")
elif operation == '-':
opButtons.append("subtraction")
elif operation == '*':
opButtons.append("multiplication")
elif operation == '/':
opButtons.append("division")
else:
opButtons.append(operation)
else:
if ',' in self.input:
self.dualOperandMatrix = True
[inputEquation1, inputEquation2] = self.input.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)
self.Matrix1 = Matrix()
self.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)
self.Matrix2 = Matrix()
self.Matrix2.value = matrixOperand2
else:
self.scalarOperationsMatrix = True
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)
self.Matrix2 = Matrix()
self.Matrix2.value = matrixOperand2
else:
self.dualOperandMatrix = False
inputEquation = self.input[:-2]
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)
self.Matrix0 = Matrix()
self.Matrix0.value = matrixOperand
opButtons = []
if ',' in self.input:
opButtons.extend(['Addition', 'Subtraction', 'Multiply'])
else:
opButtons.extend(['Determinant', 'Trace', 'Inverse'])
if self.buttonSet:
for i in reversed(range(self.solutionOptionsBox.count())):
self.solutionOptionsBox.itemAt(i).widget().setParent(None)
for i in range(int(len(opButtons) / 2) + 1):
for j in range(2):
if len(opButtons) > (i * 2 + j):
self.solutionButtons[(i, j)] = QtWidgets.QPushButton(
opButtons[i * 2 + j])
self.solutionButtons[(i, j)].resize(100, 100)
self.solutionButtons[(i, j)].clicked.connect(
self.onSolvePress(opButtons[i * 2 + j]))
self.solutionOptionsBox.addWidget(
self.solutionButtons[(i, j)], i, j)
else:
self.bottomButton.setParent(None)
self.solutionWidget = QWidget()
for i in range(int(len(opButtons) / 2) + 1):
for j in range(2):
if len(opButtons) > (i * 2 + j):
self.solutionButtons[(i, j)] = QtWidgets.QPushButton(
opButtons[i * 2 + j])
self.solutionButtons[(i, j)].resize(100, 100)
self.solutionButtons[(i, j)].clicked.connect(
self.onSolvePress(opButtons[i * 2 + j]))
self.solutionOptionsBox.addWidget(
self.solutionButtons[(i, j)], i, j)
self.solutionWidget.setLayout(self.solutionOptionsBox)
self.buttonSplitter.addWidget(self.solutionWidget)
self.buttonSet = True
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)