quantrs2-tytan 0.1.3

//! Stub for SciRS2 integration
//!
//! This module provides placeholders for SciRS2 integration.
//! The actual integration would be more comprehensive once
//! the SciRS2 API stabilizes.

#![allow(dead_code)]

use ::scirs2_core::ndarray::{Array2, ArrayD};
use ::scirs2_core::random::prelude::*;

/// Placeholder for enhanced QUBO operations
pub fn enhance_qubo_matrix(matrix: &Array2<f64>) -> Array2<f64> {
    // In a real implementation, this would:
    // - Convert to sparse format
    // - Apply optimizations
    // - Use BLAS operations
    matrix.clone()
}

/// Placeholder for HOBO tensor operations
pub fn optimize_hobo_tensor(tensor: &ArrayD<f64>) -> ArrayD<f64> {
    // In a real implementation, this would:
    // - Apply tensor decomposition
    // - Use efficient tensor operations
    // - Leverage parallelization
    tensor.clone()
}

/// Placeholder for parallel sampling
pub fn parallel_sample_qubo(matrix: &Array2<f64>, num_samples: usize) -> Vec<(Vec<bool>, f64)> {
    // In a real implementation, this would use parallel processing
    let n = matrix.shape()[0];
    let mut results = Vec::with_capacity(num_samples);

    // use rand::{rng, Rng}; // Replaced by scirs2_core::random::prelude::*
    let mut rng = thread_rng();

    for _ in 0..num_samples {
        let solution: Vec<bool> = (0..n).map(|_| rng.random()).collect();
        let energy = evaluate_qubo(&solution, matrix);
        results.push((solution, energy));
    }

    results
}

fn evaluate_qubo(solution: &[bool], matrix: &Array2<f64>) -> f64 {
    let mut energy = 0.0;
    let n = solution.len();

    for i in 0..n {
        if solution[i] {
            energy += matrix[[i, i]];
            for j in (i + 1)..n {
                if solution[j] {
                    energy += matrix[[i, j]];
                }
            }
        }
    }

    energy
}

/// Marker that SciRS2 integration is available
pub const SCIRS2_AVAILABLE: bool = cfg!(feature = "scirs");

// When SciRS2 feature is enabled, we still use stubs for now
// until SciRS2 is fully available
pub mod scirs2_core {
    pub use super::scirs2_core_stub::*;
}

pub mod scirs2_linalg {
    pub use super::scirs2_linalg_stub::*;
}

pub mod scirs2_plot {
    pub use super::scirs2_plot_stub::*;
}

pub mod scirs2_statistics {
    pub use super::scirs2_statistics_stub::*;
}

pub mod scirs2_optimization {
    pub use super::scirs2_optimization_stub::*;
}

pub mod scirs2_graphs {
    pub use super::scirs2_graphs_stub::*;
}

pub mod scirs2_ml {
    pub use super::scirs2_ml_stub::*;
}

// Define stub modules that can be used regardless of feature flags
mod scirs2_core_stub {
    use std::error::Error;

    pub fn init_simd() -> Result<(), Box<dyn Error>> {
        Ok(())
    }

    pub mod simd {
        pub trait SimdOps {}
    }

    pub mod memory {
        pub fn get_current_usage() -> Result<usize, std::io::Error> {
            Err(std::io::Error::new(
                std::io::ErrorKind::NotFound,
                "Not implemented",
            ))
        }
    }

    pub mod statistics {
        pub struct OnlineStats {
            count: usize,
            mean: f64,
            m2: f64,
        }

        impl Default for OnlineStats {
            fn default() -> Self {
                Self::new()
            }
        }

        impl OnlineStats {
            pub const fn new() -> Self {
                Self {
                    count: 0,
                    mean: 0.0,
                    m2: 0.0,
                }
            }

            pub fn update(&mut self, value: f64) {
                self.count += 1;
                let delta = value - self.mean;
                self.mean += delta / self.count as f64;
                let delta2 = value - self.mean;
                self.m2 += delta * delta2;
            }

            pub const fn mean(&self) -> f64 {
                self.mean
            }

            pub fn variance(&self) -> f64 {
                if self.count < 2 {
                    0.0
                } else {
                    self.m2 / (self.count - 1) as f64
                }
            }
        }

        pub struct MovingAverage {
            window_size: usize,
            values: Vec<f64>,
        }

