math-precision 1.0.0__tar.gz

math_precision-1.0.0/LICENSE.txt

@@ -0,0 +1,3 @@
+This is proprietary code.
+
+Its copying, alteration and distribution outside official media is strictly prohibited.

math_precision-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.2
+Name: math_precision
+Version: 1.0.0
+Home-page: https://github.com/sapiens-technology/math_precision
+Author: SAPIENS TECHNOLOGY
+License: Proprietary Software
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: home-page
+Dynamic: license

math_precision-1.0.0/math_precision/__init__.py

@@ -0,0 +1,77 @@
+"""
+The presented algorithm implements a benchmarking method designed to evaluate the **mathematical precision** of language models,
+targeting a well-known limitation of these systems: their ability to reliably perform numerical reasoning under high precision constraints.
+
+The `MathPrecision` class functions as a synthetic data generator, automatically producing a dataset of mathematically structured problems.
+Each sample consists of an expression built from three high-precision numbers (generated using the `decimal` module) combined with two randomly selected arithmetic operators:
+addition, subtraction, multiplication, or division. These numbers are not standard floats but high-precision values with many decimal places,
+significantly increasing the difficulty and minimizing the likelihood of correct answers through approximation.
+
+For every generated expression, the algorithm computes the correct result with high numerical precision and then constructs a multiple-choice question.
+Only one option corresponds to the correct answer, while the remaining alternatives are generated by applying small perturbations to the true result.
+These incorrect options are intentionally designed to be plausible,
+forcing the evaluated model to perform actual numerical reasoning rather than relying on superficial pattern recognition.
+
+Additionally, both operators and answer choices are shuffled, ensuring structural diversity across samples and reducing positional bias.
+The final output is a structured dataset containing input-output pairs, ready to be used in automated evaluation pipelines.
+
+Among the main advantages of this benchmarking approach:
+
+First, the **high numerical precision requirement** makes the test substantially more rigorous than traditional benchmarks based on simple arithmetic.
+It allows clear differentiation between models that merely approximate reasoning and those that can consistently execute precise calculations.
+
+Another key advantage is **scalable synthetic data generation**. Since the dataset is produced programmatically, it can be expanded arbitrarily,
+with full control over complexity, distribution, and format. This removes reliance on static datasets and mitigates the risk of overfitting to known benchmarks.
+
+The method is also **robust against memorization**, as each execution generates entirely new and unique problems.
+This prevents models from gaining artificial advantages by memorizing fixed question sets.
+
+Furthermore, the use of closely related incorrect alternatives enables **fine-grained evaluation**, capturing not only whether a model gets the answer right,
+but also how close it gets. This is particularly useful for identifying systematic errors, such as precision loss or difficulties handling operator precedence.
+
+Finally, the approach is **simple, automated, and easily integrable** into evaluation workflows,
+making it suitable for both offline benchmarking and continuous testing during model development.
+
+In summary, this algorithm provides an effective and rigorous benchmark for assessing a fundamental capability—mathematical precision—while balancing experimental control,
+scalability, and realistic difficulty.
+"""
+# --------------------------> A SAPIENS TECHNOLOGY®️ PRODUCTION) <--------------------------
+from .math_precision import *
+"""
+The presented algorithm implements a benchmarking method designed to evaluate the **mathematical precision** of language models,
+targeting a well-known limitation of these systems: their ability to reliably perform numerical reasoning under high precision constraints.
+
+The `MathPrecision` class functions as a synthetic data generator, automatically producing a dataset of mathematically structured problems.
+Each sample consists of an expression built from three high-precision numbers (generated using the `decimal` module) combined with two randomly selected arithmetic operators:
+addition, subtraction, multiplication, or division. These numbers are not standard floats but high-precision values with many decimal places,
+significantly increasing the difficulty and minimizing the likelihood of correct answers through approximation.
+
+For every generated expression, the algorithm computes the correct result with high numerical precision and then constructs a multiple-choice question.
+Only one option corresponds to the correct answer, while the remaining alternatives are generated by applying small perturbations to the true result.
+These incorrect options are intentionally designed to be plausible,
+forcing the evaluated model to perform actual numerical reasoning rather than relying on superficial pattern recognition.
+
+Additionally, both operators and answer choices are shuffled, ensuring structural diversity across samples and reducing positional bias.
+The final output is a structured dataset containing input-output pairs, ready to be used in automated evaluation pipelines.
+
+Among the main advantages of this benchmarking approach:
+
+First, the **high numerical precision requirement** makes the test substantially more rigorous than traditional benchmarks based on simple arithmetic.
+It allows clear differentiation between models that merely approximate reasoning and those that can consistently execute precise calculations.
+
+Another key advantage is **scalable synthetic data generation**. Since the dataset is produced programmatically, it can be expanded arbitrarily,
+with full control over complexity, distribution, and format. This removes reliance on static datasets and mitigates the risk of overfitting to known benchmarks.
+
+The method is also **robust against memorization**, as each execution generates entirely new and unique problems.
+This prevents models from gaining artificial advantages by memorizing fixed question sets.
+
+Furthermore, the use of closely related incorrect alternatives enables **fine-grained evaluation**, capturing not only whether a model gets the answer right,
+but also how close it gets. This is particularly useful for identifying systematic errors, such as precision loss or difficulties handling operator precedence.
+
+Finally, the approach is **simple, automated, and easily integrable** into evaluation workflows,
+making it suitable for both offline benchmarking and continuous testing during model development.
+
+In summary, this algorithm provides an effective and rigorous benchmark for assessing a fundamental capability—mathematical precision—while balancing experimental control,
+scalability, and realistic difficulty.
+"""
+# --------------------------> A SAPIENS TECHNOLOGY®️ PRODUCTION) <--------------------------

