Configuration and Static Methods

/**
 * Configure BigNumber global settings
 * @param {object} config - Configuration object
 * @returns {object} Current configuration object
 */
BigNumber.config(config): object

/**
 * Alias for config
 */
BigNumber.set(config): object

interface Config {
  DECIMAL_PLACES?: number;              // 0 to 1e9, default 20
  ROUNDING_MODE?: number;               // 0 to 8, default 4 (ROUND_HALF_UP)
  EXPONENTIAL_AT?: number | [number, number];  // Default [-7, 20]
  RANGE?: number | [number, number];    // Default [-1e9, 1e9]
  CRYPTO?: boolean;                     // Default false
  MODULO_MODE?: number;                 // 0,1,3,6,9, default 1 (ROUND_DOWN)
  POW_PRECISION?: number;               // 0 to 1e9, default 0
  FORMAT?: object;                      // Default formatting options
  ALPHABET?: string;                    // Base conversion alphabet
}

// Set multiple configuration options
BigNumber.config({
  DECIMAL_PLACES: 40,
  ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
  EXPONENTIAL_AT: [-10, 20],
  RANGE: [-500, 500],
  CRYPTO: true,
  MODULO_MODE: BigNumber.ROUND_FLOOR,
  POW_PRECISION: 80,
  FORMAT: {
    groupSize: 3,
    groupSeparator: ' ',
    decimalSeparator: ','
  },
  ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
});

// Get current configuration
const config = BigNumber.config();
console.log(config.DECIMAL_PLACES);    // 40

// Set individual options
BigNumber.set({ DECIMAL_PLACES: 5 });
BigNumber.set({ ROUNDING_MODE: BigNumber.ROUND_UP });

/**
 * Creates new BigNumber constructor with optional configuration
 * @param {object} [config] - Configuration object for new constructor
 * @returns {function} New BigNumber constructor
 */
BigNumber.clone(config): Constructor

// Create independent constructor
const BN = BigNumber.clone({ DECIMAL_PLACES: 9 });

const x = new BigNumber(1);
const y = new BN(1);

x.div(3);  // Uses original config (20 decimal places)
y.div(3);  // Uses BN config (9 decimal places)

// Equivalent to clone then configure
const BN2 = BigNumber.clone();
BN2.config({ DECIMAL_PLACES: 9 });

// Multiple independent constructors
const HighPrecision = BigNumber.clone({ DECIMAL_PLACES: 100 });
const LowPrecision = BigNumber.clone({ DECIMAL_PLACES: 2 });
const Financial = BigNumber.clone({ 
  DECIMAL_PLACES: 2, 
  ROUNDING_MODE: BigNumber.ROUND_HALF_EVEN 
});

/**
 * Tests if value is a BigNumber instance
 * @param {any} value - Value to test
 * @returns {boolean} True if BigNumber instance
 */
BigNumber.isBigNumber(value): boolean

const x = 42;
const y = new BigNumber(x);
const BN = BigNumber.clone();
const z = new BN(x);

BigNumber.isBigNumber(x);       // false
y instanceof BigNumber;         // true
BigNumber.isBigNumber(y);       // true

// Works across different constructors
z instanceof BigNumber;         // false (different constructor)
BigNumber.isBigNumber(z);       // true (still a BigNumber)

// Debug mode validation
BigNumber.DEBUG = true;
const invalid = { s: 1, e: 2, c: NaN, _isBigNumber: true };
BigNumber.isBigNumber(invalid); // throws error in debug mode

/**
 * Returns maximum value from arguments
 * @param {...(string|number|BigNumber)} values - Values to compare
 * @returns {BigNumber} Maximum value
 */
BigNumber.maximum(...values): BigNumber
BigNumber.max(...values): BigNumber

/**
 * Returns minimum value from arguments
 * @param {...(string|number|BigNumber)} values - Values to compare
 * @returns {BigNumber} Minimum value
 */
BigNumber.minimum(...values): BigNumber
BigNumber.min(...values): BigNumber

/**
 * Returns sum of all arguments
 * @param {...(string|number|BigNumber)} values - Values to sum
 * @returns {BigNumber} Sum of all values
 */
BigNumber.sum(...values): BigNumber

// Maximum and minimum
const x = new BigNumber('3257869345.0378653');
const max = BigNumber.maximum(4e9, x, '123456789.9');  // '4000000000'
const min = BigNumber.minimum(4e9, x, '123456789.9');  // '123456789.9'

// Using aliases
const maxAlias = BigNumber.max(4e9, x, '123456789.9');
const minAlias = BigNumber.min(4e9, x, '123456789.9');

