💥 BREAKING CHANGE: Make API more coherent.

Author: make-github-pseudonymous-again

src/_stringify_digits.js

@@ -1,19 +1,23 @@
-export function _stringify_digits ( str , base , { sign , left , transient , repetend } ) {
+export function _stringify_digits ( { str } ) {
 
-	const toStr = x => str(x, base);
+	return function ( base , { sign , integral , transient , repetend } ) {
 
-	let repr = '' ;
+		const toStr = x => str(x, base);
 
-	if (sign < 0) repr += '-' ;
+		let repr = '' ;
 
-	repr += toStr(left) ;
+		if (sign < 0) repr += '-' ;
 
-	if (transient.length || repetend.length) repr += '.' ;
-	repr += transient.map(toStr).join('') ;
+		repr += toStr(integral) ;
 
-	if (repetend.length) repr += '|' ;
-	repr += repetend.map(toStr).join('') ;
+		if (transient.length || repetend.length) repr += '.' ;
+		repr += transient.map(toStr).join('') ;
 
-	return repr ;
+		if (repetend.length) repr += '|' ;
+		repr += repetend.map(toStr).join('') ;
+
+		return repr ;
+
+	} ;
 
 }

src/decimals.js

@@ -2,9 +2,9 @@
 // for transient + repetend by multiplying x by b**M and do a single division ?
 // That may be too much space in most cases. Though necessary when d is prime.
 
-export function _decimals ( { b , eq , muln , divmod } ) {
+export function _decimals ( { eq , muln , divmod } ) {
 
-	return function* ( d , n , hasrepetend , x ) {
+	return function* ( b , d , n , hasrepetend , x ) {
 
 		// Computes the length of the repetend of x/d (1 <= x < d) in base b
 		// with transient part of size n.

src/digits.js

@@ -2,26 +2,26 @@ import { take } from '@aureooms/js-itertools' ;
 import { _decimals } from './decimals' ;
 import { _transient } from './transient' ;
 
-export function _digits ( { b , bfactors , jz , gt1 , eq , muln , divmodn , divmod , egcd , sgn , abs } ) {
+export function _digits ( { jz , gt1 , eq , muln , divmodn , divmod , egcd , sgn , abs } ) {
 
-	const tr = _transient( { bfactors , jz , gt1 , divmodn } ) ;
-	const dec = _decimals( { b , eq , muln , divmod } ) ;
+	const tr = _transient( { jz , gt1 , divmodn } ) ;
+	const dec = _decimals( { eq , muln , divmod } ) ;
 
-	return function ( x , d ) {
+	return function ( b , bfactors , x , d ) {
 
-		const [ left , r ] = divmod(abs(x), d) ;
+		const [ integral , r ] = divmod(abs(x), d) ;
 
 		const { u , v } = egcd(d, r) ;
 
-		const [ transient_length , has_repetend ] = tr( v ) ;
+		const [ transient_length , has_repetend ] = tr( bfactors , v ) ;
 
-		const decimals = dec(v, transient_length, has_repetend , u) ;
+		const decimals = dec(b, v, transient_length, has_repetend , u) ;
 
 		const transient = [ ...take(decimals, transient_length) ] ;
 
 		const repetend = [ ...decimals ] ;
 
-		return { sign: sgn(x) , left , transient , repetend } ;
+		return { sign: sgn(x) , integral , transient , repetend } ;
 
 	}
 

src/transient.js

@@ -1,8 +1,8 @@
 // credits https://github.com/aureooms-research/repeating-decimal
 
-export function _transient ( { bfactors , jz , gt1 , divmodn } ) {
+export function _transient ( { jz , gt1 , divmodn } ) {
 
-	return function ( d ) {
+	return function ( bfactors ,  d ) {
 
 		// Computes the length of the non repeating part in x / d
 		// ( for any 1 <= x < d with x and d co-prime ) decimals in

test/src/core.js

@@ -105,9 +105,10 @@ const simplify = [ 'simplify' , '=' , [
 
 
 const stringify_n = b => alu => {
-	const bfactors = ufactors( b ) ;
-	const digits = _digits({ b , bfactors , ...alu }) ;
-	return ( x , d ) => _stringify_digits( alu.str , b , digits(x, d) ) ;
+	const bfactors = ufactors(b) ;
+	const digits = _digits(alu) ;
+	const stringify_digits = _stringify_digits(alu) ;
+	return ( x , d ) => stringify_digits( b , digits(b, bfactors, x, d) ) ;
 } ;