import numwiz, { Arithmetic, Formatting, Statistics, Matrix } from "numwiz";

// Chainable API
numwiz(1234567).toCommas(); // "1,234,567"
numwiz(1000000).locale("hi").toWords(); // "दस लाख"
numwiz(50).add(50).multiply(2).abbreviate(); // "200"

// Static modules
Arithmetic.add(1, 2, 3, 4); // 10
Formatting.toWords(1000000, "en", "indian"); // "ten lakh"
Statistics.mean([1, 2, 3, 4, 5]); // 3
Matrix.determinant([
  [1, 2],
  [3, 4],
]); // -2

import numwiz from "numwiz";
// CommonJS
const { numwiz } = require("numwiz");

const result = numwiz(9876543).add(123457).multiply(2).abbreviate(); // "20M"

numwiz(1500000).locale("hi").system("indian").toWords(); // "पंद्रह लाख"

numwiz(99.5).round(0).toCurrency("USD"); // "$100.00"

numwiz(1000000).locale("en").toWords(); // "one million"
numwiz(1000000).locale("en").toWordsIndian(); // "ten lakh"
numwiz(1000000).locale("hi").toWordsIndian(); // "दस लाख"

// Default (throws)
numwiz(10).divide(0); // throws Error: Division by zero

// Safe mode via factory
numwiz.safe(10).divide(0).val(); // NaN
numwiz.safe(-9).sqrt().val(); // NaN
numwiz
  .safe("hello" as any)
  .add(1)
  .val(); // NaN

// Check validity
const n = numwiz.safe(10).divide(0);
n.isValid(); // false
n.val(); // NaN

// Enable mid-chain
numwiz(100).safe().divide(0).val(); // NaN

// Constructor form
new NumWiz(100, { safe: true });

import { Arithmetic, Formatting, Statistics, Financial, Matrix } from "numwiz";

import { Arithmetic } from "numwiz";

import { Formatting } from "numwiz";

Formatting.addCommas(1234567.89); // "1,234,567.89"
Formatting.addIndianCommas(1234567.89); // "12,34,567.89"

Formatting.toPercentage(75); // "75.00%"       value IS the percentage
Formatting.ratioToPercentage(0.75); // "75.00%"       value is a 0-1 ratio
Formatting.fromPercentage("75%"); // 0.75           string → ratio
Formatting.fromPercentageRaw("75%"); // 75             string → number

Formatting.toWords(1000000); // "one million"
Formatting.toWords(1000000, "en", "indian"); // "ten lakh"
Formatting.toWords(1000000, "hi", "indian"); // "दस लाख"
Formatting.toWordsIndian(1500000, "en"); // "fifteen lakh"
Formatting.toWordsWestern(1500000, "en"); // "one million five hundred thousand"

Formatting.padStart(5, 4); // "0005"
Formatting.padStart(5, 4, "*"); // "***5"
Formatting.padEnd(5, 4); // "5000"

Formatting.toOrdinal(1); // "1st"
Formatting.toOrdinal(2); // "2nd"
Formatting.toOrdinal(3); // "3rd"
Formatting.toOrdinal(11); // "11th"
Formatting.toOrdinal(3, "hi"); // "3वाँ"

Formatting.abbreviate(1234); // "1.2K"
Formatting.abbreviate(1500000); // "1.5M"
Formatting.abbreviate(2000000000); // "2B"
Formatting.abbreviate(1500000, 2); // "1.50M"    (2 decimal places)

Formatting.abbreviateIndian(1500000); // "15L"
Formatting.abbreviateIndian(10000000); // "1Cr"
Formatting.abbreviateIndian(1000000000); // "1Arab"

Formatting.toScientific(12345); // "1.2345e+4"
Formatting.toScientific(12345, 2); // "1.23e+4"
Formatting.toEngineering(12345); // "12.345×10^3"

Formatting.toRoman(2026); // "MMXXVI"   (1–3999)
Formatting.fromRoman("MMXXVI"); // 2026
Formatting.toFraction(0.333); // "1/3"
Formatting.toFraction(0.625, 16); // "5/8"     (maxDenominator)

import { Validation } from "numwiz";

import { Comparison } from "numwiz";

Comparison.isEqual(0.1 + 0.2, 0.3); // false (strict ===)
Comparison.isAlmostEqual(0.1 + 0.2, 0.3); // true  (ε = 1e-10)
Comparison.isAlmostEqual(0.1 + 0.2, 0.3, 1e-15); // false (custom ε)
Comparison.isGreaterThan(5, 3); // true
Comparison.isLessThan(3, 5); // true
Comparison.isGreaterThanOrEqual(5, 5); // true
Comparison.isLessThanOrEqual(4, 5); // true
Comparison.clamp(150, 0, 100); // 100
Comparison.sign(-5); // -1
Comparison.sign(0); // 0
Comparison.sign(5); // 1
Comparison.max(1, 5, 3, 9, 2); // 9
Comparison.min(1, 5, 3, 9, 2); // 1

