Struct KLINE 

pub struct KLINE {
    pub ticker: String,
    pub timestamp: Vec<i64>,
    pub open: Option<Vec<f64>>,
    pub high: Option<Vec<f64>>,
    pub low: Option<Vec<f64>>,
    pub close: Vec<f64>,
    pub volume: Option<Vec<f64>>,
    pub adjclose: Option<Vec<f64>>,
}

KLINE Struct

Description

• Represents historical price/volume data for a financial instrument
• Stores OHLCV (Open, High, Low, Close, Volume) data with UNIX timestamps
• Supports both adjusted and unadjusted closing prices
• Designed for efficient time series analysis and portfolio construction
• Flexible data ingestion from multiple sources

Fields

• ticker: Instrument symbol (e.g., “AAPL”, “BTC-USD”)
• timestamp: UNIX timestamps (seconds since epoch) for each data point
• open: Opening prices (optional)
• high: Daily high prices (optional)
• low: Daily low prices (optional)
• close: Closing prices (required)
• volume: Trading volumes (optional)
• adjclose: Adjusted closing prices (optional)

Features

• Multi-format Support: Load data from CSV, JSON, and Polars DataFrames
• Flexible Integration: Works seamlessly with Tickers and Portfolio structs
• Performance Analysis: Enables risk/return calculations and reporting

Example: Loading Data and Generating Reports

use std::error::Error;
use finalytics::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Method 1: Load from CSV files
    let aapl_csv = KLINE::from_csv("AAPL", "../examples/datasets/aapl.csv")?;
    let goog_csv = KLINE::from_csv("GOOG", "../examples/datasets/goog.csv")?;
    let gspc_csv = KLINE::from_csv("^GSPC", "../examples/datasets/gspc.csv")?;

    // Method 2: Load from JSON files
    let msft_json = KLINE::from_json("MSFT", "../examples/datasets/msft.json")?;
    let btc_json = KLINE::from_json("BTC-USD", "../examples/datasets/btcusd.json")?;

    // Method 3: Load from Polars DataFrame
    let df = KLINE::from_csv("NVDA","../examples/datasets/nvda.csv")?.to_dataframe()?;
    let nvda_df = KLINE::from_dataframe("NVDA", &df)?;

    // Combine all data sources
    let tickers_data = vec![aapl_csv, goog_csv, msft_json, btc_json, nvda_df];

    // Initialize Tickers Struct
    let tickers = Tickers::builder()
        .tickers_data(Some(tickers_data))
        .benchmark_data(Some(gspc_csv))
        .confidence_level(0.95)
        .risk_free_rate(0.02)
        .build();

    // Generate a Single Ticker Report
    let ticker = tickers.clone().get_ticker("AAPL").await?;
    ticker.report(Some(ReportType::Performance)).await?.show()?;

    // Generate a Multiple Ticker Report
    tickers.report(Some(ReportType::Performance)).await?.show()?;

    // Portfolio optimization (in-sample performance stats computed automatically)
    let mut portfolio = tickers.optimize(Some(ObjectiveFunction::MaxSharpe), None).await?;
    portfolio.report(Some(ReportType::Optimization)).await?.show()?;

    // Optionally: update with new KLINE data for out-of-sample evaluation
    let eval_tickers = vec![
        KLINE::from_csv("AAPL", "../examples/datasets/aapl.csv")?,
        KLINE::from_csv("GOOG", "../examples/datasets/goog.csv")?,
        KLINE::from_csv("MSFT", "../examples/datasets/msft.csv")?,
        KLINE::from_csv("BTC-USD", "../examples/datasets/btcusd.csv")?,
        KLINE::from_csv("NVDA", "../examples/datasets/nvda.csv")?,
    ];
    let eval_bench = KLINE::from_csv("^GSPC", "../examples/datasets/gspc.csv")?;
    portfolio.update_data(eval_tickers, Some(eval_bench)).await?;
    portfolio.performance_stats()?;
    portfolio.report(Some(ReportType::Performance)).await?.show()?;

    Ok(())
}

Supported Data Sources

1. CSV Files:

   timestamp,open,high,low,close,volume,adjclose
    1672704000,130.28,130.90,124.17,125.07,112117500,124.82
    1672790400,126.89,128.66,125.08,126.36,89113600,126.11

2. JSON Files:

   {
     "timestamp": [1672704000, 1672790400],
     "open": [130.28, 126.89],
     "high": [130.90, 128.66],
     "low": [124.17, 125.08],
     "close": [125.07, 126.36],
     "volume": [112117500, 89113600],
     "adjclose": [124.82, 126.11]
   }

