Struct EconomicsMethodology 

pub struct EconomicsMethodology {

    pub schema: String,
    pub version: u32,
    pub title: String,
    pub question: String,
    pub unit: String,
    pub primary_metric: String,
    pub classes: Vec<EconomicsClassDefinition>,
    pub variants: Vec<EconomicsVariant>,
    pub success: Vec<EconomicsGateDefinition>,
    pub pairing: EconomicsPairing,
    pub statistics: EconomicsStatisticsPolicy,
    pub publication: EconomicsPublicationPolicy,
    pub outliers: EconomicsOutlierPolicy,
    pub hypotheses: Vec<EconomicsHypothesis>,
    pub claims: Vec<EconomicsClaimBinding>,
    pub changes: Vec<EconomicsMethodologyChange>,
}

.ai/repo/benchmarks/economics/methodology.yaml: what is measured, how, and when a result may be published.

use majordomus_cli::economics::model::EconomicsMethodology;
let m: EconomicsMethodology = serde_json::from_value(serde_json::json!({
    "schema": "economics-methodology/v1", "version": 1, "title": "Token economics",
    "question": "How many tokens does a session consume with and without Majordomus?",
    "unit": "tokens per completed task", "primary_metric": "effective_token_reduction",
    "classes": [], "variants": [], "success": [],
    "pairing": { "key": ["task"], "comparable": [], "valid": "both succeeded" },
    "statistics": { "per_pair": "1 - t / c", "location": "median", "interval": "bootstrap",
        "confidence_bp": 9500, "resamples": 1000, "seed": 1, "min_pairs_for_interval": 5 },
    "publication": { "min_valid_pairs": 30, "min_categories": 4, "min_pairs_per_category": 5,
        "min_repetitions": 3, "min_valid_pair_rate_bp": 8000, "max_interval_width_bp": 2000,
        "require_current": true },
    "outliers": { "rule": "No run is excluded." }
}))
.unwrap();
assert_eq!(m.statistics.confidence_bp, 9500);
assert!(m.hypotheses.is_empty() && m.claims.is_empty() && m.changes.is_empty());

Fields

schema: String

economics-methodology/v1.

version: u32

The methodology version. Evidence under another version is never pooled.

title: String

A name.

question: String

The question the benchmark answers.

unit: String

The unit results are stated in.

primary_metric: String

The metric a headline is about.

classes: Vec<EconomicsClassDefinition>

The measurement classes.

variants: Vec<EconomicsVariant>

The arms of the experiment.

success: Vec<EconomicsGateDefinition>

The success gates.

pairing: EconomicsPairing

Pairing.

statistics: EconomicsStatisticsPolicy

Aggregation.

publication: EconomicsPublicationPolicy

The publication threshold.

outliers: EconomicsOutlierPolicy

Outliers.

hypotheses: Vec<EconomicsHypothesis>

What the benchmark tests.

claims: Vec<EconomicsClaimBinding>

The claims of docs/CLAIMS.yaml that rest on a metric, and the standing the metric must have before the claim may be guaranteed.

changes: Vec<EconomicsMethodologyChange>

The change log.

Trait Implementations

impl Clone for EconomicsMethodology

fn clone(&self) -> EconomicsMethodology

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EconomicsMethodology

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EconomicsMethodology

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for EconomicsMethodology

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for EconomicsMethodology

fn eq(&self, other: &EconomicsMethodology) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EconomicsMethodology

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EconomicsMethodology