SciMatic 1.0.0__tar.gz

scimatic-1.0.0/LICENSE

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

scimatic-1.0.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: SciMatic
+Version: 1.0.0
+Summary: A Python library for mathematics, science calculations, and experimental mathematical functions.
+Author: TheCursedOne
+License: MIT License
+        
+        Copyright (c) 2026 TheCursedOne
+        
+        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.
+        
+Project-URL: Repository, https://github.com/bingchiliingsacker-dot/SciMatic
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# SciMatic
+
+**SciMatic** is a **lightweight** and **readable**, python-only library that focuses on mathematics and scientific concepts such as **algebra, momentum and impulse, statistics, and many more** will be added.
+
+# Features
+
+## Algebra.py
+•Quadratic Equations/Inequalities
+
+•Pythagorean Theorem
+
+## convenient_utils.py
+•General-use parser(can be used for non-math related activities)
+
+•Operator - A type annotation.
+
+## errors.py
+•CaseError - For if someone tried a case that is out of the list of cases.
+
+•TrigonometryError - If no real triangle is formed, raise this.
+
+•NegativeDiscriminantError - Raises if a quadratic formulas discriminant is less than 0.
+
+•VariableError - If a > 0, raise this.
+
+•ComparisonError - If the value is not a comparison, this error is raised.
+
+•ConstantError - If the statistics k is not in the range of possible k.
+
+•DataError - If a data array is too short for process, raise this.
+
+•ModeError - For the parser. Raises if the chosen mode is not in the modes array.
+
+## statistics.py
+•Quartiles
+
+•Deciles
+
+•Percentiles
+
+•Median
+
+## Geometry.py
+•The Law of Sine
+
+•The Law of Cosine
+
+## niche.py
+•Fibonacci sequence
+
+•Collatz Conjecture
+
+•Ackermann Function
+
+# Scientific
+- A branch of SciMatic that does scientific calculations
+
+## mechanics.py
+•momentum - calculates momentum
+
+•Impulse - calculates impulse

scimatic-1.0.0/README.md

@@ -0,0 +1,61 @@
+# SciMatic
+
+**SciMatic** is a **lightweight** and **readable**, python-only library that focuses on mathematics and scientific concepts such as **algebra, momentum and impulse, statistics, and many more** will be added.
+
+# Features
+
+## Algebra.py
+•Quadratic Equations/Inequalities
+
+•Pythagorean Theorem
+
+## convenient_utils.py
+•General-use parser(can be used for non-math related activities)
+
+•Operator - A type annotation.
+
+## errors.py
+•CaseError - For if someone tried a case that is out of the list of cases.
+
+•TrigonometryError - If no real triangle is formed, raise this.
+
+•NegativeDiscriminantError - Raises if a quadratic formulas discriminant is less than 0.
+
+•VariableError - If a > 0, raise this.
+
+•ComparisonError - If the value is not a comparison, this error is raised.
+
+•ConstantError - If the statistics k is not in the range of possible k.
+
+•DataError - If a data array is too short for process, raise this.
+
+•ModeError - For the parser. Raises if the chosen mode is not in the modes array.
+
+## statistics.py
+•Quartiles
+
+•Deciles
+
+•Percentiles
+
+•Median
+
+## Geometry.py
+•The Law of Sine
+
+•The Law of Cosine
+
+## niche.py
+•Fibonacci sequence
+
+•Collatz Conjecture
+
+•Ackermann Function
+
+# Scientific
+- A branch of SciMatic that does scientific calculations
+
+## mechanics.py
+•momentum - calculates momentum
+
+•Impulse - calculates impulse

scimatic-1.0.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ['setuptools>=61']
+build-backend = 'setuptools.build_meta'
+
+[project]
+name = 'SciMatic'
+version = '1.0.0'
+description = 'A Python library for mathematics, science calculations, and experimental mathematical functions.'
+readme = 'README.md'
+requires-python = '>=3.9'
+license = {file = 'LICENSE'}
+
+authors = [
+    {name = 'TheCursedOne'}
+]
+
+[project.urls]
+Repository = 'https://github.com/bingchiliingsacker-dot/SciMatic'

