unitforge 0.4.2__tar.gz → 0.4.3__tar.gz

unitforge-0.4.3/.gitlab-ci.yml

@@ -0,0 +1,137 @@
+image: "rust:latest"
+
+stages:
+  - lint
+  - test
+  - python
+
+variables:
+  CARGO_TERM_COLOR: always
+  PIP_DISABLE_PIP_VERSION_CHECK: "1"
+
+.default_rust:
+  before_script:
+    - rustc --version
+    - cargo --version
+
+.default_python:
+  before_script:
+    - apt-get update
+    - apt-get install -y python3 python3-venv python3-dev pkg-config
+    - python3 --version
+
+# --------------------
+# LINT
+# --------------------
+
+lint:
+  stage: lint
+  extends: .default_rust
+  script:
+    - ./test.sh lint-base
+  allow_failure: true
+
+lint_serde:
+  stage: lint
+  extends: .default_rust
+  script:
+    - ./test.sh lint-serde
+  allow_failure: true
+
+lint_strum:
+  stage: lint
+  extends: .default_rust
+  script:
+    - ./test.sh lint-strum
+  allow_failure: true
+
+lint_pyo3:
+  stage: lint
+  extends: .default_rust
+  script:
+    - ./test.sh lint-pyo3
+  allow_failure: true
+
+# --------------------
+# RUST TESTS
+# --------------------
+
+test_base:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-base
+
+test_serde:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-serde
+
+test_strum:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-strum
+
+test_no_ndarray:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-no-ndarray
+
+test_serde_no_ndarray:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-serde-no-ndarray
+
+test_strum_no_ndarray:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-strum-no-ndarray
+
+test_plain_f64:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-plain-f64
+
+test_plain_f64_serde:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-plain-f64-serde
+
+test_plain_f32:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-plain-f32
+
+test_plain_f32_serde:
+  stage: test
+  extends: .default_rust
+  script:
+    - ./test.sh test-plain-f32-serde
+
+# --------------------
+# PYTHON / PYO3
+# --------------------
+
+test_pyo3:
+  stage: python
+  extends:
+    - .default_rust
+    - .default_python
+  script:
+    - ./test.sh test-pyo3
+
+typecheck_pyo3:
+  stage: python
+  extends:
+    - .default_rust
+    - .default_python
+  script:
+    - ./test.sh typecheck-pyo3

{unitforge-0.4.2 → unitforge-0.4.3}/Cargo.lock

@@ -125,6 +125,12 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
 [[package]]
 name = "portable-atomic"
 version = "1.10.0"
@@ -345,11 +351,12 @@ checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "unitforge"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "ndarray",
  "num-traits",
  "numpy",
+ "paste",
  "pyo3",
  "serde",
  "serde_json",
@@ -360,7 +367,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "regex",
 ]

{unitforge-0.4.2 → unitforge-0.4.3}/Cargo.toml

@@ -4,7 +4,7 @@ crate-type = ["cdylib", "rlib"]
 
 [package]
 name = "unitforge"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 authors = ["Dr.Q team <info@askdrq.com>", "Henrik Stromberg <henrik@askdrq.com>"]
 description = "A library for unit and quantity consistent computations in Rust"
@@ -15,20 +15,29 @@ readme = "Readme.md"
 # ToDo: documentation
 
 [dependencies]
-ndarray = { version = "0.16" }
-num-traits = "0.2.19"
+ndarray = { version = "0.16", optional = true }
+num-traits = { version = "0.2.19", default-features = false }
+paste = "1.0.15"
 serde = { version = "1", optional = true, features = ["derive"] }
 serde_json = { version = "1.0.140", optional = true }
 pyo3 = { version = "0.28.3", features = ["extension-module", "auto-initialize", "multiple-pymethods"], optional = true }
 numpy = { version = "0.28.0", optional = true }
 strum = { version = "0.28.0", optional = true }
 strum_macros = { version = "0.28.0", optional = true }
-unitforge_macros = { version = "0.4.2", path = "unitforge_macros" }
+unitforge_macros = { version = "0.4.3", path = "unitforge_macros" }
 
 [features]
-serde = ["dep:serde", "dep:serde_json", "ndarray/serde"]
-pyo3 = ["dep:pyo3", "dep:numpy"]
+default = []
+ndarray = ["dep:ndarray"]
+serde = ["dep:serde", "dep:serde_json", "ndarray?/serde"]
+pyo3 = ["dep:pyo3", "dep:numpy", "ndarray"]
 strum = ["dep:strum", "dep:strum_macros"]
+storage-f64 = []
+storage-f32 = []
+no_std = []
 
 [workspace]
 members = ["unitforge_macros"]
+
+[profile.dev]
+panic = "abort"

