export declare const add: (x: Complex, y: Complex) => Complex

export declare const div: (x: Complex, y: Complex) => Complex

export declare const mul: (x: Complex, y: Complex) => Complex

export declare const sub: (x: Complex, y: Complex) => Complex

export declare const conj: (c: Complex) => Complex

export declare const pow: (c: Complex, n: number) => Complex

export declare const sqrt: (c: Complex) => Complex

export declare const fromPolarDegrees: (r: number, theta: number) => Complex

export declare const fromPolarRadians: (r: number, psi: number) => Complex

export declare const fromVector: (v: V.Vec<2, number>) => Complex

export declare const of: (Re: number, Im: number) => Complex

export declare const one: Complex

export declare const onesN: <N extends number>(n: N) => Vec<N>

export declare const randComplex: (min: number, max: number) => IO.IO<Complex>

export declare const scalar: (a: number) => Complex

export declare const zero: Complex

export declare const zerosN: <N extends number>(n: N) => Vec<N>

export declare const argumentDegrees: (c: Complex) => O.Option<number>

export declare const argumentRadians: (c: Complex) => O.Option<number>

export declare const modulus: (c: Complex) => number

export declare const toVector: (c: Complex) => V.Vec<2, number>

export declare const $_: (s: Inf.FieldSymbol, x: Complex, y: Complex) => Complex

export declare const _: (a: Complex, s: Inf.FieldSymbol, b: Complex) => Complex

export declare const _$: (a: Complex, b: Complex, s: Inf.FieldSymbol) => Complex

export declare const AdditiveAbGrpMN: <M, N>(m: M, n: N) => TC.AbelianGroup<M.Mat<M, N, Complex>>

export declare const AdditiveAbGrpN: <N>(n: N) => TC.AbelianGroup<V.Vec<N, Complex>>

export declare const BiModMN: <M, N>(m: M, n: N) => TC.Bimodule<M.Mat<M, N, Complex>, Complex, Complex>

export declare const BiModN: <N>(n: N) => TC.Bimodule<V.Vec<N, Complex>, Complex, Complex>

export declare const ComplexAdditiveAbelianGroup: TC.AbelianGroup<Complex>

export declare const ComplexBimodule: TC.Bimodule<Complex, number, number>

export declare const Eq: Eq_.Eq<Complex>

export declare const Field: Fld.Field<Complex>

export declare const MagmaSub: Mg.Magma<Complex>

export declare const MonoidProduct: Mn.Monoid<Complex>

export declare const MonoidProductMM: <M>(m: M) => Mn.Monoid<M.Mat<M, M, Complex>>

export declare const MonoidSum: Mn.Monoid<Complex>

export declare const PolynomialAdditiveAbelianGroup: TC.AbelianGroup<Poly.Polynomial<Complex>>

export declare const PolynomialBimodule: TC.Bimodule<Poly.Polynomial<Complex>, Complex, Complex>

export declare const PolynomialEuclidianRing: TC.EuclidianRing<Poly.Polynomial<Complex>>

export declare const PolynomialRing: TC.CommutativeRing<Poly.Polynomial<Complex>>

export declare const SemigroupProduct: Sg.Semigroup<Complex>

export declare const SemigroupSum: Sg.Semigroup<Complex>

export declare const Show: Sh.Show<Complex>

export declare const getDifferentialAutomorphism: (constantTerm: Complex) => Auto.Automorphism<Poly.Polynomial<Complex>>

export declare const IsoVector: Iso.Iso<Complex, V.Vec<2, number>>

export declare const addM: <M, N>(x: M.Mat<M, N, Complex>, y: M.Mat<M, N, Complex>) => M.Mat<M, N, Complex>

export declare const addV: <N>(x: V.Vec<N, Complex>, y: V.Vec<N, Complex>) => V.Vec<N, Complex>

export declare const idMat: <M>(m: M) => M.Mat<M, M, Complex>

export declare const linMap: <M, N1, N2>(A: M.Mat<M, N1, Complex>, x: V.Vec<N2, Complex>) => V.Vec<M, Complex>

export declare const linMapR: <M, N1, N2>(x: V.Vec<N1, Complex>, A: M.Mat<N2, M, Complex>) => V.Vec<M, Complex>

export declare const mulM: <M, N1, N2, P>(x: M.Mat<M, N1, Complex>, y: M.Mat<N2, P, Complex>) => M.Mat<M, P, Complex>

export declare const subM: <M, N>(x: M.Mat<M, N, Complex>, y: M.Mat<M, N, Complex>) => M.Mat<M, N, Complex>

export declare const subV: <N>(x: V.Vec<N, Complex>, y: V.Vec<N, Complex>) => V.Vec<N, Complex>

export declare const trace: <M>(fa: M.Mat<M, M, Complex>) => Complex

export interface Complex {
  readonly Re: number
  readonly Im: number
}

export type Mat<M, N> = M.Mat<M, N, Complex>

export type Vec<N> = V.Vec<N, Complex>

export declare const derivative: (coeffs: Poly.Polynomial<Complex>) => Poly.Polynomial<Complex>

export declare const evaluatePolynomial: (p: Poly.Polynomial<Complex>) => (x: Complex) => Complex

export declare const getAntiderivative: (
  constantTerm: Complex
) => (p: Poly.Polynomial<Complex>) => Poly.Polynomial<Complex>

export declare const integrate: (lower: Complex, upper: Complex) => (p: Poly.Polynomial<Complex>) => Complex

export declare const polynomialInnerProduct: (p: Poly.Polynomial<Complex>, q: Poly.Polynomial<Complex>) => Complex

export declare const polynomialNorm: (p: Poly.Polynomial<Complex>) => Complex

export declare const polynomialProjection: (
  p: Poly.Polynomial<Complex>,
  q: Poly.Polynomial<Complex>
) => Poly.Polynomial<Complex>

export declare const cross: (x: V.Vec<3, Complex>, y: V.Vec<3, Complex>) => V.Vec<3, Complex>

export declare const dot: <N>(x: V.Vec<N, Complex>, y: V.Vec<N, Complex>) => Complex

export declare const l1Norm: <N>(x: V.Vec<N, Complex>) => Complex

export declare const l2Norm: <N>(x: V.Vec<N, Complex>) => Complex

export declare const lInfNorm: (v: V.Vec<unknown, Complex>) => number

export declare const lpNorm: (p: number) => <N>(v: V.Vec<N, Complex>) => Complex

export declare const outerProduct: <M, N>(v1: V.Vec<M, Complex>, v2: V.Vec<N, Complex>) => M.Mat<M, N, Complex>

export declare const projection: <N>(u: V.Vec<N, Complex>, v: V.Vec<N, Complex>) => V.Vec<N, Complex>