Function main

org/src/project_to_dim.rs:115–230

()

fn main() {
    let mut rng = thread_rng();
    let uniform = Uniform::new(-1.0, 1.0);

    // Create two random source vectors of 320 dimensions
    let a: Vec<f64> = (0..320).map(|_| uniform.sample(&mut rng)).collect();
    let b: Vec<f64> = (0..320).map(|_| uniform.sample(&mut rng)).collect();

    // Calculate and print cosine similarity between original A and B
    let similarity_ab_original = cosine_similarity(&a, &b);
    println!("Cosine similarity between original A and B: {:.6}", similarity_ab_original);

    // Number of samples and target dimensions
    let num_vectors = 100;
    let target_dimensions = 16;

    // Generate perturbed versions of A
    let normal = Normal::new(0.0, 0.25).unwrap();
    let perturbed_vectors: Vec<Vec<f64>> = (0..num_vectors)
        .map(|_| a.iter().map(|&x| x * (1.0 + normal.sample(&mut rng))).collect())
        .collect();

    // Print summary of perturbations
    println!("Summary of perturbations:");
    for (i, perturbed) in perturbed_vectors.iter().take(5).enumerate() {
        let diff: Vec<f64> = perturbed.iter().zip(a.iter()).map(|(p, a)| p - a).collect();
        println!("\nPerturbed vector {}:", i + 1);
        println!("  Mean difference: {:.6}", diff.iter().sum::<f64>() / diff.len() as f64);
        println!("  Max difference:  {:.6}", diff.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b)));
        println!("  Min difference:  {:.6}", diff.iter().fold(f64::INFINITY, |a, &b| a.min(b)));
    }

    // Project source A and B
    let a_source_projected = project_vector_to_x(&a, target_dimensions);
    let b_projected = project_vector_to_x(&b, target_dimensions);

    // Calculate and print cosine similarity between projected A and B
    let similarity_ab_source = cosine_similarity(&a_source_projected, &b_projected);
    println!("\nProjected A: {:?}", a_source_projected);
    println!("\nProjected B: {:?}", b_projected);
    println!("\nCosine similarity between projected A and B: {:.6}", similarity_ab_source);

    // Calculate and print indices for projected A and B
    let (index_a, alt_indices_a) = make_index(&a_source_projected);
    let (index_b, alt_indices_b) = make_index(&b_projected);
    println!("Index for projected A: {}", index_a);
    println!("Alternative indices for A: {:?}", alt_indices_a);
    println!("Index for projected B: {}", index_b);
    println!("Alternative indices for B: {:?}", alt_indices_b);

    // Main loop
    let mut similarities_ab = Vec::new();
    let mut similarities_aa = Vec::new();
    let mut main_index_counts = HashMap::new();
    let mut alt_index_counts = HashMap::new();

    for a_perturbed in &perturbed_vectors {
        let a_perturbed_projected = project_vector_to_x(a_perturbed, target_dimensions);