        impl MovingAverage {
            pub const fn new(window_size: usize) -> Self {
                Self {
                    window_size,
                    values: Vec::new(),
                }
            }

            pub fn update(&mut self, value: f64) {
                self.values.push(value);
                if self.values.len() > self.window_size {
                    self.values.remove(0);
                }
            }

            pub fn mean(&self) -> f64 {
                if self.values.is_empty() {
                    0.0
                } else {
                    self.values.iter().sum::<f64>() / self.values.len() as f64
                }
            }
        }
    }

    pub mod gpu {
        use std::error::Error;
        use std::time::Duration;

        pub const fn get_device_count() -> usize {
            0
        }

        pub struct GpuContext {
            pub device_id: usize,
        }

        impl GpuContext {
            pub fn new(_device_id: usize) -> Result<Self, Box<dyn Error>> {
                Err("GPU not available".into())
            }

            pub fn measure_kernel_latency(&self) -> Result<Duration, Box<dyn Error>> {
                Err("GPU not available".into())
            }

            pub const fn get_device_info(&self) -> DeviceInfo {
                DeviceInfo {
                    memory_mb: 0,
                    compute_units: 0,
                    clock_mhz: 0,
                }
            }
        }

        pub struct DeviceInfo {
            pub memory_mb: usize,
            pub compute_units: usize,
            pub clock_mhz: usize,
        }

        pub struct GpuDevice {
            pub id: u32,
        }

        impl GpuDevice {
            pub fn new(_id: u32) -> Result<Self, Box<dyn Error>> {
                Err("GPU not available".into())
            }

            pub fn random_array<T>(
                &self,
                _shape: (usize, usize),
            ) -> Result<GpuArray<T>, Box<dyn Error>> {
                Err("GPU not available".into())
            }

            pub fn binarize<T>(
                &self,
                _array: &GpuArray<T>,
                _threshold: f64,
            ) -> Result<GpuArray<bool>, Box<dyn Error>> {
                Err("GPU not available".into())
            }

            pub fn qubo_energy<T>(
                &self,
                _states: &GpuArray<bool>,
                _matrix: &GpuArray<T>,
            ) -> Result<GpuArray<f64>, Box<dyn Error>> {
                Err("GPU not available".into())
            }
        }

        impl Clone for GpuDevice {
            fn clone(&self) -> Self {
                Self { id: self.id }
            }
        }

        pub struct GpuArray<T> {
            _phantom: std::marker::PhantomData<T>,
        }

        impl<T> GpuArray<T> {
            pub fn from_ndarray(
                _device: GpuDevice,
                _array: &scirs2_core::ndarray::Array2<T>,
            ) -> Result<Self, Box<dyn Error>> {
                Err("GPU not available".into())
            }

            pub fn to_ndarray(&self) -> Result<scirs2_core::ndarray::Array2<T>, Box<dyn Error>>
            where
                T: Clone + Default,
            {
                Err("GPU not available".into())
            }
        }
    }
}

mod scirs2_linalg_stub {

    pub mod sparse {
        use scirs2_core::ndarray::Array2;

        pub struct SparseMatrix;

        impl SparseMatrix {
            pub const fn from_dense(_matrix: &Array2<f64>) -> Self {
                Self
            }
        }
    }

    pub mod svd {
        pub struct SVD;
    }

    pub mod pca {
        use scirs2_core::ndarray::Array2;
        use std::error::Error;

        pub struct PCA {
            n_components: usize,
        }

        impl PCA {
            pub const fn new(n_components: usize) -> Self {
                Self { n_components }
            }

            pub fn fit_transform(&self, data: &Array2<f64>) -> Result<Array2<f64>, Box<dyn Error>> {
                // Simple placeholder: just return first n_components columns
                let n_samples = data.nrows();
                let n_features = self.n_components.min(data.ncols());
                let mut result = Array2::zeros((n_samples, self.n_components));

                for i in 0..n_samples {
                    for j in 0..n_features {
                        result[[i, j]] = data[[i, j]];
                    }
                }

                Ok(result)
            }
        }
    }

    pub mod norm {
        use scirs2_core::ndarray::Array1;

        pub trait Norm {
            fn norm(&self) -> f64;
        }

        impl Norm for Array1<f64> {
            fn norm(&self) -> f64 {
                self.iter().map(|x| x * x).sum::<f64>().sqrt()
            }
        }
    }

