analysis

func AddPartitionsToStateTimeStorage ¶

func AddPartitionsToStateTimeStorage(
	storage *simulator.StateTimeStorage,
	partitions []*simulator.PartitionConfig,
	windowSizeByPartition map[string]int,
) *simulator.StateTimeStorage

AddPartitionsToStateTimeStorage extends the state time storage with newly generated values from the specified partitions.

func GetDataFrameFromPartition ¶

func GetDataFrameFromPartition(
	storage *simulator.StateTimeStorage,
	partitionName string,
) dataframe.DataFrame

GetDataFrameFromPartition converts simulation partition data into a Gota DataFrame for convenient data manipulation and analysis.

This function extracts time series data from a simulation partition and converts it into a structured DataFrame format. The resulting DataFrame has a "time" column followed by columns for each state dimension, making it easy to perform data analysis, visualization, and export operations.

DataFrame Structure:

• Column 0: "time" - Contains the time axis values
• Column 1+: State dimension columns labeled by their integer indices (0, 1, 2, ...)

Parameters:

• storage: StateTimeStorage containing the simulation data
• partitionName: Name of the partition to extract data from

Returns:

• dataframe.DataFrame: Gota DataFrame with time and state columns

Example:

// Extract price data from simulation storage
df := GetDataFrameFromPartition(storage, "prices")

// Access time column
timeCol := df.Col("time")

// Access state columns
price1Col := df.Col("0") // First price dimension
price2Col := df.Col("1") // Second price dimension

// Perform analysis
meanPrice1 := price1Col.Mean()
maxPrice2 := price2Col.Max()

Use Cases:

• Data visualization and plotting
• Statistical analysis and computation
• Data export to various formats (CSV, JSON, etc.)
• Integration with data analysis tools
• Time series analysis and forecasting

Performance:

• O(n * m) time complexity where n is number of samples, m is state dimensions
• Memory usage: O(n * m) for the resulting DataFrame
• Efficient for moderate-sized datasets (< 1M samples)

Error Handling:

• Panics if partition name is not found in storage
• Provides helpful error messages with available partition names

func NewEvolutionStrategyOptimisationPartitions ¶

func NewEvolutionStrategyOptimisationPartitions(
	applied AppliedEvolutionStrategyOptimisation,
	storage *simulator.StateTimeStorage,
) []*simulator.PartitionConfig

NewEvolutionStrategyOptimisationPartitions creates a set of PartitionConfigs for an online evolution strategies optimisation process. It builds:

1. A sampler drawing from N(mean, covariance)
2. An embedded simulation running user partitions with discounted reward
3. A sorted collection ranking samples by return
4. A weighted mean update from the top-ranked samples
5. A weighted covariance update around the mean

func NewGroupedAggregationPartition ¶

func NewGroupedAggregationPartition(
	aggregation func(
		defaultValues []float64,
		outputIndexByGroup map[string]int,
		groupings map[string][]float64,
		weightings map[string][]float64,
	) []float64,
	applied AppliedAggregation,
	storage *GroupedStateTimeStorage,
) *simulator.PartitionConfig

NewGroupedAggregationPartition creates a partition that performs grouped aggregations over historical state values with customizable binning.

This function creates a partition that aggregates data by grouping values into bins and applying custom aggregation functions within each group. It's particularly useful for computing statistics over value ranges or categorical data.

Mathematical Concept: Grouped aggregations compute statistics within value bins:

G_i(t) = aggregate({X(s) : X(s) ∈ bin_i, s ≤ t})

where bin_i represents a value range or category, and aggregate is the user-provided function (e.g., mean, sum, count).

Parameters:

• aggregation: Function that computes aggregated values from grouped data. Input parameters:
• defaultValues: Fill values for each group when no data is available
• outputIndexByGroup: Maps group names to output vector indices
• groupings: Maps group names to their historical values
• weightings: Maps group names to their time-based weights Output: []float64 aggregated results ordered by accepted value groups
• applied: AppliedAggregation configuration specifying source data and kernel
• storage: GroupedStateTimeStorage containing group definitions and binning rules

Returns:

• *PartitionConfig: Configured partition ready for simulation

Example:

// Aggregate price data by volatility bins
config := NewGroupedAggregationPartition(
    func(defaults, indices, groups, weights map[string][]float64) []float64 {
        results := make([]float64, len(indices))
        for group, idx := range indices {
            values := groups[group]
            w := weights[group]
            // Compute weighted mean
            sum := 0.0
            totalWeight := 0.0
            for i, v := range values {
                sum += v * w[i]
                totalWeight += w[i]
            }
            if totalWeight > 0 {
                results[idx] = sum / totalWeight
            } else {
                results[idx] = defaults[idx]
            }
        }
        return results
    },
    AppliedAggregation{
        Name: "volatility_aggregates",
        Data: DataRef{PartitionName: "prices"},
        Kernel: &kernels.ExponentialIntegrationKernel{},
        DefaultValue: 0.0,
    },
    volatilityStorage,
)

