def metaMinusAndPlus(self, equation):
resultMetaMinusAndPlus = []
difficultyMetaMinusAndPlus = 0
if equation.metaMinusIndexList != []:
for index in equation.metaMinusIndexList:
for metaMinusChar in metaMinusTable[equation.str[index]]:
newMetaMinusEquation = Equation(
self.replace_char(equation.str, metaMinusChar, index))
if newMetaMinusEquation.plusIndexList != []:
for newIndex in newMetaMinusEquation.plusIndexList:
if newIndex != index:
for plusChar in plusTable[
newMetaMinusEquation.str[newIndex]]:
newEquation = Equation(
self.replace_char(
newMetaMinusEquation.str, plusChar,
newIndex))
if DEBUG_MODE:
print("metaMinusAndPlus: ",
newEquation.str,
end="")
if newEquation.checkRight():
print(" Save!")
else:
print(" Drop")
if newEquation.checkRight():
resultMetaMinusAndPlus.append(
newEquation)
difficultyMetaMinusAndPlus += 1
return difficultyMetaMinusAndPlus, resultMetaMinusAndPlus
def space2OneAndMinusTwo(self, equation):
resultSpace2OneAndMinusTwo = []
difficultySpace2OneAndMinusTwo = 0
if equation.space2OneIndexList != []:
for index in equation.space2OneIndexList:
newSpace2OneEquation = Equation(
self.insert_char(equation.str, "1", index))
if newSpace2OneEquation.minusTwoIndexList != []:
for newIndex in newSpace2OneEquation.minusTwoIndexList:
if newIndex != index:
for minusTwoChar in minusTwoTable[
newSpace2OneEquation.str[newIndex]]:
newEquation = Equation(
self.replace_char(newSpace2OneEquation.str,
minusTwoChar, newIndex))
if DEBUG_MODE:
print("space2OneAndMinusTwo: ",
newEquation.str,
end="")
if newEquation.checkRight():
print(" Save!")
else:
print(" Drop")
if newEquation.checkRight():
resultSpace2OneAndMinusTwo.append(
newEquation)
difficultySpace2OneAndMinusTwo += 1
return difficultySpace2OneAndMinusTwo, resultSpace2OneAndMinusTwo
def plusAndMinus(self, equation):
resultPlusAndMinus = []
difficultyPlusAndMinus = 0
if equation.plusIndexList != []:
# 找到所有可以进行Plus操作的Char的Index
for index in equation.plusIndexList:
for plusChar in plusTable[equation.str[index]]:
# 对每个可以进行Plus操作的Char，用其所有可以变成的Char进行替换，生成新的Equation
newPlusEquation = Equation(
self.replace_char(equation.str, plusChar, index))
if newPlusEquation.minusIndexList != []:
# 在新的等式中，找到所有可以进行Minus操作的Char的Index
for newIndex in newPlusEquation.minusIndexList:
# 为减少重复，要求这里的Index与之前不同
if newIndex != index:
# 对每个可以进行Minus操作的Char，用其所有可以变成的Char进行替换，生成新的Equation
for minusChar in minusTable[
newPlusEquation.str[newIndex]]:
newEquation = Equation(
self.replace_char(
newPlusEquation.str, minusChar,
newIndex))
if DEBUG_MODE:
print("plusAndMinus: ",
newEquation.str,
end="")
if newEquation.checkRight():
print(" Save!")
else:
print(" Drop")
# 如果正确，加入结果List
if newEquation.checkRight():
resultPlusAndMinus.append(newEquation)
difficultyPlusAndMinus += 1
return difficultyPlusAndMinus, resultPlusAndMinus
def plusTwoAndMinusTwo(self, equation):
resultPlusTwoAndMinusTwo = []
difficultyPlusTwoAndMinusTwo = 0
if equation.plusTwoIndexList != []:
for index in equation.plusTwoIndexList:
for plusTwoChar in plusTwoTable[equation.str[index]]:
newPlusTwoEquation = Equation(
self.replace_char(equation.str, plusTwoChar, index))
if newPlusTwoEquation.minusTwoIndexList != []:
for newIndex in newPlusTwoEquation.minusTwoIndexList:
if newIndex != index:
for minusTwoChar in minusTwoTable[
newPlusTwoEquation.str[newIndex]]:
newEquation = Equation(
self.replace_char(
newPlusTwoEquation.str,
minusTwoChar, newIndex))
if DEBUG_MODE:
print("plusTwoAndMinusTwo: ",
newEquation.str,
end="")
if newEquation.checkRight():
print(" Save!")
else:
print(" Drop")
if newEquation.checkRight():
resultPlusTwoAndMinusTwo.append(
newEquation)
difficultyPlusTwoAndMinusTwo += 1
return difficultyPlusTwoAndMinusTwo, resultPlusTwoAndMinusTwo
def metaAndMeta(self, equation):
resultMetaAndMeta = []
difficultyMetaAndMeta = 0
if equation.metaIndexList != []:
for index in equation.metaIndexList:
for metaChar in metaTable[equation.str[index]]:
newMetaEquation = Equation(
self.replace_char(equation.str, metaChar, index))
if newMetaEquation.metaIndexList != []:
for newMetaIndex in newMetaEquation.metaIndexList:
if newMetaIndex != index:
for newMetaChar in metaTable[
newMetaEquation.str[newMetaIndex]]:
newEquation = Equation(
self.replace_char(
newMetaEquation.str, newMetaChar,
newMetaIndex))
if DEBUG_MODE:
print("metaAndMeta: ",
newEquation.str,
end="")
if newEquation.checkRight():
print(" Save!")
else:
print(" Drop")
if newEquation.checkRight():
resultMetaAndMeta.append(newEquation)
difficultyMetaAndMeta += 1
return difficultyMetaAndMeta, resultMetaAndMeta
def run(str_test):
""""
for bonus degree 3
print("------- voir si le degre de l'eqaution < 3 si oui resoudre l'equation si non exit---------------")
"""
temp = Equation(0, 0)
expression = temp.prepare_expression(str_test)
if (len(expression[0]) and len(expression[1])):
expression_minim_tab = temp.minimize_expression(expression)
min_equation = temp.get_min_expression(expression_minim_tab)
power_max = temp.get_max_power_equation(expression_minim_tab)
print("Reduced form : {0}".format(min_equation))
print("Polynomial degree : {0}".format(power_max))
if (power_max > 2):
print(
"The Polynomial degree is stricly greater than 2, I can't solve"
)
exit(0)
elif power_max == 2:
temp.solve_second(expression_minim_tab)
elif power_max == 1:
temp.solve_first(expression_minim_tab)
elif power_max == 0:
if expression_minim_tab:
print("There's no solution !!")
else:
print("All the X ∈ ℝ are the sollution !!")
else:
print(
"Wrong format: Usage Python3 '[aX2 + bX + c = 0]' / a,b,c are double "
)
def calculateGraphs(self):
self.equations = []
for eq in self.logic.getGraphs():
equation = Equation(eq[0], eq[1])
self.equations.append(equation)
for i in range(len(self.equations)):
self.equations[i].calculate_points(self.window[0], self.window[1],
0.5)
self.pointsToPixels()
def metaTwo(self, equation):
resultMetaTwo = []
difficultyMetaTwo = 0
if equation.metaTwoIndexList != []:
for index in equation.metaTwoIndexList:
for metaTwoChar in metaTwoTable[equation.str[index]]:
newEquation = Equation(
self.replace_char(equation.str, metaTwoChar, index))
if DEBUG_MODE:
print("metaTwo: ", newEquation.str, end="")
if newEquation.checkRight():
print(" Save!")
else:
print(" Drop")
if newEquation.checkRight():
resultMetaTwo.append(newEquation)
difficultyMetaTwo += 1
return difficultyMetaTwo, resultMetaTwo
def get_equation(
self, **kwargs
): #retrieves the coefficient and power values from the data (best fit equation)
print("yes")
for name, value in kwargs.items(
): #sets the corresponding keyword argument (in this case it may be type information or base; this shall later be used to speed up the process)
setattr(self, name, value)
try:
self.base #attempts to see if a base value has been provided
except AttributeError:
self.base = len(
self.x_coords
) - 1 #utilises best fit 'count of coordinates' to increase the accuracy or provide a possible equation which fits all coords
print(self.base)
self.equation_values = Differentiation.equation_obtain(
self.y_coords, self.x_coords, self.category, self.base,
0) #returned values of coefficients and coordinates in tuples
print("Equation:", self.equation_values)
self.equation = Equation.Equation(self.equation_values)
print(self.equation.equation)
# IMPLIED. IN NO EVENT WILL THE AUTHOR BE HELD LIABLE FOR ANY DAMAGES ARISING FROM
# THE USE OF THIS SOURCE-CODE. USE AT YOUR OWN RISK.
from Equation import *
EQUATION_ORDER = [
'Pixel-Size',
'DISPARITY',
'ERROR DISPARITY',
]
EQUATION_DATA = {
'Pixel-Size': {
'DATA': Equation('PixelSize = SensorLength / NumPixel ', [
EquationSymbol(name='PixelSize', min=1, max=20, value=17, unit=u'µm', factor=1e-6, isResult=True),
EquationSymbol(name='SensorLength', min=1, max=50, value=17.408, unit='mm', factor=1e-3),
EquationSymbol(name='NumPixel', min=600, max=2048, value=1024, unit='px'),
])
},
'DISPARITY': {
'DATA': Equation('Disparity = (Focal * 1/PixelSize) * Base / Distance', [
EquationSymbol(name='Distance', min=5, max=50, value=6, unit='m'),
EquationSymbol(name='Disparity', min=0, max=160, value=64, unit='px', isResult=True),
EquationSymbol(name='Base', min=1, max=200, value=40, unit='cm', factor=1e-2),
EquationSymbol(name='Focal', min=1, max=30, value=15, unit='mm', factor=1e-3),
EquationSymbol(name='PixelSize', min=1, max=20, value=17, unit=u'µm', factor=1e-6, extern='Pixel-Size'),
])
},
'ERROR DISPARITY': {
'DATA': Equation('DistanceError = (Focal * 1/PixelSize) * Base / Disparity - (Focal * 1/PixelSize) * Base / (Disparity + AccuracyFactor*1./16)', [
EquationSymbol(name='DistanceError', min=0, max=100, value=5, unit='m', factor=1, isResult=True),
