[BigInt.mod] Add TBigInteger and functionality

bigint.mod/bigint.bmx

@@ -37,17 +37,24 @@ End Rem
 Type TBigUnsigned
 
 	Field bigPtr:Byte Ptr
+
+
+	Method New(value:String)
+		Create(value)
+	End Method
+
+	Method New(value:Int)
+		CreateWithInt(value)
+	End Method
+
+
 
 	Method Create:TBigUnsigned(value:String = "")
-		Local this:TBigUnsigned = New TBigUnsigned
-		this.bigPtr = bmx_bigint_BigUnsigned_create(value)
-		Return this
+		bigPtr = bmx_bigint_BigUnsigned_create(value)
 	End Method
 
 	Method CreateWithInt:TBigUnsigned(value:Int)
-		Local this:TBigUnsigned = New TBigUnsigned
-		this.bigPtr = bmx_bigint_BigUnsigned_CreateWithInt(value)
-		Return this
+		bigPtr = bmx_bigint_BigUnsigned_CreateWithInt(value)
 	End Method
 
 	Method IsZero:Int()
@@ -61,7 +68,19 @@ Type TBigUnsigned
 
 	Method GreaterThan:Int(value:TBigUnsigned)
 	End Method
-
+
+
+	Method Add:TBigUnsigned(value:TBigUnsigned)
+		bmx_bigint_BigUnsigned_add(bigPtr, value.bigPtr)
+		return self
+	End Method
+
+
+	Method Divide:TBigUnsigned(value:TBigUnsigned)
+		bmx_bigint_BigUnsigned_divide(bigPtr, value.bigPtr)
+		return self
+	End Method
+
 
 
 	Method ToString:String()
@@ -79,3 +98,223 @@ End Type
 
 
 