Performance Notes:

• O(n * m) time complexity where n is history depth, m is number of groups
• Memory usage scales with group count and history depth
• Efficient for moderate numbers of groups (< 1000)

func NewLikelihoodComparisonPartition ¶

func NewLikelihoodComparisonPartition(
	applied AppliedLikelihoodComparison,
	storage *simulator.StateTimeStorage,
) *simulator.PartitionConfig

NewLikelihoodComparisonPartition builds a PartitionConfig embedding an inner windowed simulation to evaluate the likelihood over a rolling window, producing a per-step comparison score.

func NewLikelihoodMeanFunctionFitPartition ¶

func NewLikelihoodMeanFunctionFitPartition(
	applied AppliedLikelihoodMeanFunctionFit,
	storage *simulator.StateTimeStorage,
) *simulator.PartitionConfig

NewLikelihoodMeanFunctionFitPartition builds a PartitionConfig embedding an inner simulation that runs gradient descent to fit the likelihood mean to the referenced data window.

func NewLinePlotFromDataFrame ¶

func NewLinePlotFromDataFrame(
	df *dataframe.DataFrame,
	xAxis string,
	yAxis string,
	groupBy ...string,
) *charts.Line

NewLinePlotFromDataFrame renders a line chart from a dataframe using the specified X and Y columns.

Usage hints:

• Optionally split by a single groupBy column into multiple series.

func NewLinePlotFromPartition ¶

func NewLinePlotFromPartition(
	storage *simulator.StateTimeStorage,
	xRef DataRef,
	yRefs []DataRef,
	fillYRefs []FillLineRef,
) *charts.Line

NewLinePlotFromPartition renders a multi-series line chart from storage using an X reference and one or more Y references.

Usage hints:

• yRefs may contain multiple series each; one line per series is added.
• Optional filled bands can be added via fillYRefs.

func NewPosteriorEstimationPartitions ¶

func NewPosteriorEstimationPartitions(
	applied AppliedPosteriorEstimation,
	storage *simulator.StateTimeStorage,
) []*simulator.PartitionConfig

NewPosteriorEstimationPartitions creates a set of PartitionConfigs for an online posterior estimation process using rolling statistics.

func NewScatterPlotFromDataFrame ¶

func NewScatterPlotFromDataFrame(
	df *dataframe.DataFrame,
	xAxis string,
	yAxis string,
	groupBy ...string,
) *charts.Scatter

NewScatterPlotFromDataFrame renders a scatter plot using columns of a dataframe.

Usage hints:

• Optionally provide a single groupBy column to split series.

func NewScatterPlotFromPartition ¶

func NewScatterPlotFromPartition(
	storage *simulator.StateTimeStorage,
	xRef DataRef,
	yRefs []DataRef,
) *charts.Scatter

NewScatterPlotFromPartition renders a scatter plot from storage-backed DataRef axes.

Usage hints:

• X-axis must reference a single series (typically time).
• Each DataRef in yRefs may contain multiple series; a series is added for each.

func NewStateTimeStorageFromCsv ¶

func NewStateTimeStorageFromCsv(
	filePath string,
	timeColumn int,
	stateColumnsByPartition map[string][]int,
	skipHeaderRow bool,
) (*simulator.StateTimeStorage, error)

NewStateTimeStorageFromCsv creates a StateTimeStorage from CSV data.

This function reads time series data from a CSV file and organizes it into partitions for use in stochadex simulations. It supports multiple partitions with different column configurations.

Parameters:

• filePath: Path to the CSV file to read (must exist and be readable)
• timeColumn: Index of the column containing timestamps (0-based indexing)
• stateColumnsByPartition: Map of partition names to column indices for their state values
• skipHeaderRow: Whether to skip the first row as headers (recommended for CSV files with headers)

Returns:

• *StateTimeStorage: Storage containing the loaded time series data, organized by partition
• error: Any error encountered during file reading or parsing

CSV Format Requirements:

• Time column must contain parseable float64 values
• State columns must contain parseable float64 values
• All rows must have the same number of columns
• Missing or malformed values will cause parsing errors

Example:

// Load data from a CSV with time in column 0, prices in columns 1-2, volumes in column 3
storage, err := NewStateTimeStorageFromCsv(
    "market_data.csv",
    0, // time in first column
    map[string][]int{
        "prices": {1, 2}, // prices partition uses columns 1 and 2
        "volumes": {3},   // volumes partition uses column 3
    },
    true, // skip header row
)
if err != nil {
    log.Fatal("Failed to load CSV data:", err)
}

