vectors

func AggregationColumns ¶

func AggregationColumns(req *types.Request, schema func() *encoding.Schema, kinds AggregationKinds) func(i int) ([]string, bool)

AggregationColumns is the column lister a series overlay host hands seriesfield (seriesfield.Columns): for aggregation i of req.Aggregations, the Response.Data columns it writes — AggregationOutputColumns over the schema schema returns (called at most once, and only for an expanding slot; nil: none). With no schema an expanding slot's columns are still known when it carries its element labels inline (fields + params.labels — the prepared slot AggregationSlotRewrite hands the runtime, whose labels are the columns' element labels); otherwise known is false. A slot that does not expand writes its label (known). Predict and the runtime build it the same way, so an element column resolves identically.

func AggregationExpands ¶

func AggregationExpands(a *types.Aggregation, kinds AggregationKinds) bool

AggregationExpands reports whether a is an array-valued vector aggregation (a built-in, or an extension declared VectorInput and ArrayValued — kinds) whose params set expand (a params blob that does not decode never expands — the resolver refuses it).

func AggregationInputMembers ¶

func AggregationInputMembers(req *types.Request, schema *encoding.Schema) (members []string, ok bool)

AggregationInputMembers returns the union of every field req's aggregation slots read through inline fields (a named vector's members ride Members(req)), and whether every one resolved — projection decodes wide otherwise.

func AggregationOutputColumns ¶

func AggregationOutputColumns(req *types.Request, a *types.Aggregation, schema *encoding.Schema, kinds AggregationKinds) ([]string, bool)

AggregationOutputColumns returns the Response.Data columns slot a of req emits over schema: its label (types.AggregationLabelOf unless Label is set), or — on an expanding vector aggregation (AggregationExpands under kinds) — one ExpandedColumn per member in member order, the label itself absent. The second result is false when an expanding slot's members do not resolve (the resolver refuses the request); the label is returned then. Predict (return planning, chain stage columns, the per-slot columns) and the field-reference walk share it, so they name the columns the runtime writes.

func AggregationSlotRewrite ¶

func AggregationSlotRewrite(a *types.Aggregation, in AggregationInput) *types.Aggregation

AggregationSlotRewrite is the slot a vector aggregator's factory receives: a copy with Label the default label when empty (computed from the slot as written), Vector cleared, Fields = the resolved literal members and params.labels = the resolved display labels — so a named vector's labels survive the literal-member rewrite. An extension's slot keeps every other params key (the operator's own). The caller's slot is never mutated.

func AlignFit ¶

func AlignFit(key, slot, fit string, fitLabels, labels []string) ([]int, *errors.CodedError)

AlignFit aligns a bound vector fit's labels (fitLabels, the fit named fit) to a slot's member labels: perm[i] is the index, in fitLabels, of labels[i]. Unequal label sets are PULSE_VECTOR_REFERENCE_MISMATCH reason labels_differ (the reference Match rule) naming the fit under details.fit and the slot under details[key] (key "attribute" or "matrix"), the message prefixed with slot.

func AnyAggregationVectorInput ¶

func AnyAggregationVectorInput(req *types.Request) bool

AnyAggregationVectorInput reports whether any aggregation slot of req sets vector or fields (allocation-free).

func ArrayValuedCrosstabRefusal ¶

func ArrayValuedCrosstabRefusal(spec *types.CrosstabSpec, kinds AggregationKinds) *errors.CodedError

ArrayValuedCrosstabRefusal is the crosstab gate for an array-valued aggregator (AggregationKinds.IsArrayValued — a built-in or a declared ArrayValued extension) as the cell or a margin aggregation: PROCESSING_CONFIG {aggregation, slot, reason: "array_valued"}, whatever normalize says — a cell holds one number. The one exception is a slot selecting one element (SelectsElement: a built-in AGG_VEC_* with params.element), which is a scalar. kinds is the instance's view; nil when no slot is array-valued. processing.validateCrosstabSpec (both arms) and predict call it, so they refuse identically.

func AttributeFit ¶

func AttributeFit(typ types.AttributeType, a *types.Attribute) string

AttributeFit returns a's params.fit — the bound vector fit a fitted attribute (or a fitted-metric comparison) scores against — when a's route typ is a vector-input attribute; "" when absent, empty, for any other type, or when the params do not decode (those are refused elsewhere). The field-reference walk judges the name against the bound fits (internal/model.CheckVectorFit).

func AttributeFitLabels ¶

func AttributeFitLabels(typ types.AttributeType, a *types.Attribute, members Resolved, schema *encoding.Schema) ([]string, bool)

AttributeFitLabels returns the labels a fitted attribute slot (route typ, resolved members) aligns a bound vector fit to — the labels the engine's bind aligns: a fitted attribute's FittedLabels, a comparison slot's ComparisonParams labels — and false when they do not resolve (that refusal is the slot resolution's) or typ reads no fit.

func AttributeFitOn ¶

func AttributeFitOn(typ types.AttributeType, a *types.Attribute) []*types.Filterer

AttributeFitOn returns a's decoded params.fit_on filterers when a's route typ is a vector-input attribute (nil for "filtered", a non-vector type, or params that do not decode — those are refused elsewhere), and — a comparison slot — its centroid reference's filter after them (ComparisonCentroidFilter). Projection, the field-reference walk and the two-pass planner read it to learn which columns the pre-pass predicates read.

func AttributeInputMembers ¶

func AttributeInputMembers(req *types.Request, schema *encoding.Schema) (members []string, ok bool)

