Ulcer Index (UI)

// From price slice
UiInput::from_slice(&[f64], UiParams) -> UiInput

// From candles with custom source
UiInput::from_candles(&Candles, &str, UiParams) -> UiInput

// From candles with default params (close, period=14, scalar=100)
UiInput::with_default_candles(&Candles) -> UiInput

pub struct UiParams {
    pub period: Option<usize>, // Default: 14
    pub scalar: Option<f64>,   // Default: 100.0
}

pub struct UiOutput {
    pub values: Vec<f64>, // UI values (RMS of % drawdowns)
}

use vectorta::indicators::ui::{ui, UiError};

match ui(&input) {
    Ok(output) => process_results(output.values),
    Err(UiError::EmptyInput) =>
        println!("Input data is empty"),
    Err(UiError::AllValuesNaN) =>
        println!("All values are NaN"),
    Err(UiError::InvalidPeriod { period, data_len }) =>
        println!("Invalid period {} for data length {}", period, data_len),
    Err(UiError::NotEnoughValidData { needed, valid }) =>
        println!("Need {} valid points, got {}", needed, valid),
    Err(UiError::InvalidLength { expected, actual }) =>
        println!("Destination length {} must equal {}", actual, expected),
    Err(UiError::InvalidScalar { scalar }) =>
        println!("Scalar must be finite, got {}", scalar),
}

import numpy as np
from vectorta import ui

# Prepare price data as NumPy array
prices = np.array([100.0, 102.0, 101.5, 103.0, 105.0, 104.5])

# Calculate UI with defaults (period=14, scalar=100)
result = ui(prices, period=14, scalar=100.0)

# Or specify kernel for performance optimization ("auto", "avx2", ...)
result = ui(prices, period=14, scalar=100.0, kernel="auto")

# Result is a NumPy array matching input length
print(f"UI values: {result}")

from vectorta import UiStream

# Initialize streaming UI calculator
stream = UiStream(period=14, scalar=100.0)

# Process real-time price updates
for price in price_feed:
    ui_value = stream.update(price)

    if ui_value is not None:
        # UI value is ready (None during warmup period)
        print(f"Current UI: {ui_value}")

import numpy as np
from vectorta import ui_batch

# Your price data
prices = np.array([...])  # Your historical prices

# Define parameter ranges to test
# (start, end, step) for each parameter
period_range = (5, 50, 5)     # 5, 10, 15, ..., 50
scalar_range = (100.0, 100.0, 0.0)  # keep scalar fixed at 100

# Run batch calculation
results = ui_batch(
    prices,
    period_range=period_range,
    scalar_range=scalar_range,
    kernel="auto"
)

# Access results
print(f"Values shape: {results['values'].shape}")  # (num_combinations, len(prices))
print(f"Periods tested: {results['periods']}")
print(f"Scalars tested: {results['scalars']}")

# Coming soon: CUDA-accelerated UI calculations
# (batch optimization and many-series variants)

import { ui_js } from 'vectorta-wasm';

// Price data as Float64Array or regular array
const prices = new Float64Array([100.0, 102.0, 101.5, 103.0, 105.0, 104.5]);

// Calculate UI with specified parameters
const result = ui_js(prices, 14, 100.0);  // period=14, scalar=100

// Result is a Float64Array
console.log('UI values:', result);

// Use with async/await for better error handling
async function calculateUI(prices: Float64Array): Promise<Float64Array> {
  try {
    return ui_js(prices, 14, 100.0);
  } catch (error) {
    console.error('UI calculation failed:', error);
    throw error;
  }
}

import { ui_alloc, ui_free, ui_into, memory } from 'vectorta-wasm';

// Prepare your price data
const prices = new Float64Array([/* your data */]);
const length = prices.length;

// Allocate WASM memory for input and output
const inPtr = ui_alloc(length);
const outPtr = ui_alloc(length);

// Copy input data into WASM memory
new Float64Array(memory.buffer, inPtr, length).set(prices);

// Calculate UI directly into allocated memory
// Args: in_ptr, out_ptr, len, period, scalar
ui_into(inPtr, outPtr, length, 14, 100.0);

// Read results from WASM memory (slice() to copy out)
const uiValues = new Float64Array(memory.buffer, outPtr, length).slice();

// Free allocated memory when done
ui_free(inPtr, length);
ui_free(outPtr, length);

console.log('UI values:', uiValues);

import { ui_batch, ui_batch_into, ui_alloc, ui_free, memory } from 'vectorta-wasm';

// Your price data
const prices = new Float64Array([/* historical prices */]);

// Option A: High-level batch API with config object
const config = {
  period_range: [5, 50, 5],         // start, end, step
  scalar_range: [100.0, 100.0, 0.0] // keep scalar fixed
};
const batchOut = ui_batch(prices, config);
// batchOut: { values: Float64Array, combos: UiParams[], rows: number, cols: number }

// Option B: Fast pointer API (manual memory management)
// Compute number of combinations for allocation
const nPeriods = Math.floor((50 - 5) / 5) + 1;  // inclusive range: 5..50 step 5
const nScalars = 1;                              // scalar step = 0.0 => single value
const rows = nPeriods * nScalars;

// Allocate and copy input into WASM memory
const inPtr = ui_alloc(prices.length);
new Float64Array(memory.buffer, inPtr, prices.length).set(prices);

// Allocate output buffer for rows × cols
const outPtr = ui_alloc(rows * prices.length);
try {
  const writtenRows = ui_batch_into(
    inPtr, outPtr, prices.length,
    5, 50, 5,
    100.0, 100.0, 0.0
  );

  // Read back results (flat array: row-major [rows * cols])
  const out = new Float64Array(memory.buffer, outPtr, rows * prices.length).slice();
  console.log('rows written:', writtenRows, 'values length:', out.length);
} finally {
  ui_free(inPtr, prices.length);
  ui_free(outPtr, rows * prices.length);
}