math_precision-1.0.0/math_precision/math_precision.py

@@ -0,0 +1,159 @@
+"""
+The presented algorithm implements a benchmarking method designed to evaluate the **mathematical precision** of language models,
+targeting a well-known limitation of these systems: their ability to reliably perform numerical reasoning under high precision constraints.
+
+The `MathPrecision` class functions as a synthetic data generator, automatically producing a dataset of mathematically structured problems.
+Each sample consists of an expression built from three high-precision numbers (generated using the `decimal` module) combined with two randomly selected arithmetic operators:
+addition, subtraction, multiplication, or division. These numbers are not standard floats but high-precision values with many decimal places,
+significantly increasing the difficulty and minimizing the likelihood of correct answers through approximation.
+
+For every generated expression, the algorithm computes the correct result with high numerical precision and then constructs a multiple-choice question.
+Only one option corresponds to the correct answer, while the remaining alternatives are generated by applying small perturbations to the true result.
+These incorrect options are intentionally designed to be plausible,
+forcing the evaluated model to perform actual numerical reasoning rather than relying on superficial pattern recognition.
+
+Additionally, both operators and answer choices are shuffled, ensuring structural diversity across samples and reducing positional bias.
+The final output is a structured dataset containing input-output pairs, ready to be used in automated evaluation pipelines.
+
+Among the main advantages of this benchmarking approach:
+
+First, the **high numerical precision requirement** makes the test substantially more rigorous than traditional benchmarks based on simple arithmetic.
+It allows clear differentiation between models that merely approximate reasoning and those that can consistently execute precise calculations.
+
+Another key advantage is **scalable synthetic data generation**. Since the dataset is produced programmatically, it can be expanded arbitrarily,
+with full control over complexity, distribution, and format. This removes reliance on static datasets and mitigates the risk of overfitting to known benchmarks.
+
+The method is also **robust against memorization**, as each execution generates entirely new and unique problems.
+This prevents models from gaining artificial advantages by memorizing fixed question sets.
+
+Furthermore, the use of closely related incorrect alternatives enables **fine-grained evaluation**, capturing not only whether a model gets the answer right,
+but also how close it gets. This is particularly useful for identifying systematic errors, such as precision loss or difficulties handling operator precedence.
+
+Finally, the approach is **simple, automated, and easily integrable** into evaluation workflows,
+making it suitable for both offline benchmarking and continuous testing during model development.
+
+In summary, this algorithm provides an effective and rigorous benchmark for assessing a fundamental capability—mathematical precision—while balancing experimental control,
+scalability, and realistic difficulty.
+"""
+# --------------------------> A SAPIENS TECHNOLOGY®️ PRODUCTION) <--------------------------
+class MathPrecision:
+	def __init__(self, show_errors=True, display_error_point=False):
+		try:
+			self.__show_errors = bool(show_errors) if type(show_errors) in (bool, int, float) else True
+			self.__display_error_point = bool(display_error_point) if type(display_error_point) in (bool, int, float) else False
+			try:
+				from warnings import simplefilter, filterwarnings
+				from logging import disable, CRITICAL
+				from os import environ
+				simplefilter('ignore')
+				filterwarnings('ignore')
+				disable(CRITICAL)
+			except: pass
+			from traceback import print_exc
+			self.__print_exc = print_exc
+		except Exception as error:
+			try:
+				if self.__show_errors:
+					error_message = 'ERROR in MathPrecision.__init__: '+str(error)
+					print(error_message)
+					try: self.__print_exc() if self.__display_error_point else None
+					except: pass
+			except: pass
+	def generateDatabase(self, n_samples=10):
+		try:
+			return_dictionary, database = {}, []
+			n_samples = max(1, int(n_samples)) if type(n_samples) in (int, float) else 10
+			def _generate_high_precision_number(start=100, end=200, precision=100):
+				from decimal import getcontext, Decimal
+				from random import SystemRandom
+				getcontext().prec = precision
+				random_generator = SystemRandom()
+				integer_part = Decimal(random_generator.randint(start, end))
+				decimal_part = Decimal(str(random_generator.random()))
+				high_precision_number = integer_part + decimal_part
+				return high_precision_number
+			def _shuffle_list(input_list=[]):
+			    from random import shuffle
+			    shuffle(input_list)
+			    return input_list
+			from random import randint
+			operators, alternatives = ['+', '-', '*', '/'], ['A)', 'B)', 'C)', 'D)']
+			for _ in range(n_samples):
+				operator_a = _shuffle_list(input_list=operators)[randint(0, 3)]
+				operator_b = _shuffle_list(input_list=operators)[randint(0, 3)]
+				number1, number2, number3 = _generate_high_precision_number(), _generate_high_precision_number(), _generate_high_precision_number()
+				number1, number2, number3 = sorted([number1, number2, number3])[::-1]
+				formatted_input = f'{number1} {operator_a} {number2} {operator_b} {number3}'
+				correct_answer = eval(formatted_input)
+				alternative_answers, input_output, used_values = [], {}, set()
+				for index, alternative in enumerate(_shuffle_list(input_list=alternatives)):
+					if index == 0:
+						formatted_correct = f'{correct_answer:.10f}'
+						correct_alternative = f'{alternative} {formatted_correct}'
+						alternative_answers.append(correct_alternative)
+						input_output['output'] = correct_alternative
+						used_values.add(formatted_correct)
+					else:
+						while True:
+							operator_x = _shuffle_list(input_list=['+', '-'])[randint(0, 1)]
+							wrong_answer = eval(f'{correct_answer} {operator_x} {_generate_high_precision_number(start=0, end=1)}')
+							formatted_wrong = f'{wrong_answer:.10f}'
+							if formatted_wrong not in used_values:
+								used_values.add(formatted_wrong)
+								string_wrong_answer = f'{alternative} {formatted_wrong}'
+								alternative_answers.append(string_wrong_answer)
+								break
+				_input = f'{formatted_input} = ?\n\n'
+				alternative_answers = sorted(alternative_answers)
+				for alternative_answer in alternative_answers: _input += f'{alternative_answer}\n'
+				input_output['input'] = _input.strip()
+				database.append(input_output)
+			return_dictionary['data'] = database
+			return return_dictionary
+		except Exception as error:
+			try:
+				if self.__show_errors:
+					error_message = 'ERROR in MathPrecision.generateDatabase: '+str(error)
+					print(error_message)
+					try: self.__print_exc() if self.__display_error_point else None
+					except: pass
+			except: pass
+			return {'data': []}
+"""
+The presented algorithm implements a benchmarking method designed to evaluate the **mathematical precision** of language models,
+targeting a well-known limitation of these systems: their ability to reliably perform numerical reasoning under high precision constraints.
+
+The `MathPrecision` class functions as a synthetic data generator, automatically producing a dataset of mathematically structured problems.
+Each sample consists of an expression built from three high-precision numbers (generated using the `decimal` module) combined with two randomly selected arithmetic operators:
+addition, subtraction, multiplication, or division. These numbers are not standard floats but high-precision values with many decimal places,
+significantly increasing the difficulty and minimizing the likelihood of correct answers through approximation.
+
+For every generated expression, the algorithm computes the correct result with high numerical precision and then constructs a multiple-choice question.
+Only one option corresponds to the correct answer, while the remaining alternatives are generated by applying small perturbations to the true result.
+These incorrect options are intentionally designed to be plausible,
+forcing the evaluated model to perform actual numerical reasoning rather than relying on superficial pattern recognition.
+
+Additionally, both operators and answer choices are shuffled, ensuring structural diversity across samples and reducing positional bias.
+The final output is a structured dataset containing input-output pairs, ready to be used in automated evaluation pipelines.
+
+Among the main advantages of this benchmarking approach:
+
+First, the **high numerical precision requirement** makes the test substantially more rigorous than traditional benchmarks based on simple arithmetic.
+It allows clear differentiation between models that merely approximate reasoning and those that can consistently execute precise calculations.
+
+Another key advantage is **scalable synthetic data generation**. Since the dataset is produced programmatically, it can be expanded arbitrarily,
+with full control over complexity, distribution, and format. This removes reliance on static datasets and mitigates the risk of overfitting to known benchmarks.
+
+The method is also **robust against memorization**, as each execution generates entirely new and unique problems.
+This prevents models from gaining artificial advantages by memorizing fixed question sets.
+
+Furthermore, the use of closely related incorrect alternatives enables **fine-grained evaluation**, capturing not only whether a model gets the answer right,
+but also how close it gets. This is particularly useful for identifying systematic errors, such as precision loss or difficulties handling operator precedence.
+
+Finally, the approach is **simple, automated, and easily integrable** into evaluation workflows,
+making it suitable for both offline benchmarking and continuous testing during model development.
+
+In summary, this algorithm provides an effective and rigorous benchmark for assessing a fundamental capability—mathematical precision—while balancing experimental control,
+scalability, and realistic difficulty.
+"""
+# --------------------------> A SAPIENS TECHNOLOGY®️ PRODUCTION) <--------------------------

