easel3d/fractional/src/main.rs

//
// Test our fractional crate / module...
//
// Georg Hopp <georg@steffers.org>
//
// Copyright © 2019 Georg Hopp
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
use std::convert::{TryFrom, TryInto, Into};
use std::num::TryFromIntError;
use std::f64::consts::PI as FPI;

use fractional::fractional::{Fractional, from_vector, Continuous};
use fractional::trigonometry::{sin, cos, PI};

struct Vector {
    x: Fractional,
    y: Fractional,
    z: Fractional,
}

fn mean(v: &Vec<i64>) -> Result<Fractional, TryFromIntError> {
    let r = v.iter().fold(0, |acc, x| acc + x);
    let l = i64::try_from(v.len())?;
    Ok(Fractional(r, l))
}

fn common_fractional() {
    let a = vec![3, 6, 1, 9];
    let b = from_vector(&a);
    let c = mean(&a).unwrap(); // This might fail if the len of the
                               // vector (usize) does not fit into i32.
    let cr :f64 = c.try_into().unwrap();

    println!("         [i32] : {:?}", a);
    println!("  [Fractional] : {:?}", b);
    println!(" mean of [i32] : {}"  , c);
    println!("        as f64 : {}"  , cr);
    println!("  again as f64 : {}"  , TryInto::<f64>::try_into(c).unwrap());
}

fn continuous() {
    let d = Fractional(45, 16);
    let e = Fractional(16, 45);

    let dc :Continuous = d.into();
    let ec :Continuous = e.into();

    println!("cont frac of d : {} => {:?}", d, dc);
    println!("cont frac of e : {} => {:?}", e, ec);
    println!("   reverted dc : {:?} {}", dc, Into::<Fractional>::into(&dc));
    println!("   reverted ec : {:?} {}", ec, Into::<Fractional>::into(&ec));
}

fn sqrt() {
    let f       = Fractional(-9, 4);
    let fr :f64 = f.try_into().unwrap();
    let sq      = f.sqrt();
    let _sq     = f64::sqrt(fr);

    println!("{:>14} : {:?} / {}", format!("sqrt {}", f), sq, _sq);

    for f in [ Fractional(9, 4)
             , Fractional(45, 16)
             , Fractional(16, 45)
             , Fractional(9, 3) ].iter() {
        let fr  :f64 = (*f).try_into().unwrap();
        let sq       = f.sqrt().unwrap();
        let sqr :f64 = sq.try_into().unwrap();
        let _sqr     = f64::sqrt(fr);

        println!("{:>14} : {} {} / {}", format!("sqrt {}", f), sq, sqr, _sqr);
    }
}

fn pi() {
    let pir :f64        = PI.try_into().unwrap();
    let pit :(i32, i32) = PI.try_into().unwrap();
    let pi2r :f64       = (PI * PI).try_into().unwrap();

    println!("        Rust π : {}"     , FPI);
    println!("             π : {} {}"  , PI, pir);
    println!("    π as tuple : {:?}"   , pit);
    println!("       Rust π² : {}"     , FPI * FPI);
    println!("            π² : {} {}"  , PI * PI, pi2r);
}

fn _sin() {
    for d in [9, 17, 31, 45, 73, 123, 213, 312, 876].iter() {
        let s       = sin(*d as i32);
        let sr :f64 = s.try_into().unwrap();
        let _s      = f64::sin(*d as f64 * FPI / 180.0);

        println!("{:>14} : {} {} / {}", format!("sin {}", d), s, sr, _s);
    }
}

fn _cos() {
    for d in [9, 17, 31, 45, 73, 123, 213, 312, 876].iter() {
        let s       = cos(*d as i32);
        let sr :f64 = s.try_into().unwrap();
        let _s      = f64::cos(*d as f64 * FPI / 180.0);

        println!("{:>14} : {} {} / {}", format!("cos {}", d), s, sr, _s);
    }
}

fn main() {
    common_fractional();
    println!();
    continuous();
    println!();
    sqrt();
    println!();
    pi();
    println!();
    _sin();
    println!();
    _cos();
}