ganrac

package module

Go to main page

Versions in this module

v0

v0.0.5

Nov 10, 2023

Changes in this version

type BinInt

+ func (z *BinInt) ToInt(p *Int) *Int

type FofAO

+ Len func() int

type NObj

+ Sign func() int

type Number

+ func (x *Number) Deg(lv Level) int

type Rat

+ func (z *Rat) ToInt() *Int

v0.0.4

Aug 12, 2023

Changes in this version

+ const ATOMQE_MAX_DEG

+ const OPVS_SHIFT

+ const QEALGO_ATOM

+ const QEALGO_SDC

+ const SDCQE_MAX_DEG

+ func ExampleNames() []string

+ func NewCadErrorWO(cell *Cell) error

+ func QEOptionNames() []string

type Atom

+ func (p *Atom) Clone() *Atom

type BinInt

+ func (x *BinInt) Deg(lv Level) int

+ type CAD_error_wo struct

+ func (e *CAD_error_wo) Error() string

type CAS

+ SetLogger func(logger *log.Logger)

+ Slope func(p *Poly, q *Poly, lv Level, k int32) RObj

type Fof

+ func NewFmlImpl(f1, f2 Fof) Fof

+ func NewForAll(lv []Level, fml Fof) Fof

type Ganrac

+ func (g *Ganrac) FunctionNames() []string

+ func (g *Ganrac) SetParaNum(n int)

type Int

+ func (x *Int) Deg(lv Level) int

+ func (x *Int) QuoRem(y *Int) (*Int, *Int)

type Interval

+ func (x *Interval) Deg(lv Level) int

type List

+ func NewListN(n int, args ...interface{}) *List

type OP

+ func (op OP) Format(b fmt.State, format rune)

type Poly

+ func (f *Poly) NegX(lv Level) *Poly

+ func (f *Poly) SubstXinvLv(lv Level, n int) RObj

+ func (p *Poly) NewPoly() *Poly

+ func (x *Poly) IsZZ() bool

type RObj

+ Deg func(lv Level) int

type RObjSample

+ func (z *RObjSample) Deg(lv Level) int

type Rat

+ func (x *Rat) Deg(lv Level) int

type Uint

+ func (x Uint) Deg(lv Level) int

v0.0.3

Jan 18, 2023

Changes in this version

+ var DebugCounter map[string]int = make(map[string]int)

+ func IncDebugCounter(f string, n int) int

+ func NewFofQuadEq(g *Ganrac, p *Poly, lv Level) *fof_quad_eq

+ func NewQeCond() *qeCond

+ func NewReduceInfo() *reduce_info

type CAD

+ func (c *CAD) InitProj(algo ProjectionAlgo)

+ func (c *CAD) InitRoot()

+ func (c *CAD) Root() *Cell

type Cell

+ func (cell *Cell) Truth() int8

type Fof

+ func NewFmlAnds(pp ...Fof) Fof

+ func NewFmlEquiv(f1, f2 Fof) Fof

+ func NewFmlOrs(pp ...Fof) Fof

type Ganrac

+ func (g *Ganrac) Close()

type NumRegion

+ func NewNumRegion() *NumRegion

type Poly

+ func (q *Poly) SubsXinv() *Poly

type QEopt

+ func (qeopt *QEopt) AddAlgo(algo algo_t)

+ func (qeopt *QEopt) DelAlgo(algo algo_t)

v0.0.2

Jan 9, 2023

Changes in this version

+ const FORMAT_INDEX

+ func VarNum() int

+ func VarStr(lv Level) string

+ type CAS interface

+ Close func() error

+ Discrim func(p *Poly, lv Level) RObj

+ Eval func(p string) (GObj, error)

+ Factor func(p *Poly) *List

+ GB func(p *List, vars *List, n int) *List

+ Gcd func(p, q *Poly) RObj

+ Psc func(p *Poly, q *Poly, lv Level, j int32) RObj

+ Reduce func(p *Poly, gb *List, vars *List, n int) (RObj, bool)

+ Resultant func(p *Poly, q *Poly, lv Level) RObj

+ Sres func(p *Poly, q *Poly, lv Level, k int32) RObj

type Ganrac

+ func (g *Ganrac) Logger() *log.Logger