3. Polars DataFrames:

   use polars::prelude::*;
   
   let df = df!(
        "timestamp" => &[1672704000, 1672790400],
        "open" => &[130.28, 126.89],
        "high" => &[130.90, 128.66],
        "low" => &[124.17, 125.08],
        "close" => &[125.07, 126.36],
        "volume" => &[112117500.0, 89113600.0],
        "adjclose" => &[124.82, 126.11]
    );

Important Notes

• All sources must include timestamp and close columns
• Column names are case-sensitive and must match exactly
• Timestamps should be UNIX format (seconds since epoch)
• Missing columns will be initialized as None

Fields

ticker: String

timestamp: Vec<i64>

open: Option<Vec<f64>>

high: Option<Vec<f64>>

low: Option<Vec<f64>>

close: Vec<f64>

volume: Option<Vec<f64>>

adjclose: Option<Vec<f64>>

Implementations

impl KLINE

pub fn interval_days(&self) -> IntervalDays

pub fn start_date(&self) -> String

pub fn end_date(&self) -> String

pub fn to_dataframe(&self) -> Result<DataFrame, Box<dyn Error>>

pub fn from_dataframe( ticker: &str, df: &DataFrame, ) -> Result<KLINE, Box<dyn Error>>

pub fn from_csv(ticker: &str, path: &str) -> Result<Self, Box<dyn Error>>

Examples found in repository

examples/example.rs (line 273)

async fn custom_data() -> Result<(), Box<dyn Error>> {
    println!("=== 7. Custom Data (KLINE) ===");

    // Load data from CSV files
    let aapl = KLINE::from_csv("AAPL", "examples/datasets/aapl.csv")?;
    let msft = KLINE::from_csv("MSFT", "examples/datasets/msft.csv")?;
    let nvda = KLINE::from_csv("NVDA", "examples/datasets/nvda.csv")?;
    let goog = KLINE::from_csv("GOOG", "examples/datasets/goog.csv")?;
    let btcusd = KLINE::from_csv("BTC-USD", "examples/datasets/btcusd.csv")?;
    let gspc = KLINE::from_csv("^GSPC", "examples/datasets/gspc.csv")?;

    // Single Ticker from custom data
    println!("--- Custom Ticker ---");
    let custom_ticker = Ticker::builder()
        .ticker("AAPL")
        .benchmark_symbol("^GSPC")
        .confidence_level(0.95)
        .risk_free_rate(0.02)
        .ticker_data(Some(aapl.clone()))
        .benchmark_data(Some(gspc.clone()))
        .build();

    custom_ticker
        .report(Some(ReportType::Performance))
        .await?
        .show()?;

    // Multiple Tickers from custom data
    println!("--- Custom Tickers ---");
    let custom_tickers = Tickers::builder()
        .tickers(vec!["NVDA", "GOOG", "AAPL", "MSFT", "BTC-USD"])
        .benchmark_symbol("^GSPC")
        .confidence_level(0.95)
        .risk_free_rate(0.02)
        .tickers_data(Some(vec![
            nvda.clone(),
            goog.clone(),
            aapl.clone(),
            msft.clone(),
            btcusd.clone(),
        ]))
        .benchmark_data(Some(gspc.clone()))
        .build();

    custom_tickers
        .report(Some(ReportType::Performance))
        .await?
        .show()?;

    // Portfolio optimization from custom data
    println!("--- Custom Portfolio ---");
    let mut custom_portfolio = Portfolio::builder()
        .ticker_symbols(vec!["NVDA", "GOOG", "AAPL", "MSFT", "BTC-USD"])
        .benchmark_symbol("^GSPC")
        .confidence_level(0.95)
        .risk_free_rate(0.02)
        .objective_function(ObjectiveFunction::MaxSharpe)
        .tickers_data(Some(vec![nvda, goog, aapl, msft, btcusd]))
        .benchmark_data(Some(gspc))
        .build()
        .await?;

    custom_portfolio.optimize()?;
    custom_portfolio
        .report(Some(ReportType::Optimization))
        .await?
        .show()?;

    Ok(())
}

pub fn from_json(ticker: &str, path: &str) -> Result<Self, Box<dyn Error>>

Trait Implementations

impl Clone for KLINE

fn clone(&self) -> KLINE

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KLINE

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

Formats the value using the given formatter.