"""
Initial Author: Siddharth Kothiyal (sidkothiyal, https://github.com/sidkothiyal)
Other Authors:
Owner: AerospaceResearch.net
About: This module is created to handle the GUI of the project, this module interacts with solve initially to check for all the available functions, and then according to the event selected by the user, it interacts with solve, or polynomial roots module.
"""
import sys
import os
import copy
from PyQt5.QtGui import QPainter
from PyQt5.QtWidgets import QApplication, QWidget, QTabWidget, QGridLayout, QVBoxLayout, QHBoxLayout, QTextEdit, QSplitter, QFrame, QAbstractButton, QDialog, QMessageBox, QFileDialog
from PyQt5.QtCore import Qt, QUrl
from PyQt5 import QtGui, QtWidgets
from PyQt5.QtWebEngineWidgets import QWebEngineView
from visma.calculus.differentiation import differentiate
from visma.calculus.integration import integrate
from visma.discreteMaths.combinatorics import factorial, combination, permutation
from visma.io.checks import checkTypes, getVariables, getVariableSim, mathError
from visma.io.tokenize import tokenizer, getLHSandRHS
from visma.io.parser import resultLatex, resultMatrixStringLatex
from visma.gui.plotter import plotFigure2D, plotFigure3D, plot
from visma.gui.qsolver import quickSimplify, qSolveFigure, renderQuickSol
from visma.gui.settings import preferenceLayout
from visma.gui.steps import stepsFigure, showSteps
from visma.simplify.simplify import simplify, simplifyEquation
from visma.simplify.addsub import addition, additionEquation, subtraction, subtractionEquation
from visma.simplify.muldiv import multiplication, multiplicationEquation, division, divisionEquation
from visma.matrix.structure import Matrix, SquareMat
from visma.matrix.operations import simplifyMatrix, addMatrix, subMatrix, multiplyMatrix
from visma.solvers.solve import solveFor
from visma.solvers.polynomial.roots import rootFinder
from visma.solvers.simulEqn import simulSolver
from visma.transform.factorization import factorize
from visma.gui import logger
class Window(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
font = QtGui.QFont()
font.setPointSize(12)
self.setFont(font)
appIcon = QtGui.QIcon()
# FIXME: Use fixed file path
appIcon.addFile(os.path.abspath('assets/icons/16x16.png'))
appIcon.addFile(os.path.abspath('assets/icons/32x32.png'))
appIcon.addFile(os.path.abspath('assets/icons/64x64.png'))
self.setWindowIcon(appIcon)
def initUI(self):
exitAction = QtWidgets.QAction('Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.close)
wikiAction = QtWidgets.QAction('Wiki', self)
wikiAction.setStatusTip('Open Github wiki')
wikiAction.triggered.connect(self.popupBrowser)
addEqList = QtWidgets.QAction('Add Equations', self)
addEqList.setStatusTip('Add custom equations')
addEqList.triggered.connect(self.loadEquations)
self.statusBar()
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(exitAction)
fileMenu.addAction(addEqList)
# configMenu = menubar.addMenu('&Config')
helpMenu = menubar.addMenu('&Help')
helpMenu.addAction(wikiAction)
self.workSpace = WorkSpace()
self.setCentralWidget(self.workSpace)
self.GUIwidth = 1300
self.GUIheight = 900
self.setGeometry(300, 300, self.GUIwidth, self.GUIheight)
self.setWindowTitle('VISual MAth')
self.show()
def popupBrowser(self):
w = QDialog(self)
w.resize(600, 500)
w.setWindowTitle('Wiki')
web = QWebEngineView(w)
web.load(QUrl('https://github.com/aerospaceresearch/visma/wiki'))
web.resize(600, 500)
web.show()
w.show()
def loadEquations(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(self, "Add Custom Equations", "", "All Files (*);;Visma Files (*.vis)", options=options)
if os.path.isfile(fileName):
if os.path.getsize(fileName) == 0:
return self.workSpace.warning("Input equations file is empty!")
if self.workSpace.equations[0][0] == "No equations stored":
self.workSpace.equations.pop(0)
with open(fileName) as fileobj:
for line in fileobj:
line = line.replace(' ', '').replace('\n', '')
if not any(line in item for item in self.workSpace.equations) and not (line.isspace() or line == ''):
self.workSpace.equations.insert(0, ('Equation No.' + str(len(self.workSpace.equations) + 1), line))
self.workSpace.addEquation()
class WorkSpace(QWidget):
inputGreek = ['x', 'y', 'z', '(', ')', '7', '8', '9', 'DEL', 'C', 'f', 'g', 'h', '{', '}', '4', '5', '6', '/', '*', 'sin', 'cos', 'tan', '[', ']', '1', '2', '3', '+', '-', 'log', 'exp', '^', 'i', u'\u03C0', '.', '0', '=', '<', '>']
inputLaTeX = ['x', 'y', 'z', '(', ')', '7', '8', '9', 'DEL', 'C', 'f', 'g', 'h', '{', '}', '4', '5', '6', '\\div', '\\times', '\\sin', '\\cos', '\\tan', '[', ']', '1', '2', '3', '+', '-', 'log', 'exp', '^', 'i', '\\pi', '.', '0', '=', '<', '>']
mode = 'interaction'
showQSolver = True
showStepByStep = True
showPlotter = False
enableQSolver = True
enableInteraction = False
buttons = {}
solutionOptionsBox = QGridLayout()
solutionButtons = {}
inputBox = QGridLayout()
selectedCombo = "Greek"
equations = []
stepsFontSize = 1
axisRange = [10, 10, 10, 30] # axisRange[-1] --> MeshDensity in 3D graphs
resultOut = False
simul = False
try:
# FIXME: Use fixed file path
with open('local/eqn-list.vis', 'r+') as fp:
for line in fp:
line = line.replace(' ', '').replace('\n', '')
if not (line.isspace() or line == ''):
equations.insert(
0, ('Equation No.' + str(len(equations) + 1), line))
fp.close()
except IOError:
if not os.path.exists('local'):
os.mkdir('local')
file = open('local/eqn-list.vis', 'w')
file.close()
if len(equations) == 0:
equations = [('No equations stored', '')]
equationListVbox = QVBoxLayout()
tokens = []
lTokens = []
rTokens = []
buttonSet = False
solutionType = ""
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
hbox = QHBoxLayout(self)
self.equationList = QTabWidget()
self.equationList.tab1 = QWidget()
# self.equationList.tab2 = QWidget()
self.equationList.addTab(self.equationList.tab1, "History")
# self.equationList.addTab(self.equationList.tab2, "favourites")
self.equationList.tab1.setLayout(self.equationsLayout())
self.equationList.tab1.setStatusTip("Track of old equations")
self.equationList.setFixedWidth(300)
inputSpace = QTabWidget()
inputSpace.tab1 = QWidget()
inputSpace.tab2 = QWidget()
inputSpace.addTab(inputSpace.tab1, "Input")
inputSpace.addTab(inputSpace.tab2, "Settings")
inputSpace.tab1.setLayout(self.inputsLayout())
inputSpace.tab2.setLayout(preferenceLayout(self))
inputSpace.tab1.setStatusTip("Input characters")
inputSpace.setFixedHeight(200)
buttonSpace = QWidget()
buttonSpace.setLayout(self.buttonsLayout())
buttonSpace.setFixedWidth(300)
buttonSpace.setStatusTip("Interact")
self.tabPlot = QTabWidget()
self.tabPlot.tab1 = QWidget()
self.tabPlot.tab2 = QWidget()
self.tabPlot.addTab(self.tabPlot.tab1, "2D-plot")
self.tabPlot.addTab(self.tabPlot.tab2, "3D-plot")
self.tabPlot.tab1.setLayout(plotFigure2D(self))
self.tabPlot.tab1.setStatusTip("Visualize equation in 2D")
self.tabPlot.tab2.setLayout(plotFigure3D(self))
self.tabPlot.tab2.setStatusTip("Visualize equation in 3D")
tabStepsLogs = QTabWidget()
tabStepsLogs.tab1 = QWidget()
tabStepsLogs.tab2 = QWidget()
tabStepsLogs.addTab(tabStepsLogs.tab1, "Step-by-Step")
tabStepsLogs.addTab(tabStepsLogs.tab2, "logger")
tabStepsLogs.tab1.setLayout(stepsFigure(self))
tabStepsLogs.tab1.setStatusTip("Step-by-step solver")
tabStepsLogs.tab2.setLayout(logger.logTextBox(self))
tabStepsLogs.tab2.setStatusTip("Logger")
font = QtGui.QFont()
font.setPointSize(16)
self.textedit = QTextEdit()
self.textedit.setFont(font)
self.textedit.textChanged.connect(self.textChangeTrigger)
self.textedit.setFixedHeight(60)
self.textedit.setStatusTip("Input equation")
quickSolve = QWidget()
quickSolve.setLayout(qSolveFigure(self))
quickSolve.setFixedHeight(45)
quickSolve.setStatusTip("Quick solver")
splitter4 = QSplitter(Qt.Vertical)
splitter4.addWidget(self.textedit)
splitter4.addWidget(quickSolve)
splitter4.addWidget(inputSpace)
splitter3 = QSplitter(Qt.Horizontal)
splitter3.addWidget(splitter4)
splitter3.addWidget(buttonSpace)
splitter2 = QSplitter(Qt.Horizontal)
splitter2.addWidget(tabStepsLogs)
splitter2.addWidget(self.tabPlot)
splitter2.addWidget(self.equationList)
splitter1 = QSplitter(Qt.Vertical)
splitter1.addWidget(splitter3)
splitter1.addWidget(splitter2)
hbox.addWidget(splitter1)
self.setLayout(hbox)
self.logBox.append(logger.info('UI Initialised...'))
def textChangeTrigger(self):
self.enableInteraction = True
self.clearButtons()
if self.textedit.toPlainText() == "":
self.enableQSolver = True
self.enableInteraction = False
try:
if self.textedit.toPlainText()[:4] != 'mat_':
if self.enableQSolver and self.showQSolver:
self.qSol, self.enableInteraction, self.simul = quickSimplify(self)
if self.qSol is None:
self.qSol = ""
if not self.simul:
renderQuickSol(self, self.qSol, self.showQSolver)
elif self.showQSolver is False:
self.qSol = ""
renderQuickSol(self, self.qSol, self.showQSolver)
else:
self.matrix = True
self.enableInteraction = True
except Exception:
logger.error('Invalid Expression')
self.enableInteraction = False
if self.enableInteraction:
self.interactionModeButton.setEnabled(True)
else:
self.interactionModeButton.setEnabled(False)
def clearAll(self):
self.textedit.clear()
self.eqToks = [[]]
self.output = ""
showSteps(self)
plot(self)
def equationsLayout(self):
self.myQListWidget = QtWidgets.QListWidget(self)
for index, name in self.equations:
myQCustomQWidget = QCustomQWidget()
myQCustomQWidget.setTextUp(index)
myQCustomQWidget.setTextDown(name)
myQListWidgetItem = QtWidgets.QListWidgetItem(self.myQListWidget)
myQListWidgetItem.setSizeHint(myQCustomQWidget.sizeHint())
self.myQListWidget.addItem(myQListWidgetItem)
self.myQListWidget.setItemWidget(
myQListWidgetItem, myQCustomQWidget)
self.myQListWidget.resize(400, 300)
self.equationListVbox.addWidget(self.myQListWidget)
self.myQListWidget.itemClicked.connect(self.Clicked)
self.clearButton = QtWidgets.QPushButton('Clear equations')
self.clearButton.clicked.connect(self.clearHistory)
self.clearButton.setStatusTip("Clear history")
self.equationListVbox.addWidget(self.clearButton)
return self.equationListVbox
def clearHistory(self):
for i in reversed(range(self.equationListVbox.count())):
self.equationListVbox.itemAt(i).widget().setParent(None)
self.equations = [('No equations stored', '')]
file = open('local/eqn-list.vis', 'r+')
file.truncate()
self.myQListWidget = QtWidgets.QListWidget(self)
i = 0
for index, name in self.equations:
if i != 0:
file.write("\n")
file.write(name)
myQCustomQWidget = QCustomQWidget()
myQCustomQWidget.setTextUp(index)
myQCustomQWidget.setTextDown(name)
myQListWidgetItem = QtWidgets.QListWidgetItem(self.myQListWidget)
myQListWidgetItem.setSizeHint(myQCustomQWidget.sizeHint())
self.myQListWidget.addItem(myQListWidgetItem)
self.myQListWidget.setItemWidget(
myQListWidgetItem, myQCustomQWidget)
i += 1
file.close()
self.myQListWidget.resize(400, 300)
self.myQListWidget.itemClicked.connect(self.Clicked)
self.equationListVbox.addWidget(self.myQListWidget)
self.clearButton = QtWidgets.QPushButton('Clear equations')
self.clearButton.clicked.connect(self.clearHistory)
self.equationListVbox.addWidget(self.clearButton)
return self.equationListVbox
def Clicked(self, item):
_, name = self.equations[self.myQListWidget.currentRow()]
self.textedit.setText(name)
def buttonsLayout(self):
self.matrix = False
vbox = QVBoxLayout()
interactionModeLayout = QVBoxLayout()
self.interactionModeButton = QtWidgets.QPushButton('visma')
self.interactionModeButton.clicked.connect(self.interactionMode)
interactionModeLayout.addWidget(self.interactionModeButton)
interactionModeWidget = QWidget(self)
interactionModeWidget.setLayout(interactionModeLayout)
interactionModeWidget.setFixedSize(275, 50)
topButtonSplitter = QSplitter(Qt.Horizontal)
topButtonSplitter.addWidget(interactionModeWidget)
permanentButtons = QWidget(self)
topButtonSplitter.addWidget(permanentButtons)
self.bottomButton = QFrame()
self.buttonSplitter = QSplitter(Qt.Vertical)
self.buttonSplitter.addWidget(topButtonSplitter)
self.buttonSplitter.addWidget(self.bottomButton)
vbox.addWidget(self.buttonSplitter)
return vbox
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 refreshButtons(self, operations):
if isinstance(operations, list):
opButtons = []
if len(operations) > 0:
if len(operations) == 1:
if operations[0] == 'solve':
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)
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)
def clearButtons(self):
for i in reversed(range(self.solutionOptionsBox.count())):
self.solutionOptionsBox.itemAt(i).widget().setParent(None)
def wrtVariableButtons(self, variables, operation):
if isinstance(variables, list):
varButtons = []
if len(variables) > 0:
for variable in variables:
varButtons.append(variable)
varButtons.append("back")
for i in reversed(range(self.solutionOptionsBox.count())):
self.solutionOptionsBox.itemAt(i).widget().setParent(None)
for i in range(int(len(varButtons) / 2) + 1):
for j in range(2):
if len(varButtons) > (i * 2 + j):
self.solutionButtons[(i, j)] = QtWidgets.QPushButton(
varButtons[i * 2 + j])
self.solutionButtons[(i, j)].resize(100, 100)
self.solutionButtons[(i, j)].clicked.connect(
self.onWRTVariablePress(varButtons[i * 2 + j], operation))
self.solutionOptionsBox.addWidget(
self.solutionButtons[(i, j)], i, j)
def addEquation(self):
eqn = str(self.textedit.toPlainText()).replace(' ', '')
if any(eqn in item for item in self.equations):
return self.equationListVbox
for i in reversed(range(self.equationListVbox.count())):
self.equationListVbox.itemAt(i).widget().setParent(None)
if len(self.equations) == 1:
index, name = self.equations[0]
if index == "No equations stored":
self.equations[0] = ("Equation No. 1", eqn)
else:
self.equations.insert(0, ("Equation No. 2", eqn))
elif eqn != "":
self.equations.insert(0, ("Equation No. " + str(len(self.equations) + 1), eqn))
file = open('local/eqn-list.vis', 'r+')
self.myQListWidget = QtWidgets.QListWidget(self)
i = 0
file.truncate()
for index, name in self.equations:
if i != 0:
file.write("\n")
file.write(name)
myQCustomQWidget = QCustomQWidget()
myQCustomQWidget.setTextUp(index)
myQCustomQWidget.setTextDown(name)
myQListWidgetItem = QtWidgets.QListWidgetItem(self.myQListWidget)
myQListWidgetItem.setSizeHint(myQCustomQWidget.sizeHint())
self.myQListWidget.addItem(myQListWidgetItem)
self.myQListWidget.setItemWidget(
myQListWidgetItem, myQCustomQWidget)
i += 1
file.close()
self.myQListWidget.resize(400, 300)
self.myQListWidget.itemClicked.connect(self.Clicked)
self.equationListVbox.addWidget(self.myQListWidget)
self.myQListWidget.itemClicked.connect(self.Clicked)
self.clearButton = QtWidgets.QPushButton('Clear equations')
self.clearButton.clicked.connect(self.clearHistory)
self.equationListVbox.addWidget(self.clearButton)
return self.equationListVbox
def inputsLayout(self, loadList="Greek"):
inputLayout = QHBoxLayout(self)
inputWidget = QWidget()
self.selectedCombo = str(loadList)
for i in range(4):
for j in range(10):
if str(loadList) in "Greek":
if (i * 10 + j) < len(self.inputGreek):
self.buttons[(i, j)] = QtWidgets.QPushButton(
self.inputGreek[i * 10 + j])
self.buttons[(i, j)].resize(100, 100)
self.buttons[(i, j)].clicked.connect(
self.onInputPress(self.inputGreek[i * 10 + j]))
self.inputBox.addWidget(self.buttons[(i, j)], i, j)
elif str(loadList) in "LaTeX":
if (i * 10 + j) < len(self.inputLaTeX):
self.buttons[(i, j)] = QtWidgets.QPushButton(
self.inputLaTeX[i * 10 + j])
self.buttons[(i, j)].resize(100, 100)
self.buttons[(i, j)].clicked.connect(
self.onInputPress(self.inputLaTeX[i * 10 + j]))
# (self.inputLaTeX[i * 3 + j])
self.inputBox.addWidget(self.buttons[(i, j)], i, j)
inputWidget.setLayout(self.inputBox)
# inputSplitter.addWidget(inputTypeSplitter)
# inputSplitter.addWidget(inputWidget)
inputLayout.addWidget(inputWidget)
return inputLayout
def onActivated(self, text):
for i in reversed(range(self.inputBox.count())):
self.inputBox.itemAt(i).widget().setParent(None)
for i in range(4):
for j in range(10):
if str(text) in "Greek":
if (i * 10 + j) < len(self.inputGreek):
self.buttons[(i, j)] = QtWidgets.QPushButton(
self.inputGreek[i * 10 + j])
self.buttons[(i, j)].resize(100, 100)
self.buttons[(i, j)].clicked.connect(
self.onInputPress(self.inputGreek[i * 10 + j]))
self.inputBox.addWidget(self.buttons[(i, j)], i, j)
elif str(text) in "LaTeX":
if (i * 10 + j) < len(self.inputLaTeX):
self.buttons[(i, j)] = QtWidgets.QPushButton(
self.inputLaTeX[i * 10 + j])
self.buttons[(i, j)].resize(100, 100)
self.buttons[(i, j)].clicked.connect(
self.onInputPress(self.inputLaTeX[i * 10 + j]))
self.inputBox.addWidget(self.buttons[(i, j)], i, j)
self.selectedCombo = str(text)
def onInputPress(self, name):
def calluser():
if name == 'C':
self.clearAll()
elif name == 'DEL':
cursor = self.textedit.textCursor()
cursor.deletePreviousChar()
else:
self.textedit.insertPlainText(str(name))
return calluser
def onSolvePress(self, name):
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)
return calluser
def onWRTVariablePress(self, varName, operation):
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)
return calluser
@classmethod
def warning(self, warningstr):
warning = QMessageBox()
warning.setWindowTitle('Warning')
warning.setIcon(QMessageBox.Warning)
warning.setText(warningstr)
warning.setStandardButtons(QMessageBox.Ok)
return warning.exec_()
class QCustomQWidget(QtWidgets.QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.textQVBoxLayout = QtWidgets.QVBoxLayout()
self.textUpQLabel = QtWidgets.QLabel()
self.textDownQLabel = QtWidgets.QLabel()
self.textQVBoxLayout.addWidget(self.textUpQLabel)
self.textQVBoxLayout.addWidget(self.textDownQLabel)
self.allQHBoxLayout = QtWidgets.QHBoxLayout()
self.allQHBoxLayout.addLayout(self.textQVBoxLayout, 1)
self.setLayout(self.allQHBoxLayout)
self.textUpQLabel.setStyleSheet('''
color: black;
''')
self.textDownQLabel.setStyleSheet('''
color: black;
''')
def setTextUp(self, text):
self.textUpQLabel.setText(text)
def setTextDown(self, text):
self.textDownQLabel.setText(text)
class PicButton(QAbstractButton):
def __init__(self, pixmap, parent=None):
super().__init__(parent)
self.pixmap = pixmap
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(event.rect(), self.pixmap)
def sizeHint(self):
return self.pixmap.size()
def initGUI():
logger.setLogName('window-gui')
logger.info('Starting VisMa GUI...')
try:
app = QApplication(sys.argv)
ex = Window()
ex.initUI()
logger.setLogName('main')
sys.exit(app.exec_())
finally:
logger.info('Existing VisMa...')
