Tessero\Ext\Polynomial

polyval static

polyval($x, $c)

chebval static

chebval($x, $c)

legval static

legval($x, $c)

lagval static

lagval($x, $c)

hermval static

hermval($x, $c)

hermeval static

hermeval($x, $c)

Polynomial static

Polynomial($coef, $x)

Chebyshev static

Chebyshev($coef, $x)

Legendre static

Legendre($coef, $x)

Laguerre static

Laguerre($coef, $x)

Hermite static

Hermite($coef, $x)

HermiteE static

HermiteE($coef, $x)

polyadd static

polyadd($c1, $c2)

polysub static

polysub($c1, $c2)

polymul static

polymul($c1, $c2)

polymulx static

polymulx($c)

polypow static

polypow($c, $pow, $maxpower = 16)

polydiv static

polydiv($c1, $c2)

polyder static

polyder($c, $m = 1, $scl = 1)

polyint static

polyint($c, $m = 1, $k = 0, $lbnd = 0, $scl = 1)

polyfromroots static

polyfromroots($roots)

polyline static

polyline($off, $scl)

polytrim static

polytrim($c, $tol = 0)

polyvander static

polyvander($x, $deg)

polyvalfromroots static

polyvalfromroots($x, $r)

polyval2d static

polyval2d($x, $y, $c)

polyval3d static

polyval3d($x, $y, $z, $c)

polygrid2d static

polygrid2d($x, $y, $c)

polygrid3d static

polygrid3d($x, $y, $z, $c)

polyvander2d static

polyvander2d($x, $y, $deg)

polyvander3d static

polyvander3d($x, $y, $z, $deg)

polycompanion static

polycompanion($c)

polyroots static

polyroots($c)

polyfit static

polyfit($x, $y, $deg)

polyzero static

polyzero()

polyone static

polyone()

polyx static

polyx()

polydomain static

polydomain()

chebadd static

chebadd($c1, $c2)

chebsub static

chebsub($c1, $c2)

chebmul static

chebmul($c1, $c2)

chebmulx static

chebmulx($c)

chebpow static

chebpow($c, $pow, $maxpower = 16)

chebdiv static

chebdiv($c1, $c2)

chebder static

chebder($c, $m = 1, $scl = 1)

chebint static

chebint($c, $m = 1, $k = 0, $lbnd = 0, $scl = 1)

chebfromroots static

chebfromroots($roots)

chebline static

chebline($off, $scl)

chebtrim static

chebtrim($c, $tol = 0)

chebvander static

chebvander($x, $deg)

chebval2d static

chebval2d($x, $y, $c)

chebval3d static

chebval3d($x, $y, $z, $c)

chebgrid2d static

chebgrid2d($x, $y, $c)

chebgrid3d static

chebgrid3d($x, $y, $z, $c)

chebvander2d static

chebvander2d($x, $y, $deg)

chebvander3d static

chebvander3d($x, $y, $z, $deg)

chebcompanion static

chebcompanion($c)

chebroots static

chebroots($c)

chebfit static

chebfit($x, $y, $deg)

cheb2poly static

cheb2poly($c)

poly2cheb static

poly2cheb($pol)

chebpts1 static

chebpts1($npts)

chebpts2 static

chebpts2($npts)

chebgauss static

chebgauss($deg)

chebweight static

chebweight($x)

chebzero static

chebzero()

chebone static

chebone()

chebx static

chebx()

chebdomain static

chebdomain()

legadd static

legadd($c1, $c2)

legsub static

legsub($c1, $c2)

legmul static

legmul($c1, $c2)

legmulx static

legmulx($c)

legpow static

legpow($c, $pow, $maxpower = 16)

legdiv static

legdiv($c1, $c2)

legder static

legder($c, $m = 1, $scl = 1)

legint static

legint($c, $m = 1, $k = 0, $lbnd = 0, $scl = 1)

legfromroots static

legfromroots($roots)

legline static

legline($off, $scl)

legtrim static

legtrim($c, $tol = 0)

legvander static

legvander($x, $deg)

legval2d static

legval2d($x, $y, $c)

legval3d static

legval3d($x, $y, $z, $c)

leggrid2d static

leggrid2d($x, $y, $c)

leggrid3d static

leggrid3d($x, $y, $z, $c)

legvander2d static

legvander2d($x, $y, $deg)

legvander3d static

legvander3d($x, $y, $z, $deg)

legcompanion static

legcompanion($c)

legroots static

legroots($c)

legfit static

legfit($x, $y, $deg)

leg2poly static

leg2poly($c)

poly2leg static

poly2leg($pol)

leggauss static

