%global _empty_manifest_terminate_build 0 Name: python-primefac Version: 2.0.12 Release: 1 Summary: Module and command-line utility for factoring integers into primes License: MIT License URL: https://pypi.org/manage/project/primefac Source0: https://mirrors.nju.edu.cn/pypi/web/packages/a8/d7/1e763ff6030efb6f1f9f899d396c476b932eabf362bdff5b87fb949ad307/primefac-2.0.12.tar.gz BuildArch: noarch %description This is a module and command-line utility for factoring integers. As a module, we provide a primality test, several functions for extracting a non-trivial factor of an integer, a generator that yields all of a number's prime factors (with multiplicity), and ancillary functions used in calculating these things. As a command-line utility, this project aims to replace GNU's ``factor`` command with a more versatile utility --- in particular, this utility can operate on arbitrarily large numbers, uses multiple cores in parallel, uses better algorithms, handles input in reverse Polish notation, and can be tweaked via command-line flags. Specifically, - GNU's ``factor`` command won't factor anything greater than 2\ :sup:`127`\ -1. primefac handles arbitrarily large integers. - GNU's ``factor`` command uses Pollard's rho algorithm. While this extracts small factors quickly, large factors take a while to find. primefac uses, among other things, the elliptic curve method and the self-initializing quadratic sieve, which are far more efficient at extracting large factors. - GNU's ``factor`` command is a single-threaded application. primefac uses by default five threads to take advantage of the multiple cores typically available on modern machines. Each of these threads uses a different algorithm to factor the number: - One thread runs Brent's variation on Pollard's rho algorithm. This is good for extracting smallish factors quickly. - One thread runs the two-stage version of Pollard's *p*\ -1 method. This is good at finding factors *p* for which *p*\ -1 is a product of small primes. - One thread runs Williams' *p*\ +1 method. This is good at finding factors *p* for which *p*\ +1 is a product of small primes. - One thread runs the elliptic curve method. This is a bit slower than Pollard's rho algorithm when the factors extracted are small, but it has significantly better performance on difficult factors. - One thread runs the self-initializing quadratic sieve. This is the best algorithm for factoring "hard" numbers short of the general number field sieve. However, it's (relatively speaking) more than a little slow when the numbers are small, and the time it takes depends only on the size of the number being factored rather than the size of the factors being extracted as with Pollard's rho algorithm and the elliptic curve method, so we use the preceding algorithms to handle those. - We also extend the utility by interpreting the command-line arguments as an expression in reverse Polish notation and factoring the numbers remaining on the evaluation stack when interpretation is complete. For example, the command:: python3 -m primefac 24 ! 1 - 38 ! 1 + will factor the numbers 24! - 1 = 620448401733239439359999 and 38! + 1 = 523022617466601111760007224100074291200000001. %package -n python3-primefac Summary: Module and command-line utility for factoring integers into primes Provides: python-primefac BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip %description -n python3-primefac This is a module and command-line utility for factoring integers. As a module, we provide a primality test, several functions for extracting a non-trivial factor of an integer, a generator that yields all of a number's prime factors (with multiplicity), and ancillary functions used in calculating these things. As a command-line utility, this project aims to replace GNU's ``factor`` command with a more versatile utility --- in particular, this utility can operate on arbitrarily large numbers, uses multiple cores in parallel, uses better algorithms, handles input in reverse Polish notation, and can be tweaked via command-line flags. Specifically, - GNU's ``factor`` command won't factor anything greater than 2\ :sup:`127`\ -1. primefac handles arbitrarily large integers. - GNU's ``factor`` command uses Pollard's rho algorithm. While this extracts small factors quickly, large factors take a while to find. primefac uses, among other things, the elliptic curve method and the self-initializing quadratic sieve, which are far more efficient at extracting large factors. - GNU's ``factor`` command is a single-threaded application. primefac uses by default five threads to take advantage of the multiple cores typically available on modern machines. Each of these threads uses a different algorithm to factor the number: - One thread runs Brent's variation on Pollard's rho algorithm. This is good for extracting smallish factors quickly. - One thread runs the two-stage version of Pollard's *p*\ -1 method. This is good at finding factors *p* for which *p*\ -1 is a product of small primes. - One thread runs Williams' *p*\ +1 method. This is good at finding factors *p* for which *p*\ +1 is a product of small primes. - One thread runs the elliptic curve method. This is a bit slower than Pollard's rho algorithm when the factors extracted are small, but it has significantly better performance on difficult factors. - One thread runs the self-initializing quadratic sieve. This is the best algorithm for factoring "hard" numbers short of the general number field sieve. However, it's (relatively speaking) more than a little slow when the numbers are small, and the time it takes depends only on the size of the number being factored rather than the size of the factors being extracted as with Pollard's rho algorithm and the elliptic curve method, so we use the preceding algorithms to handle those. - We also extend the utility by interpreting the command-line arguments as an expression in reverse Polish notation and factoring the numbers remaining on the evaluation stack when interpretation is complete. For example, the command:: python3 -m primefac 24 ! 1 - 38 ! 1 + will factor the numbers 24! - 1 = 620448401733239439359999 and 38! + 1 = 523022617466601111760007224100074291200000001. %package help Summary: Development documents and examples for primefac Provides: python3-primefac-doc %description help This is a module and command-line utility for factoring integers. As a module, we provide a primality test, several functions for extracting a non-trivial factor of an integer, a generator that yields all of a number's prime factors (with multiplicity), and ancillary functions used in calculating these things. As a command-line utility, this project aims to replace GNU's ``factor`` command with a more versatile utility --- in particular, this utility can operate on arbitrarily large numbers, uses multiple cores in parallel, uses better algorithms, handles input in reverse Polish notation, and can be tweaked via command-line flags. Specifically, - GNU's ``factor`` command won't factor anything greater than 2\ :sup:`127`\ -1. primefac handles arbitrarily large integers. - GNU's ``factor`` command uses Pollard's rho algorithm. While this extracts small factors quickly, large factors take a while to find. primefac uses, among other things, the elliptic curve method and the self-initializing quadratic sieve, which are far more efficient at extracting large factors. - GNU's ``factor`` command is a single-threaded application. primefac uses by default five threads to take advantage of the multiple cores typically available on modern machines. Each of these threads uses a different algorithm to factor the number: - One thread runs Brent's variation on Pollard's rho algorithm. This is good for extracting smallish factors quickly. - One thread runs the two-stage version of Pollard's *p*\ -1 method. This is good at finding factors *p* for which *p*\ -1 is a product of small primes. - One thread runs Williams' *p*\ +1 method. This is good at finding factors *p* for which *p*\ +1 is a product of small primes. - One thread runs the elliptic curve method. This is a bit slower than Pollard's rho algorithm when the factors extracted are small, but it has significantly better performance on difficult factors. - One thread runs the self-initializing quadratic sieve. This is the best algorithm for factoring "hard" numbers short of the general number field sieve. However, it's (relatively speaking) more than a little slow when the numbers are small, and the time it takes depends only on the size of the number being factored rather than the size of the factors being extracted as with Pollard's rho algorithm and the elliptic curve method, so we use the preceding algorithms to handle those. - We also extend the utility by interpreting the command-line arguments as an expression in reverse Polish notation and factoring the numbers remaining on the evaluation stack when interpretation is complete. For example, the command:: python3 -m primefac 24 ! 1 - 38 ! 1 + will factor the numbers 24! - 1 = 620448401733239439359999 and 38! + 1 = 523022617466601111760007224100074291200000001. %prep %autosetup -n primefac-2.0.12 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-primefac -f filelist.lst %dir %{python3_sitelib}/* %files help -f doclist.lst %{_docdir}/* %changelog * Fri May 05 2023 Python_Bot - 2.0.12-1 - Package Spec generated