    pub mod gpu {
        use super::*;
        use scirs2_core::ndarray::Array2;
        use std::error::Error;

        pub struct GpuMatrix;

        impl GpuMatrix {
            pub fn from_host(
                _matrix: &Array2<f64>,
                _ctx: &crate::scirs_stub::scirs2_core::gpu::GpuContext,
            ) -> Result<Self, Box<dyn Error>> {
                Err("GPU not available".into())
            }

            pub fn to_host(&self) -> Result<Array2<f64>, Box<dyn Error>> {
                Err("GPU not available".into())
            }
        }
    }
}

mod scirs2_plot_stub {
    use std::error::Error;

    pub struct Figure;
    pub struct Subplot;
    pub struct Plot2D;
    pub struct Plot3D;
    pub struct Heatmap;
    pub struct ColorMap;
    pub struct Plot;
    pub struct Line;
    pub struct Scatter;
    pub struct Bar;
    pub struct NetworkPlot;
    pub struct MultiPlot;
    pub struct Annotation;
    pub struct Violin;
    pub struct BoxPlot;

    impl Default for Plot {
        fn default() -> Self {
            Self::new()
        }
    }

    impl Plot {
        pub const fn new() -> Self {
            Self
        }
        pub fn add_trace(&mut self, _trace: impl Trace) {}
        pub const fn set_title(&mut self, _title: &str) {}
        pub const fn set_xlabel(&mut self, _label: &str) {}
        pub const fn set_ylabel(&mut self, _label: &str) {}
        pub fn save(&self, _path: &str) -> Result<(), Box<dyn Error>> {
            Err("Plotting not available".into())
        }
    }

    impl Line {
        pub fn new(_x: Vec<f64>, _y: Vec<f64>) -> Self {
            Self
        }
        pub const fn name(self, _name: &str) -> Self {
            self
        }
    }

    impl Scatter {
        pub fn new(_x: Vec<f64>, _y: Vec<f64>) -> Self {
            Self
        }
        pub const fn name(self, _name: &str) -> Self {
            self
        }
        pub const fn mode(self, _mode: &str) -> Self {
            self
        }
        pub const fn marker_size(self, _size: u32) -> Self {
            self
        }
        pub fn text(self, _text: Vec<String>) -> Self {
            self
        }
    }

    impl Heatmap {
        pub fn new(_z: Vec<Vec<f64>>) -> Self {
            Self
        }
        pub fn x(self, _x: Vec<f64>) -> Self {
            self
        }
        pub fn y(self, _y: Vec<f64>) -> Self {
            self
        }
        pub fn x_labels(self, _labels: Vec<String>) -> Self {
            self
        }
        pub fn y_labels(self, _labels: Vec<String>) -> Self {
            self
        }
        pub const fn colorscale(self, _scale: &str) -> Self {
            self
        }
    }

    impl Bar {
        pub fn new(_x: Vec<String>, _y: Vec<f64>) -> Self {
            Self
        }
        pub const fn name(self, _name: &str) -> Self {
            self
        }
    }

    impl Trace for Line {}
    impl Trace for Scatter {}
    impl Trace for Heatmap {}
    impl Trace for Bar {}

    impl Default for Figure {
        fn default() -> Self {
            Self::new()
        }
    }

    impl Figure {
        pub const fn new() -> Self {
            Self
        }

        pub fn add_subplot(
            &mut self,
            _rows: usize,
            _cols: usize,
            _idx: usize,
        ) -> Result<Subplot, Box<dyn Error>> {
            Ok(Subplot)
        }

        pub const fn suptitle(&mut self, _title: &str) {}
        pub const fn tight_layout(&mut self) {}
        pub fn show(&self) -> Result<(), Box<dyn Error>> {
            Err("Plotting not available".into())
        }
    }