import { Conversion } from "numwiz";

Conversion.toInteger("42.9"); // 42
Conversion.toFloat("3.14"); // 3.14
Conversion.toNumber("100"); // 100  (throws if not parseable)
Conversion.toString(255); // "255"

Conversion.toBinary(10); // "1010"
Conversion.toOctal(8); // "10"
Conversion.toHex(255); // "FF"
Conversion.toBase(255, 16); // "ff"
Conversion.fromBase("ff", 16); // 255

Conversion.degreesToRadians(180); // Math.PI
Conversion.radiansToDegrees(Math.PI); // 180

Conversion.celsiusToFahrenheit(0); // 32
Conversion.fahrenheitToCelsius(32); // 0
Conversion.celsiusToKelvin(0); // 273.15
Conversion.kelvinToCelsius(273.15); // 0
Conversion.fahrenheitToKelvin(32); // 273.15
Conversion.kelvinToFahrenheit(273.15); // 32

Conversion.kmToMiles(1); // 0.621371
Conversion.milesToKm(1); // 1.60934
Conversion.cmToInches(2.54); // 1
Conversion.inchesToCm(1); // 2.54
Conversion.metersToFeet(1); // 3.28084
Conversion.feetToMeters(1); // 0.3048

Conversion.kgToLbs(1); // 2.20462
Conversion.lbsToKg(1); // 0.453592
Conversion.gramsToOunces(28.35); // ≈1
Conversion.ouncesToGrams(1); // 28.3495

Conversion.bytesToKB(1024); // 1
Conversion.bytesToMB(1048576); // 1
Conversion.bytesToGB(1073741824); // 1

Conversion.secondsToMinutes(120); // 2
Conversion.minutesToHours(120); // 2
Conversion.hoursToDays(48); // 2
Conversion.daysToYears(365.25); // 1
Conversion.msToSeconds(3000); // 3

import { Bitwise } from "numwiz";

import { Trigonometry } from "numwiz";

Trigonometry.sin(Math.PI / 2); // 1
Trigonometry.cos(0); // 1
Trigonometry.tan(Math.PI / 4); // ≈1

Trigonometry.asin(1); // Math.PI/2   (input must be [-1, 1])
Trigonometry.acos(1); // 0           (input must be [-1, 1])
Trigonometry.atan(1); // Math.PI/4
Trigonometry.atan2(1, 1); // Math.PI/4

Trigonometry.sinh(0); // 0
Trigonometry.cosh(0); // 1
Trigonometry.tanh(0); // 0
Trigonometry.asinh(0); // 0
Trigonometry.acosh(1); // 0   (input must be ≥ 1)
Trigonometry.atanh(0); // 0   (input must be in (-1, 1))

Trigonometry.sec(0); // 1   (1/cos, throws if cos=0)
Trigonometry.csc(Math.PI / 2); // 1   (1/sin, throws if sin=0)
Trigonometry.cot(Math.PI / 4); // ≈1  (1/tan, throws if tan=0)

Trigonometry.toRadians(180); // Math.PI
Trigonometry.toDegrees(Math.PI); // 180
Trigonometry.normalizeDegrees(370); // 10   (wraps to [0, 360))
Trigonometry.normalizeRadians(7); // ≈0.72 (wraps to [0, 2π))

Trigonometry.hypot(3, 4); // 5
Trigonometry.hypot(1, 1, 1); // √3
Trigonometry.lawOfCosinesSide(3, 4, Math.PI / 3); // side opposite angle C
Trigonometry.lawOfCosinesAngle(3, 4, 5); // angle (radians) opposite side c=5
Trigonometry.lawOfSinesSide(3, Math.PI / 6, Math.PI / 4); // third side
Trigonometry.lawOfSinesAngle(3, 4, Math.PI / 6); // angle B
Trigonometry.triangleArea(3, 4, Math.PI / 6); // 3

Trigonometry.log(Math.E); // 1     (natural log, n > 0)
Trigonometry.log2(8); // 3
Trigonometry.log10(100); // 2
Trigonometry.logN(8, 2); // 3     (log base n)
Trigonometry.exp(1); // ≈2.718
Trigonometry.log1p(0); // 0     (ln(1 + n))
Trigonometry.expm1(0); // 0     (e^n - 1)