scimatic-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scimatic-1.0.0/src/SciMatic.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: SciMatic
+Version: 1.0.0
+Summary: A Python library for mathematics, science calculations, and experimental mathematical functions.
+Author: TheCursedOne
+License: MIT License
+        
+        Copyright (c) 2026 TheCursedOne
+        
+        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.
+        
+Project-URL: Repository, https://github.com/bingchiliingsacker-dot/SciMatic
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# SciMatic
+
+**SciMatic** is a **lightweight** and **readable**, python-only library that focuses on mathematics and scientific concepts such as **algebra, momentum and impulse, statistics, and many more** will be added.
+
+# Features
+
+## Algebra.py
+•Quadratic Equations/Inequalities
+
+•Pythagorean Theorem
+
+## convenient_utils.py
+•General-use parser(can be used for non-math related activities)
+
+•Operator - A type annotation.
+
+## errors.py
+•CaseError - For if someone tried a case that is out of the list of cases.
+
+•TrigonometryError - If no real triangle is formed, raise this.
+
+•NegativeDiscriminantError - Raises if a quadratic formulas discriminant is less than 0.
+
+•VariableError - If a > 0, raise this.
+
+•ComparisonError - If the value is not a comparison, this error is raised.
+
+•ConstantError - If the statistics k is not in the range of possible k.
+
+•DataError - If a data array is too short for process, raise this.
+
+•ModeError - For the parser. Raises if the chosen mode is not in the modes array.
+
+## statistics.py
+•Quartiles
+
+•Deciles
+
+•Percentiles
+
+•Median
+
+## Geometry.py
+•The Law of Sine
+
+•The Law of Cosine
+
+## niche.py
+•Fibonacci sequence
+
+•Collatz Conjecture
+
+•Ackermann Function
+
+# Scientific
+- A branch of SciMatic that does scientific calculations
+
+## mechanics.py
+•momentum - calculates momentum
+
+•Impulse - calculates impulse

scimatic-1.0.0/src/SciMatic.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/SciMatic.egg-info/PKG-INFO
+src/SciMatic.egg-info/SOURCES.txt
+src/SciMatic.egg-info/dependency_links.txt
+src/SciMatic.egg-info/top_level.txt
+src/scimatic/__init__.py
+src/scimatic/algebra.py
+src/scimatic/convenient_utils.py
+src/scimatic/errors.py
+src/scimatic/geometry.py
+src/scimatic/niche.py
+src/scimatic/statistics.py
+src/scimatic/scientific/mechanics.py

scimatic-1.0.0/src/SciMatic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

scimatic-1.0.0/src/SciMatic.egg-info/top_level.txt

@@ -0,0 +1 @@
+scimatic

scimatic-1.0.0/src/scimatic/__init__.py

@@ -0,0 +1,18 @@
+from . import algebra
+from . import geometry
+from . import statistics
+from . import convenient_utils
+from . import errors
+from . import niche
+from .scientific import mechanics
+
+'''
+SciMatic
+A lightweight Python library for
+mathematics, science calculations,
+anf experimental functions.
+'''
+
+__version__ = '1.0.0'
+__author__ = 'Th3Curs3dOn3'
+__license__ = 'MIT'

scimatic-1.0.0/src/scimatic/algebra.py

