questions

type Block interface {
	// contains filtered or unexported methods
}

type BlockWrapper struct {
	Data Block
}

type Co string

type ComparisonLevel uint8

type CoordExpression struct {
	X, Y string
}

type DropDownFieldInstance RadioFieldInstance

type Enonce []Block

type EnonceInstance []instance

type ErrParameters struct {
	Origin  string
	Details string
}

type ErrQuestionInvalid struct {
	ErrParameters ErrParameters
	ErrEnonce     errEnonce
	ErrCorrection errEnonce
	Kind          ErrorKind // indicates which field is valid
}

type ErrorKind uint8

type ExerciceInstance struct {
	Title       string
	Description string
	Questions   []QuestionInstance
	Id          int64
}

type ExpressionFieldBlock struct {
	// A valid expression, in the format used by expression.Expression or expression.Compound
	Expression       string
	Label            Interpolated // optional
	ComparisonLevel  ComparisonLevel
	ShowFractionHelp bool // if true an hint for fraction is displayed when applicable
}

type ExpressionFieldInstance struct {
	// if not empty, the field is displayed on a new line
	LabelLaTeX string

	Answer          expression.Compound
	ComparisonLevel ComparisonLevel

	// If true an hint for fraction is displayed
	ShowFractionHelp bool

	ID int
}

type FigureBlock struct {
	Drawings   repere.RandomDrawings
	Bounds     repere.RepereBounds
	ShowGrid   bool
	ShowOrigin bool
}

type FigureInstance client.FigureBlock

type FiguresOrGraphs interface {
	// contains filtered or unexported methods
}

type FiguresOrGraphsWrapper struct {
	Data FiguresOrGraphs
}

type FormulaBlock struct {
	Parts Interpolated
}

type FormulaContent []FormulaPart

type FormulaDisplayInstance []string

type FormulaPart struct {
	Content      string
	IsExpression bool // when true, Content is interpreted as an expression.Expression
}

type FunctionArea struct {
	// reference to function [Label]s, with empty meaning
	// horizontal line
	Bottom, Top Interpolated
	Left, Right string // expression.Expression
	Color       repere.ColorHex
}

type FunctionDecoration struct {
	Label Interpolated
	Color string
}

type FunctionDefinition struct {
	Function   string // expression.Expression
	Decoration FunctionDecoration
	Variable   ex.Variable // usually x
	From, To   string      // definition domain, expression.Expression
}

type FunctionPoint struct {
	Function Interpolated // reference to a function [Label]
	X        string       // expression.Expression
	Color    repere.ColorHex
	Legend   Interpolated // legend
}

type FunctionPointsFieldBlock struct {
	IsDiscrete bool
	Function   string // function or sequence, valid expression.Expression
	Label      string
	Variable   ex.Variable
	XGrid      []string // valid expression.Expression
}

type FunctionPointsFieldInstance struct {
	IsDiscrete bool
	Function   expression.FunctionExpr
	Label      string
	XGrid      []int
	ID         int
	// contains filtered or unexported fields
}

type FunctionSign struct {
	Label     Interpolated
	FxSymbols []client.SignSymbol
	Signs     []bool
}

type FunctionsGraphBlock struct {
	FunctionExprs      []FunctionDefinition
	FunctionVariations []VariationTableBlock
	SequenceExprs      []FunctionDefinition // displayed as discrete sequences
	Areas              []FunctionArea
	Points             []FunctionPoint
}

type FunctionsGraphInstance struct {
	Functions []functiongrapher.FunctionGraph
	Sequences []functiongrapher.SequenceGraph
	Areas     []client.FunctionArea
	Points    []client.FunctionPoint
}

type GFAffineLine struct {
	Label string
	A     string // valid expression.Expression
	B     string // valid expression.Expression
}

type GFPoint struct {
	Answer CoordExpression
}

type GFVector struct {
	Answer         CoordExpression
	AnswerOrigin   CoordExpression // optionnal, used when MustHaveOrigin is true
	MustHaveOrigin bool
}

type GFVectorPair struct {
	Criterion VectorPairCriterion
}

type GeoField interface {
	// contains filtered or unexported methods
}

type GeoFieldWrapper struct {
	Data GeoField
}

type GeometricConstructionFieldBlock struct {
	Field      GeoField
	Background FiguresOrGraphs
}

type GeometricConstructionFieldInstance struct {
	ID         int
	Field      geoFieldInstance
	Background client.FigureOrGraph
}

type In string

type Interpolated string

type InvalidFieldAnswer struct {
	ID     int
	Reason string
}

type NumberFieldBlock struct {
	// a valid expression, in the format used by expression.Expression
	// which is only parametrized by the random parameters
	Expression string
}

type NumberFieldInstance struct {
	ID     int
	Answer float64 // expected answer
}

type OrderedListFieldBlock struct {
	Label               Interpolated
	Answer              []Interpolated // the order matters
	AdditionalProposals []Interpolated
}

type OrderedListFieldInstance struct {
	Label               string            // optionnal, LaTeX code displayed in front of the anwser field
	Answer              []client.TextLine // LaTeX code
	AdditionalProposals []client.TextLine // added to Answer when displaying the field
	ID                  int
}