+ func (g *Ganrac) SetCAS(cas CAS)

type Int

+ func (x *Int) N() *big.Int

type Level

+ func VarStr2Lv(s string) (Level, bool)

type List

+ func (z *List) Seti(i int, v GObj) error

+ func (z *List) Swap(i, j int) error

type Poly

+ func NewPolyVarn(lv Level, deg int) *Poly

+ func VarPoly(lv Level) *Poly

+ func (p *Poly) PPC() (*Poly, *Int)

+ func (x *Poly) Sdiv(y *Poly) RObj

+ func (z *Poly) Diff(lv Level) RObj

+ func (z *Poly) Level() Level

type Rat

+ func NewRat(c *big.Rat) *Rat

+ func (x *Rat) N() *big.Rat

type String

+ func (s *String) S() string

v0.0.1

Nov 3, 2022

Changes in this version

+ const CAD_STAGE_INITED

+ const CAD_STAGE_LIFTED

+ const CAD_STAGE_PROJED

+ const CMO_128BIT_MACHINE_DOUBLE

+ const CMO_64BIT_MACHINE_DOUBLE

+ const CMO_ARRAY_OF_128BIT_MACHINE_DOUBLE

+ const CMO_ARRAY_OF_64BIT_MACHINE_DOUBLE

+ const CMO_ATTRIBUTE_LIST

+ const CMO_BIGFLOAT

+ const CMO_BIGFLOAT32

+ const CMO_COMPLEX

+ const CMO_DATUM

+ const CMO_DISTRIBUTED_POLYNOMIAL

+ const CMO_DMS

+ const CMO_DMS_GENERIC

+ const CMO_DMS_OF_N_VARIABLES

+ const CMO_ERROR2

+ const CMO_IEEE_DOUBLE_FLOAT

+ const CMO_INDETERMINATE

+ const CMO_INT32

+ const CMO_INT32COEFF

+ const CMO_LAMBDA

+ const CMO_LIST

+ const CMO_LIST_R

+ const CMO_MATHCAP

+ const CMO_MONOMIAL32

+ const CMO_NULL

+ const CMO_POLYNOMIAL_IN_ONE_VARIABLE

+ const CMO_PRIVATE

+ const CMO_QQ

+ const CMO_RATIONAL

+ const CMO_RECURSIVE_POLYNOMIAL

+ const CMO_RING_BY_NAME

+ const CMO_STRING

+ const CMO_TREE

+ const CMO_ZERO

+ const CMO_ZZ

+ const EQ

+ const EVEN_LIN

+ const EVEN_LIN1

+ const EVEN_LIN2

+ const EVEN_NG

+ const EVEN_NO

+ const EVEN_OK

+ const EVEN_OKM

+ const FORMAT_DUMP

+ const FORMAT_QEPCAD

+ const FORMAT_SRC

+ const FORMAT_TEX

+ const FTAG_ALL

+ const FTAG_AND

+ const FTAG_ATOM

+ const FTAG_EX

+ const FTAG_FALSE

+ const FTAG_OR

+ const FTAG_TRUE

+ const GE

+ const GT

+ const KARATSUBA_DEG_MOD

+ const LARGEID

+ const LE

+ const LT

+ const NE

+ const NTAG_BININT

+ const NTAG_INT

+ const NTAG_INTERVAL

+ const NTAG_MOD

+ const NTAG_NONE

+ const NTAG_RAT

+ const OP_FALSE

+ const OP_TRUE

+ const OX_COMMAND

+ const OX_DATA

+ const OX_DATA_ASIR_BINARY_EXPRESSION

+ const OX_DATA_MP

+ const OX_DATA_OPENMATH_BINARY

+ const OX_DATA_OPENMATH_XML

+ const OX_DATA_WITH_SIZE

+ const OX_NOTIFY

+ const OX_SYNC_BALL

+ const PF_EVAL_NO

+ const PF_EVAL_UNKNOWN

+ const PF_EVAL_YES

+ const PROJ_HONG

+ const PROJ_McCallum

+ const QEALGO_EQLIN

+ const QEALGO_EQQUAD

+ const QEALGO_NEQ

+ const QEALGO_SMPL_EVEN

+ const QEALGO_SMPL_HOMO

+ const QEALGO_SMPL_ROTA

