Support converting strings to numbers.

Author: jjrv

README.md

@@ -9,12 +9,13 @@
 `bigfloat` is a fast arbitrary precision math library optimized for computational geometry and geoinformatics.
 It provides binary floating point:
 
-- conversion from the JavaScript number type, `x = new BigFloat53(123.456)`
+- conversion to / from the JavaScript number type, `x = new BigFloat32(123.456)` and `x.valueOf()`
 - addition, `x.add(y)`
 - subtraction, `x.sub(y)`
 - multiplication, `x.mul(y)`
 - comparison, `x.deltaFrom(y)` alias `x.cmp(y)`
-- conversion to string in even bases 2-36, `x.toString(10)`
+- string output in even bases 2-36, `x.toString(10)`
+- string parsing in bases 2-36, `x = new BigFloat32('abc.def', 16)`
 
 without ever losing any significant bits. Numbers are immutable in the above operations, so they return a new BigFloat.
 For efficiency, the following methods instead destructively change the value:

src/BaseInfo32.ts

@@ -22,11 +22,13 @@ export class BaseInfo32 {
 
 	private static baseTbl: { [base: number]: BaseInfo32 } = {};
 
-	/** Number of digits per limb, for compatibility in rounding. */
-	limbDigits = Math.log(limbSize32) / Math.log(this.base);
+	/** Average number of digits per limb. */
+	limbDigitsExact = Math.log(limbSize32) / Math.log(this.base);
+	/** Number of entire digits per limb. */
+	limbDigits = ~~this.limbDigitsExact;
 	/** Maximum power of base that fits in a limb. */
-	limbBase = Math.pow(this.base, ~~this.limbDigits);
+	limbBase = Math.pow(this.base, this.limbDigits);
 	/** String of zeroes for padding an empty limb. */
-	pad = zeroes(~~this.limbDigits);
+	pad = zeroes(this.limbDigits);
 
 }

src/BigComplex.ts

