algebraic-physics 0.1.0__py3-none-any.whl

algebraic_physics-0.1.0.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: algebraic-physics
+Version: 0.1.0
+Summary: A project for math and geometry formulas
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.4.6
+Dynamic: license-file
+
+# algebraic-physics
+
+A Python utility library for geometry and physics calculations based on the AP Physics 1 curriculum.
+
+This library provides automated functions to solve for unknown variables using standard introductory mechanics equations. It accepts numerical inputs for known physical quantities to compute values across kinematics, dynamics, energy, momentum, and rotational motion.
+
+## File Directory
+
+```text
+mathformulas/
+│
+├── .github/
+│   └── workflows/
+│       └── codeql.yml
+│
+├── assets/
+│   └── ...
+│
+├── src/
+│   ├── geometry/
+│   │   ├── __pycache__/
+│   │   └── geom.py
+│   │
+│   ├── physics/
+│   │   ├── __pycache__/
+│   │   └── mechanics.py
+│   │
+│   └── mathformulas.egg-info/
+│
+├── tests/
+│   └── make_cube.py
+│
+├── .env
+├── .gitignore
+├── LICENSE
+├── pyproject.toml
+├── README.md
+└── requirements.txt
+```
+
+## Tests Example
+
+The file 'make_cube.py' under tests/ utilizes a dictionary for holding shapes. The square uses 0.0 floats, and relies on mechanics.py functions for calculations.
+
+```python
+#make_cube.py
+import geometry.geom as gm
+import physics.mechanics as pm
+
+my_cube = {
+    "side": 4,    # Side length, note that this can be subbed out for the result of a distance formula between two coordinates
+    "mass": 10,   # Dummy mass
+    "volume": 0, 
+
+    "pos_x": 0.0, # Starts at coordinates (0,0)
+    "pos_y": 0.0,
+
+    "velocity_x": 0.0,
+    "velocity_y": 0.0,
+}
+...
+
+# Volume Calculation:
+my_cube["volume"] = gm.cube_volume(my_cube["side"])
+print(f'The volume is {my_cube["volume"]}')
+
+...
+
+# Physics Simulation:
+dt = 0.1                            # Timestep
+time = 0.0                          # Time that increases according to timestep
+max_time = 5.0                      # Dummy max_time, in a real simulation this would be undeclared until input
+current_acceleration = 1.0          # Dummy current_acceleration 
+speedy_boost = pm.speed_booster(1)  # Connects to a speed boost function in 'mechanics.py'
+
+while time < max_time:  
+    current_acceleration = pm.speed_booster(current_acceleration)
+
+    my_cube["velocity_x"] = pm.find_instantaneous_velocity(
+        my_cube["velocity_x"],
+        speedy_boost,
+        dt
+    )
+    time += dt
+```
+
+## Source Formulas
+
+![Mechanics and Fluids](assets/formulas.png)
+
+![Geometry/Conversion](assets/geometry.png)

algebraic_physics-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+algebraic_physics-0.1.0.dist-info/licenses/LICENSE,sha256=1WScu-2riEzRDTyZ2tlnLGzRwPRdiT7nqchLpbm25zE,1097
+geometry/__init__.py,sha256=FKPofqxR1ySrLIz2crjvfTWtkDQoni0pjj279JrcCR0,180
+geometry/geom.py,sha256=3uzjohelTDfe3IHrLpOTT5zP1RraJQi6TKN4MZ9o8LE,1026
+physics/__init__.py,sha256=4dSd6eHo5aaeNsxfSgpQBeR-alcevrPMrHwbyrlGp2o,326
+physics/mechanics.py,sha256=m9zgopBUIUvVYQVnxt-njnrJj-8A7yILq1YayzaDYU0,2274
+algebraic_physics-0.1.0.dist-info/METADATA,sha256=Oy8Ef64nadi_898zBcid7jkMz9raHzpor_mWAX7B0Hg,2821
+algebraic_physics-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+algebraic_physics-0.1.0.dist-info/top_level.txt,sha256=Z3yZYLPodyiWulcohbHUWaAHwuNVWAFvj9IiqfrUlGo,17
+algebraic_physics-0.1.0.dist-info/RECORD,,

algebraic_physics-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

algebraic_physics-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Caleb Brooks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

algebraic_physics-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+geometry
+physics

geometry/__init__.py

@@ -0,0 +1,11 @@
+from .geom import (
+    rectangle_area,
+    cube_volume,
+    triangle_area,
+    circle,
+    rectangular_solid,
+    cylinder,
+    sphere,
+    arc_relations,
+    pythag
+)