+ const QEALGO_SMPL_TRAN

+ const QEALGO_VSLIN

+ const QEALGO_VSQUAD

+ const SFC_PROJ_DEFINABLE

+ const SFC_PROJ_UNDEFINABLE

+ const SFC_PROJ_UNDET

+ const SM_PRIVATE

+ const SM_beginBlock

+ const SM_control_exit_debug_mode

+ const SM_control_kill

+ const SM_control_reset_connection

+ const SM_control_reset_connection_server

+ const SM_control_spawn_server

+ const SM_control_terminate_server

+ const SM_control_to_debug_mode

+ const SM_dupErrors

+ const SM_endBlock

+ const SM_evalName

+ const SM_executeFunction

+ const SM_executeFunctionAndPopCMO

+ const SM_executeFunctionAndPopSerializedLocalObject

+ const SM_executeFunctionWithOptionalArgument

+ const SM_executeStringByLocalParser

+ const SM_executeStringByLocalParserInBatchMode

+ const SM_getsp

+ const SM_mathcap

+ const SM_nop

+ const SM_popCMO

+ const SM_popSerializedLocalObject

+ const SM_popString

+ const SM_pops

+ const SM_pushCMOtag

+ const SM_setMathCap

+ const SM_setName

+ const SM_shutdown

+ const TAG_CAD

+ const TAG_FOF

+ const TAG_LIST

+ const TAG_NONE

+ const TAG_NUM

+ const TAG_POLY

+ const TAG_STR

+ var CAD_NO_WO = errors.New("NOT well-oriented")

+ func GetColordFml() bool

+ func MaxPrec(x, y *Interval) uint

+ func SetColordFml(b bool)

+ type Atom struct

+ func (p *Atom) Deg(lv Level) int

+ func (p *Atom) Equals(qq interface{}) bool

+ func (p *Atom) FmlLess(qq Fof) bool

+ func (p *Atom) Format(b fmt.State, format rune)

+ func (p *Atom) Indets(b []bool)

+ func (p *Atom) IsQff() bool

+ func (p *Atom) IsQuantifier() bool

+ func (p *Atom) Not() Fof

+ func (p *Atom) String() string

+ func (p *Atom) Subst(xs RObj, lvs Level) Fof

+ func (p *Atom) Tag() uint

+ type AtomF struct

+ func (p *AtomF) Deg(lv Level) int

+ func (p *AtomF) Equals(qq interface{}) bool

+ func (p *AtomF) FmlLess(q Fof) bool

+ func (p *AtomF) Format(s fmt.State, format rune)

+ func (p *AtomF) Indets(b []bool)

+ func (p *AtomF) IsQff() bool

+ func (p *AtomF) IsQuantifier() bool

+ func (p *AtomF) Not() Fof

+ func (p *AtomF) String() string

+ func (p *AtomF) Subst(xs RObj, lvs Level) Fof

+ func (p *AtomF) Tag() uint

+ type AtomProj struct

+ type AtomT struct

+ func (p *AtomT) Deg(lv Level) int

+ func (p *AtomT) Equals(qq interface{}) bool

+ func (p *AtomT) FmlLess(q Fof) bool

+ func (p *AtomT) Format(s fmt.State, format rune)

+ func (p *AtomT) Indets(b []bool)

+ func (p *AtomT) IsQff() bool

+ func (p *AtomT) IsQuantifier() bool

+ func (p *AtomT) Not() Fof

+ func (p *AtomT) String() string

+ func (p *AtomT) Subst(xs RObj, lvs Level) Fof

+ func (p *AtomT) Tag() uint

+ type BinInt struct

+ func NewBinInt(n *big.Int, m int) *BinInt

+ func (x *BinInt) Add(yy RObj) RObj

+ func (x *BinInt) AddInt(y *Int) RObj

+ func (x *BinInt) Div(yy NObj) RObj

+ func (x *BinInt) Equals(yy interface{}) bool

+ func (x *BinInt) Format(s fmt.State, format rune)

+ func (x *BinInt) IsMinusOne() bool

+ func (x *BinInt) IsOne() bool

+ func (x *BinInt) IsZero() bool

+ func (x *BinInt) Mul(yy RObj) RObj

+ func (x *BinInt) MulInt(y *Int) RObj