{unitforge-0.4.2 → unitforge-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitforge
-Version: 0.4.2
+Version: 0.4.3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License

{unitforge-0.4.2 → unitforge-0.4.3}/Readme.md

@@ -10,9 +10,9 @@
 - **Unit conversion:** Quantities can be set or read in arbitrary units.
 - **Computing Precision** Values are stored in exponential format (f64*10^i32) to prevent floating point precision issues.
 - **Formating** Quantities are displayed with 4 significant digits and configured display unit.
-- **ndarray support:** Quantities may be used as inner types for `ndarray`.
+- **ndarray support:** Optional `ndarray` integration with `features = ["ndarray"]`; quantities may be used as inner types for arrays.
 - **3D Vector and matrix operations:** Structs for 3D vectors and matrices are included to allow fast and unit-safe work with them.
-- **Serialization**: Optional support for sere using the serde feature.
+- **Serialization**: Optional support for serde using `features = ["serde"]`; combine with `ndarray` for ndarray serialization support.
 - **python interface** Optional Python interface when building with flag pyo3; also available on pypi
 
 ## Contribute

unitforge-0.4.3/src/errors.rs

@@ -0,0 +1,159 @@
+use core::fmt;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum UnitforgeError {
+    QuantityConversion(QuantityConversionError),
+    QuantityOperation(QuantityOperationError),
+    Linalg(LinalgError),
+}
+
+pub type UnitforgeResult<T> = Result<T, UnitforgeError>;
+
+impl fmt::Display for UnitforgeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            UnitforgeError::QuantityConversion(err) => err.fmt(f),
+            UnitforgeError::QuantityOperation(err) => err.fmt(f),
+            UnitforgeError::Linalg(err) => err.fmt(f),
+        }
+    }
+}
+
+impl From<QuantityConversionError> for UnitforgeError {
+    fn from(value: QuantityConversionError) -> Self {
+        UnitforgeError::QuantityConversion(value)
+    }
+}
+
+impl From<QuantityOperationError> for UnitforgeError {
+    fn from(value: QuantityOperationError) -> Self {
+        UnitforgeError::QuantityOperation(value)
+    }
+}
+
+impl From<LinalgError> for UnitforgeError {
+    fn from(value: LinalgError) -> Self {
+        UnitforgeError::Linalg(value)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum QuantityConversionError {
+    InvalidQuantityUnitPair,
+    InvalidQuantityExtraction,
+    InvalidPythonQuantity,
+    InvalidPythonUnit,
+    UnknownQuantityKindId { kind_id: u32 },
+    UnknownUnitKindId { kind_id: u32 },
+    UnknownUnitVariantId { kind_id: u32, variant_id: i32 },
+}
+
+pub type QuantityConversionResult<T> = Result<T, QuantityConversionError>;
+
+impl fmt::Display for QuantityConversionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            QuantityConversionError::InvalidQuantityUnitPair => {
+                write!(f, "Cannot use given pair of quantity and unit")
+            }
+            QuantityConversionError::InvalidQuantityExtraction => {
+                write!(f, "Cannot extract requested quantity type")
+            }
+            QuantityConversionError::InvalidPythonQuantity => {
+                write!(f, "Cannot interpret given value as Quantity")
+            }
+            QuantityConversionError::InvalidPythonUnit => {
+                write!(f, "Cannot interpret given value as Unit")
+            }
+            QuantityConversionError::UnknownQuantityKindId { kind_id } => {
+                write!(f, "Unknown quantity kind id: {kind_id}")
+            }
+            QuantityConversionError::UnknownUnitKindId { kind_id } => {
+                write!(f, "Unknown unit kind id: {kind_id}")
+            }
+            QuantityConversionError::UnknownUnitVariantId {
+                kind_id,
+                variant_id,
+            } => write!(
+                f,
+                "Unknown unit variant id {variant_id} for unit kind id {kind_id}"
+            ),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum QuantityOperationError {
+    AddError,
+    SubError,
+    MulError,
+    DivError,
+    PowError,
+    SqrtError,
+    ComparisonError,
+}
+
+pub type QuantityOperationResult<T> = Result<T, QuantityOperationError>;
+
+impl fmt::Display for QuantityOperationError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            QuantityOperationError::AddError => write!(f, "Addition operation failed"),
+            QuantityOperationError::SubError => write!(f, "Subtraction operation failed"),
+            QuantityOperationError::MulError => write!(f, "Multiplication operation failed"),
+            QuantityOperationError::DivError => write!(f, "Division operation failed"),
+            QuantityOperationError::PowError => write!(f, "Power operation failed"),
+            QuantityOperationError::SqrtError => write!(f, "Sqrt operation failed"),
+            QuantityOperationError::ComparisonError => write!(f, "Comparison operation failed"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum LinalgShape {
+    Vector { len: usize },
+    Matrix { rows: usize, cols: usize },
+}
+
+impl fmt::Display for LinalgShape {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LinalgShape::Vector { len } => write!(f, "vector length {len}"),
+            LinalgShape::Matrix { rows, cols } => write!(f, "matrix shape {rows}x{cols}"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum LinalgError {
+    ShapeMismatch {
+        expected: LinalgShape,
+        actual: LinalgShape,
+    },
+    ShapeConstructionFailed,
+}
+
+pub type LinalgResult<T> = Result<T, LinalgError>;
+
+impl fmt::Display for LinalgError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LinalgError::ShapeMismatch { expected, actual } => {
+                write!(f, "Shape mismatch: expected {expected}, got {actual}")
+            }
+            LinalgError::ShapeConstructionFailed => write!(f, "Shape construction failed"),
+        }
+    }
+}
+
+#[cfg(not(feature = "no_std"))]
+impl std::error::Error for UnitforgeError {}
+
+#[cfg(not(feature = "no_std"))]
+impl std::error::Error for QuantityConversionError {}
+
+#[cfg(not(feature = "no_std"))]
+impl std::error::Error for QuantityOperationError {}
+
+#[cfg(not(feature = "no_std"))]
+impl std::error::Error for LinalgError {}