leggauss($deg)

legweight static

legweight($x)

legzero static

legzero()

legone static

legone()

legx static

legx()

legdomain static

legdomain()

lagadd static

lagadd($c1, $c2)

lagsub static

lagsub($c1, $c2)

lagmul static

lagmul($c1, $c2)

lagmulx static

lagmulx($c)

lagpow static

lagpow($c, $pow, $maxpower = 16)

lagdiv static

lagdiv($c1, $c2)

lagder static

lagder($c, $m = 1, $scl = 1)

lagint static

lagint($c, $m = 1, $k = 0, $lbnd = 0, $scl = 1)

lagfromroots static

lagfromroots($roots)

lagline static

lagline($off, $scl)

lagtrim static

lagtrim($c, $tol = 0)

lagvander static

lagvander($x, $deg)

lagval2d static

lagval2d($x, $y, $c)

lagval3d static

lagval3d($x, $y, $z, $c)

laggrid2d static

laggrid2d($x, $y, $c)

laggrid3d static

laggrid3d($x, $y, $z, $c)

lagvander2d static

lagvander2d($x, $y, $deg)

lagvander3d static

lagvander3d($x, $y, $z, $deg)

lagcompanion static

lagcompanion($c)

lagroots static

lagroots($c)

lagfit static

lagfit($x, $y, $deg)

lag2poly static

lag2poly($c)

poly2lag static

poly2lag($pol)

laggauss static

laggauss($deg)

lagweight static

lagweight($x)

lagzero static

lagzero()

lagone static

lagone()

lagx static

lagx()

lagdomain static

lagdomain()

hermadd static

hermadd($c1, $c2)

hermsub static

hermsub($c1, $c2)

hermmul static

hermmul($c1, $c2)

hermmulx static

hermmulx($c)

hermpow static

hermpow($c, $pow, $maxpower = 16)

hermdiv static

hermdiv($c1, $c2)

hermder static

hermder($c, $m = 1, $scl = 1)

hermint static

hermint($c, $m = 1, $k = 0, $lbnd = 0, $scl = 1)

hermfromroots static

hermfromroots($roots)

hermline static

hermline($off, $scl)

hermtrim static

hermtrim($c, $tol = 0)

hermvander static

hermvander($x, $deg)

hermval2d static

hermval2d($x, $y, $c)

hermval3d static

hermval3d($x, $y, $z, $c)

hermgrid2d static

hermgrid2d($x, $y, $c)

hermgrid3d static

hermgrid3d($x, $y, $z, $c)

hermvander2d static

hermvander2d($x, $y, $deg)

hermvander3d static

hermvander3d($x, $y, $z, $deg)

hermcompanion static

hermcompanion($c)

hermroots static

hermroots($c)

hermfit static

hermfit($x, $y, $deg)

herm2poly static

herm2poly($c)

poly2herm static

poly2herm($pol)

hermgauss static

hermgauss($deg)

hermweight static

hermweight($x)

hermzero static

hermzero()

hermone static

hermone()

hermx static

hermx()

hermdomain static

hermdomain()

hermeadd static

hermeadd($c1, $c2)

hermesub static

hermesub($c1, $c2)

hermemul static

hermemul($c1, $c2)

hermemulx static

hermemulx($c)

hermepow static

hermepow($c, $pow, $maxpower = 16)

hermediv static

hermediv($c1, $c2)

hermeder static

hermeder($c, $m = 1, $scl = 1)

hermeint static

hermeint($c, $m = 1, $k = 0, $lbnd = 0, $scl = 1)

hermefromroots static

hermefromroots($roots)

hermeline static

hermeline($off, $scl)

hermetrim static

hermetrim($c, $tol = 0)

hermevander static

hermevander($x, $deg)

hermeval2d static

hermeval2d($x, $y, $c)

hermeval3d static

hermeval3d($x, $y, $z, $c)

hermegrid2d static

hermegrid2d($x, $y, $c)

hermegrid3d static

hermegrid3d($x, $y, $z, $c)

hermevander2d static

hermevander2d($x, $y, $deg)

hermevander3d static

hermevander3d($x, $y, $z, $deg)

hermecompanion static

hermecompanion($c)

hermeroots static

hermeroots($c)

hermefit static

hermefit($x, $y, $deg)

herme2poly static

herme2poly($c)

poly2herme static

poly2herme($pol)

hermegauss static

hermegauss($deg)

hermeweight static

hermeweight($x)

hermezero static

hermezero()

hermeone static

hermeone()

hermex static

hermex()

hermedomain static

hermedomain()

Build this with Claude Code, Cursor or Copilot