refactor: organize source tree into multi-level folder structure (#3)

* refactor: organize source tree into multi-level folder structure

Reorganized the project source files into a multi-level directory
structure for better navigability and conceptual grouping.

Changes:
- Group first-order and second-order AD separately:
  src/{mono,multi}/first_order.rs and second_order/{rr,fr,rf,common}.rs
- Group graph, tape, builder under multi/graph/
- Move compiled IR and execution backends under multi/compiled/
- Split compiled.rs into ir.rs + batches.rs (batch buffer types)
- Merge test-only example impls (mf1..mf4, f1..f3) into examples.rs
- Rename mono_fn.rs -> func.rs, multi_fn.rs -> func.rs
- Replace flat mono.rs/multi.rs with mod.rs files
- Update all internal import paths and lib.rs re-exports

No public API changes. 865 tests pass, clippy clean.

* fix: use checked arithmetic in BatchInputs::try_row to prevent overflow

The multiplication index * input_dim and subsequent slice range could
overflow when BatchInputs is constructed manually with large values
(since fields are public, validation in new() can be bypassed).

Replace direct arithmetic with checked_mul / checked_add and use
data.get(start..end) instead of direct indexing to prevent panics.
Fixes the review comment from gemini-code-assist.

Author: leafyoung

src/lib.rs

@@ -145,17 +145,16 @@ pub use mono::MonoAD;
 pub use mono::{MonoAD2FR, MonoAD2RF, MonoAD2RR};
 
 pub use multi::{
-    builder::GraphBuilder, multi_ad_fr::MultiAD2FR, multi_ad_rf::MultiAD2RF,
-    multi_ad_rr::MultiAD2RR, AcceleratorDeviceContext, AcceleratorDeviceKind, BackendCapabilities,
-    BackendKind, BackendRejectionReason, BackendSupportReport, BatchGradients,
-    BatchGradientsBuffer, BatchInputs, BatchLayout, BatchValues, BatchValuesBuffer, CompiledGraph,
-    CompiledGraphMetadata, CompiledWorkspace, DeviceBackend, DeviceBatchPlan, DeviceBuffer,
-    DeviceBufferHandle, DeviceBufferKind, DeviceBufferLayout, DeviceBufferSet, DeviceExecutionMode,
+    AcceleratorDeviceContext, AcceleratorDeviceKind, BackendCapabilities, BackendKind,
+    BackendRejectionReason, BackendSupportReport, BatchGradients, BatchGradientsBuffer,
+    BatchInputs, BatchLayout, BatchValues, BatchValuesBuffer, CompiledGraph, CompiledGraphMetadata,
+    CompiledWorkspace, DeviceBackend, DeviceBatchPlan, DeviceBuffer, DeviceBufferHandle,
+    DeviceBufferKind, DeviceBufferLayout, DeviceBufferSet, DeviceExecutionMode,
     DeviceExecutionTrace, DeviceMemoryLocation, DeviceTransferKind, DeviceTransferPlan,
     DeviceTransferPolicy, DomainPolicy, ExecutionBackend, ExprGraph, ExprNode, FlatInstruction,
-    GpuBackendBoundary, GradientCheckEntry, GradientCheckReport, Graph, GraphNode, GraphStats,
-    Instruction, MockDeviceBackend, MultiAD, NodeId, OpCode, ScalarBackend, SimdBackend, Tape,
-    TapeWorkspace, UNUSED_NODE_ID,
+    GpuBackendBoundary, GradientCheckEntry, GradientCheckReport, Graph, GraphBuilder, GraphNode,
+    GraphStats, Instruction, MockDeviceBackend, MultiAD, MultiAD2FR, MultiAD2RF, MultiAD2RR,
+    NodeId, OpCode, ScalarBackend, SimdBackend, Tape, TapeWorkspace, UNUSED_NODE_ID,
 };
 #[cfg(feature = "backend-wgpu")]
 pub use multi::{

src/mono.rs

@@ -0,0 +1,101 @@
+//! Test-only example implementations of [`MonoFn`] for library tests.
+//!
+//! These are production-type examples used internally by the test suite and
+//! are gated behind `#[cfg(test)]` to keep them out of release builds.
+
+#[cfg(test)]
+use super::func::{GraphType, MonoFn};
+#[cfg(test)]
+use crate::mono_ops;
+
+/// f(x) = exp(sin(sin(x)))
+#[cfg(test)]
+pub struct MF1(pub f64);
+
+#[cfg(test)]
+impl MonoFn for MF1 {
+    fn input(&self) -> f64 {
+        self.0
+    }
+
+    fn graph(&self) -> &'static GraphType {
+        &mono_ops![sin, sin, exp]
+    }
+
+    fn expected_value(&self) -> f64 {
+        (self.0.sin().sin()).exp()
+    }
+
+    fn expected_gradient(&self) -> f64 {
+        (self.0.sin().sin()).exp() * self.0.sin().cos() * self.0.cos()
+    }
+}
+
+/// f(x) = -x
+#[cfg(test)]
+pub struct MF2(pub f64);
+
+#[cfg(test)]
+impl MonoFn for MF2 {
+    fn input(&self) -> f64 {
+        self.0
+    }
+
+    fn graph(&self) -> &'static GraphType {
+        &mono_ops![neg]
+    }
+
+    fn expected_value(&self) -> f64 {
+        -self.0
+    }
+
+    fn expected_gradient(&self) -> f64 {
+        -1.0
+    }
+}
+
+/// f(x) = sin(-x)
+#[cfg(test)]
+pub struct MF3(pub f64);
+
+#[cfg(test)]
+impl MonoFn for MF3 {
+    fn input(&self) -> f64 {
+        self.0
+    }
+
+    fn graph(&self) -> &'static GraphType {
+        &mono_ops![neg, sin]
+    }
+
+    fn expected_value(&self) -> f64 {
+        (-self.0).sin()
+    }
+
+    fn expected_gradient(&self) -> f64 {
+        -((-self.0).cos())
+    }
+}
+
+/// f(x) = -sin(x)
+#[cfg(test)]
+pub struct MF4(pub f64);
+
+#[cfg(test)]
+impl MonoFn for MF4 {
+    fn input(&self) -> f64 {
+        self.0
+    }
+
+    fn graph(&self) -> &'static GraphType {
+        &mono_ops![sin, neg]
+    }
+
+    fn expected_value(&self) -> f64 {
+        -(self.0.sin())
+    }
+
+    fn expected_gradient(&self) -> f64 {
+        -(self.0.cos())
+    }
+}

src/mono/examples.rs

@@ -1,4 +1,4 @@
-pub use super::mono_ad::MonoAD;
+pub use super::first_order::MonoAD;
 pub use super::types::BackwardResultBox;
 
 /// Type alias for a graph of mono operations (slice of MonoAD)

src/mono/mono_ad.rs src/mono/first_order.rssrc/mono/mono_ad.rs renamed to src/mono/first_order.rs

@@ -0,0 +1,28 @@
+//! Single-variable automatic differentiation.
+//!
+//! This module provides functionality for computing derivatives of
+//! single-variable functions using reverse-mode differentiation.
+
+pub mod types;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(test)]
+mod tests_ho;
+
+pub mod first_order;
+pub use first_order::MonoAD;
+
+pub mod second_order;
+pub use second_order::fr::MonoAD2FR;
+pub use second_order::rf::MonoAD2RF;
+pub use second_order::rr::MonoAD2RR;
+
+pub mod func;
+// Re-export trait for library extension - users can implement custom mono functions
+#[allow(unused_imports)]
+pub use func::MonoFn;
+
+#[cfg(test)]
+mod examples;