AttributeInputMembers returns the union of every field req's attributes read through inline fields (a named vector's members ride Members(req)) plus every comparison slot's params.reference key_field (ComparisonKeyField — a row whose key column did not decode would read as a missing profile), and whether every one resolved — projection decodes wide otherwise.

func ChainStageSchema ¶

func ChainStageSchema(req *types.Request, in *encoding.Schema, kinds AggregationKinds) (*encoding.Schema, *errors.CodedError)

ChainStageSchema is the one synthesised schema a later ProcessChain stage reads the stage req's output rows through — the runtime's processing.ChainOutputSchema and predict's synthChainSchema both build it here, so the next stage's field references, defaults and gate see the same columns on both sides. in is the schema req itself executes over (its INPUT: the cohort's or joined schema for stage 0, else the one synthesised from the stage before it); kinds is the instance's aggregation view.

Layout, in order:

• One categorical_u32 field per Group entry, named by its key column (GroupKeyField — the Data row key the stage writes), with an empty Dictionary the runtime fills as rows materialise; a repeated key is listed once.
• One f64 field per aggregation output column (AggregationOutputColumns): the label, or — on an expanding vector aggregation — one "<label>[<element label>]" column per member in member order, the label itself absent (the row writer writes no array). An element column is an ordinary nullable f64 column there: an element no row answered (NaN) is a null.

A non-expanding array-valued or non-scalar aggregation never feeds a later stage (mergegate.StageArrayValuedRefusal), so its label is listed but never read.

The error is the first aggregation column colliding with an earlier column (a group key or another aggregation's column): PROCESSING_CONFIG {column, aggregation_index, aggregation}. The schema is still complete (the colliding column listed once) so a caller that only reports — predict — keeps judging the next stage.

func CodeFieldTypes ¶

func CodeFieldTypes(schema *encoding.Schema, codes map[string]encoding.FieldType) func(field string) (encoding.FieldType, bool)

CodeFieldTypes is the field-type lookup a code judgement reads over schema plus the code columns a chain stage inherited: a code column answers the type it is a code of, every other schema field its own type. Nil for a nil schema.

func ComparisonCentroid ¶

func ComparisonCentroid(typ types.AttributeType, a *types.Attribute) bool

ComparisonCentroid reports whether comparison slot a (route typ) compares with a centroid — a reference the pre-pass folds, so the slot is two-pass for either operator and any metric (ComparisonTwoPass).

func ComparisonCentroidFilter ¶

func ComparisonCentroidFilter(typ types.AttributeType, a *types.Attribute) []*types.Filterer

ComparisonCentroidFilter returns a centroid reference's decoded filter (nil when absent, for any other reference, or when it does not decode — refused elsewhere). AttributeFitOn folds it in beside fit_on: both are pre-pass predicates over the attribute-step record.

func ComparisonConsumer ¶

func ComparisonConsumer(t types.AttributeType) (metric.Consumer, metric.Form, types.AttributeType)

ComparisonConsumer returns the registry consumer comparison type t resolves its metric as, the form it asks for, and the operator that serves the other direction.

func ComparisonFitted ¶

func ComparisonFitted(typ types.AttributeType, a *types.Attribute, specs []types.VectorSpec, schema *encoding.Schema) bool

ComparisonFitted reports whether attribute a (route typ) is an ATTR_VEC_DISTANCE slot over a fitted metric (std_euclidean, mahalanobis) — the per-attribute two-pass predicate. The metric is params.metric, else the kind default of the vector a names in specs (before Processor.prepare's rewrite writes it out); params that do not decode report false (refused elsewhere).

func ComparisonKeyField ¶

func ComparisonKeyField(typ types.AttributeType, a *types.Attribute) string

ComparisonKeyField returns the column a comparison slot's params.reference keys each row by — a {table, key_field}'s key_field or a centroid's by — ("" for any other slot or reference form, or params that do not decode). Projection and the two-pass planner read it: the column must decode beside the members.

func ComparisonKeyFieldAccepts ¶

func ComparisonKeyFieldAccepts(ft encoding.FieldType) bool

ComparisonKeyFieldAccepts reports whether ft may be a key_field.

func ComparisonKeyFieldInteger ¶

func ComparisonKeyFieldInteger(ft encoding.FieldType) bool

ComparisonKeyFieldInteger reports whether ft is an unsigned-integer key_field, matched by its value's canonical base-10 string.

func ComparisonKeyFieldTypes ¶

func ComparisonKeyFieldTypes() []string

ComparisonKeyFieldTypes names the field types a {table, key_field} reference accepts: the categorical rungs (the label is the profile key) and the unsigned integers (the value's canonical base-10 form — no sign, no leading zero — is the key). Floats, dates, datetimes, packed_bool, decimal128 and set_* are refused.

func ComparisonPopulation ¶

func ComparisonPopulation(typ types.AttributeType, a *types.Attribute) string

ComparisonPopulation returns the bound vector fit a comparison slot's {population} reference names ("" for any other slot or form).

func ComparisonReferenceIssues ¶

func ComparisonReferenceIssues(req *types.Request, schema *encoding.Schema, resolved []Resolved, tables ReferenceTables) []*errors.CodedError

ComparisonReferenceIssues returns, in request order, the table issue (ComparisonTableIssue) of every comparison attribute slot (ATTR_PROFILE_SIMILARITY, ATTR_VEC_DISTANCE) whose members and params judge — a slot that does not is the field-reference pass's to refuse. resolved are the request's named vectors over schema.

func ComparisonSlotParams ¶

func ComparisonSlotParams(a *types.Attribute, members Resolved, schema *encoding.Schema) (json.RawMessage, bool)

ComparisonSlotParams resolves attribute a's (a comparison slot) params against its members and returns them canonical (CanonicalParams); ok is false when they do not judge (the field-reference pass has refused that request).

func ComparisonTwoPass ¶

func ComparisonTwoPass(typ types.AttributeType, a *types.Attribute, specs []types.VectorSpec, schema *encoding.Schema) bool

ComparisonTwoPass is the per-slot two-pass predicate of the comparison pair: a centroid reference (folded by the pre-pass, either operator, any metric), or an ATTR_VEC_DISTANCE over a fitted metric (ComparisonFitted) that is not bound to a prebuilt fit (FitBound). Every routing site — processing attrRequiresTwoPassIn, predict's attrTwoPass, both fused-crosstab facts — reads it.

func ComparisonTypes ¶

func ComparisonTypes() []types.AttributeType

ComparisonTypes returns the reference-comparison attribute types, in AllAttributeTypes order.

func CorrelationMethods ¶

func CorrelationMethods() []string

CorrelationMethods returns the params.method values, default first.

func DistanceBetweenTypes ¶

func DistanceBetweenTypes() []types.GroupType

DistanceBetweenTypes returns the built-in groupers MAT_DISTANCE's params.between accepts, in AllGroupTypes order: every built-in. The date family (GROUP_DATE, GROUP_DATE_RANGES) reads its zone like a top-level grouper — the zone pass walks the between as the slot "matrices[i].params.between" (internal/descriptor.ResolveZones) and ZonedRequest writes an inherited zone into its `tz`. A registered extension grouper is accepted too (ResolveMatricesRouted's ext).

func ElementLabel ¶

func ElementLabel(field string, e int) string

ElementLabel is the default display label of element e (0-based) of native vector field field when the schema declares none: "field_<e+1>".

func ElementMarginClass ¶

func ElementMarginClass(a *types.Aggregation, kinds AggregationKinds) (types.MarginReducibility, bool)

ElementMarginClass is the crosstab margin class of an element-selecting slot (SelectsElement): its scalar twin's — the selected element of AGG_VEC_MEAN is a weighted mean of one column (mean-reducible), of AGG_VEC_SUM a sum (summable). ok is false for any other slot, which keeps its type's class — an AGG_VEC_SD element included: a standard deviation recomputes its margin over the raw rows, like AGG_STDDEV (the type's MarginRecompute). Both crosstab arms' fusion facts and predict's normalize advisory read it.

func ElementMember ¶

func ElementMember(field string, e int) string

ElementMember is the member name of element e (0-based) of native vector field field: "field[e+1]".

func EmitsInputValueAggregationTypes ¶

func EmitsInputValueAggregationTypes() []types.AggregationType

EmitsInputValueAggregationTypes returns the built-in aggregation types whose one number is one of the INPUT field's own encoded values — a value picked from the column, not a figure computed over it: AGG_MODE (the modal value). Over a numeric field that value is a magnitude; over a categorical_* field it is the dictionary INDEX and over a packed_bool field the 0/1 truth value (IsCodeInputType) — a code, so an overlay scoring it would compare codes as magnitudes. AGG_MODE_COUNT (a count), AGG_FREQUENCY (a count of a value matched by label) and AGG_DISTINCT_COUNT (a cardinality) are figures, not picks. processing's TestEmitsInputValueAggregationTypes_MatchRowValues holds the list to what every built-in writes.

func EngineMatrixParams ¶

func EngineMatrixParams() []string

EngineMatrixParams are the params keys the engine owns on every matrix operator, extension ones included: the missing-data mode, the listwise heavy-drop threshold and params.fit (the bound vector fit the slot emits from — resolveFit). An extension operator never sees them (decodeExtensionParams strips them) and may not declare them.

func EstimateBuckets ¶

func EstimateBuckets(groups []*types.Group, schema *encoding.Schema) (buckets int64, basis string, known bool)

EstimateBuckets is the schema-only upper bound on the number of matrix buckets — the grouped Response.Data rows a request can emit — and how it was derived; known is false when the keys depend on the data. One grouper reports its own bound and basis; two or more report the PRODUCT of every grouper's bound (saturating at math.MaxInt64) with basis BucketBasisProduct, and are unknown when ANY grouper is — the composite keys a multi-grouper run mints are a subset of that cartesian product. It is an upper bound: a key no row carries (or that a filter removes, or a combination never observed) yields no bucket, so a run emits AT MOST this many results per spec. Unclamped by the record count (callers clamp). Header + schema only — importable from internal/descriptor.

func ExpandedColumn ¶

func ExpandedColumn(label, element string) string

ExpandedColumn is the Response.Data column an expanded vector aggregation writes element by element: "<label>[<element label>]".

func ExprLengthIssue ¶

func ExprLengthIssue(src string, lenOf func(string) (int, bool)) *errors.CodedError

ExprLengthIssue is the first PairIssue of src in the runtime build's walk order (post-order), nil when there is none or src does not parse.

func ExprRefCall ¶

func ExprRefCall(n exprast.Node) *exprast.CallNode

ExprRefCall returns n as a call of the ref() built-in with at least its two arguments (the runtime build appends a third), else nil.

func ExprRefKey ¶

func ExprRefKey(c *exprast.CallNode) (string, bool)

ExprRefKey returns a ref() call's key argument when it is a string literal.

func ExprRefSlot ¶

func ExprRefSlot(slot *exprast.Node) *exprast.Node

ExprRefSlot follows slot down the first argument of label-preserving transforms to the ref() call at the bottom; nil when the chain ends anywhere else.

func ExprRefTable ¶

func ExprRefTable(c *exprast.CallNode) (string, bool)

ExprRefTable returns a ref() call's table argument when it is a string literal.

func ExprReferenceIssues ¶

func ExprReferenceIssues(src string, s RefScope) []*errors.CodedError

ExprReferenceIssues returns every reference issue in src, in walk order (post-order: a ref() call's own check before the pair that reads it). Nil when src calls no ref() or does not parse (its compile reports that).

func ExprStaticIssue ¶

func ExprStaticIssue(src, what string, lenOf func(string) (int, bool)) *errors.CodedError

ExprStaticIssue is src's first static built-in issue at site what, lenOf answering the member count of a bare vector name (nil: no named vectors) — nil when there is none or src does not parse.

func ExprVectorLen ¶

func ExprVectorLen(resolved []Resolved, schema *encoding.Schema) func(string) (int, bool)

ExprVectorLen is the LenOf of an expression over schema with the named vectors resolved (Resolve's result): a name binds a vector when Find knows it and it is not a scalar schema field (a scalar field shadows a same-named vector, as at bind time); its length is the member count.

func FactorExtractions ¶

func FactorExtractions() []string

FactorExtractions returns MAT_FACTOR's params.extraction values, default first.

func FactorIdentified ¶

func FactorIdentified(p, k int) bool

FactorIdentified reports whether k common factors are identified on p members: the model's degrees of freedom p(p − 1)/2 − p·k + k(k − 1)/2 = ((p − k)² − (p + k))/2 are not negative.

func FactorRotations ¶

func FactorRotations() []string

FactorRotations returns MAT_FACTOR's (and ATTR_FACTOR_SCORE's) params.rotation values, default first: every criterion.

func FactorScoreMethods ¶

func FactorScoreMethods() []string

FactorScoreMethods returns params.method's values, default first.

func FieldNotScalar ¶

func FieldNotScalar(f *encoding.Field, dim int, slot, suggest string, extra map[string]any) *errors.CodedError

FieldNotScalar is the PULSE_VECTOR_FIELD_NOT_SCALAR refusal of vector field f (dim dim) read as a single value at slot (a request path such as "aggregations[0] (AGG_SUM) field"). suggest, when non-empty, names the vector operator replacing the slot (SuggestAggregation, SuggestGrouper). extra details are merged in.

func FitBound ¶

func FitBound(typ types.AttributeType, a *types.Attribute) bool

FitBound reports whether attribute a (route typ) is a fitted slot bound to a prebuilt vector fit: a FittedAttributeTypes type or an ATTR_VEC_DISTANCE whose params.fit names a fit (AttributeFit). Such a slot holds its whole fit before the scan, so it is ROW-LOCAL — no pre-pass, streamable beside groupers / features / matrices, and (for the FittedAttributeTypes) mergeable — where the same slot with fit_on takes the two-pass drive. The one per-slot predicate every routing site reads (processing attrRequiresTwoPassIn, predict's attrTwoPass, the fused-crosstab facts, mergegate). A comparison slot whose reference is a centroid is never bound: its pre-pass remains.

func FittedAttributeTypes ¶

func FittedAttributeTypes() []types.AttributeType

FittedAttributeTypes returns the vector-input attribute types that fit before they score (two-pass, params.fit_on), in AllAttributeTypes order: every VectorAttributeTypes entry but the row-local ATTR_SCALE_SCORE and the comparison pair (ATTR_VEC_DISTANCE fits per slot, by its metric: ComparisonFitted).

func FittedLabels ¶

func FittedLabels(at string, typ types.AttributeType, raw json.RawMessage, members Resolved) ([]string, *errors.CodedError)

FittedLabels judges a fitted attribute slot's params.labels against its resolved members (vector the named vector, "" for inline fields) and returns the labels a bound vector fit aligns to: params.labels (inline fields only, one unique non-empty label per member), else the members' labels (a named vector's own, the member names for inline fields). Comparison slots judge theirs in ComparisonParams.

func FittedSlotParams ¶

func FittedSlotParams(a *types.Attribute, members Resolved) (json.RawMessage, bool)

FittedSlotParams returns a fitted (non-comparison) attribute slot's params with params.labels written out as members' labels, for the literal-member rewrite (Processor.prepare): the rewrite clears the named vector, and the slot's labels are what a bound vector fit (params.fit) aligns to and what a captured one (a Compose vector fit over this slot) is stored under. ok is false — keep the params as written — when the slot names no vector or its params do not decode.

func GroupInputMembers ¶

func GroupInputMembers(req *types.Request, schema *encoding.Schema) (members []string, ok bool)

GroupInputMembers returns the union of every field req's grouper slots read through inline fields (a named vector's members ride Members(req)), and whether every one resolved — projection decodes wide otherwise.

func GroupKeyField ¶

func GroupKeyField(typ types.GroupType, g *types.Group) string

GroupKeyField is the column a grouper slot whose route is typ writes its bucket key under (the Data row key, the crosstab axis field): the slot's Field for every grouper except a vector-input one, whose key column is "<TYPE>_<vector>" or "<TYPE>_<first fields entry as written>".

func HasAggregationVectorInput ¶

func HasAggregationVectorInput(a *types.Aggregation) bool

HasAggregationVectorInput reports whether a sets any vector-input slot.

func HasAttributeVectorInput ¶

func HasAttributeVectorInput(a *types.Attribute) bool

HasAttributeVectorInput reports whether a sets any vector-input slot.

func HasGroupVectorInput ¶

func HasGroupVectorInput(g *types.Group) bool

HasGroupVectorInput reports whether g sets any vector-input slot.

func HasVectorInput ¶

func HasVectorInput(t *types.Test) bool

HasVectorInput reports whether t sets any vector-input slot.

func InferenceTypes ¶

func InferenceTypes() []types.MatrixType

InferenceTypes are the matrix operators that take params.inference.

func InvalidNormalizeMode ¶

func InvalidNormalizeMode(mode string, cause error) *errors.CodedError

InvalidNormalizeMode is the coded refusal of a vnormalize mode other than "l1" / "l2" (case-sensitive): PROCESSING_CONFIG {function, mode, valid}, cause attached.

func IsCodeInputType ¶

func IsCodeInputType(ft encoding.FieldType) bool

IsCodeInputType reports whether a value picked from a field of type ft is a code rather than a magnitude: a categorical_* field's value is its dictionary index, a packed_bool field's its 0/1 truth value.

func IsComparisonAttribute ¶

func IsComparisonAttribute(t types.AttributeType) bool

IsComparisonAttribute reports whether t is a reference-comparison attribute type.

func IsDateBetween ¶

func IsDateBetween(t types.GroupType) bool

IsDateBetween reports whether t is a date-family grouper, the only between types that accept a `tz`.

func IsDecomposition ¶

func IsDecomposition(t types.MatrixType) bool

IsDecomposition reports whether t is a decomposition operator (see Matrix.Decomposition): MAT_PARTIAL_CORRELATION, MAT_PCA (it eigen-decomposes its correlation or covariance), MAT_COLLINEARITY (it inverts and eigen-decomposes the predictors' correlation), MAT_FACTOR (it factors the correlation), and MAT_RELIABILITY, whose McDonald's omega factors the inter-item correlation (there the guard's refusal nulls omega with a warning instead of failing the matrix: alpha needs no PSD input).

func IsFittedAttribute ¶

func IsFittedAttribute(t types.AttributeType) bool

IsFittedAttribute reports whether t is a built-in fitted vector attribute type (FittedAttributeTypes).

func IsNativeVector ¶

func IsNativeVector(name string, schema *encoding.Schema) bool

IsNativeVector reports whether name is a native vector field of schema.

func IsRankMethod ¶

func IsRankMethod(method string) bool

IsRankMethod reports whether method is a rank correlation (spearman or kendall): buffered, not mergeable, frequency weights only.

func IsVectorAggregation ¶

func IsVectorAggregation(t types.AggregationType) bool

IsVectorAggregation reports whether t is a built-in vector aggregation type.

func IsVectorAttribute ¶

func IsVectorAttribute(t types.AttributeType) bool

IsVectorAttribute reports whether t is a built-in vector-input attribute type.

func IsVectorGroup ¶

func IsVectorGroup(t types.GroupType) bool

IsVectorGroup reports whether t is a built-in vector-input group type.

func IsVectorTest ¶

func IsVectorTest(t types.TestType) bool

IsVectorTest reports whether t is a built-in vector-input test type.

func KMeansK ¶

func KMeansK(g *types.Group) (int, bool)

KMeansK returns g's params.k when it decodes (EstimateBuckets' bound), false otherwise.

func KindDefault ¶

func KindDefault(c metric.Consumer, k types.VectorKind, f metric.Form, admit func(metric.Metric) bool) (metric.Metric, bool)

KindDefault returns the metric consumer c defaults to for a vector of kind k in form f (metric.DefaultFor; admit nil admits every metric): the kind's table default when c accepts it, else the first metric c accepts that suits the kind. False with no kind or no suitable metric.

func KindIn ¶

func KindIn(specs []types.VectorSpec, schema *encoding.Schema, name string) types.VectorKind

KindIn returns the declared kind of the vector named name: a Request.Vectors spec's kind, else — a native vector field of schema named directly (vec_f32 / vec_f64) — the kind its VECTORS section declares; "" when neither declares one. A spec and a native field never share a name (PULSE_VECTOR_NAME_COLLISION), so the order is immaterial.

func KindOf ¶

func KindOf(specs []types.VectorSpec, name string) types.VectorKind

KindOf returns the declared kind of the vector named name in specs ("" when it declares none or no spec has that name).

func LengthIssues ¶

func LengthIssues(req *types.Request, schema *encoding.Schema, resolved []Resolved) []*errors.CodedError

LengthIssues returns, per request expression (ExprSlots, request order), its first static length refusal (ExprLengthIssue) against the request's named vectors resolved over schema — the predict twin of the runtime build, which refuses the first.

func LengthMismatch ¶

func LengthMismatch(fn string, left, right int, cause error) *errors.CodedError

LengthMismatch is the coded refusal of an unequal-length pair: PROCESSING_VECTOR_LENGTH_MISMATCH, details {function, left, right}.

func LevelVectorParams ¶

func LevelVectorParams(at string, t *types.Test) *errors.CodedError

LevelVectorParams judges a slot that compares a member set across the levels of split_by (TEST_MANOVA, TEST_BOX_M): split_by is required (reason split_by_required) and params carry only missing (checkTestMissing's rule); unknown keys are refused. at is the slot path. Predict and the runtime factories both call it.

func MardiaParams ¶

func MardiaParams(at string, t *types.Test) (string, *errors.CodedError)

MardiaParams judges a TEST_MARDIA slot and returns its headline statistic: one sample, so split_by is refused (reason split_by_not_accepted); params carry statistic ("skewness" default, or "kurtosis") and missing (checkTestMissing's rule); unknown keys are refused. Predict and the runtime factory both call it.

func MatrixMembers ¶

func MatrixMembers(req *types.Request, schema *encoding.Schema) (members []string, ok bool)

MatrixMembers returns the union of every field req's matrix specs read beyond Request.Vectors — an inline spec's fields and a MAT_PARTIAL_CORRELATION params.control entry (a control outside the members joins the fold) — and whether every one resolved (projection decodes wide otherwise).

func MatrixMetricConsumer ¶

func MatrixMetricConsumer(t types.MatrixType) (metric.Consumer, metric.Form, bool)

MatrixMetricConsumer returns the registry consumer a matrix type resolves its params.metric as, and the form it asks for; false for a type that takes no metric.

func MaxIdentifiedFactors ¶

func MaxIdentifiedFactors(p int) int

MaxIdentifiedFactors is the largest k FactorIdentified admits on p members (0 below 3 members, where not even one factor is).

func MemberSourceFields ¶

func MemberSourceFields(members []string, schema *encoding.Schema) []string

MemberSourceFields maps a resolved member-name list to the schema fields it reads (element members to their vector field), distinct, in first-use order. A name that is no element member is kept as is.

func MemberTypeAllowed ¶

func MemberTypeAllowed(ft encoding.FieldType, coerce types.VectorCoerce) bool

MemberTypeAllowed reports whether a field of type ft may be a vector member under coerce: integer and float types always; packed_bool only under VectorCoerceBinary; nothing else.

func Members ¶

func Members(req *types.Request, schema *encoding.Schema) (members []string, ok bool)

Members returns the union of every member req's vectors resolve to against schema, in vector then member order, and whether every vector resolved. Projection calls it: a vector that fails to resolve is refused before any record is read, so ok == false only tells the caller to decode wide rather than guess.

func MetricUnsuitedIssues ¶

func MetricUnsuitedIssues(req *types.Request, schema *encoding.Schema) []*errors.CodedError

MetricUnsuitedIssues returns one PULSE_VECTOR_METRIC_UNSUITED issue per explicit poor-fit pair in req (metric.Metric.PoorFitFor: cosine on scale / measure, the Euclidean family on composition), in request order: every metric-taking matrix slot reading a kind-declared vector by name, every comparison attribute (ATTR_PROFILE_SIMILARITY, ATTR_VEC_DISTANCE) doing the same, then every expression call of a metric built-in (exprbuiltins.Metric) whose argument IS a kind-declared vector — the filterers' FILTER_EXPRESSION, each attribute's ATTR_FORMULA and its params.fit_on filterers, the slots exprReferenced scans. A wrapped argument (cosine(vcenter(v), …)) is a transform of the vector, not the vector, and is not judged. A defaulted metric is never a poor fit (KindDefault), and a vector without a kind raises nothing. The caller decides the channel: a warning, or under strict an error. A native vector field of schema named directly carries its schema kind.

func MissingModes ¶

func MissingModes() []string

MissingModes returns the params.missing values, default first.

func NativeKindsMatter ¶

func NativeKindsMatter(req *types.Request) bool

NativeKindsMatter reports whether req names, in a slot MetricUnsuitedIssues judges, a vector no Request.Vectors spec defines — a name only a native vector field's schema kind can decide. A caller holding no schema yet (the runtime's pre-dispatch strict refusal and post-dispatch warnings) opens the cohort's schema for the issue list only then; with false, MetricUnsuitedIssues(req, nil) is the full list.

func NonScalarAggregationTypes ¶

func NonScalarAggregationTypes() []types.AggregationType

NonScalarAggregationTypes returns the built-in aggregation types whose Response.Data value is not one number — every built-in whose RichAggregator lift replaces the float64 (a moment struct, a label list, a per-label count map, one figure per vector member): the map-valued (types.AggregationType.MapValued), the array-valued (ArrayValued) and the two label-list set folds. Their float64 is a scalar FALLBACK (popcount, running mean, max-bin count) that never reaches the row. processing's TestNonScalarAggregationTypes_MatchRowValues holds the list to what each built-in actually writes.

func Normalize ¶

func Normalize(req *types.Request, schema *encoding.Schema) *types.Request

Normalize returns req with every vector rewritten to its RESOLVED form — `fields` = the member list, `pattern` cleared, everything else kept — so Hash() on the result is a function of the resolved members: a pattern and the equivalent explicit field list hash identically. The request is shallow-copied (the caller's request never changes); req itself is returned when it has no vectors or a vector fails to resolve (that request is refused anyway). Request.Hash() alone is schema-free and hashes vectors as written; hash the normalized request wherever a schema is in hand and resolved-member identity is wanted.

func ObliqueRotations ¶

func ObliqueRotations() []string

ObliqueRotations returns the oblique criteria, in FactorRotations order: what MAT_PCA's refusal names.

func PCAOnValues ¶

func PCAOnValues() []string

PCAOnValues returns the params.on values, default first.

func PCARotations ¶

func PCARotations() []string

PCARotations returns MAT_PCA's (and ATTR_PC_SCORE's) params.rotation values, default first: the orthogonal criteria of FactorRotations — a component is uncorrelated by construction, so an oblique criterion is refused (rotation_oblique_unsupported).

func ParseElementMember ¶

func ParseElementMember(name string, schema *encoding.Schema) (field string, element int, ok bool)

ParseElementMember parses an element member name ("f[k]", k canonical base-10 in 1..dim of native vector field f of schema) into its field and 0-based element. ok is false for anything else.

func PopulationAlign ¶

func PopulationAlign(at, name string, fitLabels, labels []string) ([]int, *errors.CodedError)

PopulationAlign aligns a {population} reference's bound fit (its labels fitLabels) to the slot's labels by the fit rule (AlignFit): perm[i] is the fit's index of labels[i]; unequal label sets are PULSE_VECTOR_REFERENCE_MISMATCH labels_differ naming the population.

func PopulationRefusal ¶

func PopulationRefusal(at, name string, ce *errors.CodedError) *errors.CodedError

PopulationRefusal locates a {population} reference's lookup refusal (the runtime's model.Set.LookupVector or predict's model.CheckVectorFit) on slot at: an unbound name is PULSE_VECTOR_REFERENCE_UNKNOWN reason population_unknown (the bound vector fits under details.valid); any other refusal (a name bound as a regression: PULSE_MODEL_KIND_MISMATCH) keeps its code. Both carry details.attribute, details.population and details.slot.

func RecordMembersAbsent ¶

func RecordMembersAbsent(at, cohort string, missing []string) *errors.CodedError

RecordMembersAbsent is the PULSE_VECTOR_REFERENCE_MISMATCH refusal of a {record} reference on slot at whose cohort holds no usable column for the members listed in missing (absent, or a type no vector member may be: categorical, date, set, …).

func ReferenceIssues ¶

func ReferenceIssues(req *types.Request, schema *encoding.Schema, resolved []Resolved, tables ReferenceTables) []*errors.CodedError

ReferenceIssues returns every reference issue of req's comparison attributes' table references (ComparisonReferenceIssues) and of its expressions (ExprSlots), each with details.slot, against tables and the request's named vectors resolved over schema (a vector named like a schema field is shadowed by the field, as at bind time). The predict twin of the runtime build's refusal: the build raises the first issue of the first slot it binds.

func ReferenceMismatch ¶

func ReferenceMismatch(reference, vector string, refLabels, labels, missing, extra []string) *errors.CodedError

ReferenceMismatch is the PULSE_VECTOR_REFERENCE_MISMATCH refusal (reason labels_differ) of a reference labelled refLabels compared with a vector labelled labels: missing are the vector's labels the reference lacks, extra the reference's labels the vector lacks. reference names the source (a table name, or "" for an inline reference); vector the compared named vector ("" when unnamed).

func Referenced ¶

func Referenced(req *types.Request) map[string]bool

Referenced returns the vector names req's operator slots reference: every Request.Matrices spec's `vector`, every tier-1 test's `vector` / `vector2`, every attribute's `vector`, every grouper slot's `vector` (groups and both crosstab axes), every aggregation slot's `vector` (aggregations, the crosstab cell and its margin aggregations), and every Request.Vectors name an expression reads as a free identifier — an ATTR_FORMULA expression, a FILTER_EXPRESSION filterer's expression (Request.Filterers and a vector attribute's params.fit_on) and so a total() argument inside either (internal/exprident.Free, the walk the expression program binds by). It is the one reference set, so the unreferenced-vector warning and every consumer read one answer.

func ReferencedNatives ¶

func ReferencedNatives(req *types.Request, schema *encoding.Schema) []string

ReferencedNatives returns, in schema order, the native vector fields of schema req names directly in a vector slot (the slots Referenced reads). Projection decodes them; an expression's reference to a native field is an ordinary field identifier there.

func ResolveAggregations ¶

func ResolveAggregations(req *types.Request, schema *encoding.Schema, kinds AggregationKinds) (map[*types.Aggregation]AggregationInput, *errors.CodedError)

ResolveAggregations resolves every aggregation slot's vector input (AggregationSlots order) against schema (Request.Vectors first, like ResolveAttributes). kinds is the instance's view: its Route (a hidden type routes to an unknown name) and its extension declarations — an extension declared VectorInput resolves like a built-in vector aggregator, any other registered extension refuses a vector input. The result is keyed by the slot's *types.Aggregation and holds only the slots that resolved a vector input; the first refusal is returned. Like Resolve it reads only the schema.

func ResolveGroups ¶

func ResolveGroups(req *types.Request, schema *encoding.Schema, route func(types.GroupType) types.GroupType, ext func(string) bool) (map[*types.Group]GroupInput, *errors.CodedError)

ResolveGroups resolves every grouper slot's vector input (GroupSlots order) against schema (Request.Vectors first, like ResolveTests). route maps a group type to the built-in it executes as — the instance's view, where a hidden type routes to an unknown name; nil is the identity. ext reports whether a routed type that is not a built-in is a registered extension grouper (its member set is then judged); nil means none is. The result is keyed by the slot's *types.Group and holds only the slots that resolved a vector input; the first refusal is returned. Like Resolve it reads only the schema.

func ResolveKindMetric ¶

func ResolveKindMetric(c metric.Consumer, explicit string, k types.VectorKind, f metric.Form) (m metric.Metric, defaulted bool, cerr *errors.CodedError)

ResolveKindMetric resolves an operator's metric for consumer c in form f: an explicit name through the registry (metric.ResolveFor — PULSE_VECTOR_METRIC_UNKNOWN), else the kind default (defaulted true), else PULSE_VECTOR_METRIC_REQUIRED (no kind, or no metric suits it).

func RotationOblique ¶

func RotationOblique(name string) bool

RotationOblique reports whether the named criterion is oblique (its factors may correlate: Φ ≠ I, auxiliary.factor_correlation). The one classifier: the accepted lists, MAT_PCA's refusal, the auxiliary keys and the engine all read it.

func RotationTakesEpsilon ¶

func RotationTakesEpsilon(name string) bool

RotationTakesEpsilon reports whether the named criterion reads params.epsilon (the geomin pair).

func ScalarRefusal ¶

func ScalarRefusal(schema *encoding.Schema, name, slot, suggest string, extra map[string]any) *errors.CodedError

ScalarRefusal is FieldNotScalar for name when it is a vector field of schema, else nil.

func ScaleScoreSlotParams ¶

func ScaleScoreSlotParams(a *types.Attribute, members Resolved) (json.RawMessage, bool)

ScaleScoreSlotParams resolves attribute a's (an ATTR_SCALE_SCORE slot) params against its members and returns them canonical (CanonicalParams); ok is false when they do not judge (the field-reference pass has refused that request).

func ScaleStats ¶

func ScaleStats() []string

ScaleStats returns params.stat's values, default first.

func SecondVectorTypes ¶

func SecondVectorTypes() []types.TestType

SecondVectorTypes returns the built-in test types that also read a second member set from Vector2 / Fields2.

func SelectsElement ¶

func SelectsElement(a *types.Aggregation, kinds AggregationKinds) bool

SelectsElement reports whether a is a built-in vector aggregation (routed under kinds; never an extension, whose params.element is its own key) whose params decode and set element: a crosstab slot reading ONE member as a scalar. Shape faults (an unknown element, element outside a crosstab) are the resolver's; this reads only the params.

func SourceFieldsOf ¶

func SourceFieldsOf(refs []MemberRef) []string

SourceFieldsOf is SourceFields over a member-location list.

func SpecBetween ¶

func SpecBetween(spec types.MatrixSpec) (types.Group, bool)

SpecBetween decodes a MAT_DISTANCE spec's params.between as written (lenient: unknown keys are not judged here); false on any other type or when it does not decode.

func SpecMethod ¶

func SpecMethod(spec types.MatrixSpec) string

SpecMethod is spec's correlation method as the resolver reads it — params.method on MAT_CORRELATION (CorrelationPearson when absent), "" on every other type. Lenient: a params object that does not decode yields the default (the resolver refuses it elsewhere).

func SphericityParams ¶

func SphericityParams(at string, t *types.Test) *errors.CodedError

SphericityParams judges a TEST_BARTLETT_SPHERICITY slot: one sample, so split_by is refused (reason split_by_not_accepted), and params carry only missing. Predict and the runtime factory both call it.

func StaticIssues ¶

func StaticIssues(req *types.Request, schema *encoding.Schema, resolved []Resolved) []*errors.CodedError

StaticIssues returns, per request expression (ExprSlots, request order), its first static built-in issue against the request's named vectors resolved over schema — the predict twin of the runtime build, which refuses the first. Each slot is judged at the site the build compiles it as: an ATTR_FORMULA as "formula", its total() arguments first (each as "formula total() argument"; skipped when totalcall refuses the formula — that refusal comes first), every filter expression as "filter".

func TakesSecondVector ¶

func TakesSecondVector(t types.TestType) bool

TakesSecondVector reports whether t reads a second member set.

func TestInputMembers ¶

func TestInputMembers(req *types.Request, schema *encoding.Schema) (members []string, ok bool)

TestInputMembers returns the union of every field req's tier-1 tests read through inline fields / fields2 (a named vector's members ride Members(req)), and whether every one resolved — projection decodes wide otherwise.

func Unreferenced ¶

func Unreferenced(req *types.Request) []string

Unreferenced returns, in request order, the names of req's vectors no operator slot references (each is a PULSE_VECTOR_UNREFERENCED warning).

func UnreferencedWarning ¶

func UnreferencedWarning(name string) *errors.CodedError

UnreferencedWarning builds the PULSE_VECTOR_UNREFERENCED warning for vector name.

func VectorAggregationTypes ¶

func VectorAggregationTypes() []types.AggregationType

VectorAggregationTypes returns the built-in aggregation types that read their columns from Vector / Fields, in AllAggregationTypes order.

func VectorAttributeLabel ¶

func VectorAttributeLabel(typ types.AttributeType, a *types.Attribute) (string, bool)

VectorAttributeLabel is the default output label of a vector-input attribute whose route is typ: "<TYPE>_<vector>", or "<TYPE>_<first fields entry as written>" for inline fields, and on ATTR_PC_SCORE a "_PC<component>" suffix (when params.component decodes) and on ATTR_FACTOR_SCORE a "_F<factor>" suffix (when params.factor decodes) so two components or factors of one vector never share a label. ok is false for any other type (the caller's own label rule applies).

func VectorAttributeTypes ¶

func VectorAttributeTypes() []types.AttributeType

VectorAttributeTypes returns the built-in attribute types that read their columns from Vector / Fields, in AllAttributeTypes order.

func VectorField ¶

func VectorField(schema *encoding.Schema, name string) (f *encoding.Field, dim int, ok bool)

VectorField returns the schema field name names when it is a native vector field, with its dim; ok is false for any other (or unknown) name and for a nil schema.

func VectorGroupTypes ¶

func VectorGroupTypes() []types.GroupType

VectorGroupTypes returns the built-in group types that read their columns from Vector / Fields, in AllGroupTypes order.

func VectorResultRefusal ¶

func VectorResultRefusal(what string) *errors.CodedError

VectorResultRefusal refuses a vector as an expression's top-level result: the vector built-ins compose inside an expression, but an attribute value, a filter verdict and a total() term are scalars. what names the site ("formula", "filter", "formula total() argument").

func VectorTestTypes ¶

func VectorTestTypes() []types.TestType

VectorTestTypes returns the built-in test types that read their columns from Vector / Fields, in AllTestTypes order.