variate

type Accum struct {
	Sum   stats.Neumaier // compensated sum over periods
	W     stats.Welford  // count, mean and M2 over periods
	Block stats.Welford  // over the means of full blocks
	Min   float64
	Max   float64
	Zero  int64          // periods with exactly 0
	Hist  *stats.LogHist // nil when the quantity has no histogram
}

type Basis uint8

type Bounds struct {
	H            float64
	Lower, Upper []float64
	DiscGap      []float64
	Alias        float64
	Roundoff     []float64
}

type Chain struct {
	K, N         int
	Fail, Repair float64
}

type Compiled struct {
	// contains filtered or unexported fields
}

type Config struct {
	Periods          int64
	AllowUnconverged bool    // run to the caps when the plan exceeds them
	Transform        bool    // compute the transform at compile; the tail criterion then counts periods beyond its quantile
	TransformGrid    int     // largest grid of that transform; 0 = the transform's default
	TransformTol     float64 // its tolerance; 0 = the default
	TransformWork    int64   // its work budget; 0 = the default
	TransformBytes   int64   // the grids a transform pass may hold; 0 = the default
	MinHits          uint64
	ContribRSE       float64
	TargetRSE        float64
	TailP            float64
	TailHits         uint64
	MaxPeriods       int64
	MaxSteps         uint64
	Batch            int
	HistRes          float64

	Seed         uint64
	Workers      int
	BlockPeriods int
	PoolSize     int
	Series       bool
	NoBreakdown  bool
	NodeHist     bool
	Spill        int
	MaxMemory    int64
	Observer     Observer
	Watch        Watch
	Pace         time.Duration
	RoundScratch int
	RecordBuffer int
}

type Counter struct {
	ByLeaf []uint64
	Total  uint64
}

type Counts struct {
	Applicable bool
	Reason     string
	M          int
	Theta      float64
	Passes     int
	QuadNodes  int
	Entries    []Bounds // [node]; H = 1 and no discretisation gap
}

type ECPoint struct{ X, P, StdErr float64 }

type Expectation struct {
	Reach               [][]float64 // [source][node]
	EntriesPer          []float64   // [node]
	OutcomeRate         []float64   // [outcome]
	Terminal            [][]float64 // [source][node], 0 for non-leaves
	Mean                float64
	Var                 float64 // +Inf if infinite; NaN with delays or above the pair budget
	DrawsMean, DrawsVar float64
	MeanByCategory      []float64
	MeanBySource        []float64
	Contrib             []float64 // [node]
	VarByCategory       []float64 // NaN with delays or above the pair budget
	VarBySource         []float64
	ContribVar          []float64 // [node]
	StepsPerPeriod      float64
	ArrivalsPerPeriod   float64  // arrivals the renewal and chain sources draw beyond their rounds: the stream's events, the units' failures and repairs
	RoundsPerPeriod     float64  // Σ_k E[λ_k]
	Firing              []Firing // per trigger, P(fire)
	// contains filtered or unexported fields
}

type Factor struct {
	ID    string
	Model dist.Distribution // support in [0, ∞)
	Range *InputRange       // how uncertain Model is, for a sweep; nil = not swept
}

type Firing struct {
	Source int // the trigger's index among the sources
	Lo, Hi float64
	Reason string
}

type Function struct {
	Name, Category string
	Model          dist.Distribution // value; for PerTime, a rate per period
	Basis          Basis
	Scope          Scope
	Range          *InputRange // how uncertain Model is, for a sweep; nil = not swept
}

type Graph struct {
	ID, Description string
	Sources         []Source
	Nodes           []Node
	Factors         []Factor
	Schedules       []Schedule
	Layers          []Layer // functions of the period total reported beside it
	Phased          Phase   // set by Phase: the place in the cycle every schedule is fixed at
}

type Input struct {
	Name  string
	Kind  string
	Range *InputRange // nil when the model gives the input none
}

type InputRange struct {
	Low, High float64
	Factors   bool
}

type Layer struct {
	ID         string
	Attachment float64 // the total below which the layer pays nothing
	Limit      float64 // the most the layer pays before the share; 0 = no limit
	Share      float64 // the share of the band the layer pays; 0 = all of it
}

type Mode uint8