import { Statistics } from "numwiz";

const data = [2, 4, 4, 4, 5, 5, 7, 9];

import { Financial } from "numwiz";

const schedule = Financial.amortizationSchedule(500000, 10, 12);
schedule[0];
// {
//   month: 1,
//   emi: 43956.46,
//   principal: 39789.79,
//   interest: 4166.67,
//   balance: 460210.21
// }

import { Advanced } from "numwiz";

Advanced.factorial(5); // 120
Advanced.permutation(5, 2); // 20
Advanced.combination(5, 2); // 10
Advanced.catalan(5); // 42
Advanced.pascal(4); // [1, 4, 6, 4, 1]

Advanced.gcd(12, 8); // 4
Advanced.lcm(4, 6); // 12
Advanced.gcdArray([12, 8, 6]); // 2
Advanced.lcmArray([4, 6, 10]); // 60
Advanced.primeFactors(60); // [2, 2, 3, 5]
Advanced.divisors(12); // [1, 2, 3, 4, 6, 12]
Advanced.sumOfDivisors(12); // 28
Advanced.nextPrime(10); // 11
Advanced.primesInRange(10, 30); // [11, 13, 17, 19, 23, 29]
Advanced.eulerTotient(12); // 4

Advanced.fibonacci(10); // 55   (10th Fibonacci number)
Advanced.fibonacciSequence(8); // [0, 1, 1, 2, 3, 5, 8, 13]
Advanced.collatz(6); // [6, 3, 10, 5, 16, 8, 4, 2, 1]

Advanced.digitSum(12345); // 15
Advanced.digitalRoot(9875); // 2
Advanced.countDigits(12345); // 5
Advanced.reverseNumber(12345); // 54321
Advanced.isPalindrome(121); // true

Advanced.lerp(0, 100, 0.5); // 50    (linear interpolation)
Advanced.inverseLerp(0, 100, 50); // 0.5   (inverse lerp)
Advanced.map(5, 0, 10, 0, 100); // 50    (remap from [0,10] to [0,100])
Advanced.percentageOf(15, 200); // 30    (15% of 200)
Advanced.whatPercent(30, 200); // 15    (30 is what% of 200)
Advanced.percentChange(80, 100); // 25    (% increase from 80 to 100)

import { Sequences } from "numwiz";

// Custom sequence examples
Sequences.custom(5, (i) => 2 ** i); // [1, 2, 4, 8, 16]
Sequences.custom(5, (i) => i * 3 + 1); // [1, 4, 7, 10, 13]

import { Random } from "numwiz";

// Weighted random
Random.weighted([
  { value: "common", weight: 70 },
  { value: "rare", weight: 25 },
  { value: "epic", weight: 5 },
]);
// returns "common" ~70% of the time

import { Range } from "numwiz";

Range.create(0, 10, 2); // [0, 2, 4, 6, 8, 10]
Range.create(10, 1, -3); // [10, 7, 4, 1]  (negative step)
Range.wrap(370, 0, 360); // 10
Range.bounce(7, 0, 5); // 3
Range.chunk(1, 9, 3); // [[1,2,3],[4,5,6],[7,8,9]]

import { Currency } from "numwiz";

import { NumberWords } from "numwiz";

NumberWords.toWords(42); // "forty-two"
NumberWords.toWords(42, "hi"); // "बयालीस"
NumberWords.toWords(42, "de"); // "zweiundvierzig"
NumberWords.toWords(42, "es"); // "cuarenta y dos"
NumberWords.toWords(42, "fr"); // "quarante-deux"
NumberWords.toWords(1000000, "en", "indian"); // "ten lakh"
NumberWords.toWords(1000000, "en", "western"); // "one million"
NumberWords.toWordsIndian(1500000, "en"); // "fifteen lakh"
NumberWords.toWordsWestern(1500000, "en"); // "one million five hundred thousand"
NumberWords.currencyToWords(150, "USD", "en", "western"); // "one hundred fifty dollars"

import { Matrix } from "numwiz";
// or via subpath
import Matrix from "numwiz/matrix";

const m = [
  [1, 2, 3],
  [4, 5, 6],
];

Matrix.shape(m); // [2, 3]
Matrix.rows(m); // 2
Matrix.cols(m); // 3
Matrix.size(m); // 6
Matrix.get(m, 0, 1); // 2
Matrix.set(m, 0, 0, 9); // [[9,2,3],[4,5,6]]  (returns new matrix)
Matrix.getRow(m, 1); // [4, 5, 6]
Matrix.getCol(m, 0); // [1, 4]
Matrix.getDiagonal(m); // [1, 5]
Matrix.flatten(m); // [1,2,3,4,5,6]
Matrix.clone(m); // deep copy

