V0.3.1

.github/workflows/crates.yml

@@ -5,7 +5,7 @@ concurrency:
   cancel-in-progress: false
 
 env:
-  CARGO_PREFIX: ${{ github.event.repository.name }}
+  BASENAME: ${{ github.event.repository.name }}
   CARGO_TERM_COLOR: always
 
 on:
@@ -20,13 +20,13 @@ jobs:
     name: Publish (core)
     runs-on: ubuntu-latest
     env:
-      CARGO_PACKAGE_NAME: ${{ github.event.repository.name }}-core
+      CARGO_PACKAGE_NAME: ${{ github.env.BASENAME }}-core
     steps:
       - uses: actions/checkout@v4
       - name: Publish (${{ env.CARGO_PACKAGE_NAME }})
         run: cargo publish --all-features -v -p ${{ env.CARGO_PACKAGE_NAME }} --token ${{ secrets.CARGO_REGISTRY_TOKEN }}
   features:
-    name: Publish (sdk)
+    name: Publish Features
     needs: core
     runs-on: ubuntu-latest
     strategy:
@@ -39,10 +39,12 @@ jobs:
       - name: Publish (${{ env.CARGO_PACKAGE_NAME }})
         run: cargo publish --all-features -v -p ${{ env.CARGO_PACKAGE_NAME }} --token ${{ secrets.CARGO_REGISTRY_TOKEN }}
   publish:
-    name: Publish (${{ github.repository.name }})
+    env:
+      CARGO_PACKAGE_NAME: ${{ github.event.repository.name }}
+    name: Publish SDK
     needs: features
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: Publish (${{ github.event.repository.name }})
-        run: cargo publish --all-features -v -p ${{ github.event.repository.name }} --token ${{ secrets.CARGO_REGISTRY_TOKEN }}
+      - name: Publish (${{ env.CARGO_PACKAGE_NAME }})
+        run: cargo publish --all-features -v -p ${{ env.CARGO_PACKAGE_NAME }} --token ${{ secrets.CARGO_REGISTRY_TOKEN }}

.gitignore

@@ -51,8 +51,10 @@
 /**/venv/
 
 # Rust
-/**/debug/
-/**/target/
+**/debug/
+**/target/
+
+rustc-ice-**.txt
 
 # Svelte
 /**/.DS_STORE/

Cargo.toml

@@ -8,26 +8,31 @@ keywords = ["acme", "autodiff", "mathematics", "tensor"]
 license = "Apache-2.0"
 repository = "https://github.com/FL03/acme"
 readme = "README.md"
-version = "0.3.0"
-# version = "0.3.0-nightly.5"
+version = "0.3.1"
+# version = "0.3.1-nightly"
 
 [workspace]
 default-members = [
     "acme"
 ]
-exclude = [ ]
+
+exclude = [ 
+    "exp/container",
+]
+
 members = [
     "acme", 
     "core",
     "derive",
     "graphs",
     "macros",
     "tensor",
-    "exp/ndtensor"
+
 ]
 resolver = "2"
 
 [workspace.dependencies]
+paste = "1"
 strum = { features = ["derive"], version = "0.26" }
 smart-default = "0.7"
 

acme/Cargo.toml

@@ -13,7 +13,7 @@ version.workspace = true
 
 [features]
 default = [
-    "core", 
+    "core",
     "tensor",
 ]
 
@@ -22,7 +22,8 @@ full = [
     "derive",
     "graph",
     "serde",
-    "tensor"
+    "tensor",
+    "trace",
 ]
 
 core = []
@@ -59,6 +60,11 @@ tensor = [
     "dep:acme-tensor"
 ]
 
+trace = [
+    "acme-core/trace",
+    "acme-graphs/trace",
+]
+
 
 
 
@@ -81,6 +87,11 @@ required-features = ["macros"]
 name = "graph"
 required-features = ["graph"]
 
+[[example]]
+name = "macros"
+required-features = ["macros"]
+
+
 [[test]]
 name = "macros"
 required-features = ["macros"]
@@ -89,16 +100,16 @@ required-features = ["macros"]
 [build-dependencies]
 
 [dependencies]