type Node struct {
	ID, Description string
	Functions       []Function
	Mode            Mode
	Outcomes        []Outcome
	Next            string          // continuation without a selection; "" with no Outcomes = leaf
	NextOutage      bool            // the continuation holds for the block's outage (as OutageHolding)
	NextHolding     dist.Continuous // holding time on Next; nil = 0
	NextScope       Scope
	NextRange       *InputRange // how uncertain NextHolding is; nil = not swept
	Threshold       *Threshold  // a branch on one function's value, in place of Outcomes and Next; nil = none
	Trigger         *Trigger    // the node is entered once at a period's end when the period's sum of its inputs is above a level; nil = none
}

type Observer interface {
	Observe(r *Round) error
}

type Outcome struct {
	To            string
	P             dist.Distribution // nil = remainder; Constant for fixed; otherwise drawn per period
	Holding       dist.Continuous   // nil = no delay
	HoldingScope  Scope
	OutageHolding bool        // hold for the time the reliability block that fired the round stays down
	PRange        *InputRange // how uncertain P is, for a sweep, as probabilities; nil = not swept
	HoldingRange  *InputRange // how uncertain Holding is; nil = not swept
}

type Phase struct{ Index, Cycle int }

type PlanRow struct {
	Criterion        string
	Driver           string
	PlannedPerPeriod float64
	PeriodsNeeded    int64
	Observed         float64
	Met              bool
}

type Prop struct{ P, StdErr float64 }

type Range struct{ Lo, Hi float64 }

type RecordWriter struct {
	// contains filtered or unexported fields
}

type Result struct {
	Seed      uint64
	Periods   int64
	Converged bool
	Stopped   bool
	Binding   string
	Unmet     []string

	Nodes, Outcomes, Categories, Sources []string

	Events       []uint64   // [source]
	Reach        [][]uint64 // [source][node]
	OutcomeCount [][]uint64 // [source][outcome]

	Total      Accum
	ByCategory []Accum
	BySource   []Accum
	EntriesPer []Accum // [node]
	Contrib    []Accum // [node]; zero for nodes without functions
	Layers     []Accum // [layer]: the layer's payout per period

	Steps         uint64
	BeyondHorizon float64
	TailPeriods   int64
	// Per tail threshold (Compiled.TailThresholds), the periods whose
	// total reached it and their total, categories and sources summed,
	// in the row order, for the tail shares.
	TailCounts []int64
	TailSums   [][]float64

	Series *Series // raw per-period rows; fixed runs with Config.Series only
}

type Round struct {
	Seq     uint64
	Period  int64
	Source  int32
	Arrival float64
	End     float64
	Leaf    int32
	Value   float64
	Steps   []Step
}

type Schedule struct {
	ID     string
	Values []float64   // finite, not negative
	Range  *InputRange // how uncertain the values' mean is, for a sweep; nil = not swept
}

type Scope uint8

type Series struct {
	// contains filtered or unexported fields
}

type Source struct {
	ID, Description string
	Frequency       dist.Distribution // rate per period
	To              string
	Every           int               // fire on every Every-th arrival of the stream; 0 or 1 = every arrival
	Repair          dist.Distribution // holding after each firing, in periods, during which the source is silent; nil = none
	Chains          []Chain           // a reliability diagram the engine simulates in place of Frequency; nil = none
	Factor          string            // a Factor's ID scaling the rate, drawn once per period and shared; "" = none
	Schedule        string            // a Schedule's ID scaling the rate by the period's place in a cycle; "" = none
	FrequencyRange  *InputRange       // how uncertain Frequency is, for a sweep; nil = not swept
	RepairRange     *InputRange       // how uncertain Repair is; nil = not swept
}

type Stat struct {
	N                        int64
	Mean, StdErr, StdDev     float64
	Min, Max                 float64
	P50, P90, P95, P99, P999 float64
	Quantiles                bool // the percentiles exist: the quantity has a histogram
	Clipped                  bool
	Share                    float64
}

type Step struct {
	Node    int32
	Outcome int32 // −1 at the leaf
	T       float64
	Value   float64
}

type Structure struct {
	Nodes    []StructureNode
	Outcomes []StructureEdge
	Sources  []StructureSource
}

type StructureEdge struct {
	Name, From, To string
	Holding        bool
}

type StructureFunction struct {
	Name, Category string
	PerTime        bool
}

type StructureNode struct {
	ID        string
	Functions []StructureFunction
	Leaf      bool
}

type StructureSource struct {
	ID, To  string
	Trigger bool
	Inputs  []string
	Over    float64
}

