GeezerVison

import feos
import pandas as pd

# Construct datasets from numpy arrays
df_vp = pd.read_csv("vapor_pressure.csv")
df_rho = pd.read_csv("liquid_density.csv")

vp = feos.VaporPressureDataset(
    df_vp.temperature_k.values,
    df_vp.vapor_pressure_pa.values,
)
rho = feos.LiquidDensityDataset(
    df_rho.temperature_k.values,
    df_rho.pressure_pa.values,
    df_rho.liquid_density_kmol_m3.values,
)

# or from CSV:
vp = feos.VaporPressureDataset.from_csv("vapor_pressure.csv")
dh = feos.EnthalpyOfVaporizationDataset.from_csv("dh_vap.csv")

# Define regressor
regressor = feos.PureRegressor(
    model=feos.EquationOfStateAD.PcSaftNonAssoc,
    datasets=[vp, rho, dh],
    params={"m": 2.0, "sigma": 3.0, "epsilon_k": 300.0, "mu": 0.0},
    fit=["m", "sigma", "epsilon_k"],
    residual="relative_difference",  # default
    weights=[1.0, 1.0, 2.0],        # optional per-dataset weights
)

# Run fit with custom configuration
result = regressor.fit(
    config=feos.RegressorConfig(
        patience=100,
        ftol=1e-12,
        xtol=1e-12,
        gtol=1e-12,
        stepbound=0.1,
        strategy=feos.NonConvergenceStrategy.penalty(10.0),  # default
    ),
    loss=feos.LossFunction.huber(0.1),  # optional; default is L2
)

# Print results
print(result)
print(result.all_parameters())

# Evaluate datasets — no argument uses the fitted parameters
dfs = [pd.DataFrame(d) for d in regressor.evaluate_datasets()]
# or pass explicit parameters
dfs = [pd.DataFrame(d) for d in regressor.evaluate_datasets(result.all_parameters())]

# Binary mixture example
bp = feos.BubblePointDataset.from_csv("bubble_point.csv")
bin_reg = feos.BinaryRegressor(
    model=feos.EquationOfStateAD.PcSaftNonAssoc,
    datasets=[bp],
    params={"m1": 2.0, ..., "k_ij": 0.01},
    fit=["k_ij"],
)
bin_result = bin_reg.fit()

RegressorResult(converged=true, n_eval=8, elapsed=2.8ms, aad=[vapor pressure: 6.65%, liquid density: 1.02%])
{'m': 2.9455258525936583, 'sigma': 3.8549088883947196, 'epsilon_k': 242.1332276164755, 'mu': 0.0}

use feos::core::parameter_optimization::*;
use feos::pcsaft::PcSaftPure;
use std::collections::HashMap;
use std::path::Path;

fn main() {
    let vp = VaporPressureDataset::from_csv(Path::new("vapor_pressure.csv"))
        .expect("failed to read vapor pressure CSV");
    let rho = LiquidDensityDataset::from_csv(Path::new("liquid_density.csv"))
        .expect("failed to read liquid density CSV");

    let datasets = vec![
        PureDataset::VaporPressure(vp),
        PureDataset::LiquidDensity(rho),
    ];

    let params = HashMap::from([
        ("m".to_string(), 2.0),
        ("sigma".to_string(), 3.0),
        ("epsilon_k".to_string(), 300.0),
        ("mu".to_string(), 0.0),
    ]);

    let regressor = PureRegressor::<PcSaftPure<f64, 4>>::new(datasets, params, &["m", "sigma", "epsilon_k"])
        .expect("failed to build regressor");

    let config = RegressorConfig {
        patience: 100,
        ftol: 1e-12,
        xtol: 1e-12,
        gtol: 1e-12,
        stepbound: 0.1,
        strategy: NonConvergenceStrategy::Penalty(10.0),
        ..Default::default()
    };

    let (regressor, report) = regressor.fit(config);
    let result = regressor.to_result(&report);

    println!("converged:        {}", result.converged);
    println!("reason:           {}", result.termination_reason);
    println!("n_evaluations:    {}", result.n_evaluations);
    println!("aad_per_dataset:  {:?}", result.aad_per_dataset);
    println!("all_parameters:   {:?}", result.all_parameters());

    let ds_results = regressor.evaluate_datasets(&result.optimal_params);
}

converged:        true
reason:           Converged { ftol: true, xtol: false }
n_evaluations:    8
aad_per_dataset:  [Some(6.645721326146425), Some(1.0224205499118824)]
all_parameters:   {"m": 2.9455..., "sigma": 3.8549..., "epsilon_k": 242.133..., "mu": 0.0}