|
|
""" |
|
|
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() |
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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] |
|
|
resultOut = False |
|
|
simul = False |
|
|
|
|
|
try: |
|
|
|
|
|
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.addTab(self.equationList.tab1, "History") |
|
|
|
|
|
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) |
|
|
|
|
|
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.inputBox.addWidget(self.buttons[(i, j)], i, j) |
|
|
inputWidget.setLayout(self.inputBox) |
|
|
|
|
|
|
|
|
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.) |
|
|
""" |
|
|
|
|
|
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: |
|
|
|
|
|
pass |
|
|
|
|
|
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) |
|
|
|
|
|
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...') |
|
|
|
