def make_matrices(a, b, c, d, e, f): A = [a, b, d, e] B = [["x"], ["y"]] C = [[c], [f]] return A, B, C def multiply(iA, C): return [ (iA[0]*C[0][0])+(iA[1]*C[1][0]), (iA[2]*C[0][0])+(iA[3]*C[1][0]) ] if __name__ == "__main__": from util import get_vars print("ax + by = c\ndx + ey = f") vars = get_vars({ "a":float, "b":float, "c":float, "d":float, "e":float, "f":float }) A, B, C = make_matrices(**vars) iA = inverse_matrix(*A) ans = multiply(iA, C) print(f"x= {ans[0]}\ny= {ans[1]}")
| | Horizontal | Vertical | | - | ---------- | -------- | | Equation | `( (x - h)^2 / a^2 ) - ( (y - k)^2 / b^2 ) = 1` | `( (y - k)^2 / a^2 ) - ( (x - h)^2 / b^2 ) = 1 ` | | Center | `(h, k)` | `(h, k)` | | Foci | `(h - c, k)` and `(h + c, k)` | `(h, k - c)` and `(h, k + c)` | | Vertices | `(h - a, k)` and `(h + a, k)` | `(h, k - a)` and `(h, k + a)` | | Slopes of Asymptotes | `b / a` and `-b / a` | `a / b` and `-a / b` """ __doc__ = doc class Hyperbola(): __doc__ = doc def __init__(self): self.name = name def hi(self, greeting="Hello, ", puctuation="!"): return greeting + self.name + puctuation def main(a, b, c): pass if __name__ == '__main__': from util import get_vars main(**get_vars({}))
#!/usr/bin/env python3 # name_of_file.py """ An explanation of the concept/formula. Each part and it's function: a + b = b + a # check_abba(a, b) -> bool """ # import other math concepts # from determiants import determiant2 def check_abba(a, b): return (a + b) == (b + a) if __name__ == "__main__": from util import get_vars print("a + b = b + a") vars = get_vars({"a": float, "b": float}) print(check_abba(**vars))
# checkslope(x1, y1, x2, y2) -> [float or None or False] # slope(x1, y1, x2, y2) -> float """ def checkslope(x1, y1, x2, y2): if x1 == x2: return None if y1 == y2: return 0 return True def slope(x1, y1, x2, y2): check = checkslope(x1, y1, x2, y2) if check != True: return check rise = y2 - y1 run = x2 - x1 return rise / run if __name__ == "__main__": from util import get_vars print("m = (y2-y1) / (x2-x1)") vars = get_vars({"x1": float, "y1": float, "x2": float, "y2": float}) print(slope(**vars))
# determiant2(a,b,c,d) -> float """ def determiant2(a, b, c, d): return ((a * d) - (b * c)) def determiant3(a, b, c, d, e, f, g, h, i): return ((a * e * i) + (b * f * g) + (c * d * h) - (g * e * c) - (h * f * a) - (i * d * b)) if __name__ == "__main__": from util import get_vars print("|a b c, d e f, g h i| =\naei + bfg + cdb - gec - kfa - idb") vars = get_vars({ "a": float, "b": float, "c": float, "d": float, "e": float, "f": float, "g": float, "h": float, "i": float, }) print(determiant3(**vars))
if d == 0: return Parabola if d > 0: return Hyperbola if d < 0: if (self.B == 0 and self.A == self.C): return Circle if (self.B != 0): return Ellipse if (self.A != 0 and self.C != 0 and self.A != self.C): return Ellipse raise ConicSectionException( "Not a Parabola, Hyperbola, Circle, or Ellipse") def main(A, B, C, D, E, F): conic_section = ConicSection(A, B, C, D, E, F) print(conic_section.type.__name__) if __name__ == '__main__': from util import get_vars print("Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0") main(**get_vars({ "A": float, "B": float, "C": float, "D": float, "E": float, "F": float, }))
data.append(f"{row}{spaces} | {y}") row += 1 print(x_name + " | " + y_name) print("-" * (x + 1) + "|" + "-" * (len(y_name) + 1)) print("\n".join(data)) return data def format_ans(func, los, vertex, y_intercept, abc): func, los, vertex, y_intercept = map(str, [func, los, vertex, y_intercept]) return "\n".join([ "y = " + func, "", "line of symetry: " + los, "vertex: " + vertex, "y-intercept: " + y_intercept, "", "direction: " + ("up" if abc[0] > 0 else "down"), "vertex type: " + ("minimum" if abc[0] > 0 else "maximum") ]) if __name__ == "__main__": from util import get_vars print("ax^2 + bx + c") vars = get_vars({"a": float, "b": float, "c": float, "x": str, "y": str}) print() f, func, l, v, y, abc = solve_problem_with_quadratics(**vars) print(format_ans(func, l, v, y, abc)) print() data = create_table(f, vars["x"], vars["y"], 10) plot(f, v, data, vars["x"], vars["y"])
def y_intercept(a, h, k): return (a * (0.0 - h)**2 + k) def vertex_form(a, h, k): func = format_func(a, h, k) los = h v = vertex(h, k) y = y_intercept(a, h, k) los, y = strip_all(los, y) los, v, y = map(str, (los, v, y)) return "\n".join([ func, "", "line of symmetry = " + los, "vertex = " + v, "y-intercept = " + y ]) if __name__ == "__main__": from util import get_vars print("y = a(x-h)^2 + k") vars = get_vars({"a": float, "h": float, "k": float}) print() print(vertex_form(**vars))
def condition_one(a, b, c, d): return determiant2(a, b, c, d) != 0 def inverse_matrix(a, b, c, d): if not condition_one(a, b, c, d): quit("|a b, c d| == 0, none") multiplier = (1 / determiant2(a, b, c, d)) a *= multiplier b *= multiplier c *= multiplier d *= multiplier return (d, -1 * (b), -1 * (c), a) def print_matrix(a, b, c, d): print(f"[{a} {b}]\n[{c} {d}]") if __name__ == "__main__": from util import get_vars print("A = [a b]\n [c d]") vars = get_vars({ "a": float, "b": float, "c": float, "d": float, }) print_matrix(*inverse_matrix(**vars))
def sort_ans(a, b): if a["area"] < b["area"]: return 1 elif a["area"] == b["area"]: return 0 else: return -1 def maximum_area_of_rectangle(P, r=100, unit="cm"): answers = [] for l in range(-1 * r, r): for w in range(-1 * r, r): if (l + l + w + w) == P: answers.append({"area": l * w, "l": l, "w": w}) answers.sort(key=cmp_to_key(sort_ans)) max_area, l, w = answers[0].values() return f"dims= ({l}{unit} by {w}{unit}), area= {max_area}{unit}²" if __name__ == "__main__": from util import get_vars print("P = Perimeter") vars = get_vars({"P": float}) print(maximum_area_of_rectangle(**vars))
x = ans_x(*vars.values(), d) y = ans_y(*vars.values(), d) z = ans_z(*vars.values(), d) if __name__ == "__main__": from util import get_vars print("a1x + b1y + c1z = d1\na2x + b2y + c2z = d2\na3x + b3y + c3z = d3") vars = get_vars({ "a1": float, "b1": float, "c1": float, "d1": float, "a2": float, "b2": float, "c2": float, "d2": float, "a3": float, "b3": float, "c3": float, "d3": float, }) d = determiant3(vars["a1"], vars["b1"], vars["c1"], vars["a2"], vars["b2"], vars["c2"], vars["a3"], vars["b3"], vars["c3"]) x = ans_x(*vars.values(), d) y = ans_y(*vars.values(), d) z = ans_z(*vars.values(), d) print()
return f""" (x - {self.h})^2 (y - {self.k})^2 —————————— + —————————— = 1 {self.b**2} {self.a**2} """ def __repr__(self): print(self.equation) return f"{self.__class__.__name__}(a={self.a}, b={self.b}, c={self.c}, h={self.h}, k={self.k})" def main(h, k, a, b): c = sympy.sqrt(a - b) if b > a: print(f"({strip_float(h)}, {strip_float(k+c)})") print(f"({strip_float(h)}, {strip_float(k-c)})") else: print(f"({strip_float(h+c)}, {strip_float(k)})") print(f"({strip_float(h-c)}, {strip_float(k)})") if __name__ == '__main__': from util import get_vars main(**get_vars({ "h": float, "k": float, "a": float, "b": float }))
t(b) = boil_after_change - old_boil t(f) = freeze_after_change - old_freeze """ def calc_mw(temp_after_change, old_temp, k, mass, kg, i): t = temp_after_change - old_temp return i * k * ( (mass / t) / kg ) if __name__ == "__main__": from util import get_vars print("MW = i * ( ( mass / t ) / kg ) * k") print("t(b) = boil_after_change - old_boil") print("t(f) = freeze_after_change - old_freeze") print("k = k(b) or k(f), depending on what was used in t") vars = get_vars({ "temp_after_change":float, "old_temp":float, "k":float, "mass":float, "kg":float, "i":float }) print(calc_mw(**vars))
mol(m, w), # mols v # liters )) if __name__ == "__main__": from util import get_vars, alias print("Π = MRT") print("Π = ((mass/mw)/v)RT") print_R() print("") vars = get_vars({ "mass": float, "mw": float, "volume": float, "temp (C)": float, "pressure type": str }) print( osmotic_pressure(**alias( vars, { "mass": "m", "mw": "w", "volume": "v", "temp (C)": "t", "pressure type": "pressure_unit" })))