math_precision-1.0.0/math_precision.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.2
+Name: math_precision
+Version: 1.0.0
+Home-page: https://github.com/sapiens-technology/math_precision
+Author: SAPIENS TECHNOLOGY
+License: Proprietary Software
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: home-page
+Dynamic: license

math_precision-1.0.0/math_precision.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE.txt
+setup.cfg
+setup.py
+math_precision/__init__.py
+math_precision/math_precision.py
+math_precision.egg-info/PKG-INFO
+math_precision.egg-info/SOURCES.txt
+math_precision.egg-info/dependency_links.txt
+math_precision.egg-info/top_level.txt

math_precision-1.0.0/math_precision.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

math_precision-1.0.0/math_precision.egg-info/top_level.txt

@@ -0,0 +1 @@
+math_precision

math_precision-1.0.0/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+license_file = LICENSE.txt
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

math_precision-1.0.0/setup.py

@@ -0,0 +1,87 @@
+"""
+The presented algorithm implements a benchmarking method designed to evaluate the **mathematical precision** of language models,
+targeting a well-known limitation of these systems: their ability to reliably perform numerical reasoning under high precision constraints.
+
+The `MathPrecision` class functions as a synthetic data generator, automatically producing a dataset of mathematically structured problems.
+Each sample consists of an expression built from three high-precision numbers (generated using the `decimal` module) combined with two randomly selected arithmetic operators:
+addition, subtraction, multiplication, or division. These numbers are not standard floats but high-precision values with many decimal places,
+significantly increasing the difficulty and minimizing the likelihood of correct answers through approximation.
+
+For every generated expression, the algorithm computes the correct result with high numerical precision and then constructs a multiple-choice question.
+Only one option corresponds to the correct answer, while the remaining alternatives are generated by applying small perturbations to the true result.
+These incorrect options are intentionally designed to be plausible,
+forcing the evaluated model to perform actual numerical reasoning rather than relying on superficial pattern recognition.
+
+Additionally, both operators and answer choices are shuffled, ensuring structural diversity across samples and reducing positional bias.
+The final output is a structured dataset containing input-output pairs, ready to be used in automated evaluation pipelines.
+
+Among the main advantages of this benchmarking approach:
+
+First, the **high numerical precision requirement** makes the test substantially more rigorous than traditional benchmarks based on simple arithmetic.
+It allows clear differentiation between models that merely approximate reasoning and those that can consistently execute precise calculations.
+
+Another key advantage is **scalable synthetic data generation**. Since the dataset is produced programmatically, it can be expanded arbitrarily,
+with full control over complexity, distribution, and format. This removes reliance on static datasets and mitigates the risk of overfitting to known benchmarks.
+
+The method is also **robust against memorization**, as each execution generates entirely new and unique problems.
+This prevents models from gaining artificial advantages by memorizing fixed question sets.
+
+Furthermore, the use of closely related incorrect alternatives enables **fine-grained evaluation**, capturing not only whether a model gets the answer right,
+but also how close it gets. This is particularly useful for identifying systematic errors, such as precision loss or difficulties handling operator precedence.
+
+Finally, the approach is **simple, automated, and easily integrable** into evaluation workflows,
+making it suitable for both offline benchmarking and continuous testing during model development.
+
+In summary, this algorithm provides an effective and rigorous benchmark for assessing a fundamental capability—mathematical precision—while balancing experimental control,
+scalability, and realistic difficulty.
+"""
+# --------------------------> A SAPIENS TECHNOLOGY®️ PRODUCTION) <--------------------------
+from setuptools import setup, find_packages
+package_name = 'math_precision'
+version = '1.0.0'
+setup(
+    name=package_name,
+    version=version,
+    author='SAPIENS TECHNOLOGY',
+    packages=find_packages(),
+    url='https://github.com/sapiens-technology/math_precision',
+    license='Proprietary Software'
+)
+"""
+The presented algorithm implements a benchmarking method designed to evaluate the **mathematical precision** of language models,
+targeting a well-known limitation of these systems: their ability to reliably perform numerical reasoning under high precision constraints.
+
+The `MathPrecision` class functions as a synthetic data generator, automatically producing a dataset of mathematically structured problems.
+Each sample consists of an expression built from three high-precision numbers (generated using the `decimal` module) combined with two randomly selected arithmetic operators:
+addition, subtraction, multiplication, or division. These numbers are not standard floats but high-precision values with many decimal places,
+significantly increasing the difficulty and minimizing the likelihood of correct answers through approximation.
+
+For every generated expression, the algorithm computes the correct result with high numerical precision and then constructs a multiple-choice question.
+Only one option corresponds to the correct answer, while the remaining alternatives are generated by applying small perturbations to the true result.
+These incorrect options are intentionally designed to be plausible,
+forcing the evaluated model to perform actual numerical reasoning rather than relying on superficial pattern recognition.
+
+Additionally, both operators and answer choices are shuffled, ensuring structural diversity across samples and reducing positional bias.
+The final output is a structured dataset containing input-output pairs, ready to be used in automated evaluation pipelines.
+
+Among the main advantages of this benchmarking approach:
+
+First, the **high numerical precision requirement** makes the test substantially more rigorous than traditional benchmarks based on simple arithmetic.
+It allows clear differentiation between models that merely approximate reasoning and those that can consistently execute precise calculations.
+
+Another key advantage is **scalable synthetic data generation**. Since the dataset is produced programmatically, it can be expanded arbitrarily,
+with full control over complexity, distribution, and format. This removes reliance on static datasets and mitigates the risk of overfitting to known benchmarks.
+
+The method is also **robust against memorization**, as each execution generates entirely new and unique problems.
+This prevents models from gaining artificial advantages by memorizing fixed question sets.
+
+Furthermore, the use of closely related incorrect alternatives enables **fine-grained evaluation**, capturing not only whether a model gets the answer right,
+but also how close it gets. This is particularly useful for identifying systematic errors, such as precision loss or difficulties handling operator precedence.
+
+Finally, the approach is **simple, automated, and easily integrable** into evaluation workflows,
+making it suitable for both offline benchmarking and continuous testing during model development.
+
+In summary, this algorithm provides an effective and rigorous benchmark for assessing a fundamental capability—mathematical precision—while balancing experimental control,
+scalability, and realistic difficulty.
+"""
+# --------------------------> A SAPIENS TECHNOLOGY®️ PRODUCTION) <--------------------------