type Summary struct {
	Total      Stat
	Exceedance []ECPoint
	ByCategory map[string]Stat // empty, as are BySource, ContribPer and TailShares, with Config.NoBreakdown
	BySource   map[string]Stat

	ReachProb  map[string]map[string]Prop
	Terminal   map[string]map[string]Prop
	OutcomeP   map[string]Prop
	EntriesPer map[string]Stat
	ContribPer map[string]Stat // value booked per period at each node
	Layers     map[string]Stat // each layer's payout per period, its share that of the total's mean
	TailShares []TailShare     // who the tail belongs to, at each threshold with a period
	Plan       []PlanRow
}

type Sweep struct {
	Figure  string
	Screen  float64 // the screen's relative move; 0 when the inputs' ranges were swept
	Seed    uint64
	Periods int64 // of the simulated rows; 0 when there are none
	Phase   Phase // the phase the graph was fixed at; Index 0 for the whole cycle
	Rows    []SweepRow
}

type SweepConfig struct {
	// Figure is the quantity reported: "mean" (the default), "p<percent>"
	// for a quantile (p99, p99.5), "rp:<periods>" for the total at a
	// return period, "pzero" for P(T = 0), "layer:<id>", "category:<name>"
	// or "source:<id>" for that mean.
	Figure string
	// Screen, when positive, moves every selected input to 1 − Screen
	// and 1 + Screen times itself, ranges or none: a screen of the inputs'
	// leverage, for which are worth a range. 0 = each input with a range
	// moves to the two ends of it, and the others stay.
	Screen float64
	// Inputs restricts the sweep to the inputs whose name or kind is one
	// of these, or whose name starts with one followed by a space ("node
	// pump" takes every input of node pump). nil = every input.
	Inputs []string
	// Top keeps the Top inputs with the largest swing of the exact mean,
	// which ranks them before any costlier row is computed. 0 = all.
	Top int
	// Run compiles every model and runs the simulated rows: its Seed is
	// the one seed of every run, its Periods their length (0 = the length
	// the base run's plan settles on).
	Run Config
}

type SweepRow struct {
	Input  Input
	Method string
	// Low and High are the factors that took the input to the ends.
	Low, High           float64
	AtLow, Base, AtHigh Range
	// Swing is |AtHigh − AtLow| between the middles.
	Swing float64
	// LowSE and HighSE are the standard errors of AtLow − Base and AtHigh
	// − Base: 0 when exact, NaN for a bracket or too few blocks, and for a
	// simulated row measured on the runs' paired blocks.
	LowSE, HighSE float64
	// Clamped reports that a probability was held at 1, or held to its
	// node's sum, at one of the ends.
	Clamped bool
}

type TailShare struct {
	X          float64
	Periods    int64
	BySource   map[string]float64
	ByCategory map[string]float64
}

type Threshold struct {
	Function     string  // the name of the node's OnEntry function whose value is tested
	Over         float64 // above is strictly greater than Over
	Above, Below string  // the next node on each side
}

type TransformConfig struct {
	MaxGrid  int     // default 1<<22 points
	Tol      float64 // default 1e-3: at each x up to x*, (Upper − Lower)/Upper, or the quantile bracket's (hi − lo)/hi
	TailP    float64 // default from the compile criteria
	MaxWork  int64   // default 1<<34 grid-point evaluations (a rate quadrature's nodes × points, a function's or closed-form rate's points) over the whole transform
	MaxBytes int64   // default 2<<30, 3<<29 with a 32-bit int: the grids a pass holds at once
}

type Transformed struct {
	Applicable bool
	Reason     string
	H          float64
	M          int
	Theta      float64
	PZero      float64
	QuadNodes  int
	Passes     int
	Work       int64 // grid-point evaluations spent
	Total      Bounds
	ByCategory []Bounds
	BySource   []Bounds // nil when the model has more than maxSourceBounds sources
}

type Trigger struct {
	Over    float64        // fires when the sum is strictly greater
	Inputs  []TriggerInput // the values the sum adds up
	Entries []string       // or the nodes whose entries it counts, booking nothing
}

type TriggerInput struct {
	Node, Function string
}

type Warning struct {
	Code    string
	Subject string
	Message string
}

type Watch struct {
	Nodes    []string
	Leaves   []string
	MinValue float64
}

type Workspace struct {
	// contains filtered or unexported fields
}