Experiment of using cdma to encode data from multiple data

cdma_with_arrays.rs

#[derive(Debug)]
pub(crate) struct User {
    pub(crate) code: [i32; 4],
    pub(crate) data: [i32; 2],
}


// 64 bits -> 512 bits
struct Packet {
    x: f32,
    y: f32,
}


pub(crate) fn run() {

    let users = [
        User {
            code: [0, 1, 0, 1],
            data: [1, 1],
        },
        User {
            code: [0, 0, 1, 1],
            data: [1, 1],
        },
        User {
            code: [0, 0, 0, 0],
            data: [1, 1],
        },
    ];

    let encode = |users: &[User]| {
        let mut sum = [0; 8];

        for user in users {
            // 8 chips
            let spreaded = [
                user.code[0] ^ user.data[0],
                user.code[1] ^ user.data[0],
                user.code[2] ^ user.data[0],
                user.code[3] ^ user.data[0],
                user.code[0] ^ user.data[1],
                user.code[1] ^ user.data[1],
                user.code[2] ^ user.data[1],
                user.code[3] ^ user.data[1],
            ];

            for i in 0..sum.len() {
                sum[i] += if spreaded[i] == 0 { 1 } else { -1 }
            }
        }

        sum
    };

    let decode = |code: &[i32; 4], encoded: &[i32; 8]| {
        let mut decoded = encoded.clone();
        for i in 0..decoded.len() {
            let j = i % code.len();
            decoded[i] *= if code[j] == 0 { 1 } else { -1 };
        }

        [
            if (decoded[0] + decoded[1] + decoded[2] + decoded[3]) / 4 == 1 {
                0
            } else {
                1
            },
            if (decoded[4] + decoded[5] + decoded[6] + decoded[7]) / 4 == 1 {
                0
            } else {
                1
            },
        ]
    };

    let encoded = encode(&users);

    println!("encoded: {encoded:?}");

    for user in &users {
        println!(
            "code: {:?}, expected: {:?}, actual: {:?}",
            user.code,
            user.data,
            decode(&user.code, &encoded)
        );
    }
}