@@ -0,0 +1,166 @@
+import math
+from .errors import NegativeDiscriminantError, ComparisonError, VariableError
+from .convenient_utils import Operator
+
+def quadratic_equation(
+	a: int,
+	b: int,
+	c: int,
+	x: int,
+	print_result: bool = False
+) -> int | None:
+	
+	result = a * x**2 + b * x + c
+	
+	if print_result:
+		print(result)
+	return result
+		
+
+def quadratic_formula(
+	a: int,
+	b: int,
+	c: int,
+	print_result: bool = False,
+	vietas_formula: bool = False
+) -> int | None:
+	
+	discriminant = b**2 - 4 * a * c
+	
+	if discriminant < 0:
+		if print_result:
+			print('No real solution...')
+		else:
+			raise NegativeDiscriminantError('The given integers does not produce a real solution.')
+		return None
+	
+	x1 = (-b + math.sqrt(discriminant)) / (2 * a)
+	x2 = (-b - math.sqrt(discriminant)) / (2 * a)
+	
+	if print_result:
+		print(f'x = {x1}, x = {x2}')
+		if vietas_formula:
+			print(f'x1 + x2 = {x1 + x2}')
+	if vietas_formula:
+		return x1, x2, x1 + x2
+	
+	return x1, x2
+	
+def quadratic_inequality(
+	a: int,
+	b: int,
+	c: int,
+	symbol: Operator,
+	print_result: bool = False
+) -> int | None:
+	symbol_list = ['>', '<', '>=', '<=']
+	
+	if symbol not in symbol_list:
+		raise ComparisonError()
+		
+	if a == 0:
+		raise VariableError()
+
+	
+	discriminant = b**2 - 4 * a * c
+	
+	if discriminant < 0:
+		if print_result:
+			print('No real solution...')
+		else:
+			raise NegativeDiscriminantError()
+		return None
+	
+	elif discriminant == 0:
+		x = (-b + math.sqrt(discriminant)) / (2 * a)
+		
+		if print_result:
+			print('One real solution...')
+			print(f'x = {x}')
+		return x
+		
+	else:
+		x1 = (-b + math.sqrt(discriminant)) / (2 * a)
+		x2 = (-b - math.sqrt(discriminant)) / (2 * a)
+		
+		x1, x2 = sorted([x1, x2])
+		
+		parabola = a > 0
+	
+		def for_loop(x1, x2):
+			testpoint1 = x1 - 1
+			testpoint2 = (x1 + x2) / 2
+			testpoint3 = x2 + 1
+			test_points = [testpoint1, testpoint2, testpoint3]
+		  
+			torf = []
+
+			for point in test_points:
+				if symbol == '>':
+					torf.append((a * point**2 + b * point + c) > 0)
+				elif symbol == '<':
+					torf.append((a * point**2 + b * point + c) < 0)
+				elif symbol == '>=':
+					torf.append((a * point**2 + b * point + c) >= 0)
+				else:
+					torf.append((a * point**2 + b * point + c) <= 0)
+			
+			return torf
+		    
+		if parabola:
+			torf = for_loop(x1, x2)
+			
+			if symbol == '>':
+				answer = f'x < {x1} or x > {x2}'
+			elif symbol == '>=':
+				answer = f'x <= {x1} or x >= {x2}'
+			elif symbol == '<':
+				answer = f'{x1} < x < {x2}'
+			else:
+				answer = f'{x1} <= x <= {x2}'
+			
+			if print_result:
+				print(answer)
+			return answer
+			
+		else:
+			torf = for_loop(x1, x2)
+			
+			if symbol == '>':
+				answer = f'{x1} < x < {x2}'
+			elif symbol == '>=':
+				answer = f'{x1} <= x <= {x2}'
+			elif symbol == '<':
+				answer = f'x < {x1} or x > {x2}'
+			else:
+				answer = f'x <= {x1} or x >= {x2}'
+			
+			if print_result:
+				print(answer)
+			return answer
+			
+def pythagorean_theorem(
+	a: int | float,
+	b: int | float,
+	c: int | float | None = None,
+	print_result: bool = True
+) -> int | float | None:
+	
+	if c is not None:
+		c_square = a**2 + b**2
+		
+		if c**2 == (a**2 + b**2):
+			output = True
+		else:
+			output = False
+		
+		if print_result:
+			print(f'{c}^2 = {a}^2 + {b}^2')
+			print(output)
+		return output, c_square
+	
+	else:
+		c_square = math.sqrt(a**2 + b**2)
+		if print_result:
+			print(f'sqrt({a}^2 + {b}^2) = {c_square}')
+		return c_square

scimatic-1.0.0/src/scimatic/convenient_utils.py

@@ -0,0 +1,60 @@
+from typing import Literal
+from .errors import ModeError
+
+
+Operator = Literal['+', '-', '×', '•', '*', '^', '÷', '/', '//', '%', '!', '|', '(', ')', '<', '>', '<=', '>=', '==', '=', '!=', '≈', '≠']
+
+def parser(
+	raw_syntax: str,
+	mode: str = 'letter',
+	print_result: bool = True
+) -> list[int] | list[str] | None:
+	
+	modes = ['letter', 'word', 'token']
+	processor = []
+	output = []
+	token_output = []
+	word = ''
+	
+	if mode not in modes:
+		raise ModeError(f'Mode is not in modes: {modes}')
+	
+	for letter in raw_syntax:
+		processor.append(letter)
+	
+	if mode == modes[0]:
+		for p in processor:
+			if p == ' ':
+				continue
+			output.append(p)
+		
+	else:
+		for p in processor:
+			if p == ' ':
+				if word:
+					output.append(word)
+					word = ''
+				continue
+				
+			word += p
+		
+		if word:
+			output.append(word)
+		
+		if mode == modes[2]:
+			for o in output:
+				try:
+					syn = int(o)
+				except ValueError:
+					try:
+						syn = float(o)
+					except ValueError:
+						syn = o
+						
+				token_output.append(syn)
+			
+			output = token_output
+	
+	if print_result:
+		print(output)
+	return output