type ParameterEntry interface {
	// Return a user friendly description
	String() string
	// contains filtered or unexported methods
}

type ParameterEntryWrapper struct {
	Data ParameterEntry
}

type Parameters []ParameterEntry

type ProofAssertion interface {
	// contains filtered or unexported methods
}

type ProofAssertionWrapper struct {
	Data ProofAssertion
}

type ProofAssertions []ProofAssertion

type ProofEquality struct {
	Terms string // always interpreted as LaTeX, splitted by equals
}

type ProofFieldBlock struct {
	Answer ProofSequence
}

type ProofFieldInstance struct {
	Answer proofSequenceIns
	ID     int
}

type ProofInvalid struct{}

type ProofNode struct {
	Left, Right ProofAssertion `gomacro-data:"ignore"`
	Op          client.Binary
}

type ProofSequence struct {
	Parts ProofAssertions `gomacro-data:"ignore"`
}

type ProofStatement struct {
	Content Interpolated
}

type QuestionInstance struct {
	Enonce     EnonceInstance
	Correction EnonceInstance
}

type QuestionPage struct {
	Enonce     Enonce     `json:"enonce" gomacro-opaque:"dart"`
	Parameters Parameters `json:"parameters" gomacro-opaque:"dart"` // random parameters shared by the all the blocks
	Correction Enonce     `json:"correction" gomacro-opaque:"dart"`
}

type RadioFieldBlock struct {
	Answer     string         // must satisfy expression.IsValidIndex
	Proposals  []Interpolated // slice of text parts
	AsDropDown bool
}

type RadioFieldInstance struct {
	Proposals []client.TextLine
	ID        int
	Answer    int // index into Proposals, starting at 1
}

type Rp struct {
	Expression string      `json:"expression"` // as typed by the user, but validated
	Variable   ex.Variable `json:"variable"`
}

type SetFieldBlock struct {
	Answer         string // expression
	AdditionalSets []Interpolated
}

type SetFieldInstance struct {
	ID     int
	Answer sets.BinarySet
}

type SignSymbol uint8

type SignTableBlock struct {
	Xs        []string // valid expression
	Functions []FunctionSign
}

type SignTableFieldBlock struct {
	Answer SignTableBlock
}

type SignTableFieldInstance struct {
	Answer SignTableInstance
	ID     int
}

type SignTableInstance struct {
	Xs        []*expression.Expr
	Functions []client.FunctionSign
}

type StringOrExpression struct {
	Expression *expression.Expr
	String     string // LaTeX code, rendered in math mode
}

type TableBlock struct {
	HorizontalHeaders []TextPart
	VerticalHeaders   []TextPart
	Values            [][]TextPart
}

type TableFieldBlock struct {
	HorizontalHeaders []TextPart
	VerticalHeaders   []TextPart
	Answer            [][]string // valid expression.Expression
}

type TableFieldInstance struct {
	HorizontalHeaders []client.TextOrMath
	VerticalHeaders   []client.TextOrMath
	Answer            client.TableAnswer
	ID                int
}

type TableInstance client.TableBlock

type TextBlock struct {
	Parts   Interpolated
	Bold    bool
	Italic  bool
	Smaller bool
}

type TextInstance client.TextBlock

type TextKind uint8

type TextPart struct {
	Content string
	Kind    TextKind
}

type TextParts []TextPart

type TreeBlock struct {
	EventsProposals []Interpolated
	AnswerRoot      TreeNodeAnswer
}

type TreeFieldBlock struct {
	Answer TreeBlock
}

type TreeFieldInstance struct {
	Answer TreeInstance
	ID     int
}

type TreeInstance struct {
	EventsProposals []client.TextLine
	AnswerRoot      TreeNodeInstance
}

type TreeNodeAnswer struct {
	Children      []TreeNodeAnswer `gomacro-data:"ignore"`
	Probabilities []string         // edges, same length as Children, valid expression.Expression
	Value         int              // index into the proposals, 0 for the root
}

type TreeNodeInstance struct {
	Children      []TreeNodeInstance
	Probabilities []*expression.Expr // expression for edges, same length as Children
	Value         int                // index into the proposals, ignored for the root
}

type VariationTableBlock struct {
	Label Interpolated
	Xs    []string // expressions
	Fxs   []string // expressions
}

type VariationTableFieldBlock struct {
	Answer VariationTableBlock
}

type VariationTableFieldInstance struct {
	Answer VariationTableInstance
	ID     int
}

type VariationTableInstance struct {
	Label string
	Xs    []evaluatedExpression // sorted expression values for x
	Fxs   []evaluatedExpression // corresponding values for f(x)
}

type VectorFieldBlock struct {
	Answer         CoordExpression
	AcceptColinear bool // if true, all vectors colinears to `Answer` are accepted
	DisplayColumn  bool // if true, the field are displayed in column, instead of being on the same line
}

type VectorFieldInstance struct {
	ID             int
	Answer         repere.Coord
	AcceptColinear bool
	DisplayColumn  bool
}

type VectorPairCriterion uint8