// With arrays using apply
const arr = [12, '13', new BigNumber(14)];
const maxFromArray = BigNumber.maximum.apply(null, arr);  // '14'
const minFromArray = BigNumber.minimum.apply(null, arr);  // '12'

// Sum operation
const sum = BigNumber.sum(4e9, x, '123456789.9');       // '7381326134.9378653'
const sumFromArray = BigNumber.sum.apply(null, arr);     // '39'

// Mixed types
BigNumber.max(1, '2', new BigNumber(3), 0.5);           // '3'
BigNumber.sum(1, '2', new BigNumber(3), 0.5);           // '6.5'

/**
 * Generates pseudo-random BigNumber between 0 and 1
 * @param {number} [decimalPlaces] - Number of decimal places (0 to 1e9)
 * @returns {BigNumber} Random BigNumber
 */
BigNumber.random(decimalPlaces): BigNumber

// Basic random generation
BigNumber.config({ DECIMAL_PLACES: 10 });
const rand1 = BigNumber.random();      // '0.4117936847' (example)
const rand2 = BigNumber.random(20);    // '0.78193327636914089009' (example)

// Cryptographically secure random (Node.js)
global.crypto = require('crypto');
BigNumber.config({ CRYPTO: true });
const secureRand = BigNumber.random(10);  // Cryptographically secure

// Browser crypto support
BigNumber.config({ CRYPTO: true });      // Uses crypto.getRandomValues if available
const browserRand = BigNumber.random();

// Custom range generation
function randomRange(min, max, decimalPlaces) {
  const range = new BigNumber(max).minus(min);
  const random = BigNumber.random(decimalPlaces);
  return random.multipliedBy(range).plus(min);
}

const randomInRange = randomRange(1, 100, 5);  // Random between 1 and 100

BigNumber.config({ DECIMAL_PLACES: 5 });
new BigNumber(1).div(3);  // '0.33333'

BigNumber.config({ DECIMAL_PLACES: 20 });
new BigNumber(1).div(3);  // '0.33333333333333333333'

BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_UP });
new BigNumber(1.004).toFixed(2);  // '1.01'

BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_DOWN });
new BigNumber(1.006).toFixed(2);  // '1.00'

// Single threshold
BigNumber.config({ EXPONENTIAL_AT: 2 });
new BigNumber(123);       // '1.23e+2'
new BigNumber(0.0123);    // '1.23e-2'

// Range
BigNumber.config({ EXPONENTIAL_AT: [-7, 20] });
new BigNumber(123456789);    // '123456789' (e is only 8)
new BigNumber(0.000000123);  // '1.23e-7'

BigNumber.config({ RANGE: 500 });
new BigNumber('1e500');    // 'Infinity'
new BigNumber('1e-500');   // '0'

BigNumber.config({ RANGE: [-3, 4] });
new BigNumber(100000);     // 'Infinity' (e is 5)
new BigNumber(0.0001);     // '0' (e is -4)

// Node.js
global.crypto = require('crypto');
BigNumber.config({ CRYPTO: true });

// Browser (if crypto.getRandomValues available)
BigNumber.config({ CRYPTO: true });

// Fallback to Math.random if crypto unavailable
BigNumber.config({ CRYPTO: false });

BigNumber.config({ MODULO_MODE: BigNumber.ROUND_DOWN });  // JavaScript % operator
BigNumber.config({ MODULO_MODE: BigNumber.ROUND_FLOOR }); // Python % operator
BigNumber.config({ MODULO_MODE: BigNumber.EUCLID });      // Always positive remainder

BigNumber.config({ POW_PRECISION: 100 });
new BigNumber(2).pow(1000);  // Limited to 100 significant digits

BigNumber.config({ POW_PRECISION: 0 });  // Unlimited precision (slower)

// Duodecimal (base 12)
BigNumber.config({ ALPHABET: '0123456789TE' });
const x = new BigNumber('T', 12);  // 10 in base 12
x.toString();    // '10'
x.toString(12);  // 'T'

/**
 * Debug mode property
 * @type {boolean}
 */
BigNumber.DEBUG: boolean

// Enable debug mode
BigNumber.DEBUG = true;

// Errors instead of NaN
new BigNumber('blurgh');        // throws '[BigNumber Error] Not a number'
new BigNumber(9, 2);            // throws '[BigNumber Error] Not a base 2 number'

// Precision warnings
new BigNumber(823456789123456.3);
// throws '[BigNumber Error] Number primitive has more than 15 significant digits'

// Validate BigNumber instances
const x = new BigNumber(10);
x.c = NaN;  // Corrupt the instance
BigNumber.isBigNumber(x);       // throws '[BigNumber Error] Invalid BigNumber'