scimatic-1.0.0/src/scimatic/errors.py

@@ -0,0 +1,30 @@
+class CaseError(Exception):
+	def __init__(self, message='Case is not defined.'):
+		super().__init__(message)
+
+class TrigonometryError(Exception):
+	def __init__(self, message='No such valid triangle.'):
+		super().__init__(message)
+		
+class NegativeDiscriminantError(Exception):
+	def __init__(self, message='Type \'Discriminant\' is less than Zero. Therefore, equation has no real roots.'):
+		super().__init__(message)
+
+class VariableError(Exception):
+	def __init__(self, message='Variable is more than 0.'):
+		super().__init__(message)
+	
+class ComparisonError(Exception):
+	def __init__(self, message='Comparison operand not found.'):
+		super().__init__(message)
+		
+class ConstantError(Exception):
+	def __init__(self, message='Invalid constant.'):
+		super().__init__(message)
+		
+class DataError(Exception):
+	def __init__(self, message='Data cannot be used.'):
+		super().__init__(message)
+		
+class ModeError(Exception):
+	pass

scimatic-1.0.0/src/scimatic/geometry.py

@@ -0,0 +1,148 @@
+import math
+from .errors import CaseError, TrigonometryError
+
+
+def sin_law(
+	case: str,
+	a: int | float,
+	b: int | float,
+	c: int | float,
+	print_result: bool = False
+) -> int | float | list[dict[str, int | float]] | None:
+	
+	cases = ['SAA', 'AAS', 'ASA', 'SSA']
+	
+	if case not in cases:
+		raise CaseError(f'Parameter \'case\' must be: {cases}.')
+		
+	known_items = [a, b, c]
+	
+	for var in known_items:
+		if not isinstance(var, int) or isinstance(var, float):
+			raise ValueError('Invalid variables.')
+	
+	if case == cases[1]:
+		a, c = c, a
+		case = cases[0]
+	
+	if case == cases[0]:
+		B = 180 - (b + c)
+		
+		A = c
+		C = b
+		
+		sidec = (a * math.sin(math.radians(C))) / (math.sin(math.radians(A)))
+		
+		sideb = (a * math.sin(math.radians(B))) / (math.sin(math.radians(A)))
+		
+		if print_result:
+			print(f'Angle B: {B}, Side C: {sidec}, Side B: {sideb}')
+		return B, sidec, sideb
+	
+	elif case == cases[2]:
+		A = 180 - (a + c)
+		
+		B = c
+		C = a
+		
+		sidec = (b * math.sin(math.radians(C))) / (math.sin(math.radians(A)))
+		
+		sideb = (b * math.sin(math.radians(B))) / (math.sin(math.radians(A)))
+		
+		if print_result:
+			print(f'Angle B: {B}, Side C: {sidec}, Side B: {sideb}')
+		return B, sidec, sideb
+		
+	else:
+		A = c
+		
+		try:
+			B1 = math.degrees(math.asin((b * math.sin(math.radians(A))) / a))
+		except ValueError:
+			if print_result:
+				print('No real triangle is formed...')
+			else:
+				raise TrigonometryError
+			return
+		
+		B2 = 180 - B1
+		
+		valid_case = [False, False]
+		
+		if A + B1 < 180:
+			valid_case[0] = True
+		
+		if A + B2 < 180:
+			valid_case[1] = True
+			
+		output1 = []
+		output2 = []
+		
+		for i, triangle in enumerate(valid_case):
+			if not triangle:
+				continue
+			
+			B = B1 if i == 0 else B2
+			
+			C = 180 - (A + B)
+			
+			sideb = (a * math.sin(math.radians(B))) / (math.sin(math.radians(A)))
+			
+			if i == 0:
+				output1.append({
+				'angle B': B1, 
+				'angle C': C, 
+				'side b': sideb
+				})
+			else:
+				output2.append({
+				'angle B': B2, 
+				'angle C': C, 
+				'side b': sideb
+				})
+		
+		if print_result:
+			print(output1)
+			print(output2)
+		return output1, output2
+		
+
+def cos_law(
+	case: str,
+	a: int | float,
+	b: int | float,
+	c: int | float,
+	print_result: bool = False
+) -> int | float | None:
+	
+	cases = ['SSS', 'SAS']
+	
+	if case not in cases:
+		raise CaseError(f'Parameter \'case\' must be: {cases}.')
+		
+	known_items = [a, b, c]
+	
+	for var in known_items:
+		if not isinstance(var, (int, float)):
+			raise ValueError('Invalid variables.')
+	
+	if case == cases[0]:
+		A = math.degrees(math.acos((b**2 + c**2 - a**2) / (2 * b * c)))
+		B = math.degrees(math.acos((a**2 + c**2 - b**2) / (2 * a * c)))
+		C = 180 - (A + B)
+		
+		if print_result:
+			print(f'Angle A: {A}, Angle B: {B}, Angle C: {C}')
+		return A, B, C
+	
+	else:
+		C = b
+		sidec = math.sqrt(a**2 + c**2 - 2 * a * c * math.cos(math.radians(C)))
+		
+		A = math.degrees(math.acos((c**2 + sidec**2 - a**2) / (2 * c * sidec)))
+		
+		B = 180 - (A + C)
+		
+		if print_result:
+			print(f'Side c: {sidec}, Angle A: {A}, Angle B: {B}')
+		return sidec, A, B