+ func (x *BinInt) Neg() RObj

+ func (x *BinInt) Pow(r *Int) RObj

+ func (x *BinInt) Sign() int

+ func (x *BinInt) String() string

+ func (x *BinInt) Sub(yy RObj) RObj

+ func (z *BinInt) Abs() NObj

+ func (z *BinInt) Cmp(xx NObj) int

+ func (z *BinInt) CmpAbs(xx NObj) int

+ func (z *BinInt) Float() float64

+ func (z *BinInt) Subst(x RObj, lv Level) RObj

+ func (z *BinInt) ToIntRat() NObj

+ type CAD struct

+ func NewCAD(prenex_formula Fof, g *Ganrac) (*CAD, error)

+ func (c *CAD) String() string

+ func (c *CAD) Tag() uint

+ func (cad *CAD) Fprint(b io.Writer, args ...interface{}) error

+ func (cad *CAD) FprintInput(b io.Writer, args ...interface{}) error

+ func (cad *CAD) FprintProj(b io.Writer, args ...interface{}) error

+ func (cad *CAD) FprintProjs(b io.Writer, lv Level)

+ func (cad *CAD) Lift(index ...int) error

+ func (cad *CAD) Print(args ...interface{}) error

+ func (cad *CAD) PrintProj(args ...interface{})

+ func (cad *CAD) Projection(algo ProjectionAlgo) (*List, error)

+ func (cad *CAD) Sfc() (Fof, error)

+ type CADSfc struct

+ func NewCADSfc(cad *CAD) *CADSfc

+ type CADStat struct

+ func (stat CADStat) Fprint(b io.Writer, cad *CAD)

+ type Cell struct

+ func NewCell(cad *CAD, parent *Cell, idx uint) *Cell

+ func (cell *Cell) Fprint(b io.Writer, args ...interface{}) error

+ func (cell *Cell) Index() []uint

+ func (cell *Cell) Neg() *Cell

+ func (cell *Cell) Prec() uint

+ func (cell *Cell) Precs() []uint

+ func (cell *Cell) Print(args ...interface{}) error

+ func (cell *Cell) Sign() int

+ func (cell *Cell) Square(even int)

+ type Cellmod struct

+ func NewCellmod(cell *Cell) *Cellmod

+ type Dict struct

+ func NewDict() *Dict

+ func (z *Dict) Equals(vv interface{}) bool

+ func (z *Dict) Format(s fmt.State, format rune)

+ func (z *Dict) Get(k string) (GObj, error)

+ func (z *Dict) Indets(b []bool)

+ func (z *Dict) Len() int

+ func (z *Dict) Set(k string, v GObj) error

+ func (z *Dict) String() string

+ func (z *Dict) Tag() uint

+ type Exists struct

+ func (p *Exists) Deg(lv Level) int

+ func (p *Exists) Equals(qq interface{}) bool

+ func (p *Exists) Fml() Fof

+ func (p *Exists) FmlLess(q Fof) bool

+ func (p *Exists) Format(b fmt.State, format rune)

+ func (p *Exists) Get(idx *Int) (interface{}, error)

+ func (p *Exists) Indets(b []bool)

+ func (p *Exists) IsQff() bool

+ func (p *Exists) IsQuantifier() bool

+ func (p *Exists) Not() Fof

+ func (p *Exists) Qs() []Level

+ func (p *Exists) String() string

+ func (p *Exists) Subst(xs RObj, lvs Level) Fof

+ func (p *Exists) Tag() uint

+ type Flusher interface

+ Flush func() error

+ type FmlAnd struct

+ func (p *FmlAnd) Deg(lv Level) int

+ func (p *FmlAnd) Equals(qq interface{}) bool

+ func (p *FmlAnd) FmlLess(q Fof) bool

+ func (p *FmlAnd) Fmls() []Fof

+ func (p *FmlAnd) Format(b fmt.State, format rune)

+ func (p *FmlAnd) Get(idx *Int) (Fof, error)

+ func (p *FmlAnd) Indets(b []bool)

+ func (p *FmlAnd) IsQff() bool

+ func (p *FmlAnd) IsQuantifier() bool

+ func (p *FmlAnd) Len() int

+ func (p *FmlAnd) Not() Fof