-acme-core = { path = "../core", version = "0.3.0" }
-acme-derive = { optional = true, path = "../derive", version = "0.3.0" }
-acme-graphs = { optional = true, path = "../graphs", version = "0.3.0" }
-acme-macros = { optional = true, path = "../macros", version = "0.3.0" }
-acme-tensor = { optional = true, path = "../tensor", version = "0.3.0" }
-# acme-core = { path = "../core", version = "0.3.0-nightly.5" }
-# acme-derive = { optional = true, path = "../derive", version = "0.3.0-nightly.5" }
-# acme-graphs = { optional = true, path = "../graphs", version = "0.3.0-nightly.5" }
-# acme-macros = { optional = true, path = "../macros", version = "0.3.0-nightly.5" }
-# acme-tensor = { optional = true, path = "../tensor", version = "0.3.0-nightly.5" }
+acme-core = { path = "../core", version = "0.3.1" }
+acme-derive = { optional = true, path = "../derive", version = "0.3.1" }
+acme-graphs = { optional = true, path = "../graphs", version = "0.3.1" }
+acme-macros = { optional = true, path = "../macros", version = "0.3.1" }
+acme-tensor = { optional = true, path = "../tensor", version = "0.3.1" }
+# acme-core = { path = "../core", version = "0.3.1-nightly" }
+# acme-derive = { optional = true, path = "../derive", version = "0.3.1-nightly" }
+# acme-graphs = { optional = true, path = "../graphs", version = "0.3.1-nightly" }
+# acme-macros = { optional = true, path = "../macros", version = "0.3.1-nightly" }
+# acme-tensor = { optional = true, path = "../tensor", version = "0.3.1-nightly" }
 
 [dev-dependencies]
 approx = "0.5"

acme/benches/default.rs