    impl Subplot {
        pub const fn bar(&self, _x: &[f64], _y: &[f64]) -> Self {
            Self
        }
        pub const fn scatter(&self, _x: &[f64], _y: &[f64]) -> Self {
            Self
        }
        pub const fn plot(&self, _x: &[f64], _y: &[f64]) -> Self {
            Self
        }
        pub const fn contourf(&self, _x: &[f64], _y: &[f64], _z: &[f64]) -> Self {
            Self
        }
        pub const fn barh(&self, _y: &[f64], _width: &[f64], _left: &[f64], _height: f64) -> Self {
            Self
        }
        pub const fn pie(&self, _sizes: &[f64], _labels: &[String]) -> Self {
            Self
        }
        pub const fn bar_horizontal(&self, _names: &[String], _values: &[f64]) -> Self {
            Self
        }
        pub const fn text(&self, _x: f64, _y: f64, _text: &str) -> Self {
            Self
        }
        pub const fn axvline(&self, _x: f64) -> Self {
            Self
        }

        pub const fn set_xlabel(&self, _label: &str) -> &Self {
            self
        }
        pub const fn set_ylabel(&self, _label: &str) -> &Self {
            self
        }
        pub const fn set_title(&self, _title: &str) -> &Self {
            self
        }
        pub const fn set_color(&self, _color: &str) -> &Self {
            self
        }
        pub const fn set_color_data(&self, _data: &[f64]) -> &Self {
            self
        }
        pub const fn set_colormap(&self, _cmap: &str) -> &Self {
            self
        }
        pub const fn set_label(&self, _label: &str) -> &Self {
            self
        }
        pub const fn set_linewidth(&self, _width: f64) -> &Self {
            self
        }
        pub const fn set_linestyle(&self, _style: &str) -> &Self {
            self
        }
        pub const fn set_alpha(&self, _alpha: f64) -> &Self {
            self
        }
        pub const fn set_size(&self, _size: f64) -> &Self {
            self
        }
        pub const fn set_edgecolor(&self, _color: &str) -> &Self {
            self
        }
        pub const fn set_marker(&self, _marker: &str) -> &Self {
            self
        }
        pub const fn set_fontsize(&self, _size: u32) -> &Self {
            self
        }
        pub const fn set_ha(&self, _align: &str) -> &Self {
            self
        }
        pub const fn set_va(&self, _align: &str) -> &Self {
            self
        }
        pub const fn set_verticalalignment(&self, _align: &str) -> &Self {
            self
        }
        pub const fn set_transform(&self, _transform: ()) -> &Self {
            self
        }
        pub const fn set_autopct(&self, _fmt: &str) -> &Self {
            self
        }
        pub const fn set_aspect(&self, _aspect: &str) {}
        pub const fn set_yscale(&self, _scale: &str) {}
        pub const fn set_xlim(&self, _min: f64, _max: f64) {}
        pub const fn set_ylim(&self, _min: f64, _max: f64) {}
        pub const fn set_axis_off(&self) {}
        pub const fn set_xticks(&self, _ticks: &[f64]) {}
        pub const fn set_yticks(&self, _ticks: &[f64]) {}
        pub const fn set_xticklabels(&self, _labels: &[String]) {}
        pub const fn set_yticklabels(&self, _labels: &[String]) {}
        pub fn get_xticklabels(&self) -> Vec<TickLabel> {
            vec![TickLabel; self.get_xticks().len()]
        }
        pub const fn get_xticks(&self) -> Vec<f64> {
            vec![]
        }
        pub const fn axis(&self, _setting: &str) {}
        pub const fn legend(&self) {}
        pub const fn legend_unique(&self) {}
        pub const fn trans_axes(&self) {}
    }

    #[derive(Clone)]
    pub struct TickLabel;

    impl TickLabel {
        pub const fn set_rotation(&self, _angle: u32) {}
        pub const fn set_ha(&self, _align: &str) {}
    }

    pub trait Trace {}
}

mod scirs2_statistics_stub {

    pub mod descriptive {
        pub const fn mean(_data: &[f64]) -> f64 {
            0.0
        }
        pub const fn std_dev(_data: &[f64]) -> f64 {
            0.0
        }
        pub const fn quantile(_data: &[f64], _q: f64) -> f64 {
            0.0
        }
    }

    pub mod clustering {
        use scirs2_core::ndarray::Array2;
        use std::error::Error;

        pub struct KMeans {
            k: usize,
        }

        impl KMeans {
            pub const fn new(k: usize) -> Self {
                Self { k }
            }

            pub fn fit_predict(&self, _data: &Array2<f64>) -> Result<Vec<usize>, Box<dyn Error>> {
                Ok(vec![0; _data.nrows()])
            }
        }

        pub struct DBSCAN {
            eps: f64,
            min_samples: usize,
        }