+ func (p *FmlAnd) String() string

+ func (p *FmlAnd) Subst(xs RObj, lvs Level) Fof

+ func (p *FmlAnd) Tag() uint

+ type FmlOr struct

+ func (p *FmlOr) Deg(lv Level) int

+ func (p *FmlOr) Equals(qq interface{}) bool

+ func (p *FmlOr) FmlLess(q Fof) bool

+ func (p *FmlOr) Fmls() []Fof

+ func (p *FmlOr) Format(b fmt.State, format rune)

+ func (p *FmlOr) Get(idx *Int) (Fof, error)

+ func (p *FmlOr) Indets(b []bool)

+ func (p *FmlOr) IsQff() bool

+ func (p *FmlOr) IsQuantifier() bool

+ func (p *FmlOr) Len() int

+ func (p *FmlOr) Not() Fof

+ func (p *FmlOr) String() string

+ func (p *FmlOr) Subst(xs RObj, lvs Level) Fof

+ func (p *FmlOr) Tag() uint

+ type Fof interface

+ Deg func(lv Level) int

+ FmlLess func(a Fof) bool

+ IsQff func() bool

+ IsQuantifier func() bool

+ Not func() Fof

+ Subst func(xs RObj, lv Level) Fof

+ func FofEquiv(f1, f2 Fof) Fof

+ func FofImpl(f1, f2 Fof) Fof

+ func NewAtom(p RObj, op OP) Fof

+ func NewAtoms(pp []RObj, op OP) Fof

+ func NewBool(b bool) Fof

+ func NewExists(lv []Level, fml Fof) Fof

+ func NewFmlAnd(pp Fof, qq Fof) Fof

+ func NewFmlOr(pp Fof, qq Fof) Fof

+ func NewQuantifier(forex bool, lvv []Level, fml Fof) Fof

+ type FofAO interface

+ Fmls func() []Fof

+ type FofQ interface

+ Fml func() Fof

+ Qs func() []Level

+ type FofTFbase struct

+ type ForAll struct

+ func (p *ForAll) Deg(lv Level) int

+ func (p *ForAll) Equals(qq interface{}) bool

+ func (p *ForAll) Fml() Fof

+ func (p *ForAll) FmlLess(q Fof) bool

+ func (p *ForAll) Format(b fmt.State, format rune)

+ func (p *ForAll) Get(idx *Int) (interface{}, error)

+ func (p *ForAll) Indets(b []bool)

+ func (p *ForAll) IsQff() bool

+ func (p *ForAll) IsQuantifier() bool

+ func (p *ForAll) Not() Fof

+ func (p *ForAll) Qs() []Level

+ func (p *ForAll) String() string

+ func (p *ForAll) Subst(xs RObj, lvs Level) Fof

+ func (p *ForAll) Tag() uint

+ type GObj interface

+ String func() string

+ Tag func() uint

+ type Ganrac struct

+ func NewGANRAC() *Ganrac

+ func (g *Ganrac) ConnectOX(cw, dw Flusher, cr, dr io.Reader) error

+ func (g *Ganrac) Eval(r io.Reader) (interface{}, error)

+ func (g *Ganrac) InitVarList(vlist []string) error

+ func (g *Ganrac) QE(fof Fof, qeopt *QEopt) Fof

+ func (g *Ganrac) SetLogger(logger *log.Logger)

+ type Int struct

+ func NewInt(n int64) *Int

+ func NewIntZ(z *big.Int) *Int

+ func ParseInt(s string, base int) *Int

+ func (x *Int) Add(y RObj) RObj

+ func (x *Int) Bit(i int) uint

+ func (x *Int) Div(yy NObj) RObj

+ func (x *Int) Equals(y interface{}) bool

+ func (x *Int) Format(s fmt.State, format rune)

+ func (x *Int) Gcd(y *Int) *Int

+ func (x *Int) GcdEx(y *Int) (*Int, *Int, *Int)

+ func (x *Int) Int64() int64

+ func (x *Int) IsInt64() bool

+ func (x *Int) IsMinusOne() bool

+ func (x *Int) IsOne() bool

+ func (x *Int) IsZero() bool

+ func (x *Int) Mul(y RObj) RObj

+ func (x *Int) Neg() RObj