scimatic-1.0.0/src/scimatic/niche.py

@@ -0,0 +1,50 @@
+def fibonacci(
+	value: int,
+):
+	a, b = 0, 1
+
+	i = 0
+	
+	while i <= value:
+		yield a
+		a, b = b, a + b
+		i += 1
+
+def collatz(
+	value: int,
+	print_result: bool = False
+) -> list[int]:
+	
+	sequence = [value]
+	
+	for var in sequence:
+		if var % 2 == 0:
+			new_value = var // 2
+		else:
+			new_value = (3 * var) + 1
+		
+		sequence.append(new_value)
+		
+		if new_value == 1:
+			break
+	
+	if print_result:
+		print(sequence)
+	return sequence
+
+def ackermann(
+	array: list,
+	m: int,
+	n: int
+):
+	if m > 3:
+		print('The value of m is too high for python. If you want to have a niche that does not grow that quickly, I will recommend TREE.')
+		return
+	array.append((m, n))
+
+	if m == 0:
+		return n + 1
+	elif n == 0:
+		return ackermann(array, m - 1, 1)
+	else:
+		return ackermann(array, m - 1, ackermann(array, m, n - 1))

scimatic-1.0.0/src/scimatic/scientific/mechanics.py

@@ -0,0 +1,39 @@
+def momentum(
+	mass: int | float,
+	velocity: int | float,
+	print_result: bool = False
+) -> int | float | None:
+	
+	p = mass * velocity
+	
+	if print_result:
+		print(f'Momentum: {p}kg•m/s')
+	return p
+	
+def impulse(
+	force: int | float,
+	initial_time: int | float,
+	final_time: int | float,
+	print_result: bool = False,
+	return_deltat: bool = False
+) -> int | float | None:
+	
+	if initial_time >= final_time:
+		raise ValueError
+	
+	delta_t = final_time - initial_time
+	
+	J = force * delta_t
+	
+	delta = '\u0394'
+	
+	if print_result:
+		if not return_deltat:
+			print(f'Impulse: {J}N•s')
+		else:
+			print(f'Impulse: {J}N•s, {delta}t: {delta_t}s')
+			
+	if return_deltat:
+		return J, delta_t
+	else:
+		return J

scimatic-1.0.0/src/scimatic/statistics.py