const A = [
    [1, 2],
    [3, 4],
  ],
  B = [
    [5, 6],
    [7, 8],
  ];

Matrix.add(A, B); // [[6,8],[10,12]]
Matrix.subtract(A, B); // [[-4,-4],[-4,-4]]
Matrix.multiply(A, B); // [[19,22],[43,50]]
Matrix.scale(A, 3); // [[3,6],[9,12]]
Matrix.negate(A); // [[-1,-2],[-3,-4]]
Matrix.hadamard(A, B); // [[5,12],[21,32]]
Matrix.elementDivide(A, B); // element-wise division
Matrix.elementPower(A, 2); // [[1,4],[9,16]]
Matrix.power(A, 3); // A³
Matrix.scalarAdd(A, 10); // [[11,12],[13,14]]
Matrix.scalarSubtract(A, 1); // [[0,1],[2,3]]

Matrix.transpose([
  [1, 2, 3],
  [4, 5, 6],
]); // [[1,4],[2,5],[3,6]]
Matrix.inverse([
  [4, 7],
  [2, 6],
]); // [[0.6,-0.7],[-0.2,0.4]]
Matrix.adjugate(A);
Matrix.cofactor(A, 0, 0); // cofactor at [0,0]
Matrix.cofactorMatrix(A);
Matrix.minor(A, 0, 0); // sub-matrix without row 0 col 0

Matrix.swapRows(A, 0, 1);
Matrix.swapCols(A, 0, 1);
Matrix.scaleRow(A, 0, 2);
Matrix.addRowMultiple(A, 1, 0, -2); // row1 += -2 * row0
Matrix.ref(A); // row echelon form
Matrix.rref(A); // reduced row echelon form

Matrix.determinant([
  [1, 2],
  [3, 4],
]); // -2
Matrix.trace([
  [1, 2],
  [3, 4],
]); // 5
Matrix.rank([
  [1, 2],
  [2, 4],
]); // 1
Matrix.sum(A); // 10
Matrix.min(A); // 1
Matrix.max(A); // 4
Matrix.mean(A); // 2.5
Matrix.normFrobenius(A); // ≈5.477
Matrix.normInf(A); // max absolute row sum
Matrix.norm1(A); // max absolute col sum
Matrix.sumAxis(A, "row"); // [3, 7]
Matrix.sumAxis(A, "col"); // [4, 6]

const { L, U, P } = Matrix.lu(A); // PA = LU
const { Q, R } = Matrix.qr(A); // A = QR
Matrix.eigenvalues([
  [2, 1],
  [1, 2],
]); // [3, 1]
Matrix.eigenvalues2x2([
  [0, -1],
  [1, 0],
]); // [{ real:0, imag:1 }, ...]
Matrix.solve(
  [
    [2, 1],
    [1, 3],
  ],
  [5, 10]
); // [[1],[3]]
Matrix.solveCramer(
  [
    [2, 1],
    [1, 3],
  ],
  [5, 10]
); // [[1],[3]]

Matrix.isSquare(A); // true
Matrix.isIdentity(Matrix.identity(3)); // true
Matrix.isSymmetric([
  [1, 2],
  [2, 1],
]); // true
Matrix.isDiagonal(Matrix.diagonal([1, 2])); // true
Matrix.isUpperTriangular([
  [1, 2],
  [0, 3],
]); // true
Matrix.isLowerTriangular([
  [1, 0],
  [2, 3],
]); // true
Matrix.isOrthogonal(Matrix.identity(2)); // true
Matrix.isSingular([
  [1, 2],
  [2, 4],
]); // true
Matrix.isZero(Matrix.zeros(2, 2)); // true
Matrix.isVector([[1, 2, 3]]); // true
Matrix.isRowVector([[1, 2, 3]]); // true
Matrix.isColumnVector([[1], [2], [3]]); // true
Matrix.isSameShape(A, B); // true
Matrix.equals(A, A); // true
Matrix.isEqual(A, A, 1e-10); // true

Matrix.dot([1, 2, 3], [4, 5, 6]); // 32
Matrix.cross([1, 0, 0], [0, 1, 0]); // [0,0,1]
Matrix.magnitude([3, 4]); // 5
Matrix.normalize([3, 4]); // [0.6, 0.8]
Matrix.angleBetween([1, 0], [0, 1]); // Math.PI/2

