Odin/core/math/big/test.odin

//+ignore
package big

/*
	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
	Made available under Odin's BSD-2 license.

	An arbitrary precision mathematics implementation in Odin.
	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.

	This file exports procedures for use with the test.py test suite.
*/

/*
	TODO: Write tests for `internal_*` and test reusing parameters with the public implementations.
*/

import "core:runtime"
import "core:strings"

PyRes :: struct {
	res: cstring,
	err: Error,
}

@export test_initialize_constants :: proc "c" () -> (res: u64) {
	context = runtime.default_context();
	return u64(initialize_constants());
}

@export test_error_string :: proc "c" (err: Error) -> (res: cstring) {
	context = runtime.default_context();
	es := Error_String;
	return strings.clone_to_cstring(es[err], context.temp_allocator);
}

@export test_add :: proc "c" (a, b: cstring) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	aa, bb, sum := &Int{}, &Int{}, &Int{};
	defer destroy(aa, bb, sum);

	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":add:atoi(a):", err=err}; }
	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":add:atoi(b):", err=err}; }
	if bb.used == 1 {
		if err = #force_inline internal_add(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }	
	} else {
		if err = #force_inline internal_add(sum, aa, bb);          err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }
	}

	r: cstring;
	r, err = int_itoa_cstring(sum, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":add:itoa(sum):", err=err}; }
	return PyRes{res = r, err = nil};
}

@export test_sub :: proc "c" (a, b: cstring) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	aa, bb, sum := &Int{}, &Int{}, &Int{};
	defer destroy(aa, bb, sum);

	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sub:atoi(a):", err=err}; }
	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":sub:atoi(b):", err=err}; }
	if bb.used == 1 {
		if err = #force_inline internal_sub(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
	} else {
		if err = #force_inline internal_sub(sum, aa, bb);          err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
	}

	r: cstring;
	r, err = int_itoa_cstring(sum, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":sub:itoa(sum):", err=err}; }
	return PyRes{res = r, err = nil};
}

@export test_mul :: proc "c" (a, b: cstring) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	aa, bb, product := &Int{}, &Int{}, &Int{};
	defer destroy(aa, bb, product);

	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":mul:atoi(a):", err=err}; }
	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":mul:atoi(b):", err=err}; }
	if err = #force_inline internal_mul(product, aa, bb);    err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(product, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":mul:itoa(product):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	NOTE(Jeroen): For simplicity, we don't return the quotient and the remainder, just the quotient.
*/
@export test_div :: proc "c" (a, b: cstring) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	aa, bb, quotient := &Int{}, &Int{}, &Int{};
	defer destroy(aa, bb, quotient);

	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":div:atoi(a):", err=err}; }
	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":div:atoi(b):", err=err}; }
	if err = #force_inline internal_div(quotient, aa, bb);   err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(quotient, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":div:itoa(quotient):", err=err}; }
	return PyRes{res = r, err = nil};
}


/*
	res = log(a, base)
*/
@export test_log :: proc "c" (a: cstring, base := DIGIT(2)) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;
	l: int;

	aa := &Int{};
	defer destroy(aa);

	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":log:atoi(a):", err=err}; }
	if l, err = #force_inline internal_log(aa, base);        err != nil { return PyRes{res=":log:log(a, base):", err=err}; }

	#force_inline internal_zero(aa);
	aa.digit[0] = DIGIT(l)  & _MASK;
	aa.digit[1] = DIGIT(l) >> _DIGIT_BITS;
	aa.used = 2;
	clamp(aa);

	r: cstring;
	r, err = int_itoa_cstring(aa, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = base^power
*/
@export test_pow :: proc "c" (base: cstring, power := int(2)) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	dest, bb := &Int{}, &Int{};
	defer destroy(dest, bb);

	if err = atoi(bb, string(base), 16); err != nil { return PyRes{res=":pow:atoi(base):", err=err}; }
	if err = #force_inline internal_pow(dest, bb, power);       err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(dest, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = sqrt(src)
*/
@export test_sqrt :: proc "c" (source: cstring) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	src := &Int{};
	defer destroy(src);

	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":sqrt:atoi(src):", err=err}; }
	if err = #force_inline internal_sqrt(src, src);                err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = root_n(src, power)
*/
@export test_root_n :: proc "c" (source: cstring, power: int) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	src := &Int{};
	defer destroy(src);

	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":root_n:atoi(src):", err=err}; }
	if err = #force_inline internal_root_n(src, src, power);       err != nil { return PyRes{res=":root_n:root_n(src):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":root_n:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = shr_digit(src, digits)
*/
@export test_shr_digit :: proc "c" (source: cstring, digits: int) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	src := &Int{};
	defer destroy(src);

	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_digit:atoi(src):", err=err}; }
	if err = #force_inline internal_shr_digit(src, digits);        err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":shr_digit:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = shl_digit(src, digits)
*/
@export test_shl_digit :: proc "c" (source: cstring, digits: int) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	src := &Int{};
	defer destroy(src);

	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl_digit:atoi(src):", err=err}; }
	if err = #force_inline internal_shl_digit(src, digits);        err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":shl_digit:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = shr(src, bits)
*/
@export test_shr :: proc "c" (source: cstring, bits: int) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	src := &Int{};
	defer destroy(src);

	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr:atoi(src):", err=err}; }
	if err = #force_inline internal_shr(src, src, bits);           err != nil { return PyRes{res=":shr:shr(src, bits):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":shr:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = shr_signed(src, bits)
*/
@export test_shr_signed :: proc "c" (source: cstring, bits: int) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	src := &Int{};
	defer destroy(src);

	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_signed:atoi(src):", err=err}; }
	if err = #force_inline internal_shr_signed(src, src, bits);    err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":shr_signed:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = shl(src, bits)
*/
@export test_shl :: proc "c" (source: cstring, bits: int) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	src := &Int{};
	defer destroy(src);

	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl:atoi(src):", err=err}; }
	if err = #force_inline internal_shl(src, src, bits);           err != nil { return PyRes{res=":shl:shl(src, bits):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":shl:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = factorial(n)
*/
@export test_factorial :: proc "c" (n: int) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	dest := &Int{};
	defer destroy(dest);

	if err = #force_inline factorial(dest, n); err != nil { return PyRes{res=":factorial:factorial(n):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(dest, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":factorial:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = gcd(a, b)
*/
@export test_gcd :: proc "c" (a, b: cstring) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	ai, bi, dest := &Int{}, &Int{}, &Int{};
	defer destroy(ai, bi, dest);

	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":gcd:atoi(a):", err=err}; }
	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":gcd:atoi(b):", err=err}; }
	if err = #force_inline gcd(dest, ai, bi); err != nil { return PyRes{res=":gcd:gcd(a, b):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(dest, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":gcd:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}

/*
	dest = lcm(a, b)
*/
@export test_lcm :: proc "c" (a, b: cstring) -> (res: PyRes) {
	context = runtime.default_context();
	err: Error;

	ai, bi, dest := &Int{}, &Int{}, &Int{};
	defer destroy(ai, bi, dest);

	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":lcm:atoi(a):", err=err}; }
	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":lcm:atoi(b):", err=err}; }
	if err = #force_inline lcm(dest, ai, bi); err != nil { return PyRes{res=":lcm:lcm(a, b):", err=err}; }

	r: cstring;
	r, err = int_itoa_cstring(dest, 16, context.temp_allocator);
	if err != nil { return PyRes{res=":lcm:itoa(res):", err=err}; }
	return PyRes{res = r, err = nil};
}