geometry/geom.py

@@ -0,0 +1,54 @@
+import numpy as np
+
+gravity_m3 = 6.67 * 10**-11
+
+one_atm = 1.0 * 10**5
+
+
+def rectangle_area(length, width):
+    return length * width
+
+
+def cube_volume(side_length):
+    volume = side_length**3
+    return volume
+
+
+def triangle_area(base, height):
+    return 0.5 * base * height
+
+
+def circle(radius):
+    area = np.pi * (radius**2)
+    circumference = 2 * np.pi * radius
+
+    return area, circumference
+
+
+def rectangular_solid(length, width, height):
+    volume = length * width * height
+
+    return volume
+
+
+def cylinder(radius, length):
+    volume = np.pi * (radius**2) * length
+    surface_area = (2 * np.pi * radius * length) + (2 * np.pi * (radius**2))
+
+    return volume, surface_area
+
+
+def sphere(radius):
+    volume = 4/3 * np.pi * (radius**3)
+    surface_area = 4 * np.pi * (radius**2)
+    return volume, surface_area
+
+
+def arc_relations(r, theta):
+    s = r*theta
+    return s
+
+
+def pythag(side1, side2):
+    side3 = (side1**2 + side2**2)**(1/2)
+    return side3

physics/__init__.py

@@ -0,0 +1,15 @@
+from .mechanics import (
+    find_instantaneous_velocity,
+    find_position,
+    find_velocity_squared,
+    center_of_mass,
+    total_acceleration,
+    newtons_law_of_universal_gravitation,
+    kinetic_energy,
+    work,
+    delta_ke,
+    momentum,
+    centripetal_acceleration,
+    density,
+    speed_booster
+)

physics/mechanics.py

@@ -0,0 +1,113 @@
+import numpy as np
+import geometry.geom as geom
+
+# #1
+
+
+def find_instantaneous_velocity(initial_velocity, acceleration, time):
+
+    v_x = initial_velocity + (acceleration * time)
+    return v_x
+
+# #2
+
+
+def find_position(inital_position, initial_velocity, time, current_acceleration):
+
+    x = inital_position + (initial_velocity*time) + \
+        ((1/2)*current_acceleration*(time**2))
+    return x
+
+# #3
+
+
+def find_velocity_squared(initial_velocity, acceleration, current_position, initial_position=0):
+    v_x_squared = initial_velocity**2 + 2 * \
+        acceleration * (current_position - initial_position)
+    return v_x_squared
+
+# example: [["Ball", 2, 5, forceof10righthere],["Block", 4, 6, forceof8righthere]]
+
+# #4
+
+
+def center_of_mass(list_of_object_lists):
+    top_part = 0
+    total_mass = 0
+    for obj in list_of_object_lists:
+        top_part += (obj[1]*obj[2])
+        total_mass += obj[1]
+
+    center_of_mass = float(top_part/total_mass)
+    return center_of_mass
+
+# #5
+
+
+def total_acceleration(list_of_object_lists):
+    top_part = 0
+    bottom_part = 0
+
+    for obj in list_of_object_lists:
+        top_part += obj[3]
+        bottom_part += obj[1]
+
+    total_acceleration = top_part/bottom_part
+    return total_acceleration
+
+# #6
+
+
+def newtons_law_of_universal_gravitation(mass1, mass2, radius):
+    attractive_force = geom.gravity_m3 * ((mass1 * mass2)/(radius**2))
+    return attractive_force
+
+# #10
+
+
+def kinetic_energy(mass, velocity):
+    KE = (1/2) * mass * (velocity**2)
+    return KE
+
+# #11
+
+
+def work(force, distance, angle):
+
+    if isinstance(angle, float) or isinstance(angle, int):
+        angle = np.radians(angle)
+
+    work = (force * distance) * np.cos(angle)
+    return work
+
+# #12
+
+
+def delta_ke(*work):
+    return sum(work)
+
+# #16
+
+
+def momentum(mass, velocity):
+    momentum = mass * velocity
+
+    return momentum
+
+# #9
+
+
+def centripetal_acceleration(velocity, radius):
+    centripetal_acceleration = (velocity**2)/radius
+    return centripetal_acceleration
+
+
+def density(mass, volume):
+    density = mass/volume
+    return density
+
+
+def speed_booster(scalar):
+    if scalar < 1000:
+        scalar += 1
+    return scalar