+ func (x *Int) Pow(y *Int) RObj

+ func (x *Int) Set(y RObj) RObj

+ func (x *Int) Sign() int

+ func (x *Int) String() string

+ func (x *Int) Sub(y RObj) RObj

+ func (z *Int) Abs() NObj

+ func (z *Int) Cmp(xx NObj) int

+ func (z *Int) CmpAbs(xx NObj) int

+ func (z *Int) Float() float64

+ func (z *Int) Subst(x RObj, lv Level) RObj

+ type Interval struct

+ func FRealRoot(prec uint, lmax int, poly []*big.Float, rand float64) []*Interval

+ func NewIntervalFloat(n *big.Float, prec uint) *Interval

+ func NewIntervalInt64(n int64, prec uint) *Interval

+ func (c *Interval) ContainsZero() bool

+ func (x *Interval) Abs() NObj

+ func (x *Interval) Add(yy RObj) RObj

+ func (x *Interval) AddFloat(y *big.Float) *Interval

+ func (x *Interval) Cmp(y NObj) int

+ func (x *Interval) CmpAbs(y NObj) int

+ func (x *Interval) Div(yy NObj) RObj

+ func (x *Interval) Equals(v interface{}) bool

+ func (x *Interval) Float() float64

+ func (x *Interval) Format(s fmt.State, format rune)

+ func (x *Interval) IsMinusOne() bool

+ func (x *Interval) IsNumeric() bool

+ func (x *Interval) IsOne() bool

+ func (x *Interval) IsZero() bool

+ func (x *Interval) Mul(yy RObj) RObj

+ func (x *Interval) Mul2Exp(m uint) NObj

+ func (x *Interval) MulFloat(y *big.Float) *Interval

+ func (x *Interval) MulInt64(y int64) *Interval

+ func (x *Interval) Neg() RObj

+ func (x *Interval) Pow(yy *Int) RObj

+ func (x *Interval) Sign() int

+ func (x *Interval) Sub(yy RObj) RObj

+ func (x *Interval) SubFloat(y *big.Float) *Interval

+ func (x *Interval) Subst(v RObj, lv Level) RObj

+ func (x *Interval) Tag() uint

+ func (z *Interval) Prec() uint

+ func (z *Interval) SetFloat(n *big.Float)

+ func (z *Interval) SetFloat64(n float64)

+ func (z *Interval) SetInt64(n int64)

+ func (z *Interval) SetPrec(prec uint)

+ func (z *Interval) String() string

+ type Level int8

+ type Levels []Level

+ type List struct

+ func NewList(args ...interface{}) *List

+ func (z *List) Append(a GObj)

+ func (z *List) Equals(vv interface{}) bool

+ func (z *List) Format(s fmt.State, format rune)

+ func (z *List) Get(ii *Int) (GObj, error)

+ func (z *List) Geti(i int) (GObj, error)

+ func (z *List) Indets(b []bool)

+ func (z *List) Iter() []GObj

+ func (z *List) Len() int

+ func (z *List) Set(ii *Int, v GObj) error

+ func (z *List) String() string

+ func (z *List) Subst(xs RObj, lvs Level) *List

+ func (z *List) Tag() uint

+ type Moder interface

+ type NObj interface

+ Abs func() NObj

+ Cmp func(x NObj) int

+ CmpAbs func(x NObj) int

+ Float func() float64

+ type NumRegion struct

+ func (m *NumRegion) Format(s fmt.State, format rune)

+ type Number struct

+ func (x *Number) IsNumeric() bool

+ func (x *Number) String() string

+ func (x *Number) Tag() uint

+ type OP uint8

+ func (op OP) String() string

+ type OpenXM struct

+ func NewOpenXM(controlw, dataw Flusher, controlr, datar io.Reader, logger *log.Logger) *OpenXM

+ func (ox *OpenXM) Discrim(p *Poly, lv Level) RObj

+ func (ox *OpenXM) ExecFunction(funcname string, argv ...interface{}) error

+ func (ox *OpenXM) ExecString(val string) error

+ func (ox *OpenXM) Factor(p *Poly) *List

+ func (ox *OpenXM) GB(p *List, vars *List, n int) *List

+ func (ox *OpenXM) Gcd(p, q *Poly) RObj

+ func (ox *OpenXM) Init() error