Error Handling:

• File not found: Returns error with file path
• CSV parsing errors: Returns error with parsing details
• Invalid numeric values: Returns error with conversion details
• Inconsistent row lengths: Returns error with row information

Performance Notes:

• Loads entire file into memory (consider file size for large datasets)
• O(n) time complexity where n is the number of rows
• Memory usage: O(n * m) where m is the total number of state columns

func NewStateTimeStorageFromJsonLogEntries ¶

func NewStateTimeStorageFromJsonLogEntries(
	filename string,
) (*simulator.StateTimeStorage, error)

NewStateTimeStorageFromJsonLogEntries reads a file up to a given number of iterations into a simulator.StateTimeStorage struct.

func NewStateTimeStorageFromPartitions ¶

func NewStateTimeStorageFromPartitions(
	partitions []*simulator.PartitionConfig,
	termination simulator.TerminationCondition,
	timestep simulator.TimestepFunction,
	initTime float64,
) *simulator.StateTimeStorage

NewStateTimeStorageFromPartitions generates a new simulator.StateTimeStorage by running a simulation with the specified partitions configured.

func NewStateTimeStorageFromPostgresDb ¶

func NewStateTimeStorageFromPostgresDb(
	db *PostgresDb,
	partitionNames []string,
	startTime float64,
	endTime float64,
) (*simulator.StateTimeStorage, error)

NewStateTimeStorageFromPostgresDb reads from a PostgreSQL database over a pre-defined time interval into a simulator.StateTimeStorage struct.

func NewVectorCovariancePartition ¶

func NewVectorCovariancePartition(
	mean DataRef,
	applied AppliedAggregation,
	storage *simulator.StateTimeStorage,
) *simulator.PartitionConfig

NewVectorCovariancePartition constructs a PartitionConfig that computes the rolling windowed weighted covariance matrix of the referenced data values. Provide the corresponding rolling mean via the mean DataRef.

func NewVectorMeanPartition ¶

func NewVectorMeanPartition(
	applied AppliedAggregation,
	storage *simulator.StateTimeStorage,
) *simulator.PartitionConfig

NewVectorMeanPartition creates a partition that computes rolling weighted means for each dimension of the referenced data.

This function creates a partition that maintains running weighted averages over historical data using the specified integration kernel for time weighting. Each dimension of the source data is aggregated independently.

Mathematical Concept: Vector mean aggregation computes:

μ_i(t) = Σ w(t-s) * X_i(s) / Σ w(t-s)

where μ_i(t) is the mean for dimension i at time t, w(t-s) is the kernel weight, and X_i(s) is the value of dimension i at historical time s.

Parameters:

• applied: AppliedAggregation specifying source data, kernel, and output name
• storage: StateTimeStorage containing the source data

Returns:

• *PartitionConfig: Partition that outputs rolling weighted means

Example:

// Compute exponentially weighted moving averages of price data
meanPartition := NewVectorMeanPartition(
    AppliedAggregation{
        Name: "price_ema",
        Data: DataRef{
            PartitionName: "prices",
            ValueIndices: []int{0, 1, 2}, // Use first 3 price dimensions
        },
        Kernel: &kernels.ExponentialIntegrationKernel{},
        DefaultValue: 100.0, // Initial price assumption
    },
    priceStorage,
)

Performance:

• O(d * h) time complexity where d is data dimensions, h is history depth
• Memory usage: O(d) for output state
• Efficient for moderate dimensions (< 100)

func NewVectorVariancePartition ¶

func NewVectorVariancePartition(
	mean DataRef,
	applied AppliedAggregation,
	storage *simulator.StateTimeStorage,
) *simulator.PartitionConfig

NewVectorVariancePartition constructs a PartitionConfig that computes the rolling windowed weighted variance per-index of the referenced data values. Provide the corresponding rolling mean via the mean DataRef.

func SetPartitionFromDataFrame ¶

func SetPartitionFromDataFrame(
	storage *simulator.StateTimeStorage,
	partitionName string,
	df dataframe.DataFrame,
	overwriteTime bool,
)

SetPartitionFromDataFrame updates a partition's values from a Gota dataframe with schema [time, 0, 1, ...]. If overwriteTime is true, the storage's time vector is replaced with the "time" column.

func WriteStateTimeStorageToPostgresDb ¶

func WriteStateTimeStorageToPostgresDb(
	db *PostgresDb,
	storage *simulator.StateTimeStorage,
)

WriteStateTimeStorageToPostgresDb writes all of the data in the state time storage to a PostgreSQL database.