@@ -18,11 +18,12 @@ function __extends<Child, Parent>(child: new(...args: any[]) => Child, parent: n
 export class BigComplex<Base extends BigFloatBase<Base>> {
 
 	constructor(
-		real?: Base | number,
-		imag?: Base | number
+		real?: Base | number | string,
+		imag?: Base | number | string,
+		base?: number
 	) {
-		this.real = typeof(real) == 'object' ? real : new this.Base(real);
-		this.imag = typeof(imag) == 'object' ? imag : new this.Base(imag);
+		this.real = typeof(real) == 'object' ? real : new this.Base(real, base);
+		this.imag = typeof(imag) == 'object' ? imag : new this.Base(imag, base);
 	}
 
 	clone() {
@@ -113,7 +114,7 @@ export class BigComplex<Base extends BigFloatBase<Base>> {
 		return(this);
 	}
 
-	Base: new(x?: number) => Base;
+	Base: new(x?: Base | number | string, base?: number) => Base;
 	real: Base;
 	imag: Base;
 

src/BigFloat32.ts

@@ -7,8 +7,8 @@ import { trimNumber } from './util';
 
 export class BigFloat32 implements BigFloatBase<BigFloat32> {
 
-	constructor(value?: number | BigFloat32) {
-		value ? this.setValue(value) : this.setZero();
+	constructor(value?: BigFloat32 | number | string, base?: number) {
+		value ? this.setValue(value, base) : this.setZero();
 	}
 
 	clone() {
@@ -23,12 +23,16 @@ export class BigFloat32 implements BigFloatBase<BigFloat32> {
 		return(this);
 	}
 
-	setValue(other: number | BigFloat32) {
+	setValue(other: BigFloat32 | number | string, base?: number) {
 		if(typeof(other) == 'number') {
 			return(this.setNumber(other));
 		}
 
-		return(this.setBig(other));
+		if(other instanceof BigFloat32) {
+			return(this.setBig(other));
+		}
+
+		return(this.setString(other.toString(), base || 10));
 	}
 
 	private setBig(other: BigFloat32) {
@@ -87,8 +91,10 @@ export class BigFloat32 implements BigFloatBase<BigFloat32> {
 		len += pos + 1;
 
 		// Handle integer part.
+
 		while(iPart) {
 			// Extract limbs starting from the least significant.
+
 			limb = iPart % limbSize32; // Could also be iPart >>> 0
 			iPart = (iPart - limb) / limbSize32;
 
@@ -103,6 +109,112 @@ export class BigFloat32 implements BigFloatBase<BigFloat32> {
 		return(this);
 	}
 
+	private parseFraction(value: string, base: number, start: number, offset: number, limbBase: number, limbDigits: number) {
+		const limbList = this.limbList;
+		let pos = value.length;
+
+		// Set limbs to zero, because divInt uses them as input.
+
+		let limbNum = offset - 1;
+
+		while(limbNum) {
+			limbList[--limbNum] = 0;
+		}
+
+		// Read initial digits so their count becomes divisible by limbDigits.
+
+		let posNext = pos - ((pos - start + limbDigits - 1) % limbDigits + 1);
+
+		limbList[offset - 1] = parseInt(value.substr(posNext, pos - posNext), base);
+		this.divInt(Math.pow(base, pos - posNext), offset);
+
+		pos = posNext;
+
+		// Read rest of the digits in limbDigits sized chunks.
+
+		while(pos > start) {
+			pos -= limbDigits;
+
+			limbList[offset - 1] = parseInt(value.substr(pos, limbDigits), base);
+
+			// Divide by maximum power of base that fits in a limb.
+			this.divInt(limbBase, offset);
+		}
+	}
+
+	private setString(value: string, base: number) {
+		const { limbBase, limbDigits, limbDigitsExact } = BaseInfo32.init(base);
+		const limbList = this.limbList;
+		let pos = -1;
+		let c: string;
+
+		this.sign = 1;
+
+		// Handle leading signs and zeroes.
+
+		while(1) {
+			c = value.charAt(++pos);
+
+			switch(c) {
+				case '-':
+					this.sign = -1;
+				case '+':
+				case '0':
+					continue;
+			}
+
+			break;
+		}
+
+		const posDot = (value.indexOf('.', pos) + 1 || value.length + 1) - 1;
+
+		// Handle fractional part.
+
+		if(posDot < value.length - 1) {
+			// Reserve enough limbs to contain digits in fractional part.
+			const len = ~~((value.length - posDot - 1) / limbDigitsExact) + 1;
+
+			this.parseFraction(value, base, posDot + 1, len + 1, limbBase, limbDigits);
+
+			this.fractionLen = len;
+			this.len = len;
+
+			// Remove trailing zeroes.
+			this.trimLeast();
+		} else {
+			this.fractionLen = 0;
+			this.len = 0;
+		}
+
+		const offset = this.fractionLen;
+
+		// Handle integer part.
+
+		if(posDot > pos) {
+			// Read initial digits so their count becomes divisible by limbDigits.
+
+			let posNext = pos + (posDot - pos + limbDigits - 1) % limbDigits + 1;
+
+			++this.len;
+			limbList[offset] = parseInt(value.substr(pos, posNext - pos), base);
+			pos = posNext;
+
+			// Read rest of the digits in limbDigits sized chunks.
+
+			while(pos < posDot) {
+				// Multiply by maximum power of base that fits in a limb.
+				if(this.mulInt(limbBase, limbList, offset, offset, 0)) ++this.len;
+
+				// Add latest limb.
+				limbList[offset] += parseInt(value.substr(pos, limbDigits), base);
+
+				pos += limbDigits;
+			}
+		}
+
+		return(this);
+	}
+
 	/** Trim zero limbs from most significant end. */
 
 	private trimMost() {
@@ -481,21 +593,20 @@ export class BigFloat32 implements BigFloatBase<BigFloat32> {
 
 	/** Divide by integer, replacing current value by quotient. Return integer remainder. */
 
-	private divInt(divisor: number) {
+	private divInt(divisor: number, pos: number) {
 		let limbList = this.limbList;
-		let limbNum = this.len;
 		let limb: number;
 		let hi: number, lo: number;
 		let carry = 0;
 
 		// If most significant limb is zero after dividing, decrement number of limbs remaining.
-		if(limbList[limbNum - 1] < divisor) {
-			carry = limbList[--limbNum];
-			this.len = limbNum;
+		if(limbList[pos - 1] < divisor) {
+			carry = limbList[--pos];
+			this.len = pos;
 		}
 
-		while(limbNum--) {
-			limb = limbList[limbNum];
+		while(pos--) {
+			limb = limbList[pos];
 
 			carry = carry * 0x10000 + (limb >>> 16);
 			hi = (carry / divisor) >>> 0;
@@ -505,7 +616,7 @@ export class BigFloat32 implements BigFloatBase<BigFloat32> {
 			lo = (carry / divisor) >>> 0;
 			carry = carry - lo * divisor;
 
-			limbList[limbNum] = ((hi << 16) | lo) >>> 0;
+			limbList[pos] = ((hi << 16) | lo) >>> 0;
 		}
 
 		return(carry);
@@ -545,11 +656,29 @@ export class BigFloat32 implements BigFloatBase<BigFloat32> {
 		}
 	}
 
+	getExpansion(output: number[]) {
+		const limbList = this.limbList;
+		const len = this.len;
+		let exp = this.sign;
+		let pos = this.fractionLen;
+
+		while(pos--) {
+			exp *= limbInv32;
+		}
+
+		while(++pos < len) {
+			output[pos] = limbList[pos] * exp;
+			exp *= limbSize32;
+		}
+
+		return(len);
+	}
+
 	valueOf() {
 		const limbList = this.limbList;
-		let len = this.fractionLen;
 		let result = 0;
 		let exp = limbInv32 * this.sign;
+		let len = this.fractionLen;
 		let pos = 0;
 
 		while(pos < len) {
@@ -584,7 +713,7 @@ export class BigFloat32 implements BigFloatBase<BigFloat32> {
 
 			// Loop while 2 or more limbs remain, requiring arbitrary precision division to extract digits.
 			while(iPart.len > 1) {
-				limbStr = iPart.divInt(limbBase).toString(base);
+				limbStr = iPart.divInt(limbBase, iPart.len).toString(base);
 
 				// Prepend digits into final result, padded with zeroes to 9 digits.
 				// Since more limbs still remain, whole result will not have extra padding.

src/BigFloat53.ts

@@ -72,8 +72,8 @@ export class BigFloat53 implements BigFloatBase<BigFloat53> {
 	/** @param value Initial value, a plain JavaScript floating point number
 	  * (IEEE 754 double precision). */
 
-	constructor(value?: number | BigFloat53) {
-		if(value) this.setValue(value);
+	constructor(value?: BigFloat53 | number | string, base?: number) {
+		if(value) this.setValue(value, base);
 	}
 
 	clone() {
@@ -90,12 +90,15 @@ export class BigFloat53 implements BigFloatBase<BigFloat53> {
 		return(this);
 	}
 
-	setValue(other: number | BigFloat53) {
+	setValue(other: BigFloat53 | number | string, base?: number) {
 		if(typeof(other) == 'number') {
 			return(this.setNumber(other));
 		}
+		if(other instanceof BigFloat53) {
+			return(this.setBig(other));
+		}
 
-		return(this.setBig(other));
+		return(this.setString(other.toString(), base || 10));
 	}
 
 	private setBig(other: BigFloat53) {
@@ -123,6 +126,15 @@ export class BigFloat53 implements BigFloatBase<BigFloat53> {
 		return(this);
 	}
 
+	private setString(value: string, base: number) {
+		temp32[0].setValue(value, base);
+
+		this.len = temp32[0].getExpansion(this.limbList);
+		this.normalize();
+
+		return(this);
+	}
+
 	/** Set value to the sum of two JavaScript numbers.
 	  *
 	  * @param a Augend.

src/BigFloatBase.ts

@@ -2,10 +2,9 @@
 // Released under the MIT license, see LICENSE.
 
 export interface BigFloatBase<Type> {
-
 	clone(): Type;
 	setZero(): Type;
-	setValue(value: number | Type): Type;
+	setValue(value: Type | number | string, base?: number): Type;
 	mul(multiplier: number | Type, product?: Type): Type;
 	// absDeltaFrom(other: number | Type): Type;
 	cmp(other: number | Type): number;
@@ -19,4 +18,5 @@ export interface BigFloatBase<Type> {
 	round(decimalCount: number): Type;
 	valueOf(): number;
 	toString(base: number): string;
+
 }