+ func (ox *OpenXM) PopCMO() (interface{}, error)

+ func (ox *OpenXM) PopOXTag() (int32, int32, error)

+ func (ox *OpenXM) PopString() (string, error)

+ func (ox *OpenXM) Psc(p *Poly, q *Poly, lv Level, j int32) RObj

+ func (ox *OpenXM) PushOXCommand(sm_command int32) error

+ func (ox *OpenXM) PushOXTag(tag int32) error

+ func (ox *OpenXM) PushOxCMO(vv interface{}) error

+ func (ox *OpenXM) Reduce(p *Poly, gb *List, vars *List, n int) (RObj, bool)

+ func (ox *OpenXM) Resultant(p *Poly, q *Poly, lv Level) RObj

+ func (ox *OpenXM) Sres(p *Poly, q *Poly, lv Level, k int32) RObj

+ type Poly struct

+ func NewPoly(lv Level, deg_plus_1 int) *Poly

+ func NewPolyCoef(lv Level, coeffs ...interface{}) *Poly

+ func NewPolyInts(lv Level, coeffs ...int64) *Poly

+ func NewPolyVar(lv Level) *Poly

+ func (p *Poly) Cmp(q *Poly) int

+ func (p *Poly) Less(q *Poly) bool

+ func (p *Poly) RealRootIsolation(prec int) (*List, error)

+ func (x *Poly) Add(y RObj) RObj

+ func (x *Poly) Div(y NObj) RObj

+ func (x *Poly) Mul(yy RObj) RObj

+ func (x *Poly) Pow(y *Int) RObj

+ func (z *Poly) Clone() *Poly

+ func (z *Poly) Coef(lv Level, deg uint) RObj

+ func (z *Poly) Deg(lv Level) int

+ func (z *Poly) Equals(x interface{}) bool

+ func (z *Poly) Format(s fmt.State, format rune)

+ func (z *Poly) Indets(b []bool)

+ func (z *Poly) IsMinusOne() bool

+ func (z *Poly) IsNumeric() bool

+ func (z *Poly) IsOne() bool

+ func (z *Poly) IsZero() bool

+ func (z *Poly) LeadinfCoef() NObj

+ func (z *Poly) Neg() RObj

+ func (z *Poly) RootBound() (NObj, error)

+ func (z *Poly) Set(x RObj) RObj

+ func (z *Poly) Sign() int

+ func (z *Poly) String() string

+ func (z *Poly) Sub(y RObj) RObj

+ func (z *Poly) Subst(xs RObj, lv Level) RObj

+ func (z *Poly) SubstIntv(x *Interval, lv Level, prec uint) RObj

+ func (z *Poly) Tag() uint

+ type ProjFactor interface

+ Deg func() int

+ FprintProjFactor func(b io.Writer, cad *CAD)

+ Index func() uint

+ Input func() bool

+ Lv func() Level

+ P func() *Poly

+ SetIndex func(i uint)

+ SetInputT func(b bool)

+ SetSign func(sgn sign_t)

+ Sign func() sign_t

+ type ProjFactorBase struct

+ func (pfb *ProjFactorBase) Deg() int

+ func (pfb *ProjFactorBase) Index() uint

+ func (pfb *ProjFactorBase) Input() bool

+ func (pfb *ProjFactorBase) Lv() Level

+ func (pfb *ProjFactorBase) P() *Poly

+ func (pfb *ProjFactorBase) SetIndex(i uint)

+ func (pfb *ProjFactorBase) SetInputT(b bool)

+ func (pfb *ProjFactorBase) SetSign(b sign_t)

+ func (pfb *ProjFactorBase) Sign() sign_t

+ type ProjFactorHH struct

+ func (pf *ProjFactorHH) FprintProjFactor(b io.Writer, cad *CAD)

+ type ProjFactorMC struct

+ func (pf *ProjFactorMC) FprintProjFactor(b io.Writer, cad *CAD)

+ type ProjFactors interface

+ Len func() int

+ type ProjFactorsHH struct

+ func (pfs *ProjFactorsHH) Len() int

+ type ProjFactorsMC struct

+ func (pfs *ProjFactorsMC) Len() int

+ type ProjLink struct

+ func (pl *ProjLink) Fprint(b io.Writer)

