Open Hub
Open Hub

 Settings |  Report Duplicate

0
I Use This!
Very Low Activity

Commits : Listings

Analyzed about 8 hours ago. based on code collected 1 day ago.
Nov 05, 2025 — Nov 05, 2026
Commit Message Contributor Files Modified Lines Added Lines Removed Code Location Date
(THEORY and FEATURE) People Analytics - Drone Electronic Voting Machine - Python 3.7.5 upgrade and Paper ballot shuffle simulation, PRAM Breadth First and Depth First Search, Set Partition Analytics, Money Trail Economic EventNet Graph Random Walk, Expander Graphs, Cheeger's Constant, Random Closed Packing, Space Filling, Pseudorandomness Extractors and Generators, Birthday Paradox, Unique Identification, Ramsey coloring, Computational Chaos, Voting analytics
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) People Analytics - Drone Electronic Voting Machine - Python 3.7.5 upgrade and Paper ballot shuffle simulation, PRAM Breadth First and Depth First Search, Set Partition Analytics, Money Trail Economic EventNet Graph Random Walk, Expander Graphs, Cheeger's Co nstant, Random Closed Packing, Space Filling, Pseudorandomness Extractors and Generators, Birthday Paradox, Unique Identification, Ramsey colo ring
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Computational Geometric Factorization - Quadcore Python 3.7.5 + Spark 2.4.3 benchmarks - 1024 bits integers
Srinivasan Kannan
More... almost 7 years ago
----------------------------------------------------------------------------------------------------------------------------------------------- 742. (THEORY and FEATURE) Computational Geometric Factorization - Quadcore Python 3.7.5 + Spark 2.4.3 benchmarks - 1024 bits integers - 11 January 2020 - related to all sections on Factorization ----------------------------------------------------------------------------------------------------------------------------------------------- (*) Few 1024 bits hard random integers of mixed digits have been factorized and logs have been captured in testlogs/DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.Python3.7.5Upgrade.1024bits.11January2020 - all the integers are factorized from 28 seconds onwards - logs have been truncated and only first few factors are printed. Integers factorized are: - 99999999029309203902939293232903920930293092039029302302382983927382382637627636263623823928328938981982819289839274878478374792392893829839289382983982938298392893829839829732739729839289382938293828392893828398293928372939289382983928839289382983928938298392893829839283982938239829389283982938298398293823 - 99999999029309203902939293232903920930293092039029302302382983927382382637627636263623823928328938981982819289839274878478374792392893829839289382983982938298392893829839829732739729839289382938293828392893828828083782872939289382983928839289382983928938298392893829839283982938239829389283982938298398293823 - 99999999029309203902939293232903920930293092039029302302382983927382382637627636263623823928328938981982819289839274883838888888888833333838838923928998238298392893829839829732739729839289382938293828392893828828083782872939289382983928839289382983928938298392893829839283982938239829389283982938298398293823 - 99999999029309203902939293232903920930293092039029302302382983927382382637627636263623823928328938981982819289839274883838888888888833333838838923928998238211111111111111111111111111111111111118293828392893828828083782872939289382983928839289382983928938298392893829839283982938239829389283982938298398293823 - 99999999029309203902939293232903920930293092039029388888999922222222188882777777777777772277778938981982819289839274883838888888888833333838838923928998238211111111111111111111111111111111111118293828392893828828083782872939289382983928839289382983928938298392893829839283982938239829389283982938298398293833
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Computational Geometric NC-PRAM-BSP Factorization - Spark 2.4.3 + Python 3.7.5 benchmarks - 1213 and 1243 bits integers factorized, Hyperbolic Rasterization graphics example, Multidimensional hyperplanar point location, Integer Diophantines, Multiplicative partitions and sundry resolutions
Srinivasan Kannan
More... almost 7 years ago
---------------------------------------------------------------------------------------------------------------------------------------------- 741. (THEORY and FEATURE) Computational Geometric NC-PRAM-BSP Factorization - Spark 2.4.3 + Python 3.7.5 benchmarks - 1213 bits integer factorized, Hyperbolic Rasterization graphics example, Multidimensional hyperplanar point location, Integer Diophantines, Multiplicative partitions and sundry resolutions - related to all sections on factorization - 9 January 2020 ---------------------------------------------------------------------------------------------------------------------------------------------- (*) New function hyperbolic_arc_rasterization() has been defined which sequentially rasterizes the hyperbolic arc and creates a graphic image of how hyperbola looks like post-rasterization. A related schematic diagram for rasterization has already been committed to GRAFIT course material (https://github.com/shrinivaasanka/Grafit/blob/master/course_material/NeuronRain/LinuxKernelAndCloud/BigdataAnalyticsCloud_CourseNotes.txt) on Geometric search of a point on hyperplanes separating halfspaces by multidimensional Hyperplanar point location which widens the scope of factorization to arbitrary algebraic curves (e.g diophantines) for integer solutions, not limited to hyperbolae - example: uvwxyz=N is a multiplicative partition problem solvable by rasterizing on Z^6 hyperplane point location - (u,v,w,x,y,z) (*) Hyperbolic arc rasterized tile segments are plotted by matplotlib and example logs-images for a small integer are committed to testlogs/ - DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.Rasterization.9January2020.png and DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.Python3.7.5Upgrade.RasterizationGraphics.log.9January2020 (*) matplotlib rasterization graphics is enabled by a boolean flag passed on by commandline sys.argv arguments (*) Depth of the non-uniform NC circuit which was hardcoded earlier has been parametrized as commandline argument (*) Normal order loop has been changed because of overflow errors for large exponents (*) Huge 1213 bits non-smooth hard integer of random digits 99999999999928918219821828128918928918281939787878773273872837129818280829189289178718738718732378278467475452652773628381712918298198298182918928198298192891892718278178261627167261726716721627162761762617271267617261762716726172671627167267162761726716271626715365365636635157612126716725162561526516256152613389132311132838292323233433434123212839289382832983291 has been factorized by a depth 58 NC circuit (PRAM time O((logN)^58) and first few factors are printed as ordered pairs (requires division because of or clause and division has been cast to Decimal() because of overflow errors) in testlogs/DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.Python3.7.5Upgrade.1213bits_and_1243bits.9January2020 from 51st second onwards: ================================================= ('Factors are: (', 3, ',', Decimal('3.333333333330963940660727604E+364'), ') (at ', 'Thu, 09 Jan 2020 10:49:02 GMT', ')') ================================================= ================================================= ('Factors are: (', 7, ',', Decimal('1.428571428570413117426026116E+364'), ') (at ', 'Thu, 09 Jan 2020 10:49:02 GMT', ')') ================================================= ================================================= ('Factors are: (', 21, ',', Decimal('4.761904761901377058086753720E+363'), ') (at ', 'Thu, 09 Jan 2020 10:49:03 GMT', ')') =================================================
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) People Analytics - Drone Electronic Voting Machine - Python 3.7.5 upgrade and Paper ballot shuffle simulation, PRAM Breadth First and Depth First Search, Set Partition Analytics, Money Trail Economic EventNet Graph Random Walk, Expander Graphs, Cheeger's Constant, Random Closed Packing, Space Filling, Pseudorandomness Extractors and Generators, Birthday Paradox, Unique Identification
Srinivasan Kannan
More... almost 7 years ago
----------------------------------------------------------------------------------------------------------------------------------------------- 740. (THEORY and FEATURE) People Analytics - Drone Electronic Voting Machine - Python 3.7.5 upgrade and Paper ballot shuffle simulation, PRAM Breadth First and Depth First Search, Set Partition Analytics, Money Trail Economic EventNet Graph Random Walk, Expander Graphs, Cheeger's Constant, Random Closed Packing, Space Filling, Pseudorandomness Extractors and Generators, Birthday Paradox, Unique Identification - 7 January 2020 - related to 135,230,461,739 ----------------------------------------------------------------------------------------------------------------------------------------------- (*) Drone Electronic Voting Machine implementation in Streaming_SetPartitionAnalytics.py - electronic_voting_machine() - has been updated to simulate random shuffle of paper ballots in boxes to ensure disorder - votes appended to bucket per candidate are shuffled after each vote - every new vote is randomly inserted into obfuscated encrypted bucket of votes per candidate which simulates a shuffle (shuffle is essentially a permutation group Sn) while an exact shuffle has to enumerate the permutation group (O(n!)) and choose one element - every shuffle of a candidate bucket is also a reduction from space filling and random closed packing (*) Drone EVM implementation has been upgraded to Python 3.7.5 by autopep8 and 2to3 utilities and 2.7 version has been separately committed with eponymous suffix - random.randint() has been invoked to get an index to insert a new vote somewhere in the candidate bucket (*) Traditional incremental counters coalesce votes of multiple voters into one integer which prohibits forensic examination of individual votes if there is a dispute. Votes per candidate bucket thus isolates each anonymous encrypted vote but subverts chronological ordering. (*) Serial number unique id(s) of paper currencies were envisaged earlier as non-digital one time passwords for authenticating a voter. Rationale for choice of currencies is the unpredictable pseudorandom flow of paper currency unique id(s) in economy which creates a huge EventNet Money Trail Graph (edges are labelled by flow of uniquely ID-ed currencies between buyers and sellers) which is non-digital and thus insulated from electronic sabotage. Money Trail EventNet Graph is a high entropy randomness source and could serve as a psueodrandomness generator and extractor e.g topological sort or random walk of a subgraph of money trail EventNet is a random concatenation of unique id(s) (*) If Money Trail EventNet Graph is an edge expander, it could be a gadget for Pseudorandom Number Generator. Edge expander graphs are defined with Cheeger's constant for minimum high edge boundary per vertex subset: minimum(|boundary(S)|/|S|), 1 < |S| < n/2 where boundary(S) of a subset S of vertices of G (V(G)) is: boundary(S) = { (u,v) | u in S, v in V(G) \ S} Random walks on an expander graph are conventionally applied to Pseudorandom Generators e.g. Margulis [Mar88] and Lubotzky, Phillips and Sarnak [LPS88] (*) Locating an encrypted vote in a candidate bucket of votes (if bucket is a linked list) could be done in sublinear time by Parallel RAM Breadth First Search and Depth First Search of the linked list line graph - GRAFIT course material in https://github.com/shrinivaasanka/Grafit/blob/master/course_material/NeuronRain/AdvancedComputerScienceAndMachineLearning/AdvancedComputerScienceAndMachineLearning.txt mention usefulness of parallel RAM sublinear linked list search in the context of Survival Index Timeout OS Scheduler version of Process IDs Set Partition in OS Kernels (*) Limitations of unique identification are best explained by birthday paradox - GRAFIT course material in https://github.com/shrinivaasanka/Grafit/blob/master/course_material/ComputerScienceMiscellaneous/ComputerScienceMiscellaneous_CourseNotes.txt have a Q and A on birthday paradox probability of collision of unique IDs in a population. (*) An expander graph simulation of Economic Network by Neuro Cryptocurrency in NeuronRain which is Boost UUID, Protocol Buffer, Perfect-Forward and Object Move based, theoretically could source pseudorandom bits.
Srinivasan Kannan
More... almost 7 years ago
Theory Updates to: (*) Computational Geometric NC-PRAM-BSP Factorization - Python 3.7.5 Single node cluster quadcore benchmarks - 1067 bits integer - some factcheck references on NC-PRAM equivalence and input size (*) Intrinsic Merit - Unique Identification and its necessity in People Analytics (Drone Electronic Voting Machines), Online Citizen Science, Sports Analytics and Academic Rankings, BKS Conjecture, Consensus versus Majority
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Computational Geometric NC-PRAM-BSP Factorization - Python 3.7.5 Single node cluster quadcore benchmarks - 1067 bits integer - some factcheck references on NC-PRAM equivalence and input size - 24 December 2019,31 December 2019 - related to all sections on Factorization - Rasterization optimization
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Intrinsic Merit - Unique Identification and its necessity in People Analytics (Drone Electronic Voting Machines), Online Citizen Science, Sports Analytics and Academic Rankings, BKS Conjecture, Consensus versus Majority
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Intrinsic Merit - Unique Identification and its necessity in People Analytics (Drone Electronic Voting Machines), Online Citizen Science, Sports Analytics and Academic Rankings, BKS Conjecture, Consensus versus Majority
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Computational Geometric NC-PRAM-BSP Factorization - Python 3.7.5 Single node cluster quadcore benchmarks - 1067 bits integer - some factcheck references on NC-PRAM equivalence and input size
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Computational Geometric NC-PRAM-BSP Factorization - Python 3.7.5 Single node cluster quadcore benchmarks - 1067 bits integer - some factcheck references on NC-PRAM equivalence and input size
Srinivasan Kannan
More... almost 7 years ago
----------------------------------------------------------------------------------------------------------------------------------------------- 738. (THEORY and FEATURE) Computational Geometric NC-PRAM-BSP Factorization - Python 3.7.5 Single node cluster quadcore benchmarks - 1067 bits integer - some factcheck references on NC-PRAM equivalence and input size - 24 December 2019 - related to all sections on Factorization ----------------------------------------------------------------------------------------------------------------------------------------------- 1.In continuation of previous benchmarks on 1000 bits integer another hard non-smooth random 1067 bits integer of randomly mixed digits - 939483849839493438483989489384983948938843984983984983984938948348938499384928830928380289389283982983928398249748378478378738478738748729839289389289382983982983928938298398298328938298398239274873874873874928338298938298392893298392893829839289382983928398298392839289382983928748738758374837483737481349384833499384979 - has been factorized on single node cluster of quadcores and first few factors - mostly primes - are printed from 18th second onwards: ================================================= ('Factor is = ', 11, '(at ', 'Tue, 24 Dec 2019 08:21:47 GMT', ')') ================================================= ================================================= ('Factor is = ', 17, '(at ', 'Tue, 24 Dec 2019 08:21:47 GMT', ')') ================================================= ================================================= ('Factor is = ', 47, '(at ', 'Tue, 24 Dec 2019 08:21:49 GMT', ')') ================================================= ================================================= ('Factor is = ', 51, '(at ', 'Tue, 24 Dec 2019 08:21:49 GMT', ')') ================================================= ================================================= ('Factor is = ', 141, '(at ', 'Tue, 24 Dec 2019 08:21:53 GMT', ')') ================================================= ================================================= ('Factor is = ', 187, '(at ', 'Tue, 24 Dec 2019 08:21:55 GMT', ')') ================================================= ================================================= ('Factor is = ', 289, '(at ', 'Tue, 24 Dec 2019 08:22:00 GMT', ')') ================================================= ================================================= ('Factor is = ', 311, '(at ', 'Tue, 24 Dec 2019 08:22:01 GMT', ')') ================================================= ================================================= ('Factor is = ', 517, '(at ', 'Tue, 24 Dec 2019 08:22:11 GMT', ')') ================================================= ================================================= ('Factor is = ', 561, '(at ', 'Tue, 24 Dec 2019 08:22:13 GMT', ')') ================================================= ================================================= ('Factor is = ', 799, '(at ', 'Tue, 24 Dec 2019 08:22:24 GMT', ')') ================================================= ================================================= ('Factor is = ', 867, '(at ', 'Tue, 24 Dec 2019 08:22:27 GMT', ')') ================================================= ================================================= ('Factor is = ', 3179, '(at ', 'Tue, 24 Dec 2019 08:24:16 GMT', ')') ================================================= ================================================= ('Factor is = ', 3421, '(at ', 'Tue, 24 Dec 2019 08:24:27 GMT', ')') ================================================= ================================================= ('Factor is = ', 5287, '(at ', 'Tue, 24 Dec 2019 08:25:54 GMT', ')') ================================================= ================================================= ('Factor is = ', 8789, '(at ', 'Tue, 24 Dec 2019 08:28:37 GMT', ')') ================================================= ================================================= ('Factor is = ', 9537, '(at ', 'Tue, 24 Dec 2019 08:29:12 GMT', ')') ================================================= ================================================= ('Factor is = ', 10263, '(at ', 'Tue, 24 Dec 2019 08:29:46 GMT', ')') ================================================= ================================================= ('Factor is = ', 13583, '(at ', 'Tue, 24 Dec 2019 08:32:20 GMT', ')') ================================================= [....truncated....] 2.float() cast has been changed to Decimal() for highest precision and remove overflow errors for tile segments and interval midpoint computations 3.Recursion limit has been increased to 10000 4.Exponentiation by math.pow() for normal order computation in local search optimization has been replaced by faster ** exponentiation operator of Python. 5.Exponent k in local search loop - (logN)^k (iterations) * N/(logN)^k (PRAMs) - has been parametrized in SearchTiles_and_Factorize() function which simulates non-uniform NC circuit of (logN)^k depth and N/(logN)^k circuit elements.
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Spark NC-PRAM-BSP Computational Geometric Factorization quadcore Python 3.7.5 benchmarks - 1000+ bits non-smooth random integer of mixed digits
Srinivasan Kannan
More... almost 7 years ago
---------------------------------------------------------------------------------------------------------------------------------------------- 737. (THEORY and FEATURE) Spark NC-PRAM-BSP Computational Geometric Factorization quadcore Python 3.7.5 benchmarks - 1000+ bits non-smooth random integer of mixed digits - 22 December 2019 - related to all sections on Computational Geometric Factorization ---------------------------------------------------------------------------------------------------------------------------------------------- 1.DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.py has been changed to increase k to 100 which factorizes a difficult 1000 bits integer of mixed digits (low omega and less number of prime factors) which is by far the largest integer factorized in NeuronRain - 99320930203909302903909209302309029309029039203819821892891217288172871728718728172817287187281728718728178728173183617637939029309112882189434889893898293112982918998767676767565656545455343787878787876767566565645454534434333878738728738278372243439848343884384983984989483849839483984983984983984977 - in O((logN)^100) Parallel RAM time requiring O(N/(logN)^100) PRAM processors - first few factors are printed below within 20 seconds and 73 seconds respectively which includes Spark-Python-Py4j-Java 8 bidirectional marshalling and VM bytecode interpretation overhead (Cythonized C++ DLL version might be still faster):
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Reduction from Set Partition to Exact Square Tiles Cover of Rectangular Region, Lagrange Four Square Theorem, Complementary Sets, Computational Geometric Factorization, Space Filling, Tile Cover, Packing, Set Partition/Histogram Analytics, LSH Partitions, Separate Chaining Hashtables - CGAL and TBB Parallel Planar Point Location for Factor points on rasterized hyperbolic arc bow - references
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Computational Geometric PRAM-NC-BSP Factorization - Python 3.7.5 upgrade - Spark Quadcore benchmarks - 512 bit integer
Srinivasan Kannan
More... almost 7 years ago
---------------------------------------------------------------------------------------------------------------------------------------------- 736. (THEORY and FEATURE) Computational Geometric PRAM-NC-BSP Factorization - Python 3.7.5 upgrade - Spark Quadcore benchmarks - 512 bit integer - related to 477,481 and all other sections on Factorization ---------------------------------------------------------------------------------------------------------------------------------------------- 1.Computational Geometric Factorization Python-Spark implementation has been upgraded to Python 3.7.5 and following local tile search algorithm mentioned in 477 and 481 has been implemented which obviates parallel sorting and completely removes the maximum integer barrier altogether:
Srinivasan Kannan
More... almost 7 years ago
Fame-Merit Equilibrium and Converging Markov Random Walk on World Wide Web, Condorcet Jury Theorem, Bipartite Decomposition of World Wide Web, Margulis-Ruzzo Threshold - Conjecture, Market economics, Demand-Supply equilibrium
Srinivasan Kannan
More... almost 7 years ago
(THEORY and FEATURE) Complement Diophantines - Least Squares Vandermonde Polynomial Fit Learning - related to all sections on Complement Diophantines - Python 3.7.5 upgrade
Srinivasan Kannan
More... almost 7 years ago
---------------------------------------------------------------------------------------------------------------------------------------------- 735. (THEORY and FEATURE) Complement Diophantines - Least Squares Vandermonde Polynomial Fit Learning - related to all sections on Complement Diophantines - Python 3.7.5 upgrade - 14 December 2019 ---------------------------------------------------------------------------------------------------------------------------------------------- 1. complement.py complement diophantine learner has been updated to learn a degree 5 interpolated polynomial for a complementary set (non-squares) 2. polyfit() from numeric python has been invoked on a complementary set of non-squares (https://docs.scipy.org/doc/numpy/reference/generated/numpy.polyfit.html) which is a least squares solution solver for Vandermonde coefficient matrix 3. polyfit() least square interpolation is an alternative to Lagrangian polynomial interpolation (https://en.wikipedia.org/wiki/Lagrange_polynomial) mentioned in arXiv version (https://arxiv.org/abs/1106.4102v1, https://scholar.google.com/citations?user=eLZY7CIAAAAJ&hl=en). 4. complement.py has been upgraded to Python 3.7.5 from Python 2.7 by autopep8 and 2to3 utilities. Python 2.7 version has been suffixed as .2.7 5. polyfit() least square interpolation is guaranteed to be unique - https://en.wikipedia.org/wiki/Polynomial_interpolation 6. logs for polyfit() are committed to testlogs/complement.PolyFitPython3.7.5.14December2019 7. Least Squares and Lagrangian interpolations are total functions while Lagrange Four Square Theorem complement map is a partial function (not all domain tuples are mapped to a point in complementary set)
Srinivasan Kannan
More... almost 7 years ago
(FEATURE) Merit of Large Scale Visuals - Video EventNet Tensor Decomposition to Rank-1 Tensors on Python 3.7.5 - slicing
Srinivasan Kannan
More... almost 7 years ago
---------------------------------------------------------------------------------------------------------------------------------------------- 734. (FEATURE) Merit of Large Scale Visuals - Video EventNet Tensor Decomposition to Rank-1 Tensors on Python 3.7.5 - slicing - 12 December 2019 ---------------------------------------------------------------------------------------------------------------------------------------------- 1.ImageNet_Keras_Theano.py videograph_eventnet_tensor_product() has been changed to accept side of square slice per frame as an argument which is by default 100*100 pixels. 2.Square slicing per frame is necessary when elements of video tensor product matrix are of unequal rectangular dimensions and tensorly stipulates equal dimensions. 3.Usual videos have frames of equal dimensions but the example montage video footage in NeuronRain has unequal frame sizes and minimum frame sides have to be found which are then used to slice each frame. 4.Since a video can have arbitrarily large number of frames in millions, finding the minimum sides of the frame rectangles could be daunting. 5.Instead of finding minimum frame sides, square slicing has been made default and configurable by user in function argument "squareslice" which is by default 100. 6.Python 3.6.8 for TensorLy has been upgraded to Python 3.7.5 which is the fastest python distribution.
Srinivasan Kannan
More... almost 7 years ago
(THEORY) Category Theory formulation of EventNet - Objects, Morphisms, Functors - Ramsey Theorem and Emergence of Order in Chaotic EventNet
Srinivasan Kannan
More... almost 7 years ago
----------------------------------------------------------------------------------------------------------------------------------------------- 733. (FEATURE and THEORY) Computational Geometric Factorization - Quadcore Python 3.6 Upgrade Benchmarks - 11 December 2019 - related to all sections of Factorization ----------------------------------------------------------------------------------------------------------------------------------------------- 1.This commit upgrades Spark Python Computational Geometric Factorization implementation DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.py from Python 2.7 to Python 3.6 for performance and availing the better range() utility in Python 3.x which breaches the maximum range barrier limitation in Python 2.7. Python 3.6 range() is a rewrite and supports huge integers (of hundreds of digits). 2.Following Spark Python environment variables have been set to Python 3.6m binary for PySpark upgrade to Python 3.6: SPARK_PYTHON=/usr/bin/python3.6m SPARK_DRIVER_PYTHON=/usr/bin/python3.6m 3.Large Integer 999999999999999999 (60 bits) has been factorized which is by far the largest integer factorized in Spark BSP-NC-PRAM model. Larger integers throw a Spark Python error in PySpark context.py (File "spark-2.4.3-bin-hadoop2.7/python/lib/pyspark.zip/pyspark/context.py", line 501, in parallelize, OverflowError: Python int too large to convert to C ssize_t): if isinstance(c, xrange): size = len(c) because of len() failure for larger integers [ Error can also be produced from commandline: >>> x=range(9999999999999999999) >>> len(x) Traceback (most recent call last): File "<stdin>", line 1, in <module> OverflowError: Python int too large to convert to C ssize_t >>> x=range(999999999999999999) >>> len(x) 999999999999999999 ] 4.Previous error requires Spark rewrite of context.py parallelize() to: range().stop - range().start replacing len() specific to Python 3.x range() 5.Python 2.7 Spark Factorization implementation has been upgraded to Python 3.6 by autopep8 followed by 2to3-2.7 utilities. Python 2.7 version has been marked as DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.py.2.7 6.Spark Python version is printed by sys.version: Spark Python version: 3.6.8 (default, Oct 7 2019, 12:59:55) [GCC 8.3.0] 7.First few factors of 999999999999999999 are printed to testlogs/DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.Python3.6Upgrade.11December2019. Timestamp of each factor is printed. 8.Ray shooting queries excluding Hardy-Ramanujan and some imports have been commented.
Srinivasan Kannan
More... almost 7 years ago
----------------------------------------------------------------------------------------------------------------------------------------------- 733. (FEATURE and THEORY) Computational Geometric Factorization - Quadcore Python 3.6 Upgrade Benchmarks - 11 December 2019 - related to all sections of Factorization ----------------------------------------------------------------------------------------------------------------------------------------------- 1.This commit upgrades Spark Python Computational Geometric Factorization implementation DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.py from Python 2.7 to Python 3.6 for performance and availing the better range() utility in Python 3.x which breaches the maximum range barrier limitation in Python 2.7. Python 3.6 range() is a rewrite and supports huge integers (of hundreds of digits). 2.Following Spark Python environment variables have been set to Python 3.6m binary for PySpark upgrade to Python 3.6: SPARK_PYTHON=/usr/bin/python3.6m SPARK_DRIVER_PYTHON=/usr/bin/python3.6m 3.Large Integer 999999999999999999 (60 bits) has been factorized which is by far the largest integer factorized in Spark BSP-NC-PRAM model. Larger integers throw a Spark Python error in PySpark context.py (File "spark-2.4.3-bin-hadoop2.7/python/lib/pyspark.zip/pyspark/context.py", line 501, in parallelize, OverflowError: Python int too large to convert to C ssize_t): if isinstance(c, xrange): size = len(c) because of len() failure for larger integers [ Error can also be produced from commandline: >>> x=range(9999999999999999999) >>> len(x) Traceback (most recent call last): File "<stdin>", line 1, in <module> OverflowError: Python int too large to convert to C ssize_t >>> x=range(999999999999999999) >>> len(x) 999999999999999999 ] 4.Previous error requires Spark rewrite of context.py parallelize() to: range().stop - range().start replacing len() specific to Python 3.x range() 5.Python 2.7 Spark Factorization implementation has been upgraded to Python 3.6 by autopep8 followed by 2to3-2.7 utilities. Python 2.7 version has been marked as DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.py.2.7 6.Spark Python version is printed by sys.version: Spark Python version: 3.6.8 (default, Oct 7 2019, 12:59:55) [GCC 8.3.0] 7.First few factors of 999999999999999999 are printed to testlogs/DiscreteHyperbolicFactorizationUpperbound_TileSearch_Optimized.Python3.6Upgrade.11December2019. Timestamp of each factor is printed. 8.Ray shooting queries excluding Hardy-Ramanujan and some imports have been commented.
Srinivasan Kannan
More... almost 7 years ago
Updated Requirements.txt
Srinivasan Kannan
More... almost 7 years ago
Updated Requirements.txt
Srinivasan Kannan
More... almost 7 years ago