@@ -0,0 +1,230 @@
+import math
+from .errors import NegativeDiscriminantError, VariableError, ConstantError, ComparisonError, DataError
+	
+def quartile(
+	raw_data: list[int],
+	k: int,
+	print_result: bool = False
+) -> int:
+	
+	constant_check = [1, 2, 3]
+	
+	if k not in constant_check:
+		raise ConstantError
+	
+	if len(raw_data) <= 1:
+		raise DataError('Raw data is too short.')
+		
+	processed_data = sorted(raw_data)
+	
+	n = 0
+	
+	for data in processed_data:
+		n += 1
+	
+	formula = k * (n + 1) / 4
+	syntax_list = []
+	is_float = False
+	
+	formula = str(formula)
+	
+	if print_result:
+		print(formula)
+	
+	for f in formula:
+		if f == '.':
+			is_float = True
+			continue
+			
+		f = int(f)
+		
+		syntax_list.append(f)
+	
+	if is_float:
+		position1 = syntax_list[0]
+		position2 = position1 + 1
+			
+		lower_value = processed_data[position1 - 1]
+		higher_value = processed_data[position2 - 1]
+			
+		formula = lower_value + float(f'0.{syntax_list[1]}') * (higher_value - lower_value)
+	
+	if print_result:
+		print(f'Q{k} = {k}({n} + 1) / 4')
+		print(formula)
+	return formula
+	
+def decile(
+	raw_data: int,
+	k: int,
+	print_result: bool = False
+) -> int | None:
+	
+	constant_check = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+	
+	if k not in constant_check:
+		raise ConstantError
+
+	if len(raw_data) < 10:
+		raise DataError('Raw data is too short.')
+		
+	
+	processed_data = sorted(raw_data)
+	
+	n = 0
+	
+	for data in processed_data:
+		n += 1
+	
+	formula = k * (n + 1) / 10
+	syntax_list = []
+	is_float = False
+	
+	formula = str(formula)
+	
+	if print_result:
+		print(formula)
+	
+	for f in formula:
+		if f == '.':
+			is_float = True
+			continue
+			
+		f = int(f)
+		
+		syntax_list.append(f)
+	
+	if is_float:
+		position1 = syntax_list[0]
+		position2 = position1 + 1
+			
+		lower_value = processed_data[position1 - 1]
+		higher_value = processed_data[position2 - 1]
+			
+		formula = lower_value + float(f'0.{syntax_list[1]}') * (higher_value - lower_value)
+	
+	if print_result:
+		print(f'D{k} = {k}({n} + 1) / 10')
+		print(formula)
+	return formula
+	
+def percentile(
+	raw_data: int,
+	k: int,
+	print_result: bool = False
+) -> int | None:
+	
+	constant_check = []
+	
+	for i in range(100):
+		if i == 0:
+			continue
+		
+		constant_check.append(i)
+	
+
+	
+	if k not in constant_check:
+		raise ConstantError
+
+	if len(raw_data) < 10:
+		raise DataError('Raw data is too short.')
+	
+	processed_data = sorted(raw_data)
+	
+	if print_result:
+		print(processed_data)
+		
+	n = 0
+	
+	for data in processed_data:
+		n += 1
+	
+	formula = k * (n + 1) / 100
+	syntax_list = []
+	is_float = False
+	
+	formula = str(formula)
+	
+	if print_result:
+		print(formula)
+	
+	for f in formula:
+		if f == '.':
+			is_float = True
+			continue
+			
+		f = int(f)
+		
+		syntax_list.append(f)
+	
+	if is_float:	
+		position1 = syntax_list[0]
+		position2 = position1 + 1
+			
+		lower_value = processed_data[position1 - 1]
+		higher_value = processed_data[position2 - 1]
+			
+		formula = lower_value + float(f'0.{syntax_list[1]}') * (higher_value - lower_value)
+		
+	if print_result:
+		print(f'P{k} = {k}({n} + 1) / 100')
+		print(formula)
+	return formula
+	
+def median(
+	raw_data: list[int],
+	print_result: bool = False
+) -> int | None:
+	
+	processed_data = sorted(raw_data)
+	
+	if len(raw_data) <= 1:
+		raise DataError('Raw data is too short.')
+	
+	n = 0
+	
+	for data in processed_data:
+		n += 1
+	
+	position = (n + 1) / 2
+	
+	syntax_list = []
+	
+	num = ''
+	
+	position = str(position)
+	
+	is_float = False
+	
+	for p in position:
+		if p == '.':
+			is_float = True
+			syntax_list.append(num)
+			continue
+		
+		num += p
+	
+	syntax_list.append(num)
+
+	position = float(position)
+
+	if position.is_integer():
+		formula = processed_data[int(position) - 1]
+	
+	else:
+		position1 = int(position)
+		position2 = position1 + 1
+	
+		lower_value = processed_data[position1 - 1]
+		higher_value = processed_data[position2 - 1]
+	
+		fraction = position - position1
+	
+		formula = lower_value + fraction * (higher_value - lower_value)
+	
+	if print_result:
+		print(processed_data)
+		print('Position:', position)
+		print('Median', formula)
+	return position, formula