+ type ProjectionAlgo int

+ type QEopt struct

+ Algo algo_t

+ func NewQEopt() *QEopt

+ func (qeopt *QEopt) SetAlgo(algo algo_t, v bool)

+ type QeExample struct

+ DOI string

+ Input Fof

+ Output Fof

+ Ref string

+ func GetExampleFof(name string) *QeExample

+ type RObj interface

+ Add func(x RObj) RObj

+ Div func(x NObj) RObj

+ IsMinusOne func() bool

+ IsNumeric func() bool

+ IsOne func() bool

+ IsZero func() bool

+ Mul func(x RObj) RObj

+ Neg func() RObj

+ Pow func(x *Int) RObj

+ Sign func() int

+ Sub func(x RObj) RObj

+ Subst func(x RObj, lv Level) RObj

+ func Add(x, y RObj) RObj

+ func Mul(x, y RObj) RObj

+ func Sub(x, y RObj) RObj

+ type RObjSample struct

+ func (z *RObjSample) Add(x RObj) RObj

+ func (z *RObjSample) Div(x NObj) RObj

+ func (z *RObjSample) Equals(x interface{}) bool

+ func (z *RObjSample) Format(s fmt.State, format rune)

+ func (z *RObjSample) IsMinusOne() bool

+ func (z *RObjSample) IsNumeric() bool

+ func (z *RObjSample) IsOne() bool

+ func (z *RObjSample) IsZero() bool

+ func (z *RObjSample) Mul(x RObj) RObj

+ func (z *RObjSample) Neg() RObj

+ func (z *RObjSample) Pow(x *Int) RObj

+ func (z *RObjSample) Set(x RObj) RObj

+ func (z *RObjSample) Sign() int

+ func (z *RObjSample) String() string

+ func (z *RObjSample) Sub(x RObj) RObj

+ func (z *RObjSample) Subst(x RObj, lv Level) RObj

+ func (z *RObjSample) Tag() uint

+ type Rat struct

+ func NewRatFrac(num, den *Int) *Rat

+ func NewRatInt64(num, den int64) *Rat

+ func (x *Rat) Add(yy RObj) RObj

+ func (x *Rat) Div(yy NObj) RObj

+ func (x *Rat) Equals(y interface{}) bool

+ func (x *Rat) Format(s fmt.State, format rune)

+ func (x *Rat) IsMinusOne() bool

+ func (x *Rat) IsOne() bool

+ func (x *Rat) IsZero() bool

+ func (x *Rat) Mul(yy RObj) RObj

+ func (x *Rat) Neg() RObj

+ func (x *Rat) Pow(y *Int) RObj

+ func (x *Rat) Sign() int

+ func (x *Rat) String() string

+ func (x *Rat) Sub(yy RObj) RObj

+ func (z *Rat) Abs() NObj

+ func (z *Rat) Cmp(xx NObj) int

+ func (z *Rat) CmpAbs(xx NObj) int

+ func (z *Rat) Float() float64

+ func (z *Rat) Subst(x RObj, lv Level) RObj

+ type String struct

+ func NewString(s string) *String

+ func (s *String) String() string

+ func (s *String) Tag() uint

+ func (z *String) Format(s fmt.State, format rune)

+ type Uint uint32

+ func (p Uint) Abs() NObj

+ func (p Uint) Add(x RObj) RObj

+ func (p Uint) Cmp(x NObj) int

+ func (p Uint) CmpAbs(x NObj) int

+ func (p Uint) Div(x NObj) RObj

+ func (p Uint) Equals(v interface{}) bool

+ func (p Uint) Float() float64

+ func (p Uint) Format(s fmt.State, format rune)

+ func (p Uint) IsMinusOne() bool

+ func (p Uint) IsNumeric() bool

+ func (p Uint) IsOne() bool

+ func (p Uint) IsZero() bool

+ func (p Uint) Mul(x RObj) RObj

+ func (p Uint) Neg() RObj

+ func (p Uint) Pow(x *Int) RObj

+ func (p Uint) Sign() int

+ func (p Uint) String() string

+ func (p Uint) Sub(x RObj) RObj

+ func (p Uint) Subst(x RObj, lv Level) RObj

+ func (p Uint) Tag() uint

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL