Equation calculator

Question

Function

Calculates values for user defined equations. Just a concept right now. I plan to add many more equations.

Equations in code

Density:

$$ p = \frac{m}{v} $$

Speed:

$$ s = u + a \cdot t $$

class Equations:
    def __init__(self) -> None:
       self.p = lambda m, v: m / v
       self.m = lambda p, v: m * v
       self.v = lambda p, m: m / p
       self.s = lambda u, a, t: u + a * t
    
    
def calculate() -> None:
    density = Equations()
    answer = density.p(1.23, 1.66)
    print(f'density: {answer:.2f}')

    speed = Equations()
    answer = speed.s(3, 4, 5)
    print(f'speed: {answer:.2f}')
   

if __name__ == '__main__':
    calculate()

Output:

density: 0.74

speed: 23.00

Notes

• I am a beginner so I’m definitely doing things wrong here, suggestions welcome.

• Is this OOP and classes done right?

Background

I asked a similar question like this and the answer I got was from a very kind user and was very elegant, however it works for 1 equation, and this users suggestion to make it work for multiple equations went over my head:

Other question

https://codereview.stackexchange.com/questions/276177/class-to-calculate-values-of-equation-ρ-m-v/276181?noredirect=1#comment547477_276181

Answer 1

Your use case is quite simple. You said that you wanted to use Sympy, but you're not sure how to generalise to multiple equations. You also want real number assumptions in Sympy (mind you this is different from validation). Your existing class doesn't offer much - it's basically a collection of functions saved as members, which you should not do. Instead consider a class that parses expressions for the sides of an equation; one instance per equation.

Suggested

import sympy
from sympy import Equality, solve, Symbol, Expr


def parse_real(expr_str: str) -> tuple[Expr, dict[str, Symbol]]:
    symbols_expr = sympy.S(expr_str)

    symbols = {
        s.name: Symbol(
            s.name, real=True, finite=True, nonnegative=True,
        )
        for s in symbols_expr.free_symbols
    }

    expr = sympy.parse_expr(expr_str, symbols)
    return expr, symbols


class EqnSystem:
    def __init__(self, left: str, right: str) -> None:
        left_expr, left_syms = parse_real(left)
        right_expr, right_syms = parse_real(right)
        self.equation = Equality(left_expr, right_expr)
        self.symbols = left_syms | right_syms

    def solve(self, **kwargs: float) -> float:
        unknown, = self.symbols.keys() - kwargs.keys()
        solved, = solve(self.equation, self.symbols[unknown])
        value = solved.subs({
            self.symbols[k]: known
            for k, known in kwargs.items()
        })
        return float(value)


DENSITY = EqnSystem('p', 'm/v')
SPEED = EqnSystem('s', 'u + a*t')


def test() -> None:
    p = DENSITY.solve(m=1.23, v=1.66)
    print(f'density: {p:.2f}')

    s = SPEED.solve(u=3, a=4, t=5)
    print(f'speed: {s:.2f}')


if __name__ == '__main__':
    test()