package lutin

You can search for identifiers within the package.

in-package search v0.2.0

package lutin

lutin
- Auto2Lucky
- AutoGen
- Bddd
- CheckEnv
- CheckType
- CkIdentInfo
- CkTypeEff
- CoAlgExp
- CoIdent
- CoTraceExp
- Constraint
- Draw
- Exp
- ExpEval
- Expand
- ExprUtil
- FGen
- Formula_to_bdd
- GenOcamlGlue
- Glue
- Gne
- Guard
- Lexeme
- LoopWeights
- Luc2alice
- Luc2c
- LucFGen
- Lucky
- LutErrors
- LutExe
- LutLexer
- LutParser
- LutPredef
- LutProg
- LutinRun
- LutinUtils
- MainArg
- Ne
- Parsers
- Poly_draw
- Polyhedron
- Prevar
- Prog
- Reactive
- Rif
- Sol_nb
- Solver
- Store
- Syntaxe
- SyntaxeDump
- Thickness
- Type
- Util
  - StringMap
- Utils
- Value
- Var
- Verbose
- Version

Legend:
Library
Module
Module type
Parameter
Class
Class type

Internal (normal) representation of expressions.

type t

Normal expressions type.

type subst = (string * Value.num) * t

val is_a_constant : t -> bool

is_a_constant ne returns true iff ne is a constant.

val dimension : t -> int

dimension ne returns the number of variables involved in ne

type split_res =

| Split of string * Value.num * t
| No_solution
| Dont_know

split ne returns a monome (a,x) of ne (where x is not "", namely a is not the constant of ne) as well as the rest of the expr, namely, ne-a.x.

If it is a monome over integers, we return such a couple iff a divide the rest.

We suppose that the dimension is > 0.

val split : t -> split_res

val neg_nexpr : t -> t

neg_nexpr ne returns the opposite of ne, namely, -ne.

val opposite : t -> t

Various operations over normal expression.

val add : t -> t -> t

val diff : t -> t -> t

val mult : t -> t -> t

val modulo : t -> t -> t

val div : t -> t -> t

val quot : t -> t -> t