        impl DBSCAN {
            pub const fn new(eps: f64, min_samples: usize) -> Self {
                Self { eps, min_samples }
            }

            pub fn fit_predict(&self, _data: &Array2<f64>) -> Result<Vec<usize>, Box<dyn Error>> {
                Ok(vec![0; _data.nrows()])
            }
        }

        pub fn hierarchical_clustering(
            _data: &Array2<f64>,
            _n_clusters: usize,
            _linkage: &str,
        ) -> Result<Vec<usize>, Box<dyn Error>> {
            Ok(vec![0; _data.nrows()])
        }
    }

    pub mod kde {
        use std::error::Error;

        pub struct KernelDensityEstimator;

        impl KernelDensityEstimator {
            pub fn new(_kernel: &str) -> Result<Self, Box<dyn Error>> {
                Ok(Self)
            }

            pub fn estimate_2d(
                &self,
                _x: &[f64],
                _y: &[f64],
                _xi: f64,
                _yi: f64,
            ) -> Result<f64, Box<dyn Error>> {
                Ok(0.0)
            }
        }
    }
}

mod scirs2_optimization_stub {
    use scirs2_core::ndarray::Array1;
    use std::error::Error;

    pub trait Optimizer: Send {
        fn minimize(
            &mut self,
            objective: &dyn ObjectiveFunction,
            x0: &Array1<f64>,
            bounds: &Bounds,
            max_iter: usize,
        ) -> Result<OptimizationResult, Box<dyn Error>>;
    }

    pub trait OptimizationProblem {}

    pub trait ObjectiveFunction {
        fn evaluate(&self, x: &Array1<f64>) -> f64;
        fn gradient(&self, x: &Array1<f64>) -> Array1<f64>;
    }

    pub struct Bounds {
        lower: Array1<f64>,
        upper: Array1<f64>,
    }

    impl Bounds {
        pub const fn new(lower: Array1<f64>, upper: Array1<f64>) -> Self {
            Self { lower, upper }
        }
    }

    pub struct OptimizationResult {
        pub x: Array1<f64>,
        pub f: f64,
        pub iterations: usize,
    }

    pub mod gradient {
        use super::*;

        pub struct LBFGS {
            dim: usize,
        }

        impl LBFGS {
            pub const fn new(dim: usize) -> Self {
                Self { dim }
            }
        }

        impl Optimizer for LBFGS {
            fn minimize(
                &mut self,
                objective: &dyn ObjectiveFunction,
                x0: &Array1<f64>,
                _bounds: &Bounds,
                _max_iter: usize,
            ) -> Result<OptimizationResult, Box<dyn Error>> {
                Ok(OptimizationResult {
                    x: x0.clone(),
                    f: objective.evaluate(x0),
                    iterations: 1,
                })
            }
        }
    }

    pub mod bayesian {
        use super::*;

        #[derive(Debug, Clone, Copy)]
        pub enum AcquisitionFunction {
            ExpectedImprovement,
            UCB,
            PI,
            Thompson,
        }

        #[derive(Debug, Clone, Copy)]
        pub enum KernelType {
            RBF,
            Matern52,
            Matern32,
        }

        pub struct BayesianOptimizer {
            dim: usize,
            kernel: KernelType,
            acquisition: AcquisitionFunction,
            exploration: f64,
        }

        impl BayesianOptimizer {
            pub fn new(
                dim: usize,
                kernel: KernelType,
                acquisition: AcquisitionFunction,
                exploration: f64,
            ) -> Result<Self, Box<dyn Error>> {
                Ok(Self {
                    dim,
                    kernel,
                    acquisition,
                    exploration,
                })
            }

            pub fn update(
                &mut self,
                _x_data: &[Array1<f64>],
                _y_data: &Array1<f64>,
            ) -> Result<(), Box<dyn Error>> {
                Ok(())
            }

            pub fn suggest_next(&self) -> Result<Array1<f64>, Box<dyn Error>> {
                Ok(Array1::zeros(self.dim))
            }
        }

        pub struct GaussianProcess;
    }
}

mod scirs2_ml_stub {
    use scirs2_core::ndarray::Array2;
    use std::error::Error;

    pub struct RandomForest {
        n_estimators: usize,
        max_depth: Option<usize>,
        min_samples_split: usize,
    }

