osiris-process 0.3.1

//! Implements a floating-point register bank.

use osiris_data::data::atomic::Word;
use osiris_data::data::composite::Array;
use osiris_data::data::identification::Identifier;

use crate::register::{RangeApplication, RegisterBank, RegisterId, RegisterRange, REGISTERS_IN_BANK};

/// A function on a range which returns a [Number].
pub type VectorApplication = RangeApplication<Number>;

/// A [Number] is the machine's floating point number type.
#[derive(Copy, Clone, Debug, Default)]
pub struct Number(f64);

impl Number {
    /// Creates a value from a raw value.
    pub fn new(data: f64) -> Self { Self(data) }
    
    /// Returns the number raw value.
    pub fn to_f64(&self) -> f64 { self.0 }
    
    /// Creates a value from its raw data.
    pub fn from_u64(data: u64) -> Self { Self::new(f64::from_bits(data)) }
    
    /// Creates a value from its raw data.
    pub fn from_word(data: Word) -> Self { Self::new(f64::from_bits(data.to_u64())) }
    
    /// Returns the raw data representing the number.
    pub fn to_u64(&self) -> u64 { self.0.to_bits() }

    /// Returns the raw data representing the number in a [Word].
    pub fn to_word(&self) -> Word { Word::new(self.to_u64()) }

    /// Creates an array of [Number] from a slice containing raw data. 
    pub fn from_words_slice(from: &[Word]) -> Vec<Self> {
        let mut slice = vec![];
        for e in from {
            slice.push(Self::from_word(*e));
        }
        slice
    }

    /// Creates an array of raw data [Word]s from a [Number] slice.
    pub fn slice_to_array(from: &[Self]) -> Array {
        let mut array:Array = Array::new(0);
        for e in from {
            array.push(e.to_word());
        }
        array
    }
}


/// The register bank of floating point values.
///
/// The struct contains the whole register array.
#[derive(Clone, Debug)]
pub struct Vector {
    registers: Vec<Number>,
}

impl RegisterBank<Number> for Vector {
    fn new() -> Self {
        Self { registers: vec![Number::default(); REGISTERS_IN_BANK] }
    }

    fn set(&mut self, register: RegisterId, number: Number) {
        if register.to_usize() > REGISTERS_IN_BANK {
            return;
        }
        self.registers[register.to_usize()] = number;
    }
    
    fn get(&self, register: RegisterId) -> Number {
        self.registers[register.to_usize()]
    }

    fn apply(&self, range: RegisterRange, function: VectorApplication) -> Number {
        let slice = &self.registers[range.to_usize_range()];
        function(slice)
    }

    fn slice(&self, range: RegisterRange) -> &[Number] {
        &self.registers[range.to_usize_range()]
    }

    fn copy(&mut self, to: RegisterId, slice: &[Number]) {
        let mut index = to.to_usize();
        for w in slice {
            self.registers[index] = *w;
            index += 1;
        }
    }
}

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