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]
	// contains filtered or unexported fields
}

type Factor struct {
	ID    string
	Model dist.Distribution // support in [0, ∞)
}

type Function struct {
	Name, Category string
	Model          dist.Distribution // value; for PerTime, a rate per period
	Basis          Basis
	Scope          Scope
}

type Graph struct {
	ID, Description string
	Sources         []Source
	Nodes           []Node
	Factors         []Factor
	Schedules       []Schedule
	Layers          []Layer // functions of the period total reported beside it
}

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
}

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
}

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

type Prop struct{ P, StdErr 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
}

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
}

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
}

type Summary struct {
	Total      Stat
	Exceedance []ECPoint
	ByCategory map[string]Stat
	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 TailShare struct {
	X          float64
	Periods    int64
	BySource   map[string]float64
	ByCategory map[string]float64
}

type TransformConfig struct {
	MaxGrid  int     // default 1<<22 points
	Tol      float64 // default 1e-3: max of (Upper − Lower)/Upper over x up to x*
	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: 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 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
}