export declare const fromCoefficientArray: <R>(Eq: Eq.Eq<R>, R: Rng.Ring<R>) => (rs: readonly R[]) => Polynomial<R>

export declare const one: <R>(R: Rng.Ring<R>) => Polynomial<R>

export declare const randPolynomial: <R>(terms: number, make: IO.IO<R>) => IO.IO<Polynomial<R>>

export declare const zero: <R>() => Polynomial<R>

export declare const coefficients: <R>(p: Polynomial<R>) => readonly R[]

export declare const add: <R>(Eq: Eq.Eq<R>, R: Rng.Ring<R>) => (x: Polynomial<R>, y: Polynomial<R>) => Polynomial<R>

export declare const map: <A, B>(f: (a: A) => B) => (fa: Polynomial<A>) => Polynomial<B>

export declare const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (fa: Polynomial<A>) => Polynomial<B>

export declare const mul: <R>(Eq: Eq.Eq<R>, R: Rng.Ring<R>) => (xs: Polynomial<R>, ys: Polynomial<R>) => Polynomial<R>

export declare const sub: <R>(Eq: Eq.Eq<R>, R: Rng.Ring<R>) => (x: Polynomial<R>, y: Polynomial<R>) => Polynomial<R>

export declare const Functor: Fun.Functor1<'Polynomial'>

export declare const FunctorWithIndex: FunI.FunctorWithIndex1<'Polynomial', number>

export declare const URI: 'Polynomial'

export type URI = typeof URI

export declare const getAdditiveAbelianGroup: <R>(Eq: Eq.Eq<R>, R: Rng.Ring<R>) => TC.AbelianGroup<Polynomial<R>>

export declare const getBimodule: <R>(E: Eq.Eq<R>, R: Rng.Ring<R>) => TC.Bimodule<Polynomial<R>, R, R>

export declare const getCommutativeRing: <R>(E: Eq.Eq<R>, R: Rng.Ring<R>) => TC.CommutativeRing<Polynomial<R>>

export declare const getCompositionMonoid: <R>(Eq_: Eq.Eq<R>, R: Rng.Ring<R>) => Monoid<Polynomial<R>>

export declare const getCompositionSemigroup: <R>(Eq_: Eq.Eq<R>, R: Rng.Ring<R>) => Semigroup<Polynomial<R>>

export declare const getEuclidianRing: <F>(E: Eq.Eq<F>, F: Fld.Field<F>) => TC.EuclidianRing<Polynomial<F>>

export declare const getPolynomialEq: <R>(Eq: Eq.Eq<R>) => Eq.Eq<Polynomial<R>>

export declare const getPolynomialOrd: <R>(Eq: Ord.Ord<R>) => Ord.Ord<Polynomial<R>>

export declare const getShow: (
  variable: string
) => <A>(S: Show<A>, isZero: (a: A) => boolean, isOne: (a: A) => boolean) => Show<Polynomial<A>>

export declare const shiftBy: <R>(n: number, r: R) => (p: readonly R[]) => readonly R[]

export interface Polynomial<R> extends ReadonlyArray<R> {
  _URI: PolynomialSymbol
}

export declare const antiderivative: <R>(
  constantTerm: R,
  scaleLeft: (n: number, r: R) => R
) => (p: Polynomial<R>) => Polynomial<R>

export declare const constant: <R>(Eq: Eq.Eq<R>, R: Rng.Ring<R>) => (a: R) => Polynomial<R>

export declare const derivative: <R>(scaleLeft: (n: number, r: R) => R) => (coeffs: Polynomial<R>) => Polynomial<R>

export declare const evaluate: <R>(R: Rng.Ring<R>) => (p: Polynomial<R>) => (x: R) => R

export declare const identity: <R>(R: Rng.Ring<R>) => Polynomial<R>

export declare const integrate: <R>(
  R: Rng.Ring<R>,
  scaleLeft: (n: number, r: R) => R
) => (lower: R, upper: R) => (p: Polynomial<R>) => R

export declare const l2InnerProduct: <R extends number | Complex>(
  Eq_: Eq.Eq<R>,
  R: Rng.Ring<R>,
  scaleLeft: (n: number, r: R) => R,
  conj: (r: R) => R
) => (p: Polynomial<R>, q: Polynomial<R>) => R

export declare const norm: <R extends number | Complex>(
  Eq_: Eq.Eq<R>,
  R: Rng.Ring<R>,
  scaleLeft: (n: number, r: R) => R,
  sqrt: (r: R) => R,
  conj: (r: R) => R
) => (p: Polynomial<R>) => R

export declare const polynomialCompose: <R>(
  Eq: Eq.Eq<R>,
  R: Rng.Ring<R>
) => (x: Polynomial<R>) => (y: Polynomial<R>) => Polynomial<R>

export declare const polynomialDegree: <R>(p: Polynomial<R>) => number

export declare const projection: <R extends number | Complex>(
  Eq_: Eq.Eq<R>,
  F: Fld.Field<R>,
  scaleLeft: (n: number, r: R) => R,
  conj: (r: R) => R
) => (p: Polynomial<R>, q: Polynomial<R>) => Polynomial<R>

export declare const preservingZipWith: <R, S>(
  f: (x: R, y: R) => S,
  def: R
) => (xs: readonly R[], ys: readonly R[]) => readonly S[]