linebender · richard-uk1 · Mar 18, 2023 · Mar 4, 2023 · Mar 4, 2023 · Mar 9, 2023
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -47,6 +47,8 @@ jobs:
           profile: minimal
           override: true
 
+      - run: rustup target add thumbv7m-none-eabi
+
       - name: cargo clippy
         uses: actions-rs/cargo@v1
         with:
@@ -59,6 +61,10 @@ jobs:
           command: test
           args: --all-features
 
+      - name: Build with no default features
+        # Use no-std target to ensure we don't link to std.
+        run: cargo build --no-default-features --features libm --target thumbv7m-none-eabi
+
   test-stable-wasm:
     runs-on: ${{ matrix.os }}
     strategy:

diff --git a/Cargo.toml b/Cargo.toml
@@ -13,8 +13,17 @@ categories = ["graphics"]
 [package.metadata.docs.rs]
 features = ["mint", "schemars", "serde"]
 
-[dependencies]
-arrayvec = "0.7.1"
+[features]
+default = ["std"]
+std = []
+
+[dependencies.arrayvec]
+version = "0.7.1"
+default-features = false
+
+[dependencies.libm]
+version = "0.2.6"
+optional = true
 
 [dependencies.mint]
 version = "0.5.1"
@@ -27,6 +36,7 @@ optional = true
 [dependencies.serde]
 version = "1.0.105"
 optional = true
+default-features = false
 features = ["derive"]
 
 # This is used for research but not really needed; maybe refactor.

diff --git a/examples/circle.rs b/examples/circle.rs
@@ -1,18 +1,24 @@
 //! Example of circle
 
-use kurbo::{Circle, Shape};
-
+#[cfg(feature = "std")]
 fn main() {
+    use kurbo::{Circle, Shape};
+
     let circle = Circle::new((400.0, 400.0), 380.0);
     println!("<!DOCTYPE html>");
     println!("<html>");
     println!("<body>");
     println!("<svg height=\"800\" width=\"800\">");
     let path = circle.to_path(1e-3).to_svg();
-    println!("  <path d=\"{path}\" stroke=\"black\" fill=\"none\" />");
+    println!("  <path d=\"{}\" stroke=\"black\" fill=\"none\" />", path);
     let path = circle.to_path(1.0).to_svg();
-    println!("  <path d=\"{path}\" stroke=\"red\" fill=\"none\" />");
+    println!("  <path d=\"{}\" stroke=\"red\" fill=\"none\" />", path);
     println!("</svg>");
     println!("</body>");
     println!("</html>");
 }
+
+#[cfg(not(feature = "std"))]
+fn main() {
+    println!("This example requires the standard library");
+}
diff --git a/examples/ellipse.rs b/examples/ellipse.rs
@@ -1,19 +1,25 @@
 //! Example of ellipse
 
-use kurbo::{Ellipse, Shape};
-use std::f64::consts::PI;
-
+#[cfg(feature = "std")]
 fn main() {
+    use kurbo::{Ellipse, Shape};
+    use std::f64::consts::PI;
+
     let ellipse = Ellipse::new((400.0, 400.0), (200.0, 100.0), 0.25 * PI);
     println!("<!DOCTYPE html>");
     println!("<html>");
     println!("<body>");
     println!("<svg height=\"800\" width=\"800\" style=\"background-color: #999\">");
     let path = ellipse.to_path(1e-3).to_svg();
-    println!("  <path d=\"{path}\" stroke=\"black\" fill=\"none\" />");
+    println!("  <path d=\"{}\" stroke=\"black\" fill=\"none\" />", path);
     let path = ellipse.to_path(1.0).to_svg();
-    println!("  <path d=\"{path}\" stroke=\"red\" fill=\"none\" />");
+    println!("  <path d=\"{}\" stroke=\"red\" fill=\"none\" />", path);
     println!("</svg>");
     println!("</body>");
     println!("</html>");
 }
+
+#[cfg(not(feature = "std"))]
+fn main() {
+    println!("This example requires the standard library");
+}
diff --git a/src/affine.rs b/src/affine.rs
@@ -1,9 +1,12 @@
 //! Affine transforms.
 
-use std::ops::{Mul, MulAssign};
+use core::ops::{Mul, MulAssign};
 
 use crate::{Point, Rect, Vec2};
 
+#[cfg(not(feature = "std"))]
+use crate::common::FloatFuncs;
+
 /// A 2D affine transform.
 #[derive(Clone, Copy, Debug, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]

diff --git a/src/arc.rs b/src/arc.rs
@@ -1,11 +1,14 @@
 //! An ellipse arc.
 
 use crate::{PathEl, Point, Rect, Shape, Vec2};
