fidget-core 0.4.3

Core infrastructure for Fidget
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Core infrastructure for evaluating complex closed-form implicit surfaces.
//!
//! ```
//! use fidget_core::{
//!     context::Context,
//!     shape::EzShape,
//!     vm::VmShape
//! };
//! let mut ctx = Context::new();
//! let x = ctx.x();
//! let y = ctx.y();
//! let x_squared = ctx.mul(x, x)?;
//! let y_squared = ctx.mul(y, y)?;
//! let radius = ctx.add(x_squared, y_squared)?;
//! let circle = ctx.sub(radius, 1.0)?;
//!
//! let shape = VmShape::new(&ctx, circle)?;
//! let mut eval = VmShape::new_point_eval();
//! let tape = shape.ez_point_tape();
//!
//! let (v, _trace) = eval.eval(&tape, 0.0, 0.0, 0.0)?;
//! assert_eq!(v, -1.0);
//!
//! let (v, _trace) = eval.eval(&tape, 1.0, 0.0, 0.0)?;
//! assert_eq!(v, 0.0);
//!
//! const N: usize = 15;
//! for i in 0..N {
//!     for j in 0..N {
//!         let x = (i as f32 + 0.5) / (N as f32 / 2.0) - 1.0;
//!         let y = (j as f32 + 0.5) / (N as f32 / 2.0) - 1.0;
//!         let (v, _trace) = eval.eval(&tape, x, y, 0.0)?;
//!         print!("{}", if v < 0.0 { "##" } else { "  " });
//!     }
//!     println!();
//! }
//!
//! // This will print
//! //           ##########
//! //       ##################
//! //     ######################
//! //   ##########################
//! //   ##########################
//! // ##############################
//! // ##############################
//! // ##############################
//! // ##############################
//! // ##############################
//! //   ##########################
//! //   ##########################
//! //     ######################
//! //       ##################
//! //           ##########
//! # Ok::<(), fidget_core::Error>(())
//! ```
#![warn(missing_docs)]

pub mod context;
pub use context::Context;

pub mod compiler;
pub mod eval;
pub mod render;
pub mod shape;
pub mod types;
pub mod var;
pub mod vm;

mod error;
pub use error::Error;

#[cfg(test)]
mod test {
    use crate::Error;
    use crate::context::*;
    use crate::var::Var;

    #[test]
    fn it_works() {
        let mut ctx = Context::new();
        let x1 = ctx.x();
        let x2 = ctx.x();
        assert_eq!(x1, x2);

        let a = ctx.constant(1.0);
        let b = ctx.constant(1.0);
        assert_eq!(a, b);
        assert_eq!(ctx.get_const(a).unwrap(), 1.0);
        assert!(matches!(ctx.get_const(x1), Err(Error::NotAConst)));

        let c = ctx.add(a, b).unwrap();
        assert_eq!(ctx.get_const(c).unwrap(), 2.0);

        let c = ctx.neg(c).unwrap();
        assert_eq!(ctx.get_const(c).unwrap(), -2.0);
    }

    #[test]
    fn test_constant_folding() {
        let mut ctx = Context::new();
        let a = ctx.constant(1.0);
        assert_eq!(ctx.len(), 1);
        let b = ctx.constant(-1.0);
        assert_eq!(ctx.len(), 2);
        let _ = ctx.add(a, b);
        assert_eq!(ctx.len(), 3);
        let _ = ctx.add(a, b);
        assert_eq!(ctx.len(), 3);
        let _ = ctx.mul(a, b);
        assert_eq!(ctx.len(), 3);
    }

    #[test]
    fn test_eval() {
        let mut ctx = Context::new();
        let x = ctx.x();
        let y = ctx.y();
        let v = ctx.add(x, y).unwrap();

        assert_eq!(
            ctx.eval(v, &[(Var::X, 1.0), (Var::Y, 2.0)].into_iter().collect())
                .unwrap(),
            3.0
        );
        assert_eq!(ctx.eval_xyz(v, 2.0, 3.0, 0.0).unwrap(), 5.0);
    }
}