locutus
Version:
Locutus other languages' standard libraries to JavaScript for fun and educational purposes
368 lines (367 loc) • 9.91 kB
TypeScript
import type { PhpInput } from './_phpTypes.ts';
declare function createBcLibrary(): {
PLUS: string;
MINUS: string;
BASE: number;
scale: number;
/**
* Basic number structure
*/
bc_num: () => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
/**
* Base add function
*
// Here is the full add routine that takes care of negative numbers.
// N1 is added to N2 and the result placed into RESULT. SCALE_MIN
// is the minimum scale for the result.
*
* @param {bc_num} n1
* @param {bc_num} n2
* @param {int} scaleMin
* @return bc_num
*/
bc_add: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, scaleMin: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
/**
* This is the "user callable" routine to compare numbers N1 and N2.
* @param {bc_num} n1
* @param {bc_num} n2
* @return int -1, 0, 1 (n1 < n2, ===, n1 > n2)
*/
bc_compare: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}) => -1 | 0 | 1;
_one_mult: (num: number[], nPtr: number, size: number, digit: number, result: number[], rPtr: number) => void;
bc_divide: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, scale: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
} | -1;
MUL_BASE_DIGITS: number;
MUL_SMALL_DIGITS: number;
/**
* @param n1 bc_num
* @param n2 bc_num
* @param scale [int] optional
*/
bc_multiply: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, scale: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
new_sub_num: (length: number, scale: number, value: number[], ptr?: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
_bc_simp_mul: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n1len: number, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2len: number, fullScale: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
_bc_shift_addsub: (accum: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, val: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, shift: number, sub: number | boolean) => boolean;
_bc_rec_mul: (u: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, ulen: number, v: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, vlen: number, fullScale: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
/**
*
* @param {bc_num} n1
* @param {bc_num} n2
* @param {boolean} useSign
* @param {boolean} ignoreLast
* @return -1, 0, 1 (see bc_compare)
*/
_bc_do_compare: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, useSign: boolean, ignoreLast: boolean) => -1 | 0 | 1;
bc_sub: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, scaleMin: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
_bc_do_add: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, scaleMin: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
/**
* Perform a subtraction
*
* Perform subtraction: N2 is subtracted from N1 and the value is
* returned. The signs of N1 and N2 are ignored. Also, N1 is
* assumed to be larger than N2. SCALE_MIN is the minimum scale
* of the result.
*
* Basic school maths says to subtract 2 numbers..
* 1. make them the same length, the decimal places, and the integer part
* 2. start from the right and subtract the two numbers from each other
* 3. if the sum of the 2 numbers < 0, carry -1 to the next set and add 10
* (ie 18 > carry 1 becomes 8). thus 0.9 + 0.9 = 1.8
*
* @param {bc_num} n1
* @param {bc_num} n2
* @param {int} scaleMin
* @return bc_num
*/
_bc_do_sub: (n1: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, n2: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}, scaleMin: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
/**
*
* @param {int} length
* @param {int} scale
* @return bc_num
*/
bc_new_num: (length: number, scale: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
safe_emalloc: (size: number, len: number, extra: number) => number[];
/**
* Create a new number
*/
bc_init_num: () => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
_bc_rm_leading_zeros: (num: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}) => void;
/**
* Convert to bc_num detecting scale
*/
php_str2num: (str: string) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
CH_VAL: (c: string) => number;
BCD_CHAR: (d: number) => string;
isdigit: (c: string) => boolean;
bc_str2num: (strIn: string, scale: number) => {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
};
cint: (v: PhpInput) => number;
/**
* Basic min function
* @param {int} a
* @param {int} b
*/
MIN: (a: number, b: number) => number;
/**
* Basic max function
* @param {int} a
* @param {int} b
*/
MAX: (a: number, b: number) => number;
/**
* Basic odd function
* @param {int} a
*/
ODD: (a: number) => number;
/**
* replicate c function
* @param {array} r return (by reference)
* @param {int} ptr
* @param {string} chr char to fill
* @param {int} len length to fill
*/
memset: (r: number[], ptr: number, chr: number, len: number) => void;
/**
* Replacement c function
* Obviously can't work like c does, so we've added an "offset"
* param so you could do memcpy(dest+1, src, len) as memcpy(dest, 1, src, len)
* Also only works on arrays
*/
memcpy: (dest: number[], ptr: number, src: number[], srcptr: number, len: number) => boolean;
/**
* Determine if the number specified is zero or not
* @param {bc_num} num number to check
* @return boolean true when zero, false when not zero.
*/
bc_is_zero: (num: {
n_sign: string;
n_len: number;
n_scale: number;
n_value: number[];
toString: () => string;
}) => boolean;
bc_out_of_memory: () => never;
};
export declare function _bc(): ReturnType<typeof createBcLibrary>;
export {};