+
+
+Rem
+bbdoc: A TBigUnsigned object represents an integer of size limited only by available memory.
+End Rem
+Type TBigInteger
+
+	Field bigPtr:Byte Ptr
+
+
+	Method New(value:String)
+		Create(value)
+	End Method
+
+	Method New(value:Int)
+		CreateWithInt(value)
+	End Method
+
+
+
+	Method Create:TBigInteger(value:String = "")
+		bigPtr = bmx_bigint_BigInteger_create(value)
+	End Method
+
+	Method CreateWithInt:TBigInteger(value:Int)
+		bigPtr = bmx_bigint_BigInteger_CreateWithInt(value)
+	End Method
+
+	Method IsZero:Int()
+	End Method
+
+	Method Equals:Int(value:TBigInteger)
+		Return bmx_bigint_BigInteger_equal(bigPtr, value.bigPtr)
+	End Method
+
+	Method LessThan:Int(value:TBigInteger)
+		Return bmx_bigint_BigInteger_lessThan(bigPtr, value.bigPtr)
+	End Method
+
+	Method LessThanOrEqual:Int(value:TBigInteger)
+		Return bmx_bigint_BigInteger_lessThanOrEqual(bigPtr, value.bigPtr)
+	End Method
+
+	Method GreaterThan:Int(value:TBigInteger)
+		Return bmx_bigint_BigInteger_greaterThan(bigPtr, value.bigPtr)
+	End Method
+
+	Method GreaterThanOrEqual:Int(value:TBigInteger)
+		Return bmx_bigint_BigInteger_greaterThanOrEqual(bigPtr, value.bigPtr)
+	End Method
+
+
+	Method Add:TBigInteger(value:TBigInteger)
+		bmx_bigint_BigInteger_add(bigPtr, value.bigPtr)
+		return self
+	End Method
+
+
+	Method Subtract:TBigInteger(value:TBigInteger)
+		bmx_bigint_BigInteger_add(bigPtr, value.bigPtr)
+		return self
+	End Method
+
+
+	Method Modulo:TBigInteger(value:TBigInteger)
+		bmx_bigint_BigInteger_modulo(bigPtr, value.bigPtr)
+		return self
+	End Method
+
+
+	Method Divide:TBigInteger(value:TBigInteger)
+		bmx_bigint_BigInteger_divide(bigPtr, value.bigPtr)
+		return self
+	End Method
+
+
+	Method Multiply:TBigInteger(value:TBigInteger)
+		bmx_bigint_BigInteger_multiply(bigPtr, value.bigPtr)
+		return self
+	End Method
+
+
+
+	Method CreateAddResult:TBigInteger(value:TBigInteger)
+		Local result:TBigInteger = new TBigInteger()
+		result.bigPtr = bmx_bigint_new_BigInteger_add(bigPtr, value.bigPtr)
+		return result
+	End Method
+
+
+	Method CreateSubtractResult:TBigInteger(value:TBigInteger)
+		Local result:TBigInteger = new TBigInteger()
+		result.bigPtr = bmx_bigint_new_BigInteger_subtract(bigPtr, value.bigPtr)
+		return result
+	End Method
+
+
+	Method CreateModuloResult:TBigInteger(value:TBigInteger)
+		Local result:TBigInteger = new TBigInteger()
+		result.bigPtr = bmx_bigint_new_BigInteger_modulo(bigPtr, value.bigPtr)
+		return result
+	End Method
+
+
+	Method CreateDivideResult:TBigInteger(value:TBigInteger)
+		Local result:TBigInteger = new TBigInteger()
+		result.bigPtr = bmx_bigint_new_BigInteger_divide(bigPtr, value.bigPtr)
+		return result
+	End Method
+
+
+	Method CreateMultiplyResult:TBigInteger(value:TBigInteger)
+		Local result:TBigInteger = new TBigInteger()
+		result.bigPtr = bmx_bigint_new_BigInteger_multiply(bigPtr, value.bigPtr)
+		return result
+	End Method
+
+
+	'add value directly
+    Method Operator :+(value:TBigInteger)
+		Add(value)
+    End Method
+
+
+	'add value and return sum!
+    Method Operator +:TBigInteger(value:TBigInteger)
+		Return CreateAddResult(value)
+    End Method
+
+
+	'subtract value directly
+    Method Operator :-(value:TBigInteger)
+		Subtract(value)
+    End Method
+
+
+	'subtract value and return difference!
+    Method Operator -:TBigInteger(value:TBigInteger)
+		Return CreateSubtractResult(value)
+    End Method
+
+
+	'multiply value directly
+    Method Operator :*(value:TBigInteger)
+		Multiply(value)
+    End Method
+
+
+	'multiply value and return product!
+    Method Operator *:TBigInteger(value:TBigInteger)
+		Return CreateMultiplyResult(value)
+    End Method
+
+
+	'divide value directly
+    Method Operator :/(value:TBigInteger)
+		Divide(value)
+    End Method
+
+
+	'divide value and return quotient!
+    Method Operator /:TBigInteger(value:TBigInteger)
+		Return CreateDivideResult(value)
+    End Method
+
+
+	'divide value and return remainder / modulo!
+    Method Operator :mod(value:TBigInteger)
+		Modulo(value)
+    End Method
+
+
+	'divide value and return remainder / modulo!
+    Method Operator mod:TBigInteger(value:TBigInteger)
+		Return CreateModuloResult(value)
+    End Method
+
+
+    Method Operator >:Int(value:TBigInteger)
+		Return GreaterThan(value)
+    End Method
+
+
+    Method Operator >=:Int(value:TBigInteger)
+		Return GreaterThanOrEqual(value)
+    End Method
+
+
+    Method Operator <:Int(value:TBigInteger)
+		Return LessThan(value)
+    End Method
+
+
+    Method Operator <=:Int(value:TBigInteger)
+		Return LessThanOrEqual(value)
+    End Method
+
+
+    Method Operator =:Int(value:TBigInteger)
+		Return Equals(value)
+    End Method
+
+    Method Operator <>:Int(value:TBigInteger)
+		Return not Equals(value)
+    End Method
+
+
+	Method ToString:String()
+		Return bmx_bigint_BigInteger_ToString(bigPtr)
+	End Method
+
+	Method Delete()
+		If bigPtr Then
+			bmx_bigint_BigInteger_free(bigPtr)
+			bigPtr = Null
+		End If
+	End Method
+
+End Type
+