-use std::{
+use core::{
     f64::consts::{FRAC_PI_2, PI},
     iter,
 };
 
+#[cfg(not(feature = "std"))]
+use crate::common::{FloatFuncs, FloatFuncsExtra};
+
 /// A single arc segment.
 #[derive(Clone, Copy, Debug, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]

diff --git a/src/bezpath.rs b/src/bezpath.rs
@@ -2,9 +2,11 @@
 
 #![allow(clippy::many_single_char_names)]
 
-use std::iter::{Extend, FromIterator};
-use std::mem;
-use std::ops::{Mul, Range};
+use core::iter::{Extend, FromIterator};
+use core::mem;
+use core::ops::{Mul, Range};
+
+use alloc::vec::Vec;
 
 use arrayvec::ArrayVec;
 
@@ -15,6 +17,9 @@ use crate::{
     ParamCurveExtrema, ParamCurveNearest, Point, QuadBez, Rect, Shape, TranslateScale, Vec2,
 };
 
+#[cfg(not(feature = "std"))]
+use crate::common::FloatFuncs;
+
 /// A Bézier path.
 ///
 /// These docs assume basic familiarity with Bézier curves; for an introduction,
@@ -404,7 +409,7 @@ impl FromIterator<PathEl> for BezPath {
 /// slice, as it returns `PathEl` items, rather than references.
 impl<'a> IntoIterator for &'a BezPath {
     type Item = PathEl;
-    type IntoIter = std::iter::Cloned<std::slice::Iter<'a, PathEl>>;
+    type IntoIter = core::iter::Cloned<core::slice::Iter<'a, PathEl>>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.elements().iter().cloned()
@@ -413,7 +418,7 @@ impl<'a> IntoIterator for &'a BezPath {
 
 impl IntoIterator for BezPath {
     type Item = PathEl;
-    type IntoIter = std::vec::IntoIter<PathEl>;
+    type IntoIter = alloc::vec::IntoIter<PathEl>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()
@@ -1108,7 +1113,7 @@ impl From<QuadBez> for PathSeg {
 }
 
 impl Shape for BezPath {
-    type PathElementsIter<'iter> = std::iter::Copied<std::slice::Iter<'iter, PathEl>>;
+    type PathElementsIter<'iter> = core::iter::Copied<core::slice::Iter<'iter, PathEl>>;
 
     fn path_elements(&self, _tolerance: f64) -> Self::PathElementsIter<'_> {
         self.0.iter().copied()
@@ -1178,7 +1183,7 @@ impl PathEl {
 impl<'a> Shape for &'a [PathEl] {
     type PathElementsIter<'iter>
 
-    = std::iter::Copied<std::slice::Iter<'a, PathEl>> where 'a: 'iter;
+    = core::iter::Copied<core::slice::Iter<'a, PathEl>> where 'a: 'iter;
 
     #[inline]
     fn path_elements(&self, _tolerance: f64) -> Self::PathElementsIter<'_> {
@@ -1218,7 +1223,7 @@ impl<'a> Shape for &'a [PathEl] {
 ///
 /// If the array starts with `LineTo`, `QuadTo`, or `CurveTo`, it will be treated as a `MoveTo`.
 impl<const N: usize> Shape for [PathEl; N] {
-    type PathElementsIter<'iter> = std::iter::Copied<std::slice::Iter<'iter, PathEl>>;
+    type PathElementsIter<'iter> = core::iter::Copied<core::slice::Iter<'iter, PathEl>>;
 
     #[inline]
     fn path_elements(&self, _tolerance: f64) -> Self::PathElementsIter<'_> {

diff --git a/src/circle.rs b/src/circle.rs
@@ -1,13 +1,16 @@
 //! Implementation of circle shape.
 
-use std::{
+use core::{
     f64::consts::{FRAC_PI_2, PI},
     iter,
     ops::{Add, Mul, Sub},
 };
 
 use crate::{Affine, Arc, ArcAppendIter, Ellipse, PathEl, Point, Rect, Shape, Vec2};
 
+#[cfg(not(feature = "std"))]
+use crate::common::FloatFuncs;
+
 /// A circle.
 #[derive(Clone, Copy, Default, Debug, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
@@ -260,7 +263,7 @@ impl Sub<Vec2> for CircleSegment {
     }
 }
 
-type CircleSegmentPathIter = std::iter::Chain<
+type CircleSegmentPathIter = iter::Chain<
     iter::Chain<
         iter::Chain<iter::Chain<iter::Once<PathEl>, iter::Once<PathEl>>, ArcAppendIter>,
         iter::Once<PathEl>,

diff --git a/src/common.rs b/src/common.rs
@@ -4,6 +4,91 @@
 
 use arrayvec::ArrayVec;
 
+/// Defines a trait that chooses between libstd or libm implementations of float methods.
+macro_rules! define_float_funcs {
+    ($(
+        fn $name:ident(self $(,$arg:ident: $arg_ty:ty)*) -> $ret:ty
+        => $lname:ident/$lfname:ident;
+    )+) => {
+        #[cfg(not(feature = "std"))]
+        pub(crate) trait FloatFuncs : Sized {
+            $(fn $name(self $(,$arg: $arg_ty)*) -> $ret;)+
+        }
+
+        #[cfg(not(feature = "std"))]
+        impl FloatFuncs for f32 {
+            $(fn $name(self $(,$arg: $arg_ty)*) -> $ret {
+                #[cfg(feature = "libm")]
+                return libm::$lfname(self $(,$arg as _)*);
+
+                #[cfg(not(feature = "libm"))]
+                compile_error!("kurbo requires either the `std` or `libm` feature")
+            })+
+        }
+
+        #[cfg(not(feature = "std"))]
+        impl FloatFuncs for f64 {
+            $(fn $name(self $(,$arg: $arg_ty)*) -> $ret {
+                #[cfg(feature = "libm")]
+                return libm::$lname(self $(,$arg as _)*);
+
+                #[cfg(not(feature = "libm"))]
+                compile_error!("kurbo requires either the `std` or `libm` feature")
+            })+
+        }
+    }
+}
+
+define_float_funcs! {
+    fn abs(self) -> Self => fabs/fabsf;
+    fn atan2(self, other: Self) -> Self => atan2/atan2f;
+    fn cbrt(self) -> Self => cbrt/cbrtf;
+    fn ceil(self) -> Self => ceil/ceilf;
+    fn copysign(self, sign: Self) -> Self => copysign/copysignf;
+    fn floor(self) -> Self => floor/floorf;
+    fn hypot(self, other: Self) -> Self => hypot/hypotf;
+    fn ln(self) -> Self => log/logf;
+    fn log2(self) -> Self => log2/log2f;
+    fn mul_add(self, a: Self, b: Self) -> Self => fma/fmaf;
+    fn powi(self, n: i32) -> Self => pow/powf;
+    fn powf(self, n: Self) -> Self => pow/powf;
+    fn round(self) -> Self => round/roundf;
+    fn sin_cos(self) -> (Self, Self) => sincos/sincosf;
+    fn sqrt(self) -> Self => sqrt/sqrtf;
+    fn tan(self) -> Self => tan/tanf;
+    fn trunc(self) -> Self => trunc/truncf;
+}
+
+/// Special implementation for signum, because libm doesn't have it.
+#[cfg(not(feature = "std"))]
+pub(crate) trait FloatFuncsExtra {
+    fn signum(self) -> Self;
+}
+
+#[cfg(not(feature = "std"))]
+impl FloatFuncsExtra for f32 {
+    #[inline]
+    fn signum(self) -> f32 {
+        if self.is_nan() {
+            f32::NAN
+        } else {
+            1.0_f32.copysign(self)
+        }
+    }
+}
+
+#[cfg(not(feature = "std"))]
+impl FloatFuncsExtra for f64 {
+    #[inline]
+    fn signum(self) -> f64 {
+        if self.is_nan() {
+            f64::NAN
+        } else {
+            1.0_f64.copysign(self)
+        }
+    }
+}
+
 /// Adds convenience methods to `f32` and `f64`.
 pub trait FloatExt<T> {
     /// Rounds to the nearest integer away from zero,

diff --git a/src/cubicbez.rs b/src/cubicbez.rs
@@ -1,6 +1,8 @@
 //! Cubic Bézier segments.
 
-use std::ops::{Mul, Range};
+use alloc::vec;
+use alloc::vec::Vec;
+use core::ops::{Mul, Range};
 
 use crate::MAX_EXTREMA;
 use crate::{Line, QuadSpline, Vec2};
@@ -15,6 +17,9 @@ use crate::{
     ParamCurveDeriv, ParamCurveExtrema, ParamCurveNearest, PathEl, Point, QuadBez, Rect, Shape,
 };
 
+#[cfg(not(feature = "std"))]
+use crate::common::FloatFuncs;
+
 const MAX_SPLINE_SPLIT: usize = 100;
 
 /// A single cubic Bézier segment.
@@ -217,7 +222,7 @@ impl CubicBez {
         let delta_2 = dt * dt;
         let delta_3 = dt * delta_2;
 
-        std::iter::from_fn(move || {
+        core::iter::from_fn(move || {
             // if storage exists, we use it exclusively
             if let Some(storage) = storage.as_mut() {
                 return storage.pop();

diff --git a/src/ellipse.rs b/src/ellipse.rs
@@ -1,13 +1,16 @@
 //! Implementation of ellipse shape.
 
-use std::f64::consts::PI;
-use std::{
+use core::f64::consts::PI;
+use core::{
     iter,
     ops::{Add, Mul, Sub},
 };
 
 use crate::{Affine, Arc, ArcAppendIter, Circle, PathEl, Point, Rect, Shape, Size, Vec2};
 
+#[cfg(not(feature = "std"))]
+use crate::common::FloatFuncs;
+
 /// An ellipse.
 #[derive(Clone, Copy, Default, Debug, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]

diff --git a/src/insets.rs b/src/insets.rs
@@ -14,7 +14,7 @@
 
 //! A description of the distances between the edges of two rectangles.
 
-use std::ops::{Add, Neg, Sub};
+use core::ops::{Add, Neg, Sub};
 
 use crate::{Rect, Size};