From 48498d477ac3f6e098c87ea55bc5038804c6c3cd Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Wed, 28 Oct 2026 22:19:37 -0400 Subject: [PATCH] Wave 324/509: Fill: a patch's edges are the body's own edges again, circles and ellipses included (and 3 more) 4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 9095fce42 jyviko: SMLib export: a NURBS edge's interval a rounding past its knots is the NURBS's own - b68f71a2d jyviko: Fill: a patch's edges are the body's own edges again, circles and ellipses included - b540faaf5 jyviko: Thicken: a surface turned to its back grows the other way again - ebb1d843a jyviko: Sweep: a parallel sweep whose path runs along the profile's plane is refused again Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ --- .../kernel/src/chamfer_sides_curved_tests.rs | 2 +- crates/kernel/src/fair.rs | 1 + crates/kernel/src/fill.rs | 24 ++++++----- crates/kernel/src/fill_general_tests.rs | 4 +- crates/kernel/src/sew.rs | 17 ++++++-- crates/kernel/src/smlib_sweeps.rs | 12 ++++++ crates/kernel/src/surfaces.rs | 7 ++- crates/kernel/src/sweep_path.rs | 28 ++++++++---- crates/kernel/src/tess/tests.rs | 11 +++-- crates/kernel/src/thin_face_tests.rs | 2 + crates/smlib/src/export.rs | 11 +++-- crates/smlib/src/export/tests.rs | 43 +++++++++++++++++++ 12 files changed, 130 insertions(+), 32 deletions(-) diff --git a/crates/kernel/src/chamfer_sides_curved_tests.rs b/crates/kernel/src/chamfer_sides_curved_tests.rs index 915901a13..07b834010 100644 --- a/crates/kernel/src/chamfer_sides_curved_tests.rs +++ b/crates/kernel/src/chamfer_sides_curved_tests.rs @@ -214,7 +214,7 @@ fn too_large_or_unsupported_is_refused() { .record() .edges .iter() - .filter_map(|e| solidcraft_geom::brep::eval::CurveEval::new(&e.curve).ok()?.point(0.5 * (e.interval[0] + e.interval[1]))) + .filter_map(|e| solidcraft_geom::brep::eval::CurveEval::new(e.parameters()).ok()?.point(0.5 * (e.interval[0] + e.interval[1]))) .find(|m| (m.z - 10.0).abs() < 1e-6) .unwrap(); match chamfer_sides(&t, &[rim], 1.0, ChamferSide::Distance(2.0), false) { diff --git a/crates/kernel/src/fair.rs b/crates/kernel/src/fair.rs index e009123e5..592693acb 100644 --- a/crates/kernel/src/fair.rs +++ b/crates/kernel/src/fair.rs @@ -1379,6 +1379,7 @@ mod tests { let vertices: Vec<[f64; 3]> = corners.iter().map(|&(i, j)| net[j * cu + i]).collect(); let edges = (0..4) .map(|k| PartEdge { + nurbs: None, curve: b::Curve::Line { start: vertices[k], end: vertices[(k + 1) % 4] }, interval: [0.0, 1.0], vertices: [k as u32, ((k + 1) % 4) as u32], diff --git a/crates/kernel/src/fill.rs b/crates/kernel/src/fill.rs index 999ef263b..57cebd6f5 100644 --- a/crates/kernel/src/fill.rs +++ b/crates/kernel/src/fill.rs @@ -709,7 +709,7 @@ fn patch_body(body: &Body, record: &b::Brep, chain: &[(usize, bool)], surface: b })?), Pcurves::Computed => None, }; - edges.push(PartEdge { curve: edge.parameters().clone(), interval: edge.interval, vertices: ends }); + edges.push(PartEdge { curve: edge.curve.clone(), nurbs: edge.nurbs.clone(), interval: edge.interval, vertices: ends }); uses.push(PartUse { edge: k as u32, forward, given }); } if !ccw { @@ -797,9 +797,9 @@ fn quilt_body(body: &Body, record: &b::Brep, chain: &[(usize, bool)], fill: &Iso }; } let id = index(edges.len())?; - // The curve the interval and the pcurve's parameter are on: a conic's - // NURBS form. - edges.push(PartEdge { curve: edge.parameters().clone(), interval: [lo, hi], vertices: ends }); + // The edge itself: the interval and the pcurve's parameter are on its + // NURBS form (a conic's), which it keeps. + edges.push(PartEdge { curve: edge.curve.clone(), nurbs: edge.nurbs.clone(), interval: [lo, hi], vertices: ends }); origin.push(Some(e)); piece_of.insert(key, id); id @@ -827,7 +827,7 @@ fn quilt_body(body: &Body, record: &b::Brep, chain: &[(usize, bool)], fill: &Iso b::Curve::Spline { knots: curve.knots.clone(), points: curve.points.iter().map(|p| [p.x, p.y, p.z]).collect() } } }; - edges.push(PartEdge { curve: spline, interval: [0.0, 1.0], vertices: [start, end] }); + edges.push(PartEdge { curve: spline, nurbs: None, interval: [0.0, 1.0], vertices: [start, end] }); origin.push(None); spoke_of.insert(spoke, id); id @@ -976,11 +976,14 @@ mod tests { worst } - /// Whether every edge of `made` is one of `of`'s own (the same curve record on the same - /// interval). + /// Whether every edge of `made` is one of `of`'s own: the same kind of curve, on the same + /// curve record it is parameterised on (its NURBS form where it has one), on the same + /// interval. (A circle's or ellipse's frame is SMLib's again after a round trip, its axes + /// renormalised to the last bit.) fn own_edges(made: &Body, of: &Body) -> bool { let own = record(of).edges; - record(made).edges.iter().all(|e| own.iter().any(|o| o.curve == e.curve && o.interval == e.interval)) + let kind = |e: &b::Edge| std::mem::discriminant(&e.curve); + record(made).edges.iter().all(|e| own.iter().any(|o| kind(o) == kind(e) && o.parameters() == e.parameters() && o.interval == e.interval)) } /// The fill's mesh: every normal finite, and no triangle folded over (all face the same way @@ -1109,9 +1112,10 @@ mod tests { let mut edges = Vec::new(); for k in 0..n { let c = &top[k]; - edges.push(PartEdge { curve: c.clone(), interval: interval(c), vertices: [k as u32, ((k + 1) % n) as u32] }); - edges.push(PartEdge { curve: moved(c), interval: interval(c), vertices: [(n + k) as u32, (n + (k + 1) % n) as u32] }); + edges.push(PartEdge { nurbs: None, curve: c.clone(), interval: interval(c), vertices: [k as u32, ((k + 1) % n) as u32] }); + edges.push(PartEdge { nurbs: None, curve: moved(c), interval: interval(c), vertices: [(n + k) as u32, (n + (k + 1) % n) as u32] }); edges.push(PartEdge { + nurbs: None, curve: b::Curve::Line { start: arr(corners[k]), end: arr(corners[k] + drop) }, interval: [0.0, 1.0], vertices: [k as u32, (n + k) as u32], diff --git a/crates/kernel/src/fill_general_tests.rs b/crates/kernel/src/fill_general_tests.rs index 4ca551e15..b0fa414f1 100644 --- a/crates/kernel/src/fill_general_tests.rs +++ b/crates/kernel/src/fill_general_tests.rs @@ -108,7 +108,7 @@ fn rim_points(body: &Body, per: usize) -> Vec { let r = body.record(); let mut out = Vec::new(); for e in r.edges.iter().filter(|e| e.uses.len() == 1) { - let c = CurveEval::new(&e.curve).unwrap(); + let c = CurveEval::new(e.parameters()).unwrap(); let [t0, t1] = e.interval; for k in 0..per { out.push(c.point(t0 + (t1 - t0) * (k as f64 + 0.5) / per as f64).unwrap()); @@ -238,7 +238,7 @@ fn free_edge_points(body: &Body) -> Vec { .edges .iter() .filter(|e| e.uses.len() == 1) - .map(|e| CurveEval::new(&e.curve).unwrap().point(0.5 * (e.interval[0] + e.interval[1])).unwrap()) + .map(|e| CurveEval::new(e.parameters()).unwrap().point(0.5 * (e.interval[0] + e.interval[1])).unwrap()) .collect::>(); // In a fixed order. points.sort_by(|a, b| (a.z, a.y, a.x).partial_cmp(&(b.z, b.y, b.x)).unwrap()); diff --git a/crates/kernel/src/sew.rs b/crates/kernel/src/sew.rs index 7a7a0199c..81a449426 100644 --- a/crates/kernel/src/sew.rs +++ b/crates/kernel/src/sew.rs @@ -286,7 +286,7 @@ impl Builder { } }; let id = u32::try_from(self.edges.len()).map_err(|_| KernelError::Invalid("sew: edge budget exceeded".into()))?; - self.edges.push(PartEdge { curve, interval, vertices: [va, vb] }); + self.edges.push(PartEdge { nurbs: None, curve, interval, vertices: [va, vb] }); self.by_key.insert((ka, fa, kb, fb, mid, sheet), id); Ok((id, true)) } @@ -1303,6 +1303,10 @@ pub(crate) struct PartUse { pub(crate) struct PartEdge { pub curve: b::Curve, + /// The NURBS form the edge is parameterised on, as a record edge keeps it + /// ([`b::Edge::nurbs`]): given, `interval` is on it and `curve` only says what the edge is, + /// so an edge taken from a record goes back as that same edge. + pub nurbs: Option, pub interval: [f64; 2], pub vertices: [u32; 2], } @@ -1366,8 +1370,8 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result { g }; // Each edge's label and NURBS form (`form::edge`): a circle about a revolved face's axis on - // that face's frame, so its form lies on the face's quarter grid; an edge the caller gave a - // pcurve for keeps the parameter that pcurve is on. + // that face's frame, so its form lies on the face's quarter grid; an edge given with its form + // keeps it, and an edge the caller gave a pcurve for keeps the parameter that pcurve is on. let mut frames_of: Vec> = vec![Vec::new(); edges.len()]; for f in &faces { let Some(frame) = b::form::frame_of(&f.surface) else { continue }; @@ -1380,6 +1384,13 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result { let mut labels: Vec<(b::Curve, [f64; 2])> = Vec::with_capacity(edges.len()); let mut forms: Vec> = Vec::with_capacity(edges.len()); for ((e, frames), given) in edges.iter().zip(&frames_of).zip(&given_on) { + if let Some(form) = &e.nurbs { + let on_label = + b::curve_interval(&e.curve, Some(form), e.interval).ok_or_else(|| fail("an edge's NURBS form does not evaluate".into()))?; + labels.push((e.curve.clone(), on_label)); + forms.push(Some((form.clone(), e.interval))); + continue; + } if *given { labels.push((e.curve.clone(), e.interval)); forms.push(None); diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rs index bc26f505b..c9bbd3214 100644 --- a/crates/kernel/src/smlib_sweeps.rs +++ b/crates/kernel/src/smlib_sweeps.rs @@ -531,6 +531,16 @@ mod imp { /// it when `translate`. SMLib's sweep follows a smooth path; at a corner (the direction /// jumping) the path is swept piece by piece ([`cornered`]). pub(crate) fn sweep(plane: &Plane, pieces: &[Piece], path: &[crate::PathSeg], translate: bool) -> Result { + if translate { + // Every segment's direction of travel, at its ends and between them. + let bad = || KernelError::Invalid("a path segment has no direction".into()); + let tangents = path + .iter() + .flat_map(|s| (0..=CROSSING_SAMPLES).map(move |i| seg_at(s, i as f64 / CROSSING_SAMPLES as f64).map(|(_, t)| t))) + .collect::>>() + .ok_or_else(bad)?; + crate::sweep_path::crossing_check(plane, &tangents)?; + } let runs = smooth_runs(path)?; if runs.len() > 1 { return cornered(plane, pieces, path, &runs, translate); @@ -823,6 +833,8 @@ mod imp { /// Fewest and most stations of a sweep that twists, scales or follows rails. const MIN_STATIONS: usize = 16; + /// Directions of travel read along each path segment for the parallel sweep's crossing check. + const CROSSING_SAMPLES: usize = 32; const MAX_STATIONS: usize = 2048; /// The profile `region` on `plane` swept along the smooth `path` the way `ctl` asks: twisted, diff --git a/crates/kernel/src/surfaces.rs b/crates/kernel/src/surfaces.rs index 89569711a..b8411cbc1 100644 --- a/crates/kernel/src/surfaces.rs +++ b/crates/kernel/src/surfaces.rs @@ -765,7 +765,12 @@ pub(crate) fn stitch_no_worse(bodies: &[&Body], tol: f64, exempt: &[u32]) -> Res /// ([`crate::offset_backend::thicken`]). pub fn thicken(body: &Body, thickness: f64, symmetric: bool) -> Result { body.require_brep("thicken")?; - imp::thicken(body, thickness, symmetric) + // SMLib holds a sheet's faces with both sides and thickens along their surfaces' natural + // normals; a sheet turned to its back (every face used against its natural normal) grows the + // other way. + let sides = face_sides(body.record()); + let turned = !sides.is_empty() && sides.iter().all(|forward| !forward); + imp::thicken(body, if turned { -thickness } else { thickness }, symmetric) } /// The faces `picked` of `body` (indices in its face order) offset one by one by SMLib, each onto diff --git a/crates/kernel/src/sweep_path.rs b/crates/kernel/src/sweep_path.rs index 49d1ef8e3..6729f6d6a 100644 --- a/crates/kernel/src/sweep_path.rs +++ b/crates/kernel/src/sweep_path.rs @@ -221,6 +221,21 @@ fn frames_toward(tangents: &[Vec3], d: Vec3) -> Result> { .collect() } +/// Kept as drawn (parallel), the profile flattens to nothing where the path runs along its +/// plane: the path, by its directions of travel `tangents` (the first leaving the profile), has to +/// cross the plane at 5 degrees or more all the way. +pub(crate) fn crossing_check(plane: &Plane, tangents: &[Vec3]) -> Result<()> { + let n = plane.normal().normalized().ok_or_else(|| KernelError::Invalid("sweep frame".into()))?; + let t0 = *tangents.first().ok_or_else(|| KernelError::Invalid("sweep path".into()))?; + let axis = if n.dot(t0) < 0.0 { n * -1.0 } else { n }; + if tangents.iter().any(|t| t.dot(axis) < 5f64.to_radians().sin()) { + return Err(KernelError::Invalid( + "kept parallel, the profile would lie along the sweep path: the path must keep crossing the profile's plane (by 5 deg or more)".into(), + )); + } + Ok(()) +} + /// Stations shaped by sweep options: each maps a world vector at the first station to its image /// at its own (twisted and scaled about the profile's normal through the first station, then /// turned by the orientation's frames), optionally stretched across a corner (mitre). Twist and @@ -246,12 +261,8 @@ pub(crate) fn controlled_stations( // Twist and scale act about the profile's normal, pointing the way the path leaves it. let n = plane.normal().normalized().ok_or_else(|| KernelError::Invalid("sweep frame".into()))?; let axis = if n.dot(t0) < 0.0 { n * -1.0 } else { n }; - // Kept as drawn, the profile flattens to nothing where the path runs along its plane: the - // path has to cross it at 5 degrees or more all the way. - if ctl.orientation == SweepOrientation::Parallel && tangents.iter().any(|t| t.dot(axis) < 5f64.to_radians().sin()) { - return Err(KernelError::Invalid( - "kept parallel, the profile would lie along the sweep path: the path must keep crossing the profile's plane (by 5 deg or more)".into(), - )); + if ctl.orientation == SweepOrientation::Parallel { + crossing_check(plane, tangents)?; } let mut run = Vec::with_capacity(pts.len()); let mut total = 0.0; @@ -457,8 +468,9 @@ mod tests { let want = std::f64::consts::PI * 4.0 * len; assert!((v - want).abs() < 0.02 * want, "{v} vs {want}"); // The path is its lines (no wall is fitted through the points): a wall per profile - // segment (the circle's two arcs) along each of the 40 lines, and two caps. - assert_eq!(b.faces(0.01).unwrap().len(), 2 * 40 + 2, "walls along each line"); + // segment (the circle is one closed arc, one edge in SMLib) along each of the 40 lines, + // and two caps. + assert_eq!(b.faces(0.01).unwrap().len(), 40 + 2, "walls along each line"); // An L-shaped path (a sharp corner) with a holed square: mitred ruled walls. let path = [Vec3::ZERO, Vec3::new(0.0, 0.0, 20.0), Vec3::new(20.0, 0.0, 20.0)]; let plane = Plane::from_normal(Vec3::ZERO, Vec3::Z).unwrap(); diff --git a/crates/kernel/src/tess/tests.rs b/crates/kernel/src/tess/tests.rs index 45f5163c2..07f35669e 100644 --- a/crates/kernel/src/tess/tests.rs +++ b/crates/kernel/src/tess/tests.rs @@ -784,11 +784,16 @@ fn a_face_bounded_by_two_short_arcs_keeps_an_area_to_mesh() { let sq = [[3000.0, 0.0, 0.0], [5000.0, 0.0, 0.0], [5000.0, 2000.0, 0.0], [3000.0, 2000.0, 0.0]]; let plane = Surface::Plane { origin: [0.0; 3], u_axis: [1.0, 0.0, 0.0], v_axis: [0.0, 1.0, 0.0] }; let mut edges = vec![ - PartEdge { curve: circle(-c), interval: [top, PI - top], vertices: [0, 1] }, - PartEdge { curve: circle(c), interval: [PI + top, TAU - top], vertices: [1, 0] }, + PartEdge { nurbs: None, curve: circle(-c), interval: [top, PI - top], vertices: [0, 1] }, + PartEdge { nurbs: None, curve: circle(c), interval: [PI + top, TAU - top], vertices: [1, 0] }, ]; for k in 0..4 { - edges.push(PartEdge { curve: line(sq[k], sq[(k + 1) % 4]), interval: [0.0, 1.0], vertices: [2 + k as u32, 2 + ((k + 1) % 4) as u32] }); + edges.push(PartEdge { + nurbs: None, + curve: line(sq[k], sq[(k + 1) % 4]), + interval: [0.0, 1.0], + vertices: [2 + k as u32, 2 + ((k + 1) % 4) as u32], + }); } let uses = |es: &[u32]| es.iter().map(|&edge| PartUse { edge, forward: true, given: None }).collect::>(); let mut vertices = vec![[half, 0.0, 0.0], [-half, 0.0, 0.0]]; diff --git a/crates/kernel/src/thin_face_tests.rs b/crates/kernel/src/thin_face_tests.rs index a365f25a2..cdbcb2269 100644 --- a/crates/kernel/src/thin_face_tests.rs +++ b/crates/kernel/src/thin_face_tests.rs @@ -61,11 +61,13 @@ fn a_face_touching_its_own_edge_meshes() { let (h, dip) = (0.3175, 2.8e-7); let vertices = vec![[0.0, 0.0, 0.0], [5.0, 0.0, 0.0], [5.0, h, 0.0], [0.0, h, 0.0]]; let line = |a: usize, b: usize| PartEdge { + nurbs: None, curve: Curve::Line { start: vertices[a], end: vertices[b] }, interval: [0.0, 1.0], vertices: [a as u32, b as u32], }; let arch = PartEdge { + nurbs: None, curve: Curve::Spline { knots: vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0], points: vec![[5.0, h, 0.0], [2.5, -h - 2.0 * dip, 0.0], [0.0, h, 0.0]] }, interval: [0.0, 1.0], vertices: [2, 3], diff --git a/crates/smlib/src/export.rs b/crates/smlib/src/export.rs index bded300ce..e81fefe01 100644 --- a/crates/smlib/src/export.rs +++ b/crates/smlib/src/export.rs @@ -531,11 +531,14 @@ fn curves(flat: View, n_edges: usize) -> Res<(Vec<(b::Curve, Option, [ } } CURVE_NURBS => { - let c = next_nurbs()?; + let c = next_nurbs()?.record(); // A NURBS edge stays the NURBS SMLib holds, its trims on its own parameter: SMLib // gives lines, circles and ellipses as their own kinds, and nothing is recognised here. + // SMLib's interval may start or end a rounding past its knots (a variable round's + // end trimmed by a cylinder, ladder 07-fillets/012: 7e-15 before the first knot). kept += 1; - (c.record(), None, r, Some([1.0, 0.0])) + let r = onto(r, c.natural()); + (c, None, r, Some([1.0, 0.0])) } other => return Err(unsupported(format!("SMLib curve kind {other}"))), }); @@ -626,8 +629,8 @@ fn mapped(trim: &b::Curve2, same: bool, [scale, offset]: [f64; 2], [t0, t1]: [f6 }) } -/// A domain side moved onto the natural range where it overshoots it by rounding (a sphere's -/// latitudes, a cone's apex). +/// A domain side or an edge's interval moved onto the natural range where it overshoots it by +/// rounding (a sphere's latitudes, a cone's apex, a NURBS edge's end knots). fn onto(r: [f64; 2], natural: b::Natural) -> [f64; 2] { match natural { b::Natural::Range(lo, hi) => { diff --git a/crates/smlib/src/export/tests.rs b/crates/smlib/src/export/tests.rs index 867543589..523d3a255 100644 --- a/crates/smlib/src/export/tests.rs +++ b/crates/smlib/src/export/tests.rs @@ -227,6 +227,49 @@ mod native_tests { assert!((got - want).abs() < 1e-6 * want, "volume {got} vs {want}"); } + /// The variable round r1 -> r5 along a box's top back edge run on into the R5 round of its + /// corner (ladder 07-fillets/012): its end trimmed by the R5 cylinder is a NURBS edge, whose + /// interval SMLib gave 7e-15 before the first knot. The record's interval is the NURBS's own + /// where it overshoots it by rounding, and the record validates; farther past it stays an error. + #[test] + fn a_nurbs_edge_interval_a_rounding_past_its_knots_is_moved_onto_them() { + let block = Brep::make_box([0.0; 3], [60.0, 40.0, 20.0]).unwrap(); + let rounded = block.fillet(&[[60.0, 40.0, 10.0]], 0.1, 5.0).unwrap(); + let r = rounded.fillet_variable([27.5, 40.0, 20.0], 0.1, [0.0, 40.0, 20.0], 1, &[0.0, 0.0, 1.0, 1.0], &[1.0, 5.0]).unwrap(); + let arrays = r.arrays().unwrap(); + let kinds = arrays.ints.get(&EDGE_CURVE_TYPE).cloned().unwrap_or_default(); + let counts = arrays.ints.get(&EDGE_NURBS_VERTEX_COUNT).cloned().unwrap_or_default(); + let orders = arrays.ints.get(&EDGE_NURBS_ORDER).cloned().unwrap_or_default(); + let forms = arrays.ints.get(&EDGE_NURBS_FORM).cloned().unwrap_or_default(); + let knots = arrays.reals.get(&EDGE_NURBS_KNOTS).cloned().unwrap_or_default(); + // Each NURBS block's first and last knots of its domain, in edge order. + let (mut at, mut block_of) = (0usize, Vec::new()); + for (n, o) in counts.iter().zip(&orders) { + let (n, o) = (*n as usize, *o as usize); + block_of.push((knots[at + o - 1], knots[at + n])); + at += n + o; + } + let mut nurbs = 0usize; + let mut edge = None; + for (e, kind) in kinds.iter().enumerate() { + let has_block = *kind == CURVE_NURBS || forms.get(e) == Some(&1); + if *kind == CURVE_NURBS && edge.is_none() { + edge = Some((e, block_of[nurbs])); + } + nurbs += usize::from(has_block); + } + let (e, (first, last)) = edge.expect("the round's end on the cylinder is a NURBS edge"); + let shifted = |by: f64| { + let mut a = arrays.clone(); + a.reals.get_mut(&EDGE_RANGE).unwrap()[2 * e] = first - by; + a + }; + let (record, _) = native(&shifted(7e-15)).unwrap(); + record.validate().unwrap(); + assert!(record.edges.iter().any(|x| x.interval[0] == first && x.interval[1] <= last), "an interval on the NURBS's first knot"); + assert!(native(&shifted(1e-3)).map(|(r, _)| r.validate()).map_or(true, |v| v.is_err()), "a real overshoot is not moved"); + } + #[test] fn hostile_arrays_are_errors_never_panics() { let good = Brep::make_box([0.0; 3], [1.0, 2.0, 3.0]).unwrap().arrays().unwrap();