bigint.mod/common.bmx

@@ -31,6 +31,36 @@ Extern
 
 	Function bmx_bigint_BigUnsigned_ToString:String(handle:Byte Ptr)
 
+	Function bmx_bigint_BigUnsigned_add(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigUnsigned_divide(target:Byte Ptr, value:Byte Ptr)
+
+
+
+	Function bmx_bigint_BigInteger_create:Byte Ptr(value:String)
+	Function bmx_bigint_BigInteger_free(handle:Byte Ptr)
+	Function bmx_bigint_BigInteger_CreateWithInt:Byte Ptr(value:Int)
+
+	Function bmx_bigint_BigInteger_ToString:String(handle:Byte Ptr)
+
+	Function bmx_bigint_BigInteger_equal:Int(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_notequal:Int(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_lessThan:Int(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_lessThanOrEqual:Int(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_greaterThan:Int(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_greaterThanOrEqual:Int(target:Byte Ptr, value:Byte Ptr)
+
+	Function bmx_bigint_BigInteger_add(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_subtract(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_divide(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_multiply(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_BigInteger_modulo(target:Byte Ptr, value:Byte Ptr)
+
+	Function bmx_bigint_new_BigInteger_add:Byte Ptr(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_new_BigInteger_subtract:Byte Ptr(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_new_BigInteger_divide:Byte Ptr(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_new_BigInteger_multiply:Byte Ptr(target:Byte Ptr, value:Byte Ptr)
+	Function bmx_bigint_new_BigInteger_modulo:Byte Ptr(target:Byte Ptr, value:Byte Ptr)
+
 End Extern
 
 

bigint.mod/examples/example_02.bmx

@@ -0,0 +1,53 @@
+SuperStrict
+
+Framework BaH.BigInt
+Import BRL.StandardIO
+
+'create a
+Local bigUnsigned:TBigUnsigned = New TBigUnsigned("100000000000000000000000000000000000000000000000000000000")
+
+Print "100 + 500 = " + new TBigUnsigned(100).Add( new TBigUnsigned(500) ).ToString()
+Print "500 : 10 = " + new TBigUnsigned(500).Divide(new TBigUnsigned(10)).ToString()
+
+
+'now with signs (allows negative numbers)
+Print "-100 + 500 = " + new TBigInteger(-100).Add( new TBigInteger(500) ).ToString()
+Print "500 : 10 = " + new TBigInteger(500).Divide(new TBigInteger(10)).ToString()
+Print "5 : 2 = 2 remaining " + new TBigInteger(5).Modulo(new TBigInteger(2)).ToString()
+Print "500 * 20 = " + new TBigInteger(500).Multiply(new TBigInteger(20)).ToString()
+
+local big1:TBigInteger = new TBigInteger(500)
+'do something with it
+big1.Add(new TBigInteger(20))
+print big1.ToString()
+
+'keep big1 intact ()
+Local big2:TBigInteger = big1.CreateAddResult(new TBigInteger(20))
+print big1.ToString()
+print big2.ToString()
+
+
+'checkout overloaded operators
+Local op1:TBigInteger = new TBigInteger(100)
+Local op2:TBigInteger = new TBigInteger(50)
+Local op3:TBigInteger = op1 + op2
+print op3.ToString()
+op1 :+ op2 'op1 now 150
+print ((op1 + op2).ToString())
+
+'modulo?
+print ((new TBigInteger(50) mod new TBigInteger(8)).ToString())
+
+'bigger?
+if new TBigInteger(50) > new TBigInteger(5)
+	print "50 > 5"
+else
+	print "50 < 5"
+endif
+
+'same value?
+if new TBigInteger(50) = new TBigInteger(50)
+	print "50 = 50"
+else
+	print "50 <> 50"
+endif