    impl Default for RandomForest {
        fn default() -> Self {
            Self::new()
        }
    }

    impl RandomForest {
        pub const fn new() -> Self {
            Self {
                n_estimators: 100,
                max_depth: None,
                min_samples_split: 2,
            }
        }

        pub const fn n_estimators(mut self, n: usize) -> Self {
            self.n_estimators = n;
            self
        }

        pub const fn max_depth(mut self, depth: Option<usize>) -> Self {
            self.max_depth = depth;
            self
        }

        pub const fn min_samples_split(mut self, samples: usize) -> Self {
            self.min_samples_split = samples;
            self
        }

        pub fn fit(&mut self, _x: &Vec<Vec<f64>>, _y: &Vec<f64>) -> Result<(), Box<dyn Error>> {
            Ok(())
        }

        pub fn predict(&self, _x: &Vec<Vec<f64>>) -> Vec<f64> {
            vec![0.0; _x.len()]
        }

        pub fn feature_importances(&self) -> Vec<f64> {
            vec![0.5; 10] // Placeholder
        }
    }

    pub struct GradientBoosting {
        n_estimators: usize,
        learning_rate: f64,
        max_depth: usize,
    }

    pub struct NeuralNetwork {
        hidden_layers: Vec<usize>,
        activation: String,
        learning_rate: f64,
    }

    pub struct KMeans {
        k: usize,
    }

    impl KMeans {
        pub const fn new(k: usize) -> Self {
            Self { k }
        }

        pub fn fit_predict(&self, _data: &Array2<f64>) -> Result<Vec<usize>, Box<dyn Error>> {
            Ok(vec![0; _data.nrows()])
        }
    }

    pub struct DBSCAN {
        eps: f64,
        min_samples: usize,
    }

    impl DBSCAN {
        pub const fn new(eps: f64, min_samples: usize) -> Self {
            Self { eps, min_samples }
        }

        pub fn fit_predict(&self, _data: &Array2<f64>) -> Result<Vec<usize>, Box<dyn Error>> {
            Ok(vec![0; _data.nrows()])
        }
    }

    pub struct PCA {
        n_components: usize,
    }

    impl PCA {
        pub const fn new(n_components: usize) -> Self {
            Self { n_components }
        }

        pub fn fit_transform(&self, data: &Array2<f64>) -> Result<Array2<f64>, Box<dyn Error>> {
            // Simple placeholder: just return first n_components columns
            let n_samples = data.nrows();
            let n_features = self.n_components.min(data.ncols());
            let mut result = Array2::zeros((n_samples, self.n_components));

            for i in 0..n_samples {
                for j in 0..n_features {
                    result[[i, j]] = data[[i, j]];
                }
            }

            Ok(result)
        }
    }

    pub struct StandardScaler;

    pub struct CrossValidation {
        n_folds: usize,
    }

    impl CrossValidation {
        pub const fn new(n_folds: usize) -> Self {
            Self { n_folds }
        }

        pub fn cross_val_score<T>(
            &self,
            _model: &T,
            _x: &Vec<Vec<f64>>,
            _y: &Vec<f64>,
        ) -> CVScores {
            CVScores {
                scores: vec![0.5; self.n_folds],
            }
        }
    }

    pub struct CVScores {
        scores: Vec<f64>,
    }

    impl CVScores {
        pub fn mean(&self) -> f64 {
            self.scores.iter().sum::<f64>() / self.scores.len() as f64
        }
    }

    pub const fn train_test_split<T>(
        _x: &[T],
        _y: &[f64],
        _test_size: f64,
    ) -> (Vec<T>, Vec<T>, Vec<f64>, Vec<f64>)
    where
        T: Clone,
    {
        (vec![], vec![], vec![], vec![])
    }
}

mod scirs2_graphs_stub {
    pub struct Graph;
    pub struct GraphLayout;

    pub fn spring_layout(
        _edges: &[(usize, usize)],
        n_nodes: usize,
    ) -> Result<Vec<(f64, f64)>, Box<dyn std::error::Error>> {
        // Simple circular layout
        let mut positions = Vec::new();
        for i in 0..n_nodes {
            let angle = 2.0 * std::f64::consts::PI * i as f64 / n_nodes as f64;
            positions.push((angle.cos(), angle.sin()));
        }
        Ok(positions)
    }
}