def __init__(self, data: str, ctx: Context):
self.args = []
self.is_monomial = False
self.variables = []
try:
self.type, self.value, arg1, arg2 = parse(data)
except (TypeError):
input_error_message(data)
self.type = 'error'
return
if self.type == 'symp':
expr = Expression(self.value, ctx)
simplify(expr)
self.__clone(expr)
elif self.type[0:4] == 'plot':
expr = Expression(self.value, ctx)
simplify(expr)
plot(expr, arg1, arg2, self.type[4], self.type[5])
elif self.type == 'func':
for arg in (arg1, arg2):
self.__get_args(arg, self.value, ctx)
elif self.type == 'symbol':
expr = ctx.get_func_from_list(self.value)
if expr != -1:
expr = Expression(expr, ctx)
self.__clone(expr)
else:
self.variables.append([self.value, 1])
self.value = 1
self.is_monomial = True
else:
self.is_monomial = True
def derive_ui(expr):
expr = br.transform_brackets(expr)
util.debug_print("Transformed:\t\t" + expr, 1)
expr = sim.simplify(expr)
util.debug_print("Simplified:\t" + expr, 1)
expr = dev.derive_sub(expr)
util.debug_print("Derived:\t\t" + expr, 1)
expr = br.remove_brackets(expr)
util.debug_print("Removed:\t\t" + expr, 1)
expr = sim.simplify(expr)
util.debug_print("Simplified:\t\t" + expr, 1)
expr = br.back_transform_brackets(expr)
util.debug_print("Backtransformed:\t" + expr, 1)
return expr
def editorValidateExpression(win):
if win.editor_output == None:
win.editor_compiletext[3].setText("You have not selected an output node!")
else:
try:
output = editorGenerateExpression(win, win.editor_output)
win.editor_compiletext[3].setText("")
popup = createPanel(win, 0, win.height/2-120, win.width, 240)
# text elements to display the final result
exp1 = simplify.prettyPrint(output)
exp2 = simplify.prettyPrint(simplify.simplify(output))
title1 = createText(win, win.width/2, win.height/2-100, "Generated Expression", 24)
expression = createText(win, win.width/2, win.height/2-70, exp1, 20)
copy1 = createButton(win, win.width/2-75, win.height/2-45, 150, 40, "Copy to Clipboard", lambda: copyToClipboard(exp1), "grey")
title2 = createText(win, win.width/2, win.height/2+20, "Simplified Expression", 24)
simplified = createText(win, win.width/2, win.height/2+50, exp2, 20)
copy2 = createButton(win, win.width/2-75, win.height/2+75, 150, 40, "Copy to Clipboard", lambda: copyToClipboard(exp2), "grey")
close = createButton(win, win.width-50, win.height/2+-120, 50, 30, "X", None, "red")
close[4] = lambda: undrawElements(win, popup, title1, title2, expression, simplified, copy1, copy2, close)
except EditorError as e:
win.editor_compiletext[3].setText(e)
if e.element:
e.element[1][3][0].setFill("red")
def test_simplification(self):
for expr in self.expressions_simplify:
sol = self.expressions_simplify.get(expr)
expr = br.transform_brackets(expr)
expr = sim.simplify(expr)
with self.subTest():
self.assertEqual(expr, sol)
def process_data_file(data_file):
print(data_file)
# Read geojson from file
with open(data_file) as json_file:
geojson = json.load(json_file)
# Remove duplicate geojson features
starting_geojson = remove_duplicate_features(geojson)
simplified_geojson = starting_geojson
# Count number of features
number_of_features = count_number_of_features(starting_geojson)
tolerance = 0.0001
print('starting # of features', number_of_features)
# If number of features greater than 100, apply
# simplify routine
while number_of_features > 500:
# Collect lat/lon into an list of dicts
starting_lon_lat_list = collect_lon_lat_to_list(starting_geojson)
simplified_lon_lat_list = simplify(starting_lon_lat_list,
tolerance=tolerance,
highestQuality=True)
# Expand back to geojson feature for each point
simplified_geojson = create_simplified_geojson(simplified_lon_lat_list,
starting_geojson)
number_of_features = count_number_of_features(simplified_geojson)
if number_of_features < 100:
# Revert back one to larger number of features
simplified_geojson = starting_geojson
number_of_features = count_number_of_features(simplified_geojson)
break
else:
starting_geojson = simplified_geojson
tolerance = tolerance + 0.0005
print('ending # of features', number_of_features)
# Save geojson to file
output_folder = './output_simplified_jsonld_geojson_ctd_check'
# get filename of data_file
filename = Path(data_file).name
output_file = Path(output_folder, filename)
with open(output_file, 'w') as f:
json.dump(simplified_geojson, f)
def simplify_coordinates(coordinates):
tolerance = 0.0001
number_of_coordinates = len(coordinates)
starting_lon_lat_list = collect_lon_lat_to_list(coordinates)
while number_of_coordinates > 500:
# Collect lat/lon into an list of dicts to apply simplify
# routine to
simplified_lon_lat_list = simplify(starting_lon_lat_list,
tolerance=tolerance,
highestQuality=True)
number_of_coordinates = len(simplified_lon_lat_list)
if number_of_coordinates < 100:
# Revert back one to larger number of coordinates
# Use starting_lon_lat_list
break
else:
tolerance = tolerance + 0.00005
starting_lon_lat_list = simplified_lon_lat_list
# Convert list of dicts to list of lists for lon/lat
coordinates = convert_simplified_lon_lat_list(starting_lon_lat_list)
print('ending # of coordinates', len(coordinates))
return coordinates
def splosci(f):
"""
Splosci (flatten) dano formulo f, kolikor je mozno.
"""
a = simplify(f)
def splosci_aux(p):
"""
Pomozna funkcija za rekurzivne klice.
"""
if isinstance(p, And):
nove = []
for fr in p.formule:
if isinstance(fr, And):
nove += [splosci_aux(x) for x in fr.formule]
else:
nove.append(splosci_aux(fr))
p.formule = nove
elif isinstance(p, Or):
nove = []
for fr in p.formule:
if isinstance(fr, Or):
nove += [splosci_aux(x) for x in fr.formule]
else:
nove.append(splosci_aux(fr))
p.formule = nove
else:
return p
return p
return splosci_aux(a)
def _test_GivenStrings(self):
self.assertEqual("x**2-1", simplify("(x-1)*(x+1)"))
self.assertEqual("x**2+2*x+1", simplify("(x+1)*(x+1)"))
self.assertEqual("x**2+6*x", simplify("(x+3)*x*2-x*x"))
self.assertEqual("x**3+x**2+x", simplify("x+x*x+x*x*x"))
self.assertEqual("x**4+3*x+6", simplify("(2*x+3)*2-x+x*x*x*x"))
self.assertEqual("0", simplify("x*x-(x-1)*(x+1)-1"))
self.assertEqual("-x", simplify("5-5-x"))
self.assertEqual("-1", simplify("x*x*x-x*x*x-1"))
def _test_GivenStrings(self):
self.assertEqual("x**2-1", simplify("(x-1)*(x+1)"))
self.assertEqual("x**2+2*x+1", simplify("(x+1)*(x+1)"))
self.assertEqual("x**2+6*x", simplify("(x+3)*x*2-x*x"))
self.assertEqual("x**3+x**2+x", simplify("x+x*x+x*x*x"))
self.assertEqual("x**4+3*x+6", simplify("(2*x+3)*2-x+x*x*x*x"))
self.assertEqual("0", simplify("x*x-(x-1)*(x+1)-1"))
self.assertEqual( "-x", simplify("5-5-x"))
self.assertEqual("-1", simplify("x*x*x-x*x*x-1"))
def solve(heuristic, file):
start = time.time()
heuristics = {0: "Random", 1: "Jeroslaw", 2: "MOMs"}
print("Solving using {} heuristic".format(heuristics[int(heuristic)]))
which_method = int(heuristic)
# List for data analysis EXCEL
# [#unit_clauses, %of reduction from first simplify, #splits, #backtrackings, #time]
results = [0, 0, 100., 0, 0, 0]
split_count = 0
back_track_count = 0
problem_start_time = time.time()
rules = read_files.read_DIMACS_file(file)
rules, literals_dict, truth_values = read_files.init_database(rules)
results[1] = len(truth_values)
old_clauses_count = len(rules)
done = False
rules_before_split, literals_dict_before_split, truth_values_before_split = {}, {}, {}
split_choice, neg_literal = [], []
while done == False:
back_track = False
# Simplify
rules, literals_dict, truth_values, split_choice, neg_literal, \
rules_before_split, literals_dict_before_split, truth_values_before_split, back_track = \
simplify.simplify(rules, literals_dict, truth_values, split_choice, neg_literal,
rules_before_split, literals_dict_before_split, truth_values_before_split, back_track)
new_clauses_count = len(rules)
if split_count > 2000:
break
if back_track:
back_track_count += 1
if new_clauses_count == 0:
pretty_print.solution(truth_values)
results[3] = split_count
results[4] = back_track_count
results[5] = float("{0:.2f}".format(time.time() -
problem_start_time))
print("Solved in {0:.2f}s".format(time.time() -
problem_start_time))
print("# splits {}".format(split_count))
done = True
with open("{}.out".format(file), 'w') as f:
for truth in truth_values:
f.write("{} 0\n".format(truth))
elif old_clauses_count == new_clauses_count and back_track == False:
split_count += 1
# Split
rules, literals_dict, truth_values, split_choice, neg_literal, \
rules_before_split, literals_dict_before_split, truth_values_before_split = \
split.split(rules, literals_dict, truth_values, split_choice, neg_literal,
rules_before_split, literals_dict_before_split, truth_values_before_split, which_method)
old_clauses_count = new_clauses_count
def solve(heuristic, file):
start = time.time()
heuristics = {1: "Basic DPLL -- Random", 2: "Jeroslow-Wang", 3: "MOMs"}
print('')
print('=============== SAT Solver ================')
print("Solving using {} heuristic".format(heuristics[int(heuristic)]))
print('...\n')
which_method = int(heuristic)
rules = read_files.read_DIMACS_file(file)
rules, literals_dict, truth_values = read_files.init_database(rules)
rules_before_split, literals_dict_before_split, truth_values_before_split = {}, {}, {}
split_choice, neg_literal = [], []
old_clauses_count = len(rules)
back_track_count = 0
split_count = 0
done = False
problem_start_time = time.time()
while done == False:
back_track = False
# Simplify
rules, literals_dict, truth_values, split_choice, neg_literal, \
rules_before_split, literals_dict_before_split, truth_values_before_split, back_track, file = \
simplify.simplify(rules, literals_dict, truth_values, split_choice, neg_literal,
rules_before_split, literals_dict_before_split, truth_values_before_split, back_track, file)
new_clauses_count = len(rules)
if back_track:
back_track_count += 1
if new_clauses_count == 0:
print('The problem has a solution -- SAT')
print("Solved in {0:.2f}s".format(time.time() -
problem_start_time))
print("Number of splits: {}".format(split_count))
print("Number of backtracks: {}".format(back_track_count))
print('The solution can be found at the file: {}.out'.format(
str(file)))
print('')
done = True
with open("{}.out".format(file), 'w') as f:
f.write("p cnf {} {}\n".format(len(truth_values),
len(truth_values)))
for truth in truth_values:
f.write("{} 0\n".format(truth))
elif old_clauses_count == new_clauses_count and back_track == False:
split_count += 1
# Split
rules, literals_dict, truth_values, split_choice, neg_literal, \
rules_before_split, literals_dict_before_split, truth_values_before_split = \
split.split(rules, literals_dict, truth_values, split_choice, neg_literal,
rules_before_split, literals_dict_before_split, truth_values_before_split, which_method)
old_clauses_count = new_clauses_count
def main():
print("Boolean Algebra Utility")
print("Commands: 'table', 'eval', 'same', 'simplify', 'ui' and 'quit'")
print("TO USE THE CIRCUIT UI, TYPE 'ui'")
print("TO END THE PROGRAM, TYPE 'quit'")
while True:
command = input("\n[COMMAND] > ")
if command.lower() in ["table", "truth", "truthtable"]:
print(
"\nEnter the boolean expression to generate a truth table for it."
)
expression = generateExpressionErrorless(input("[BOOLEAN] > "))
calcTruthTable(expression)
elif command.lower() in [
"eval", "evaluate", "calc", "calculate", "calcvalue"
]:
print("\nEnter the boolean expression to get the output of.")
expression = generateExpressionErrorless(input("[BOOLEAN] > "))
print("OUTPUT = {}".format(calcValue(expression)))
elif command.lower() in ["equiv", "equivalent", "same", "compare"]:
print("\nEnter the 2 boolean expressions to comapre.")
expression1 = generateExpressionErrorless(input("[BOOLEAN #1] > "))
expression2 = generateExpressionErrorless(input("[BOOLEAN #2] > "))
print(
isEquivalent(expression1, expression2)
and "The 2 expressions are equivalent"
or "The 2 expressions are not equivalent")
elif command.lower() in ["simplify", "simple"]:
print("\nEnter the expression to simplify.")
expression = removeBrackets(
generateExpressionErrorless(input("[BOOLEAN] > ")))
print("SIMPLIFIED = {}".format(
simplify.prettyPrint(simplify.simplify(expression))))
print(
"NOTE: Letters may not be in alphabetical order, but should be correct due to the Commutative Law."
)
elif command.lower() in ["ui", "builder", "creator"]:
print("UI Launching...")
print("Check your taskbar for a window called 'Circuit Builder'")
ui.createEditor()
elif command.lower() in ["stop", "quit", "close", "end", "leave"]:
print("\nQuitting...")
break
else:
print("Unknown Command")
print(
"Commands: 'table', 'eval', 'same', 'simplify', 'ui' and 'quit'"
)
def test_GivenExpressions(self):
#"(x-1)*(x+1)"
self.assertEqual("x**2-1", p(s(x(1), c(-1)), s(x(1), c(1))).simplify().fmt())
self.assertEqual("x**2+2*x+1", simplify("(x+1)*(x+1)"))
self.assertEqual("x**2+6*x", simplify("(x+3)*x*2-x*x"))
self.assertEqual("x**3+x**2+x", simplify("x+x*x+x*x*x"))
self.assertEqual("x**4+3*x+6", simplify("(2*x+3)*2-x+x*x*x*x"))
self.assertEqual("0", simplify("x*x-(x-1)*(x+1)-1"))
self.assertEqual( "-x", simplify("5-5-x"))
self.assertEqual("-1", simplify("x*x*x-x*x*x-1"))
def run(self):
while True:
inp = self.input_method()
inp_strip = inp.strip()
if inp_strip[0] == '@':
inp_split = inp_strip[1:].split()
order = OrderToken(inp_split, self.keywords)
if order.value == 'exit':
break
else:
self.raw_calc_input.append(inp)
self.processed_calc_input.append(self.preprocess(inp))
self.calc_output.append(simplify(calcparser.parse(self.processed_calc_input[-1])))
def test_GivenExpressions(self):
#"(x-1)*(x+1)"
self.assertEqual("x**2-1",
p(s(x(1), c(-1)), s(x(1), c(1))).simplify().fmt())
self.assertEqual("x**2+2*x+1", simplify("(x+1)*(x+1)"))
self.assertEqual("x**2+6*x", simplify("(x+3)*x*2-x*x"))
self.assertEqual("x**3+x**2+x", simplify("x+x*x+x*x*x"))
self.assertEqual("x**4+3*x+6", simplify("(2*x+3)*2-x+x*x*x*x"))
self.assertEqual("0", simplify("x*x-(x-1)*(x+1)-1"))
self.assertEqual("-x", simplify("5-5-x"))
self.assertEqual("-1", simplify("x*x*x-x*x*x-1"))
def start_cube():
c = Cube(3)
s = Solution(c)
possible_steps = [
'D', 'd', 'U', 'u', 'L', 'l', 'R', 'r', 'B', 'b', 'F', 'f'
]
print("Hello! Here is the program to help you with solving Rubik's Cube.")
print(
"Do you want to shuffle cube yourself, or perform autoshuffle? (enter 'my' for your shuffle or enter 'auto' for shuffle)"
)
shuffle_type = str(input())
shuffle_type = shuffle_type.strip().lower()
if shuffle_type == "my":
print(
"Enter steps you want to make seperated by spaces (possible steps: D, d, U, u, L, l, R, r, B, b, F, f)"
)
shuffle_steps_str = str(input())
shuffle_steps = shuffle_steps_str.split()
for i in shuffle_steps:
if i not in possible_steps:
print("Invalid input! No such steps allowed")
return 1
s.shuffle_user(shuffle_steps)
elif shuffle_type == "auto":
print(
"Enter numeric value of seed which is used to generate random steps"
)
try:
shuffle_seed = int(input())
except:
print("Invalid input! Try again")
return 1
s.shuffle(shuffle_seed)
print("Used steps to shuffle the cube:")
print(s.shuffle_steps)
else:
print("Invalid input! Try again")
return 1
s.solve_cube()
# vidualizatsia
result_steps = s.result_steps
for i in range(3):
result_steps = simplify(result_steps)
print("Steps to solve a cube:")
print(result_steps)
return s.shuffle_steps, result_steps
def decomposePolynomial( polynomial ):
ret = []
if isinstance( polynomial, astPlus ):
return decomposePolynomial( polynomial.left ) + decomposePolynomial( polynomial.right )
elif isinstance( polynomial, astMinus ):
if isinstance( polynomial.right, astUminus ):
return decomposePolynomial( polynomial.left ) + decomposePolynomial( polynomial.right.arg )
return decomposePolynomial( polynomial.left ) + decomposePolynomial( simplify.simplify( -polynomial.right ) )
else:
# it is a monomial
if isinstance( polynomial, astUminus ):
return [ ( MINUS, polynomial.arg ) ]
else:
return [ ( PLUS, polynomial ) ]
def parts(u, dv):
du = derivatives.main(u)
v = antiderivative(dv, variable, limit)
ddu = derivatives.main(du)
ddv = derivatives.main(dv)
if func in (BinaryOp(left = ddu, op = '⋅', right = dv), BinaryOp(left = dv, op = '⋅', right = ddu)):
return BinaryOp(
left = BinaryOp(
left = BinaryOp(
left = u,
op = '⋅',
right = v
),
op = '-',
right = BinaryOp(
left = du,
op = '⋅',
right = dv
)
),
op = '÷',
right = Constant(2)
)
vdu = simplify.simplify(
antiderivative(
BinaryOp(
left = du,
op = '⋅',
right = v
),
variable,
limit
)
)
return BinaryOp(
left = BinaryOp(
left = u,
op = '⋅',
right = v
),
op = '-',
right = vdu
)
def load():
data = None
with open(sys.argv[1], 'r') as in_file:
data = geojson.loads(in_file.read())
cluster = Cluster()
session = cluster.connect('global')
level = 16
ins_statement = session.prepare(
'''INSERT INTO slave (level, s2_id, time, osm_id, json)
VALUES (?, ?, ?, ?, ?)''')
s = Set()
for feature in data['features']:
osm_id = feature['id']
json = geojson.dumps(feature)
featuretype = feature['geometry']['type']
featurecoord = feature['geometry']['coordinates']
# A list of every lon,lat pairs a feature has
ptlist = []
if (featuretype == "Point"):
ptlist = case1(featurecoord)
if (featuretype == "LineString" or featuretype == "MultiPoint"):
ptlist = case2(featurecoord)
if (featuretype == "Polygon" or featuretype == "MultiLineString"):
ptlist = case3(featurecoord)
if (featuretype == "MultiPolygon"):
ptlist = case4(featurecoord)
# Set to track distinct S2 values
s2set = Set()
# 16242 without simp
sptlist = simplify(ptlist, 0.01, True)
for pt in ptlist:
latlng = s2sphere.LatLng.from_degrees(pt[1], pt[0])
cell = s2sphere.CellId.from_lat_lng(latlng).parent(level)
s2set.add(ctypes.c_long(cell.id()).value)
for s2 in s2set:
session.execute(ins_statement,
(level, s2, uuid.uuid1(), osm_id, json))
cluster.shutdown()
def simplify_lon_lat_list(lon_lat_list):
# convert to numeric and apply simplify routine
lon_lat_list = np.array(lon_lat_list, dtype=np.float32)
lon_lat_list = np.array(lon_lat_list).tolist()
tolerance = 0.5
highQuality = True
lon_lat_list = simplify.simplify(lon_lat_list, tolerance, highQuality)
# Convert back to strings
lon_lat_list = np.array(lon_lat_list)
lon_lat_list = lon_lat_list.astype(str)
lon_lat_list = lon_lat_list.tolist()
return lon_lat_list
def unifyPolynomialMonomials( a, b ):
"""Take two monomials of a polynomial and attempt to unify them.
Return values can be:
* None, if no unification is possible
* A single astNode instance, if the two factors have been successfully unified
* A list of astNodes if the unification yielded multiple terms (e.g. by expansion)
"""
# minuses have been pulled out by the polynomial decomposer
assert( not isinstance( a, astUminus ) )
assert( not isinstance( b, astUminus ) )
( s, p ) = a
( t, q ) = b
if isinstance( p, astConst ) and p.const == 0:
return b
if isinstance( q, astConst ) and q.const == 0:
return a
if isinstance( p, astConst ) and isinstance( q, astConst ):
if s == t:
return ( s, astConst( p.const + q.const ) )
if p.const > q.const:
return ( s, astConst( p.const - q.const ) )
return ( t, astConst( q.const - p.const ) )
if isinstance( p, astTimes ) and isinstance( p.left, astConst ) \
and isinstance( q, astTimes ) and isinstance( q.left, astConst ) \
and p.right == q.right:
# n * a + m * a = (n + m) * a
( sign, factor ) = unifyPolynomialMonomials( ( s, p.left ), ( t, q.left ) )
return ( sign, simplify.simplify( factor * p.right ) )
if isinstance( p, astTimes ) and isinstance( p.left, astConst ) \
and q == p.right:
# n * a + 1 * a = (n + 1) * a
return unifyPolynomialMonomials( a, ( t, astConst( 1 ) * q ) )
if isinstance( q, astTimes ) and isinstance( q.left, astConst ) \
and p == q.right:
# 1 * a + n * a = (n + 1) * a
return unifyPolynomialMonomials( ( s, astConst( 1 ) * p ), b )
if p == q:
# a + a = 2a
return unifyPolynomialMonomials( ( s, astConst( 1 ) * p ), ( t, astConst( 1 ) * q ) )
return None
def simplifyMonomial(monomial):
(sign, parts) = decomposeMonomial(monomial)
# print( "Decomposed monomial %s into:" % monomial )
# print( sign )
# print( parts )
unificationNeeded = True
while unificationNeeded:
unificationNeeded = False
for i, parti in enumerate(parts):
for j, partj in enumerate(parts[i + 1 :]):
res = unifyMonomialFactors(parti, partj)
if res is not None:
# we found a possible unification between two factors
# parti and partj
# combine them, remove the original parts and
# restart unification from scratch
unificationNeeded = True
del parts[j + i + 1]
del parts[i]
if isinstance(res, astNode):
parts.append(res)
else:
# parts is a list
parts += res
break
if unificationNeeded:
break
parts.sort()
expr = composeMonomial(parts)
if sign == MINUS:
res = astUminus(expr)
else:
res = expr
if monomial != res:
# may need to re-apply simplification
# until we reach a fixed point
# if, for example, the monomial simplification
# yielded a polynomial through distributivity of multiplication
return simplify.simplify(res)
# we've reached a fixes point
return res
def transform(formula, output):
"""
:param formula: String representation of a modal formula.
The syntax for such a formula is per the grammar as stipulated in the README.
Example input: "(a|b) & (~c => d)"
:param output: boolean value.
:return: if output is true, prints modal clausal form (mcf) of transformed formula.
Otherwise returns mcf as dictionary.
"""
try:
modal_clause = clausify.clausify(simplify.simplify(nnf.to_nnf(parser.parse(formula)))) # type: dictionary
if output:
print(clausify.to_string(modal_clause))
else:
return modal_clause
except RuntimeError as re:
print('Unable to form modal clause: {}'.format(re.args[0]))
raise SystemExit(1)
def convert_to_cnf_aux(f):
"""
Prevede funkcijo v CNF obliko.
Kot vhod prejme funkcijo. Funkcija mora biti v primerni obliki (negacije
so lahko le pred spremenljivkami).
"""
if isinstance(f, (V, Not, Tru, Fls)):
return f
if isinstance(f, And):
combined = [] # Ze v cnf obliki, samo zdruzimo skupaj posamezne konjunkcije.
for p in f.formule:
combined.append(convert_to_cnf_aux(p))
return simplify(And(combined))
if isinstance(f, Or):
combined = [] # Moramo pretvoriti v CNF.
for p in f.formule:
combined.append(convert_to_cnf_aux(p))
# Pretvorimo tako, da naredimo vse mozne kombinacije med konjunkcijo in disjunkcijo.
combined = kombinacije(combined)
comb2 = []
for p in combined:
comb2.append(Or(p))
return And(comb2)
def main(options):
result = {}
with open(options.training_file, "r") as training_data_file:
training_data = training_data_file.read()
training_data = json.loads(training_data)
language = training_data["language"]
letters = training_data["data"]
training_data_dir = os.path.dirname(os.path.realpath(
options.training_file))
print("Language %s(%s)" % (language["name"], language["code"]))
for letter in letters:
# print("Letter %s" % (letter["letter"]))
samples = []
for sample_file_name in letter["samples"]:
sample_file = os.path.join(training_data_dir, sample_file_name)
strokes = extract_strokes(sample_file)
simplifiedStrokes = [
simplify.simplify(stroke, 3, True) for stroke in strokes
]
# print("\t%s" % (sample_file_name))
samples.append({"strokes": simplifiedStrokes})
result[letter["letter"]] = {"samples": samples}
return result
def test_exponential_exponential(capsys):
abstract_syntax_tree = "3^3^2"
expected = 3**9
assert simplify(abstract_syntax_tree) = expected
def test_solver_mult_combine_symbols():
assert test_generator(simplify('x * x')) == E('x', 2)
assert test_generator(simplify('3 * x * y * 3 * y / (4 * y * x)')) == F(M(9, S('y')), 4)
def test_exp():
assert test_generator(simplify('3 ^ 4')) == 81
assert test_generator(simplify('(x ^ 4) ^ 3')) == E('x', 12)
assert test_generator(simplify('(x / y) ^ 2')) == F(E('x', 2), E('y', 2))
assert test_generator(simplify('(x * y) ^ 2')) == M(E('x', 2), E('y', 2))
def test_division(capsys):
abstract_syntax_tree = ("DIVIDE", ("DIVIDE", 50, 10), 5)
expected = 1
assert simplify(abstract_syntax_tree) = expected
def test_subtraction_subtraction(capsys):
abstract_syntax_tree = ("MINUS", ("MINUS", 4, 3), 10)
expected = -11
assert simplify(abstract_syntax_tree) = expected
def antiderivative(func, variable = 'x', limit = 1 << 12):
def parts(u, dv):
du = derivatives.main(u)
v = antiderivative(dv, variable, limit)
ddu = derivatives.main(du)
ddv = derivatives.main(dv)
if func in (BinaryOp(left = ddu, op = '⋅', right = dv), BinaryOp(left = dv, op = '⋅', right = ddu)):
return BinaryOp(
left = BinaryOp(
left = BinaryOp(
left = u,
op = '⋅',
right = v
),
op = '-',
right = BinaryOp(
left = du,
op = '⋅',
right = dv
)
),
op = '÷',
right = Constant(2)
)
vdu = simplify.simplify(
antiderivative(
BinaryOp(
left = du,
op = '⋅',
right = v
),
variable,
limit
)
)
return BinaryOp(
left = BinaryOp(
left = u,
op = '⋅',
right = v
),
op = '-',
right = vdu
)
if not limit:
raise Exception('Unable to find antiderivative in time')
limit -= 1
if isinstance(func, str):
if func in standard_integrals:
return standard_integrals[func]
func = mathparser.parse(func)
if func in derivatives.standard_derivatives.values():
for key, value in derivatives.standard_derivatives.items():
if value == func:
return mathparser.parse(key + '({})'.format(variable))
if isinstance(func, Constant):
Ifunc = mathparser.parse('{}{}'.format(func.value, variable))
if isinstance(func, Variable):
if is_x(func, variable):
Ifunc = mathparser.parse('{}²÷2'.format(variable))
else:
Ifunc = mathparser.parse('{}{}'.format(func.name, variable))
if isinstance(func, UnaryOp):
if func.pos == 'Prefix':
if func.op in standard_integrals and is_x(func.operand, variable):
return nest(standard_integrals[func.op], Variable(variable), 'x')
if is_axb(func.operand, variable):
if func.op in '√∛':
# Power rule with fractional powers
# ∫(ax+b)ⁿ dx = ∫uⁿ du÷a, u = ax+b, du = a dx
# = u*(n+1)÷(a(n+1))
# = (ax+b)*(n+1) ÷ (a(n+1))
f = func.operand
n = 1 / ('√∛'.index(func.op) + 2)
a = derivatives.main(f).value
Ifunc = BinaryOp(
left = BinaryOp(
left = f,
op = '*',
right = Constant(n+1)
),
op = '÷',
right = Constant(a*(n+1))
)
else:
# Basic u-substitution
# ∫f(ax+b) dx = ∫f(u) du÷a, u = ax+b, du = a dx
fu = UnaryOp('Prefix', op = func.op, operand = Variable('u'))
Ifu = nest(antiderivative(fu, 'u', limit), Variable(variable), 'u')
a = derivatives.main(func.operand)
Ifunc = BinaryOp(
left = nest(Ifu, func.operand, variable),
op = '÷',
right = a
)
if func.op == '-':
return UnaryOp('Prefix', op = '-', operand = antiderivative(func.operand))
if func.pos == 'Postfix':
if derivatives.REGEX['exponent'].search(func.op):
n = mathparser.normalise(func.op)
f = func.operand
if is_axb(f, variable):
# Power rule
# ∫(ax+b)ⁿ dx = ∫uⁿ du÷a, u = ax+b, du = a dx
# = u*(n+1)÷(a(n+1))
# = (ax+b)*(n+1) ÷ (a(n+1))
a = derivatives.main(f).value
Ifunc = BinaryOp(
left = BinaryOp(
left = f,
op = '*',
right = Constant(n+1)
),
op = '÷',
right = Constant(a*(n+1))
)
else:
# Generalised power rule
# ∫f(x)ⁿ dx
if is_trig(f):
# Integration by reduction formula
if is_x(f.operand, variable):
Ifunc = reduce_trig(f, n, variable, limit)
elif is_axb(f.operand, variable):
fu = UnaryOp('Prefix', op = f.op, operand = Variable('u'))
Ifu = nest(antiderivative(fu, 'u', limit), Variable(variable), 'u')
a = derivatives.main(func.operand)
Ifunc = BinaryOp(
left = nest(Ifu, func.operand, variable),
op = '÷',
right = a
)
if isinstance(func, BinaryOp):
f = func.left
op = func.op
g = func.right
df = derivatives.main(f)
dg = derivatives.main(g)
if op in '+-':
# Addition rule
# ∫f(x)±g(x) dx = ∫f(x) dx ± ∫g(x) dx
If = antiderivative(f, variable, limit = limit)
Ig = antiderivative(g, variable, limit = limit)
Ifunc = BinaryOp(
left = If,
op = op,
right = Ig
)
if op == '⋅':
if isinstance(f, Constant):
# Constant product rule
# ∫af(x) dx = a∫f(x) dx
Ig = antiderivative(g, variable, limit = limit)
Ifunc = BinaryOp(
left = f,
op = '⋅',
right = Ig
)
elif inspect(func, f, g, variable) or inspect(func, g, f, variable):
# Integration by inspection
# ∫f'(g(x))g'(x) dx = f(g(x))
if inspect(func, g, f, variable):
df, dg = g, f
else:
df, dg = f, g
f = antiderivative(
UnaryOp(
df.pos,
op = df.op,
operand = Variable('u')
),
'u', limit)
g = df.operand
d_g = derivatives.main(g)
consts = []
while dg != d_g and is_const_prod(dg, d_g):
if isinstance(d_g.left, Constant):
consts.append(d_g.left.value)
d_g = d_g.right
prod = 1
for v in consts:
prod *= v
prod = Constant(1/prod)
Ifunc = BinaryOp(
left = prod,
op = '⋅',
right = nest(f, g, 'u')
)
elif is_power(f) and is_power(g):
if is_trig(f.operand) and is_trig(g.operand):
m = mathparser.normalise(f.op)
n = mathparser.normalise(g.op)
f = f.operand
g = g.operand
if is_trig(f.left) and is_trig(g.left):
m = f.right.value
n = g.right.value
f = f.left
g = g.left
# Product of exponentiated trig
# ∫f(x)ᵐ⋅g(x)ⁿ dx
if is_x(f.operand, variable) and is_x(g.operand, variable):
Ifunc = reduce_trig_prod(f, g, m, n, 1, 0, variable, limit)
elif is_ax(f.operand, variable) and is_ax(g.operand, variable) and f.operand == g.operand:
a = f.operand.left.value
Ifunc = reduce_trig_prod(f, g, m, n, a, 0, variable, limit)
elif is_axb(f.operand, variable) and is_axb(g.operand, variable) and f.operand == g.operand:
if isinstance(f.operand.right, Constant):
a = f.operand.left.left.value
b = f.operand.right.value
else:
a = f.operand.right.left.value
b = f.operand.left.value
Ifunc = reduce_trig_prod(f, g, m, n, a, b, variable, limit)
else:
# Integration by parts
# ∫u dv = uv - ∫v du
# ∫f(x)g(x) dx = f(x)∫g(x) dx - ∫(∫g(x) dx)f'(x) dx
try:
Ifunc = parts(f, g)
except:
Ifunc = parts(g, f)
if op == '*':
if is_axb(f, variable) and isinstance(g, Constant):
if g.value != -1:
# Power rule
# ∫(ax+b)ⁿ dx = ∫uⁿ du÷a, u = ax+b, du = a dx
# = u*(n+1)÷(a(n+1))
# = (ax+b)*(n+1) ÷ (a(n+1))
a = df.value
n = g.value
Ifunc = BinaryOp(
left = BinaryOp(
left = f,
op = '*',
right = Constant(n+1)
),
op = '÷',
right = Constant(a*(n+1))
)
if g.value == -1:
# Log rule
# ∫(ax+b)⁻¹ dx = ∫u⁻¹ du÷a, u = ax+b, du = a dx
# = ln(u)÷a
# = ln(ax+b)÷a
a = df
Ifunc = BinaryOp(
left = UnaryOp(
'Prefix',
op = 'ln',
operand = f
),
op = '÷',
right = a
)
if isinstance(f, Constant) and is_axb(g, variable):
# Exponential rule
# ∫c*(ax+b) dx = c*b∫c*(ax) dx
# = (c*(ax+b)) ÷ (aln(c))
a = dg
c = f
Ifunc = BinaryOp(
left = func,
op = '÷',
right = BinaryOp(
left = a,
op = '⋅',
right = UnaryOp(
'Prefix',
op = 'ln',
operand = c
)
)
)
if is_trig(f) and isinstance(g, Constant):
# Integration by reduction formula
n = g.value
if is_x(f.operand, variable):
Ifunc = reduce_trig(f, n, variable, limit)
elif is_axb(f.operand, variable):
fu = UnaryOp('Prefix', op = f.op, operand = Variable('u'))
Ifu = nest(antiderivative(fu, 'u', limit), Variable(variable), 'u')
a = derivatives.main(func.operand)
Ifunc = BinaryOp(
left = nest(Ifu, func.operand, variable),
op = '÷',
right = a
)
if op == '÷':
if isinstance(simplify.simplify(f), Constant):
f = simplify.simplify(f)
if isinstance(simplify.simplify(g), Constant):
g = simplify.simplify(g)
if isinstance(f, Constant):
if (
isinstance(g, UnaryOp) and \
g.pos == 'Postfix' and \
derivatives.REGEX['exponent'].search(g.op)
) or (
isinstance(g, UnaryOp) and \
g.pos == 'Prefix' and \
g.op in '√∛'
):
# ∫c÷f(x)ⁿ dx = ∫cf(x)⁻ⁿ
if g.pos == 'Postfix':
n = mathparser.normalise(g.op)
else:
n = 1 / ('√∛'.index(g.op) + 2)
if is_axb(g.operand, variable):
# ∫c÷(ax+b)ⁿ dx
if n != -1:
# Power rule with negative power
# ∫c÷(ax+b)ⁿ dx = c∫(ax+b)⁻ⁿ dx
# = c(ax+b)*(1-n) ÷ (a(1-n))
a = derivatives.main(g.operand).value
Ifunc = BinaryOp(
left = f,
op = '⋅',
right = BinaryOp(
left = BinaryOp(
left = g.operand,
op = '*',
right = Constant(1-n)
),
op = '÷',
right = Constant(a*(1-n))
)
)
if n == -1:
# Log rule
# ∫c÷(ax+b) dx = c∫1÷(ax+b) dx
# = cln(ax+b)÷a
a = derivatives.main(g.operand)
Ifunc = BinaryOp(
left = f,
op = '⋅',
right = BinaryOp(
left = UnaryOp(
'Prefix',
op = 'ln',
operand = g.operand
),
op = '÷',
right = a
)
)
if is_axb(g, variable):
# ∫c÷(ax+b) dx = c∫1÷(ax+b) dx
# = cln(ax+b)÷a
a = dg
Ifunc = BinaryOp(
left = f,
op = '⋅',
right = BinaryOp(
left = UnaryOp(
'Prefix',
op = 'ln',
operand = g
),
op = '÷',
right = a
)
)
if isinstance(g, Constant):
# ∫f(x)÷a dx = ∫f(x) dx÷a
Ifunc = BinaryOp(
left = simplify.simplify(antiderivative(
f,
variable,
limit
)),
op = '÷',
right = g
)
if is_poly(f, variable) and is_poly(g, variable):
print('>', f, g)
try:
return Ifunc
except:
raise Exception('Unable to find antiderivative')
def test_factorial_factorial(capsys):
abstract_syntax_tree = "4!!"
expected = factorial(factorial(4))
assert simplify(abstract_syntax_tree) = expected
def test_addition(capsys):
abstract_syntax_tree = ('PLUS', 3, 4)
expected = 7
assert simplify(abstract_syntax_tree) = expected
def test_factorial_parenthesis(capsys):
abstract_syntax_tree = "(2 + 1)!"
expected = 6
assert simplify(abstract_syntax_tree) = expected
pimg = Image.frombytes('F', (w, h), fimg.tostring(), 'raw', 'F;32NF')
pimg.save(args.file + ".tif")
hmin = e1 * (1 - imin) + e2 * imin
hmax = e1 * (1 - imax) + e2 * imax
contours = []
hstep = 2.5
nc = m.ceil((hmax - hmin) / hstep)
for i in range(nc):
hgt = imin + i * hstep / (hmax - hmin)
npc = measure.find_contours(img, hgt)
cs = []
for c in npc:
c = simplify(c, 5, True)
cs.append(c)
cs = np.array(cs)
contours.append(cs)
np.savez_compressed(args.file + "-contours", *contours)
# mi,ma = float(np.amin(img)),float(np.amax(img))
# print("contour",mi,ma)
# for i in range(50):
# d = float(mi*(1-i/50)+ma*i/50)
# print("contour",d)
# npc = measure.find_contours(img, d)
# for n,c in enumerate(npc):
# contours = [((x[1]-512)/1024*3499.99975586*2,(x[0]-512)/1024*3499.99975586*2) for x in c]
# if norm(c[-1] - c[0]) < 0.01:
# self.canvas.create_polygon(contours,fill="",outline='red',tag="contour")
clauses = len(rules)
variables = len(truth_values)
print('========= SAT Problem: {}/{} ========='.format(sdk, len(sudokus)))
old_len = len(rules)
print(' Initial number of rules:', len(rules), '\n')
# We need it for data analysis
init_len_clauses = len(rules)
finish = False
while finish == False:
bk = False
# Simplify
rules, literals_dict, truth_values, split_choice, neg_literal, \
rules_before_split, literals_dict_before_split, truth_values_before_split, results[4], bk = \
simplify.simplify(rules, literals_dict, truth_values, split_choice, neg_literal,
rules_before_split, literals_dict_before_split, truth_values_before_split, results[4], bk)
new_len = len(rules)
print(' #clauses: after simplify:', new_len, end='\r')
if new_len == 0 :
# Solution
if not check_sudoku.check_sudoku(sorted(list([val for val in truth_values if val > 0]))):
print(list(truth_values))
print(type(list(truth_values)[0]))
pretty_print.solution(truth_values)
quit()
pretty_print.solution(truth_values)
finish = True
# get the solution time
# In case you're running this file from this folder.
from data_processing import NewsQaDataset
if __name__ == "__main__":
dir_name = os.path.dirname(os.path.abspath(__file__))
parser = argparse.ArgumentParser()
parser.add_argument('--cnn_stories_path',
default=os.path.join(dir_name, 'cnn_stories.tgz'),
help="The path to the CNN stories (cnn_stories.tgz).")
parser.add_argument(
'--dataset_path',
default=os.path.join(dir_name, 'newsqa-data-v1.csv'),
help="The path to the dataset with questions and answers.")
args = parser.parse_args()
newsqa_data = NewsQaDataset(args.cnn_stories_path, args.dataset_path)
logger = logging.getLogger('newsqa')
logger.setLevel(logging.INFO)
# Dump the dataset to common formats.
newsqa_data.dump(path='combined-newsqa-data-v1.json')
newsqa_data.dump(path='combined-newsqa-data-v1.csv')
tokenized_data_path = os.path.join(dir_name,
'newsqa-data-tokenized-v1.csv')
tokenize(output_path=tokenized_data_path)
split_data(dataset_path=tokenized_data_path)
simplify(output_dir_path='split_data')
def test_solver_mult_basic():
assert test_generator(simplify('5 * (4 * 3)')) == 60
assert test_generator(simplify('5 * (4 * x)')) == M(20, 'x')
assert test_generator(simplify('(x * 5) * 4 * 3')) == M(60, 'x')
assert test_generator(simplify('(x * y * 5) * 4 * 3')) == M(60, 'x', 'y')
def test_exponential_exponential_multiplication(capsys):
abstract_syntax_tree = "3^3^2*2"
expected = (3**9)*2
assert simplify(abstract_syntax_tree) = expected
def test_minus_function(capsys):
abstact_syntax_tree = ("FUNCTION", 'sin', ("NEGATIVE", 'pi'))
expected = 0
assert simplify(abstract_syntax_tree) = expected
def test_exponential_negative_exponential(capsys):
abstract_syntax_tree = "9^-2"
expected = 3
assert simplify(abstract_syntax_tree) = expected
def test_functions_parenthesis(capsys):
abstact_syntax_tree = ("FUNCTION", 'cos', ("TIMES", ("FUNCTION", 'cos', ("NEGATIVE", 'pi')), pi))
expected = -1
assert simplify(abstract_syntax_tree) = expected
def test_factorial_complex(capsys):
abstract_syntax_tree = "-4!^3!"
expected = -factorial(4) ** factorial(3)
assert simplify(abstract_syntax_tree) = expected
def simplify(self):
import simplify
return simplify.simplify(self)
def test_empty(capsys):
abstract_syntax_tree = ""
expected = ""
assert simplify(abstract_syntax_tree) = expected
def test_simplify_fractions():
assert test_generator(simplify('a/b')) == F('a', 'b')
assert test_generator(simplify('a/b/c/d/e')) == F('a', M('b', 'c', 'd', 'e'))
assert test_generator(simplify('a/(b/(c/(d/e)))')) == F(M('a','c','e'),M('b','d'))
def test_function(capsys):
abstract_syntax_tree = "{sin$1}(0)"
expected = ("FUNCTION", 'sin', 0)
assert simplify(abstract_syntax_tree) = expected
hmax = e1 * (1 - imax) + e2 * imax
print(imin, imax)
print(e1, e2, e3, e4)
print(hmin, hmax)
contours = []
hstep = 10
nc = m.ceil((hmax - hmin) / hstep)
istep = (imax - imin) / nc
for i in range(nc):
hgt = imin + i * istep
h = hmin + i * hstep
npc = measure.find_contours(img, hgt)
cs = []
for c in npc:
c = simplify(c, 10, True)
if len(c):
print(h)
cs.append(c)
csa = np.array(cs)
contours.append(csa)
np.savez_compressed(args.file + "-contours", *contours)
# mi,ma = float(np.amin(img)),float(np.amax(img))
# print("contour",mi,ma)
# for i in range(50):
# d = float(mi*(1-i/50)+ma*i/50)
# print("contour",d)
# npc = measure.find_contours(img, d)
# for n,c in enumerate(npc):
# contours = [((x[1]-512)/1024*3499.99975586*2,(x[0]-512)/1024*3499.99975586*2) for x in c]
def test_function_1_function_1(capsys):
abstact_syntax_tree = ("FUNCTION", 'cos', ("FUNCTION", 'sin', 0))
expected = 1
assert simplify(abstract_syntax_tree) = expected
def test_solver_plus():
assert test_generator(simplify('5 + 4 + 3')) == 12
assert test_generator(simplify('5 + x + x + 3')) == P(8, M(2, 'x'))
def test_define_function_0(capsys):
abstact_syntax_tree = ("ASSIGN", 'hello', 5)
expected = 5
assert simplify(abstract_syntax_tree) = expected
def test_number(capsys):
abstract_syntax_tree = 7
expected = 7
assert expected == simplify(abstract_syntax_tree)
def test_multiplication(capsys):
abstract_syntax_tree = ("TIMES", 4, 3, 10)
expected = 120
assert simplify(abstract_syntax_tree) = expected
def test_parenthesis_division(capsys):
abstract_syntax_tree = "1000/(90 + 10)"
expected = 10
assert simplify(abstract_syntax_tree) = expected
def test_division_multiplication(capsys):
abstract_syntax_tree = ("TIMES", ("DIVIDE", 50, 10), 5)
expected = 25
assert simplify(abstract_syntax_tree) = expected
def test_exponential(capsys):
abstract_syntax_tree = "2^5"
expected = 2**5
assert simplify(abstract_syntax_tree) = expected
def test_parenthesis_whole(capsys):
abstract_syntax_tree = ("MINUS", 11 1)
expected = 10
assert simplify(abstract_syntax_tree) = expected
print_heuristic = ['Basic DPLL (random)', 'Jeroslow-Wang method
', 'MOMs method']
print(' Heuristic: ', print_heuristic[which_method])
print('=====================================\n')
old_clauses_count = len(rules)
back_track_count = 0
split_count = 0
done = False
problem_start_time = time.time()
while done == False:
back_track = False
# Simplify
rules, literals_dict, truth_values, split_choice, neg_literal, \
rules_before_split, literals_dict_before_split, truth_values_before_split, back_track = \
simplify.simplify(rules, literals_dict, truth_values, split_choice, neg_literal,
rules_before_split, literals_dict_before_split, truth_values_before_split,back_track)
new_clauses_count = len(rules)
if back_track:
back_track_count += 1
if new_clauses_count == 0:
print('The problem has a solution -- SAT')
print("Solved in {0:.2f}s".format(time.time() - problem_start_time))
print("Number of splits: {}".format(split_count))
print("Number of backtracks: {}".format(back_track_count))
print('The solution can be found at the file: {}.out'.format(str(file)))
print('')
done = True
elif old_clauses_count == new_clauses_count and back_track == False:
def test_parenthesis_unary(capsys):
abstract_syntax_tree = "-(-1)"
expected = 1
assert simplify(abstract_syntax_tree) = expected
def test_solver_mult_fractions():
assert test_generator(simplify('5 * (4 / y)')) == F(20, 'y')
assert test_generator(simplify('4 / x * y * 1 * z')) == F(M(4.0, 'y', 'z'), 'x')
assert test_generator(simplify('4 / x * (y / 1) * z')) == F(M(4, 'y', 'z'), 'x')
assert test_generator(simplify('4 / x * (y * 1) * z')) == F(M(4, 'y', 'z'), 'x')
assert test_generator(simplify('3 * x / 4 * y')) == F(M(3, 'x', 'y'), 4)