formulon-physics 0.1.3__tar.gz

formulon_physics-0.1.3/.gitignore

@@ -0,0 +1,16 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.egg-info/
+
+# Build artifacts
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+
+# OS
+.DS_Store

formulon_physics-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SRIKALEESWARAR-S
+
+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, 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.

formulon_physics-0.1.3/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026-present SRIKALEESWARAR-S <srikaleeswarar675@gmail.com>
+
+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, 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.

formulon_physics-0.1.3/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.1
+Name: formulon-physics
+Version: 0.1.3
+Summary: An open-source Python library offering classical physics formulas with automatic input validation and NumPy support.
+Project-URL: Documentation, https://github.com/SRIKALEESWARAR-S/formulon#readme
+Project-URL: Issues, https://github.com/SRIKALEESWARAR-S/formulon/issues
+Project-URL: Source, https://github.com/SRIKALEESWARAR-S/formulon
+Author-email: SRIKALEESWARAR-S <srikaleeswarar675@gmail.com>
+License: MIT
+License-File: LICENSE
+License-File: LICENSE.txt
+Keywords: education,formulas,numpy,physics,science
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.20
+Description-Content-Type: text/markdown
+
+
+# formulon
+
+[![PyPI - Version](https://img.shields.io/pypi/v/formulon.svg)](https://pypi.org/project/formulon)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/formulon.svg)](https://pypi.org/project/formulon)
+[![License](https://img.shields.io/pypi/l/formulon.svg)](https://spdx.org/licenses/MIT.html)
+
+**formulon** is a lightweight, open-source Python library that provides commonly used
+**classical physics formulas** with automatic input validation.This project is designed 
+and developed by SRI KALEESWARAR S, a Physics post graduate student from India.Its a 
+open source,free to use library.I thank my professors from Scott Christian college, special mention to 
+Kaniyam.com and open science labs
+
+It is designed for **students, educators, and scientific Python users**, with support
+for both scalar and NumPy-based vector calculations.
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Features](#features)
+- [License](#license)
+
+---
+
+## Installation
+
+Install formulon from PyPI:
+
+```bash
+pip install formulon
+
+## License
+
+formulon is distributed under the terms of the MIT License.
+
+MIT License (Summary)
+
+Free to use, modify, and distribute
+
+Permitted for commercial and academic use
+
+Provided without warranty
+
+Full license text:
+https://spdx.org/licenses/MIT.html
+>>>>>>> 0350b6d (Welcome,Im born now)

formulon_physics-0.1.3/README.md

@@ -0,0 +1,49 @@
+
+# formulon
+
+[![PyPI - Version](https://img.shields.io/pypi/v/formulon.svg)](https://pypi.org/project/formulon)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/formulon.svg)](https://pypi.org/project/formulon)
+[![License](https://img.shields.io/pypi/l/formulon.svg)](https://spdx.org/licenses/MIT.html)
+
+**formulon** is a lightweight, open-source Python library that provides commonly used
+**classical physics formulas** with automatic input validation.This project is designed 
+and developed by SRI KALEESWARAR S, a Physics post graduate student from India.Its a 
+open source,free to use library.I thank my professors from Scott Christian college, special mention to 
+Kaniyam.com and open science labs
+
+It is designed for **students, educators, and scientific Python users**, with support
+for both scalar and NumPy-based vector calculations.
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Features](#features)
+- [License](#license)
+
+---
+
+## Installation
+
+Install formulon from PyPI:
+
+```bash
+pip install formulon
+
+## License
+
+formulon is distributed under the terms of the MIT License.
+
+MIT License (Summary)
+
+Free to use, modify, and distribute
+
+Permitted for commercial and academic use
+
+Provided without warranty
+
+Full license text:
+https://spdx.org/licenses/MIT.html
+>>>>>>> 0350b6d (Welcome,Im born now)

formulon_physics-0.1.3/formulon/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SRIKALEESWARAR-S
+
+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, 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.

formulon_physics-0.1.3/formulon/README.md

@@ -0,0 +1 @@
+# formulon

formulon_physics-0.1.3/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "formulon-physics"
+version = "0.1.3"
+description = "An open-source Python library offering classical physics formulas with automatic input validation and NumPy support."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+keywords = ["physics", "formulas", "science", "education", "numpy"]
+authors = [
+  { name = "SRIKALEESWARAR-S", email = "srikaleeswarar675@gmail.com" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Education",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "numpy>=1.20",
+]
+
+[project.urls]
+Documentation = "https://github.com/SRIKALEESWARAR-S/formulon#readme"
+Issues = "https://github.com/SRIKALEESWARAR-S/formulon/issues"
+Source = "https://github.com/SRIKALEESWARAR-S/formulon"
+
+
+[tool.hatch.envs.types]
+extra-dependencies = [
+  "mypy>=1.0.0",
+]
+
+[tool.hatch.envs.types.scripts]
+check = "mypy --install-types --non-interactive {args:src/formulon tests}"
+
+[tool.coverage.run]
+source_pkgs = ["formulon", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/formulon/__about__.py",
+]
+
+[tool.coverage.paths]
+formulon = ["src/formulon", "*/formulon/src/formulon"]
+tests = ["tests", "*/formulon/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]
+

formulon_physics-0.1.3/src/formulon/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2026-present SRIKALEESWARAR-S <srikaleeswarar675@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+__version__ = "0.1.0"

formulon_physics-0.1.3/src/formulon/__init__.py

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2026-present SRIKALEESWARAR-S <srikaleeswarar675@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+"""
+formulon
+========
+
+An open-source Python library providing classical physics formulas with
+automatic input validation and NumPy support.
+
+Designed for educational, scientific, and engineering use.
+"""
+
+from .__about__ import __version__
+
+# --- Public physics formula modules ---
+from .classicalphysics import *
+
+# --- Public API ---
+__all__ = [
+    "__version__",
+]
+

formulon_physics-0.1.3/src/formulon/classical_physics.py

@@ -0,0 +1,842 @@
+import numpy as np
+from .error_handler import validator
+__all__ = [
+
+  "velocity",
+  "acceleration",
+  "velocity_at_const_accelaration",
+  "second_law_motion",
+  "final_velocity",
+  "kinematics_displacement",
+  "initial_velocity",
+  "average_acceleration",
+  "kinematics_time",
+  "average_velocity",
+  "average_speed",
+  "angular_frequency",
+  "alpha",
+  "linear_velocity",
+  "force",
+  "weight",
+  "momentum",
+  "force_momentum",
+  "arc_length",
+  "inertia"
+
+
+
+
+
+]
+
+@validator("x","t")
+def velocity(x,t):
+  """
+   Compute velocity from position and time.
+
+For scalar inputs, velocity is calculated as v = x / t.
+For iterable inputs, velocity is computed using finite differences:
+v = Δx / Δt.
+
+Parameters
+----------
+x : float or array-like
+    Position value(s).
+t : float or array-like
+    Time value(s).
+
+Returns
+-------
+float or numpy.ndarray
+    Velocity value(s).
+
+Raises
+------
+ValueError
+    If time or time differences are zero.
+ValueError
+    If input arrays have mismatched lengths.
+
+  """
+  #varibles with single value
+  if isinstance(x, (int, float)) and isinstance(t, (int, float)):
+         if t == 0:
+            raise ValueError("Time cannot be zero")
+         return x / t
+
+    # Case 2: iterables
+  x = np.array(x, dtype=float)
+  t = np.array(t, dtype=float)
+
+  if x.shape != t.shape:
+        raise ValueError("Position and time must have the same length")
+
+  dx = np.diff(x)
+  dt = np.diff(t)
+
+  if np.any(dt == 0):
+        raise ValueError("Time difference cannot be zero")
+
+  velocities = dx / dt
+  return velocities
+@validator("v","t")
+def acceleration(v,t):
+    """
+     Compute acceleration from velocity and time.
+
+For scalar inputs, acceleration is calculated as a = v / t.
+For iterable inputs, acceleration is computed using finite differences:
+a = Δv / Δt.
+
+Parameters
+----------
+v : float or array-like
+    Velocity value(s).
+t : float or array-like
+    Time value(s).
+
+Returns
+-------
+float or numpy.ndarray
+    Acceleration value(s).
+
+Raises
+------
+ValueError
+    If time or time differences are zero.
+TypeError
+    If input arrays have mismatched lengths.
+  
+    """
+    if isinstance(v,(int,float)) and isinstance(t,(int,float)):
+        if t == 0:
+            raise ValueError("The Time values can not be zero")
+        return v/t
+    #case :2 iterables
+    v = np.array(v,dtype=float)
+    t = np.array(t,dtype=float)
+    if v.shape != t.shape:
+        raise TypeError("The arguments should have the same length")
+    dv = np.diff(v)
+    dt = np.diff(t)
+    if np.any(dt == 0):
+        raise ValueError("The time arguments should not be equal to zero")
+    accelarations = dv/dt
+    return accelarations
+@validator("u","a","t")
+def velocity_at_const_accelaration(u,a,t):
+    """ 
+      Compute final velocity under constant acceleration.
+
+Uses the kinematic equation:
+v = u + at
+
+Parameters
+----------
+u : float or array-like
+    Initial velocity.
+a : float or array-like
+    Constant acceleration.
+t : float or array-like
+    Time interval.
+
+Returns
+-------
+float or numpy.ndarray
+    Final velocity.
+
+Raises
+------
+ValueError
+    If any input value is zero or negative.
+TypeError
+    If input arrays have mismatched lengths.
+    """
+    
+    if isinstance (t,(int,float)) and isinstance(a,(int,float)) and isinstance(u,(int,float)):
+        if t <= 0:
+            raise ValueError("the values can not be zero at this point")
+        return u+(a*t)
+    u = np.array(u,dtype=float)
+    t = np.array(t,dtype=float)
+    a = np.array(a,dtype=float)
+    if u.shape != t.shape or u.shape != a.shape:
+        raise TypeError("All the files should have the same length")
+    if t <= 0:
+      raise v
+    velocity = u+(t*a)
+    return velocity
+@validator("u","a","t")
+def second_law_motion(u,a,t):
+  """
+  Compute displacement using the second equation of motion.
+
+Uses the formula:
+s = ut + (1/2)at²
+
+Parameters
+----------
+u : float or array-like
+    Initial velocity.
+a : float or array-like
+    Acceleration.
+t : float or array-like
+    Time.
+
+Returns
+-------
+float or numpy.ndarray
+    Displacement.
+
+Raises
+------
+ValueError
+    If any input value is zero or negative.
+TypeError
+    If input arrays have mismatched lengths.
+    """
+   if isinstance (t,(int,float)) and isinstance(a,(int,float)) and isinstance(u,(int,float)):
+        if t <= 0 or a <= 0 or u <= 0:
+            raise ValueError("the values can not be zero at this point")
+        return u*t + (0.5*a*t**2)
+   u = np.array(u,dtype=float)
+   t = np.array(t,dtype=float)
+   a = np.array(a,dtype=float)
+   if u.shape != t.shape or u.shape != a.shape:
+        raise TypeError("All the files should have the same length")
+   if any(u <= 0) or any(t <= 0) or any(a<= 0 ):
+       raise ValueError("The arguments should not be less than or equal to zero at any point")
+   motion = u*t + (0.5*a*t**2)
+   return motion
+@validator("s","u","a")
+def final_velocity(s,u,a):
+    """
+    Compute final velocity using the third equation of motion.
+
+Uses the formula:
+v² = u² + 2as
+
+Parameters
+----------
+s : float or array-like
+    Displacement.
+u : float or array-like
+    Initial velocity.
+a : float or array-like
+    Acceleration.
+
+Returns
+-------
+float or numpy.ndarray
+    Final velocity (or velocity squared for arrays).
+
+Raises
+------
+ValueError
+    If any input value is zero or negative.
+TypeError
+    If input arrays have mismatched lengths.
+    
+    """
+    if isinstance(s,(int,float)) and isinstance(u,(int,float)) and isinstance(a,(int,float)):
+        if s <= 0 or u <= 0 or a <=0:
+            raise ValueError("The values can not be less than or equal to zero")
+        v = u**2 + 2*a*s
+        return np.sqrt(v)
+    s = np.array(s,dtype=float)
+    u = np.array(u,dtype=float)
+    a = np.array(a,dtype=float)
+    if s.shape != u.shape or u.shape != a.shape:
+        raise TypeError("The values should be in the same length")
+    final_velocitys = np.sqrt(u**2 + 2*a*s)
+    return final_velocitys
+def kinematics_displacement(u,v,t):
+  """
+  Compute displacement using average velocity.
+
+Uses the formula:
+s = (u + v)t / 2
+
+Parameters
+----------
+u : float or array-like
+    Initial velocity.
+v : float or array-like
+    Final velocity.
+t : float or array-like
+    Time.
+
+Returns
+-------
+float or numpy.ndarray
+    Displacement.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+TypeError
+    If input arrays have mismatched lengths.
+  """
+    if isinstance(u,(int,float)) and isinstance(v,(int,float)) and isinstance(t,(int,float)):
+        if u < 0 or v <= 0 or t == 0:
+            raise ValueError("The input data values seems like having low or negative values")
+        return (u+v)*t/2
+    u = np.array(u,dtype=float)
+    v = np.array(v,dtype=float)
+    t = np.array(t,dtype=float)
+    if u.shape != v.shape or u.shape != t.shape:
+        raise TypeError("The arguments should have the same length")
+    if any(u <= 0) or any(v <= 0) or any(t <= 0):
+        raise ValueError("The values should not be less than or equal to zero")
+    displacement = (u+v)*t/2
+    return displacement
+@validator("v","a","t")
+def initial_velocity(v,a,t):
+
+   """
+Compute initial velocity from final velocity, acceleration, and time.
+
+Uses the formula:
+u = v − at
+
+Parameters
+----------
+v : float or array-like
+    Final velocity.
+a : float or array-like
+    Acceleration.
+t : float or array-like
+    Time.
+
+Returns
+-------
+float or numpy.ndarray
+    Initial velocity.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+TypeError
+    If input arrays have mismatched lengths.
+"""
+
+    if isinstance(v,(int,float)) and isinstance(a,(int,float)) and isinstance(t,(int,float)):
+        if v <= 0 or t<= 0 or a <= 0:
+            raise ValueError("The arguments can not be zero or negative")
+        return v-a*t
+    v,a,t = np.array(v,dtype=float),np.array(a,dtype=float),np.array(t,dtype=float)
+    if v.shape != a.shape or v.shape != t.shape:
+      raise TypeError("The arguments should have the same length")
+    if any(v <= 0) or any(t <= 0) or any(a <= 0):
+        raise ValueError("The arguments should not be less than or equal to zero")
+    velocity = v-a*t
+    return velocity
+def average_acceleration(v,u,t):
+   """
+Compute average acceleration.
+
+Uses the formula:
+a = (v − u) / t
+
+Parameters
+----------
+v : float or array-like
+    Final velocity.
+u : float or array-like
+    Initial velocity.
+t : float or array-like
+    Time interval.
+
+Returns
+-------
+float or numpy.ndarray
+    Average acceleration.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+TypeError
+    If input arrays have mismatched lengths.
+"""
+
+    if isinstance(v,(int,float)) and isinstance(u,(int,float)) and isinstance(t,(int,float)):
+        if t <= 0 or v < 0 or u < 0:
+            raise ValueError("the arguments should not be zero or negative value")
+        return (v-u)/t
+    v,u,t = np.array(v,dtype=float),np.array(u,dtype=float),np.array(t,dtype=float)
+    if v.shape != u.shape or v.shape != t.shape:
+        raise TypeError("The arguments should have the same length")
+    if np.any(v <= 0) or np.any(t <= 0) or np.any(u <= 0):
+        raise ValueError("The arguments should not be less than or equal to zero")
+    acceleration = (v-u)/t
+    return acceleration
+@validator("v","u","a")
+def kinematics_time(v,u,a):
+    """
+Compute time using velocity and acceleration.
+
+Uses the formula:
+t = (v − u) / a
+
+Parameters
+----------
+v : float or array-like
+    Final velocity.
+u : float or array-like
+    Initial velocity.
+a : float or array-like
+    Acceleration.
+
+Returns
+-------
+float or numpy.ndarray
+    Time.
+
+Raises
+------
+ValueError
+    If inputs contain negative values.
+"""
+
+    if isinstance(v,(int,float)) and isinstance(u,(int,float) and isinstance(a,(int,float)):
+        if v < 0 or u < 0 or a < 0:
+            raise ValueError("Theres a negative value in the input, recheck ")
+        return (v-u)/a
+    if hasattr(v,"__iter__") and hasattr(u,"__iter__") and hasattr(a,"__iter__"):
+        v_list,u_list,a_list = v,u,a
+        if any(v_list <= 0) or any(u_list <= 0) or any(a_list <= 0):
+            raise ValueError("The values should not be zero")
+        return (v_list-u_list)/a_list
+@validator("distance","time")
+def average_velocity(distance,time):
+    """
+Compute average velocity.
+
+Uses the formula:
+v_avg = distance / time
+
+Parameters
+----------
+distance : float or array-like
+    Total displacement.
+time : float or array-like
+    Total time.
+
+Returns
+-------
+float or numpy.ndarray
+    Average velocity.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+"""
+
+    if isinstance(time,(int,float)) and isinstance(distance,(int,float)):
+        if time <= 0 or distance <= 0:
+            raise ValueError("I think some values seems like zero or negative")
+        return distance/time
+    if hasattr(time,"__iter__") and hasattr(distance,"__iter__"):
+        t_list,d_list = time,distance
+        if any(t_list <= 0) or any(d_list <= 0):
+            raise ValueError("I think some values seems like zero or negative")
+        return d_list/t_list
+
+@validator("distance","time")
+def average_speed(distance,time):
+    """
+Compute average speed.
+
+Uses the formula:
+speed = distance / time
+
+Parameters
+----------
+distance : float or array-like
+    Total distance travelled.
+time : float or array-like
+    Time taken.
+
+Returns
+-------
+float or numpy.ndarray
+    Average speed.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+"""
+
+    if isinstance(distance,(int,float)) and isinstance(time,(int,float)):
+        if distance <= 0 or time <= 0:
+            raise ValueError("I think youre entered a lower value")
+        return distance/time
+    if hasattr(distance,"__iter__") and hasattr(time,"__iter__"):
+        d_list,t_list = distance,time
+        if np.any(d_list <= 0) or np.any(t_list <= 0):
+            raise ValueError("I think you have entered a low value")
+        return d_list/t_list
+@validator("theta","time")
+def angular_frequency(theta,time):
+    """
+Compute angular frequency.
+
+Uses the formula:
+ω = θ / t
+
+Parameters
+----------
+theta : float or array-like
+    Angular displacement in degrees.
+time : float or array-like
+    Time interval.
+
+Returns
+-------
+float or numpy.ndarray
+    Angular frequency.
+
+Raises
+------
+ValueError
+    If theta is outside 0–360 degrees or time is negative.
+"""
+
+    if isinstance(theta,(int,float)) and isinstance(time,(int,float)):
+        if theta > 360 or time < 0 or theta < 0:
+            raise ValueError("Theres a value error please check the values")
+        return theta/time
+    if hasattr(theta,"__iter__") and hasattr(time,"__iter__"):
+        t_list,theta_list = time,theta
+        for ti in t_list:
+            if ti < 0:
+                raise ValueError("Theres some low values. check")
+        for di in theta_list:
+            if di < 0 or di > 360:
+                raise ValueError("The theta values should be from 0 to 360")
+        return theta_list/t_list
+@validator("omega","time")
+def alpha(omega,time):
+    """
+Compute angular acceleration.
+
+Uses the formula:
+α = Δω / Δt
+
+Parameters
+----------
+omega : float or array-like
+    Angular velocity.
+time : float or array-like
+    Time.
+
+Returns
+-------
+float or numpy.ndarray
+    Angular acceleration.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+"""
+
+    if isinstance(omega,(int,float)) and isinstance(time,(int,float)):
+        if omega <= 0 or time <= 0:
+            raise ValueError("The arguments should not be less than zero")
+        return omega/time
+    if hasattr(omega,"__iter__") and hasattr(time,"__iter__"):
+        omega_list,t_list = list(omega),list(time)
+        if len(omega_list) != len(t_list):
+           raise IndexError("Both of the arguments have the same length")
+        if np.any(omega_list <= 0) or np.any(t_list <= 0):
+            raise("Value ERROR due to low value arguments")
+           
+        alphas  = []
+        for i in range(len(omega_list) - 1):
+            da = omega_list[i + 1] - omega_list[i]
+            dt = t_list[i + 1] - t_list[i]
+            alphas.append(da/dt)
+
+        return alphas
+@validator("v","w")
+def linear_velocity(r,w):
+    """
+Compute linear velocity from angular velocity.
+
+Uses the formula:
+v = rω
+
+Parameters
+----------
+r : float or array-like
+    Radius.
+w : float or array-like
+    Angular velocity.
+
+Returns
+-------
+float or numpy.ndarray
+    Linear velocity.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+"""
+
+    if isinstance(r,(int,float)) and isinstance(w,(int,float)):
+        if r <= 0 or w <= 0:
+            raise ValueError("The values should be greater than 0")
+        return r*w
+    if hasattr(r,"__iter__") and hasattr(w,"__iter__"):
+        r_list,w_list = list(r),list(w)
+        if np.any(r_list <= 0) or np.any(w_list <= 0):
+                raise ValueError("The values cant be less than or equal to zero")
+        l_velo = []
+        l_velo.append(r_list*w_list)#has to revise the code in the next version
+        return l_velo#runtime issues
+@validator("m","a")
+def force(m,a):
+    """
+Compute force using Newton’s second law.
+
+Uses the formula:
+F = ma
+
+Parameters
+----------
+m : float or array-like
+    Mass.
+a : float or array-like
+    Acceleration.
+
+Returns
+-------
+float or numpy.ndarray
+    Force.
+
+Raises
+------
+ValueError
+    If inputs contain negative values.
+"""
+
+    if isinstance(m,(int,float)) and isinstance(a,(int,float)):
+        if m < 0 or a < 0:
+            raise ValueError("This values should be greater than 0")
+        return m*a
+    
+    m_arr = np.array(m,dtype = float)
+    a_arr = np.array(a,dtype=float)
+
+    if m_arr.shape != a_arr.shape:
+        raise ValueError("Both must have same length")
+    if np.any(m_arr <= 0) or np.any(a_arr <= 0):
+        raise ValueError("None of the value should be zero or negative")
+    return m_arr*a_arr
+validator("m","g")
+def weight(m, g):
+    """
+    Compute force using the formula:
+    momentum = m × g
+
+    Parameters
+    ----------
+    m : float or list/array of float
+        Mass in kilograms (kg)
+    g : float or list/array of float
+        gravity
+
+    Returns
+    -------
+    float or numpy.ndarray
+       weight in (kg)
+    """
+
+    # Scalar case
+    if isinstance(m, (int, float)) and isinstance(g, (int, float)):
+        if m <= 0 or g <= 0:
+            raise ValueError("Mass and acceleration must be positive values")
+        return m * g
+
+    # Array case
+    m_arr = np.array(m, dtype=float)
+    g_arr = np.array(g, dtype=float)
+
+    if m_arr.shape != g_arr.shape:
+        raise ValueError("Mass and acceleration must have the same length")
+
+    if np.any(m_arr <= 0) or np.any(g_arr <= 0):
+        raise ValueError("All values must be positive")
+
+    return m_arr * g_arr 
+@validator("m","v")
+def momentum(m, v):
+    """
+    Compute force using the formula:
+    momentum = m × v
+
+    Parameters
+    ----------
+    m : float or list/array of float
+        Mass in kilograms (kg)
+    v : float or list/array of float
+        velocity (m/s)
+
+    Returns
+    -------
+    float or numpy.ndarray
+        momentum in (kg·m/s)
+    """
+
+    # Scalar case
+    if isinstance(m, (int, float)) and isinstance(v, (int, float)):
+        if m <= 0 or v <= 0:
+            raise ValueError("Mass and velocity must be positive values")
+        return m * v
+
+    # Array case
+    m_arr = np.array(m, dtype=float)
+    v_arr = np.array(v, dtype=float)
+
+    if m_arr.shape != v_arr.shape:
+        raise ValueError("Mass and velocity must have the same length")
+
+    if np.any(m_arr <= 0) or np.any(v_arr <= 0):
+        raise ValueError("All values must be positive")
+
+    return m_arr * v_arr
+@validator("p","t")
+def force_momentum(p, t):
+    """
+Compute force from rate of change of momentum.
+
+Uses the formula:
+F = dp / dt
+
+Parameters
+----------
+p : float or array-like
+    Momentum.
+t : float or array-like
+    Time interval.
+
+Returns
+-------
+float or numpy.ndarray
+    Force.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+"""
+
+
+    # Scalar case
+    if isinstance(p, (int, float)) and isinstance(t, (int, float)):
+        if p <= 0 or t <= 0:
+            raise ValueError("values must be greater than zero")
+
+        
+        return p / t
+
+    # Iterable case
+    p_arr = np.array(p, dtype=float)
+    t_arr = np.array(t, dtype=float)
+
+    if p_arr.shape != t_arr.shape:
+        raise ValueError("momentum and time must have same length")
+
+    if np.any(p_arr <= 0) or np.any(t_arr <= 0):
+        raise ValueError("both should be greater than 0")
+
+   
+
+   
+    return p_arr / t_arr
+@validator("r","theta")
+def arc_length(r,theta):
+    """
+Compute arc length of a circle.
+
+Uses the formula:
+s = rθ
+
+Parameters
+----------
+r : float or array-like
+    Radius.
+theta : float or array-like
+    Angle in degrees.
+
+Returns
+-------
+float or numpy.ndarray
+    Arc length.
+
+Raises
+------
+ValueError
+    If theta is outside 0–360 degrees.
+"""
+
+    if isinstance(r,(int,float)) and isinstance(theta,(int,float)):
+        if r <= 0 or theta < 0 or theta > 360:
+            raise ValueError("""The values should be greater than zero,
+                              and theta should be in the range of 0 to 360""")
+        theta_rad = np.deg2rad(theta)
+        return r*theta_rad
+    r_arr = np.array(r,dtype = float)
+    theta_arr = np.array(theta,dtype = float)
+    if theta_arr.shape != r_arr.shape:
+       raise ValueError("The both of the arguments should have same length")
+    if np.any(theta_arr < 0) or np.any(theta_arr > 360):
+        raise ValueError("Theta value must be in between 0 to 360")
+    theta_rad = np.deg2rad(theta_arr)
+    return r_arr*theta_rad
+@validator("m","r")
+def inertia(m,r):
+    """
+Compute moment of inertia of a point mass.
+
+Uses the formula:
+I = mr²
+
+Parameters
+----------
+m : float or array-like
+    Mass.
+r : float or array-like
+    Radius.
+
+Returns
+-------
+float or numpy.ndarray
+    Moment of inertia.
+
+Raises
+------
+ValueError
+    If inputs contain zero or negative values.
+"""
+
+    if isinstance (m,(int,float)) and isinstance(r,(int,float)):
+        if m <= 0 or r <= 0:
+            raise ValueError("The values should not be less than or equal to 0")
+        return m*(r**2)
+    m_arr = np.array(m,dtype = float)
+    r_arr = np.array(r,dtype = float)
+    if m_arr.shape != r_arr.shape:
+        raise TypeError("The arguments should be in same length")
+    if np.any(m_arr <= 0) or np.any(r_arr <= 0):
+        raise ValueError("The arguments should be greater than 0")
+    return m_arr*(r_arr**2)
+    
+

formulon_physics-0.1.3/src/formulon/errorhandler.py

@@ -0,0 +1,31 @@
+import numpy as np
+def error_handler(x,name = "Value"):#finds 
+    """
+    """
+    if x is None:
+        raise ValueError(f"The input {name} arguments should not be None")
+    
+    if isinstance(x,str):# finds string input and empty string
+        if x == "":
+            raise ValueError("The values should not be a empty string")
+
+        raise TypeError(f"The {name} argument should not be string,it must be number")
+    if isinstance(x,tuple,list):
+        if len(x) == 0:
+            raise ValueError(f"The {name} list or tuple should not be zero")
+        x = np.array(x,dtype=float)
+    if isinstance(x,np.ndarray):
+        if x.size == 0:
+            raise ValueError(f"The {name} numpy array cant be zero")
+        if not np.all(np.isfinite(x)):
+            raise ValueError(f"The {name} values should be finite ")
+        return x
+    if isinstance(x, (int, float)):
+        if not np.isfinite(x):
+            raise ValueError(f"{name} contains NaN or Inf")
+        return x
+
+    # Anything else
+    raise TypeError(f"{name} has invalid type: {type(x)}")
+        
+

formulon_physics-0.1.3/tests/__init__.py

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2026-present SRIKALEESWARAR-S <srikaleeswarar675@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+"""
+formulon
+========
+
+An open-source Python library providing classical physics formulas with
+automatic input validation and NumPy support.
+
+Designed for educational, scientific, and engineering use.
+"""
+
+from .__about__ import __version__
+
+# --- Public physics formula modules ---
+from .classicalphysics import *
+
+# --- Public API ---
+__all__ = [
+    "__version__",
+]
+