Matrix.rowSums(m); // n×1 column vector of row sums
Matrix.colSums(m); // 1×n row vector of col sums
Matrix.rowMeans(m); // n×1 column vector of row means
Matrix.colMeans(m); // 1×n row vector of col means

Matrix.map(m, (v, i, j) => v * 2); // double every element
Matrix.forEach(m, (v, i, j) => {}); // iterate (returns void)
Matrix.every(m, (v) => v > 0); // true if all elements match
Matrix.some(m, (v) => v > 5); // true if any element matches
Matrix.round(m, 2); // round to 2 decimal places
Matrix.abs(m); // |element| for all elements

Matrix.hStack(A, B); // horizontal concat (same rows)
Matrix.vStack(A, B); // vertical concat (same cols)
Matrix.hConcat(A, B); // alias for hStack
Matrix.vConcat(A, B); // alias for vStack
Matrix.slice(m, 0, 0, 2, 2); // sub-matrix [start, end) exclusive
Matrix.subMatrix(m, 0, 0, 2, 2); // alias for slice
Matrix.reshape([[1, 2, 3, 4, 5, 6]], 2, 3); // [[1,2,3],[4,5,6]]

Matrix.toString(A); // formatted grid with box-drawing chars
Matrix.print(A); // console.log + returns matrix
Matrix.toHTML(A); // <table> HTML string
Matrix.toJSON(A); // { rows: 2, cols: 2, data: [[...]] }
Matrix.fromJSON(json); // number[][] from JSON object

const result = new Matrix([
  [1, 2],
  [3, 4],
])
  .add([
    [10, 20],
    [30, 40],
  ])
  .multiply([
    [1, 0],
    [0, 1],
  ])
  .scale(2)
  .transpose()
  .round(4)
  .toArray(); // → number[][]

// Scalar terminal methods
new Matrix([
  [1, 2],
  [3, 4],
]).determinant(); // -2
new Matrix([
  [1, 2],
  [3, 4],
]).trace(); // 5

// Boolean terminal methods
new Matrix([
  [1, 0],
  [0, 1],
]).isIdentity(); // true

// Decomposition & solving
const { L, U, P } = new Matrix(A).lu();
const { Q, R } = new Matrix(A).qr();
new Matrix([
  [2, 1],
  [1, 3],
])
  .solve([[5], [10]])
  .toArray(); // [[1],[3]]

import Arithmetic from "numwiz/arithmetic";
import Comparison from "numwiz/comparison";
import Validation from "numwiz/validation";
import Conversion from "numwiz/conversion";
import Bitwise from "numwiz/bitwise";
import Trigonometry from "numwiz/trigonometry";
import Range from "numwiz/range";
import Statistics from "numwiz/statistics";
import Financial from "numwiz/financial";
import Sequences from "numwiz/sequences";
import Random from "numwiz/random";
import Advanced from "numwiz/advanced";
import Formatting from "numwiz/formatting";
import Currency from "numwiz/currency";
import Matrix from "numwiz/matrix";
import NumberWords from "numwiz/number-words";

// Types only
import type { Matrix2D, LUResult, QRResult } from "numwiz/types";

import { Formatting } from "numwiz";

Formatting.toWords(42, "en"); // "forty-two"
Formatting.toWords(42, "hi"); // "बयालीस"
Formatting.toWords(42, "de"); // "zweiundvierzig"
Formatting.toWords(42, "es"); // "cuarenta y dos"
Formatting.toWords(42, "fr"); // "quarante-deux"
Formatting.toWords(42, "ar"); // "اثنان وأربعون"
Formatting.toWords(42, "bn"); // "বিয়াল্লিশ"
Formatting.toWords(42, "mr"); // "बेचाळीस"
Formatting.toWords(42, "gu"); // "બેતાળીસ"
Formatting.toWords(42, "ta"); // "நாற்பத்திரண்டு"

Formatting.toOrdinal(1, "en"); // "1st"
Formatting.toOrdinal(3, "hi"); // "3वाँ"

// Indian scale
Formatting.toWords(10000000, "en", "indian"); // "one crore"
Formatting.toWords(10000000, "hi", "indian"); // "एक करोड़"

import numwiz, {
  NumWiz,
  Arithmetic,
  Matrix,
  Statistics,
  Financial,
  type NumWizOptions,
} from "numwiz";
import type {
  Matrix2D,
  LUResult,
  QRResult,
  AmortizationEntry,
} from "numwiz/types";

const m: Matrix2D = [
  [1, 2],
  [3, 4],
];
const { L, U, P }: LUResult = Matrix.lu(m);
const schedule: AmortizationEntry[] = Financial.amortizationSchedule(
  500000,
  10,
  12
);