Function project_vector_to_x

org/src/project_and_partition.rs:107–181

(v: &[f32], x: usize)

}

fn project_vector_to_x(v: &[f32], x: usize) -> Vec<ProjectedValue> {
    let mut projected = v
        .chunks(2)
        .map(|chunk| {
            if chunk.len() == 2 {
                ProjectedValue {
                    value: chunk[0],
                    weight: if is_sensitive_pair(chunk[0], chunk[1]) {
                        calculate_weight(1)
                    } else {
                        0.0
                    },
                    iterations: 1,
                }
            } else {
                ProjectedValue {
                    value: chunk[0],
                    weight: 0.0,
                    iterations: 1,
                }
            }
        })
        .collect::<Vec<_>>();

    let mut iteration: u8 = 2;
    while projected.len() > x {
        if projected.len() / 2 < x {
            let pairs_to_project = projected.len() - x;
            let mut new_projected = Vec::new();

            for i in 0..pairs_to_project {
                let z = project_to_3d(projected[2 * i].value, projected[2 * i + 1].value);
                let inherited_weight = projected[2 * i].weight + projected[2 * i + 1].weight;
                let sensitivity_weight =
                    if is_sensitive_pair(projected[2 * i].value, projected[2 * i + 1].value) {
                        calculate_weight(iteration)
                    } else {
                        0.0
                    };
                let new_weight = inherited_weight + sensitivity_weight;

                new_projected.push(ProjectedValue {
                    value: z,
                    weight: new_weight,
                    iterations: iteration,
                });
            }

            new_projected.extend_from_slice(&projected[pairs_to_project * 2..]);
            projected = new_projected;
        } else {
            projected = projected
                .chunks(2)
                .map(|chunk| {
                    let z = project_to_3d(chunk[0].value, chunk[1].value);
                    let inherited_weight = chunk[0].weight + chunk[1].weight;
                    let sensitivity_weight = if is_sensitive_pair(chunk[0].value, chunk[1].value) {
                        calculate_weight(iteration)