@@ -20,7 +20,7 @@ fn recursive_fibonacci(b: &mut Bencher) {
 
 #[bench]
 fn iterative_fibonacci(b: &mut Bencher) {
-    b.iter(|| fib::Fibonacci::seq().take(BENCH_SIZE))
+    b.iter(|| fib::Fibonacci::seq().take(BENCH_SIZE).collect::<Vec<_>>())
 }
 
 pub mod fib {

acme/examples/autodiff.rs

@@ -3,24 +3,40 @@
     Contrib: FL03 <jo3mccain@icloud.com>
 */
 // #![cfg(feature = "macros")]
-
+#![allow(unused_variables)]
 extern crate acme;
 
 use acme::autodiff;
 
+macro_rules! format_exp {
+    (symbolic: {exp: $ex:expr, vars: [$($var:ident),*] }) => {
+        {
+            format!("f({})\t= {}", stringify!($($var),*), stringify!($ex))
+        }
+
+    }
+}
+
 macro_rules! eval {
     ($var:ident: $ex:expr) => {
-        println!("Eval: {:?}", $ex);
-        println!("Gradient: {:?}", autodiff!($var: $ex));
+        {
+            let tmp = autodiff!($var: $ex);
+            let var = stringify!($var);
+            println!("*** Eval ***\nf({})\t= {}\nf({})\t= {:?}\nf'({})\t= {:?}\n", &var, stringify!($ex), $var, $ex, $var, &tmp);
+            tmp
+        }
+
     }
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let x = 2_f64;
-
+    let y = 3f64;
+    let exp = format_exp!(symbolic: {exp: x * y, vars: [x, y]});
+    println!("{}", exp);
     // multiply(x, x);
 
-    samples(x);
+    trig_functions(x);
 
     Ok(())
 }
@@ -33,10 +49,10 @@ fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 //     x * y
 // }
 
-fn samples(x: f64) {
-    eval!(x: x.tan());
-
-    eval!(x: x.sin());
+fn trig_functions(x: f64) {
+    let _tangent = eval!(x: x.tan());
 
-    eval!(x: x.cos().sin());
+    let sine = eval!(x: x.sin());
+    assert_eq!(sine, x.cos());
+    let _cos_sin = eval!(x: x.cos().sin());
 }

acme/examples/macros.rs

@@ -0,0 +1,35 @@
+/*
+    Appellation: autodiff <example>
+    Contrib: FL03 <jo3mccain@icloud.com>
+*/
+extern crate acme;
+
+use acme::{autodiff, operator};
+use num::Float;
+
+fn main() -> acme::prelude::BoxResult {
+    let x = 5f64;
+    let lex = sigmoid_lexical();
+    println!("{}", sigmoid(x));
+    println!("{}", sigmoid_lexical());
+    let dx = sigmoid_prime(x);
+    // assert_eq!(dx, autodiff!(x: SIGMOID_LEXICAL));
+    println!("{}", dx);
+
+    Ok(())
+}
+
+#[operator]
+pub fn sigmoid<T>(x: T) -> T
+where
+    T: Float,
+{
+    x.exp() / (T::one() + x.exp())
+}
+
+pub fn sigmoid_prime<T>(x: T) -> T
+where
+    T: Float,
+{
+    sigmoid(x) * (T::one() - sigmoid(x))
+}

acme/examples/simple.rs

@@ -4,8 +4,12 @@
 */
 extern crate acme;
 
-use acme::prelude::BoxResult;
+use acme::prelude::{nested, BoxResult};
 
 fn main() -> BoxResult {
+    nested!(
+        i in 0..3 => j in 0..3 => k in 0..3 => {
+        println!("({}, {}, {})", i, j, k)
+    });
     Ok(())
 }

acme/examples/tensor.rs

@@ -6,13 +6,98 @@
 
 extern crate acme;
 
-use acme::prelude::{BoxResult, Matmul, Tensor};
+use acme::prelude::{Axis, BoxResult, IntoShape, Linspace, Matmul, Tensor};
 
 fn main() -> BoxResult {
+    let shape = (3, 3);
+
+    // tensor_iter_mut(shape)?;
+    axis_iter(shape, 0)?;
+    Ok(())
+}
+
+pub fn axis_iter(shape: impl IntoShape, axis: usize) -> BoxResult<Tensor<f64>> {
+    let axis = Axis::new(axis);
+    let shape = shape.into_shape();
+    let n = shape.size();
+    let tensor = Tensor::linspace(0f64, n as f64, n).reshape(shape.clone())?;
+
+    let mut res = Vec::new();
+    for i in 0..tensor.shape()[axis] {
+        let mut tmp = Tensor::zeros(shape.ncols());
+        for k in 0..shape.ncols() {
+            tmp[[k]] = tensor[[i, k]];
+        }
+        res.push(tmp);
+    }
+    for i in res {
+        println!("{:?}", &i.to_vec());
+    }
+    Ok(tensor)
+}
+
+#[allow(dead_code)]
+pub fn axis_iter_impl(shape: impl IntoShape, axis: usize) -> BoxResult<Tensor<f64>> {
+    let axis = Axis::new(axis);
+    let shape = shape.into_shape();
+    let n = shape.size();
+    let tensor = Tensor::linspace(0f64, n as f64, n).reshape(shape.clone())?;
+
+    let ns = tensor.layout().remove_axis(axis);
+    let mut res = Vec::new();
+    for i in 0..tensor.shape()[axis] {
+        for j in ns.shape().iter().copied() {
+            let mut tmp = Tensor::zeros(j);
+            for k in 0..ns.shape()[j] {
+                tmp[[k]] = tensor[[i, k]];
+            }
+            res.push(tmp);
+        }
+    }
+    for i in res {
+        println!("{:?}", &i.to_vec());
+    }
+    Ok(tensor)
+}
+
+pub fn example_matmul() -> BoxResult<Tensor<f64>> {
     let shape = (2, 3);
     let tensor: Tensor<f64> = Tensor::linspace(1.0, 7.0, 6).reshape(shape)?;
     let b = tensor.t();
     let c = tensor.matmul(&b);
     println!("{:?}", &c);
-    Ok(())
+    Ok(c)
+}
+
+pub fn tensor_iter_mut(shape: impl IntoShape) -> BoxResult<Tensor<f64>> {
+    let shape = shape.into_shape();
+    let n = shape.size();
+    let exp = Vec::linspace(0f64, n as f64, n);
+    let mut tensor = Tensor::zeros(shape);
+    assert_ne!(&tensor, &exp);
+    for (elem, val) in tensor.iter_mut().zip(exp.iter()) {
+        *elem = *val;
+    }
+    assert_eq!(&tensor, &exp);
+    println!("{:?}", Vec::from_iter(&mut tensor.iter().rev()));
+    Ok(tensor)
+}
+
+pub fn tensor_iter_mut_rev(shape: impl IntoShape) -> BoxResult<Tensor<f64>> {
+    let shape = shape.into_shape();
+    let n = shape.size();
+    let exp = Vec::linspace(0f64, n as f64, n);
+    let mut tensor = Tensor::zeros(shape.clone());
+    assert_ne!(&tensor, &exp);
+    for (elem, val) in tensor.iter_mut().rev().zip(exp.iter()) {
+        *elem = *val;
+    }
+    // assert_eq!(&tensor, &exp);
+    let sample = Tensor::linspace(0f64, n as f64, n).reshape(shape)?;
+    println!("*** Reversed ***");
+    for i in sample.clone().iter().copied().rev() {
+        println!("{:?}", i);
+    }
+
+    Ok(tensor)
 }