diff --git a/crates/difftest/src/units/geom_context.rs b/crates/difftest/src/units/geom_context.rs new file mode 100644 index 0000000000..6d310e9db7 --- /dev/null +++ b/crates/difftest/src/units/geom_context.rs @@ -0,0 +1,558 @@ +//! Runner for unit `geom.context`: context marks and mark locks, the Boolean flag, +//! notify callbacks, the context model size estimate / zone tolerance and the +//! `SmTol` context overloads, `SmMassPropertyBehavior`, the `SM_API` context. +//! +//! C++: `solidcore_ffi::units::geom_context` (upstream `SmContext`, +//! `SmNewMarkAndLock`, `source/SMLib/{inc,src}/SmContext.*`). +//! Rust: `solidcore::geom::context`, `solidcore::geom::tol`. +//! +//! Every case is a script of [`Step`]s run on `contexts` (model size, ratio) with the +//! system tolerances set from `sys_model` / `sys_ratio` and `slots` mark-lock slots. +//! Output: `i` (integers: marks, locks, flags, mark types, context indices) and `f` +//! (floats: model sizes, ratios, tolerances), each step's results followed by a +//! snapshot of every context, and a final snapshot after the live locks are dropped +//! in slot order. Every run uses at least [`MIN_GENERATED`] generated scripts. + +use serde::{Deserialize, Serialize}; +use serde_json::Value; + +use solidcore::geom::context::{ + self as ctxmod, Context, MarkLock, MarkType, MassPropertyBehavior, NotifyCallback, +}; +use solidcore::geom::tol::{self, SmallTopoType}; +use solidcore::{Kernel, KernelOptions}; +use solidcore_ffi::units::geom_context::{self as ffi, op, Item, Step}; + +use crate::case::CaseContext; +use crate::runner::default_cases; +use crate::{Case, HarnessError, Output, Rng, UnitDiff}; + +/// Generated scripts per run, whatever `--seeds` says (it can only raise this). +pub const MIN_GENERATED: usize = 2000; + +/// `geom.context` runner. +pub struct Runner; + +/// One script step as written in fixtures (absent fields are 0). +#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)] +#[serde(default)] +struct StepIn { + op: i64, + slot: i64, + ctx: i64, + ctx2: i64, + m: i64, + flag: i64, + x: [f64; 4], +} + +impl From for Step { + fn from(s: StepIn) -> Self { + Self { + op: s.op, + slot: s.slot, + ctx: s.ctx, + ctx2: s.ctx2, + m: s.m, + flag: s.flag, + x: s.x, + } + } +} + +fn default_size() -> f64 { + tol::USE_DEFAULT +} + +fn default_contexts() -> Vec<[f64; 2]> { + vec![[tol::USE_DEFAULT, tol::USE_DEFAULT]] +} + +fn default_slots() -> usize { + 4 +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Inputs { + #[serde(default = "default_size")] + sys_model: f64, + #[serde(default = "default_size")] + sys_ratio: f64, + #[serde(default = "default_contexts")] + contexts: Vec<[f64; 2]>, + #[serde(default = "default_slots")] + slots: usize, + #[serde(default)] + steps: Vec, +} + +impl Inputs { + fn steps(&self) -> Vec { + self.steps.iter().map(|&s| Step::from(s)).collect() + } +} + +fn output(items: &[Item]) -> Output { + let mut ints = Vec::new(); + let mut floats = Vec::new(); + for it in items { + match *it { + Item::Int(v) => ints.push(v), + Item::Float(v) => floats.push(v), + } + } + Output::new().ints("i", ints).values("f", floats) +} + +fn harness(e: impl std::fmt::Display) -> HarnessError { + HarnessError::new(e.to_string()) +} + +// ---- C++ side ---------------------------------------------------------------------- + +fn cpp(i: &Inputs) -> Result { + let contexts: Vec<(f64, f64)> = i.contexts.iter().map(|c| (c[0], c[1])).collect(); + let items = + ffi::script(i.sys_model, i.sys_ratio, &contexts, i.slots, &i.steps()).map_err(harness)?; + Ok(output(&items)) +} + +// ---- Rust side --------------------------------------------------------------------- + +/// The kernel `SmTol::SetModelSizeEstimate(model)` + +/// `SmTol::SetLargeSmallSizeRatio(ratio)` would leave behind. +fn kernel(model: f64, ratio: f64) -> Kernel { + let model = if model == tol::USE_DEFAULT { + tol::MODEL_SIZE_ESTIMATE + } else { + model + }; + let ratio = if ratio == tol::USE_DEFAULT { + tol::LARGE_SMALL_SIZE_RATIO + } else { + ratio + }; + let zone = tol::size_estimate_to_zone_tol_3d(model); + let mut o = KernelOptions::default(); + o.tolerances.model_size_estimate = model; + o.tolerances.zone_tol_3d = zone; + o.tolerances.xsect_tol_3d = zone * 2.0; + o.tolerances.approx_tol_3d = zone / 2.0; + o.tolerances.large_small_size_ratio = ratio; + Kernel::new(&o) +} + +/// The callback object installed by `CALLBACK` steps. +#[derive(Debug)] +struct Notify; + +impl NotifyCallback for Notify {} + +const MARKS: [MarkType; 7] = [ + MarkType::NoMark, + MarkType::Mark, + MarkType::Mark2, + MarkType::Mark3, + MarkType::MarkIo, + MarkType::MarkAssert, + MarkType::AllMarks, +]; + +struct Sim { + k: Kernel, + ctxs: Vec, + slots: Vec>, + out: Vec, + api: Option, +} + +fn idx(v: i64) -> Result { + usize::try_from(v).map_err(|_| harness(format!("index {v}"))) +} + +fn mark(v: i64) -> Result { + i32::try_from(v) + .ok() + .and_then(MarkType::from_code) + .ok_or_else(|| harness(format!("mark type {v}"))) +} + +impl Sim { + fn int(&mut self, v: i64) { + self.out.push(Item::Int(v)); + } + + fn float(&mut self, v: f64) { + self.out.push(Item::Float(v)); + } + + fn ctx(&mut self, i: i64) -> Result<&mut Context, HarnessError> { + let i = idx(i)?; + self.ctxs.get_mut(i).ok_or_else(|| harness("context index")) + } + + fn opt_ctx(&self, i: i64) -> Option<&Context> { + usize::try_from(i).ok().and_then(|i| self.ctxs.get(i)) + } + + fn slot(&mut self, s: i64) -> Result<&mut Option, HarnessError> { + let s = idx(s)?; + self.slots.get_mut(s).ok_or_else(|| harness("slot index")) + } + + /// `delete slot`: runs the lock's destructor. + fn drop_slot(&mut self, s: i64) -> Result<(), HarnessError> { + if let Some(mut l) = self.slot(s)?.take() { + l.release(&mut self.ctxs).map_err(harness)?; + } + Ok(()) + } + + fn snapshot(&mut self) { + let mut v = Vec::new(); + for c in &self.ctxs { + for m in MARKS { + v.push(Item::Int(c.current_mark(m) as i64)); + v.push(Item::Int(i64::from(c.is_mark_locked(m)))); + } + v.push(Item::Int(i64::from(c.doing_boolean()))); + v.push(Item::Int(i64::from(c.sys_notify_callback().is_some()))); + v.push(Item::Int(i64::from(c.user_notify_callback().is_some()))); + v.push(Item::Float(c.stored_model_size_estimate())); + v.push(Item::Float(c.stored_large_small_size_ratio())); + v.push(Item::Float(c.this_zone_tol_3d())); + } + self.out.extend(v); + } + + fn step(&mut self, s: &Step) -> Result<(), HarnessError> { + let x = s.x; + match s.op { + op::CUR_MARK => { + let m = mark(s.m)?; + let v = self.ctx(s.ctx)?.current_mark(m); + self.int(v as i64); + } + op::IS_LOCKED => { + let m = mark(s.m)?; + let v = self.ctx(s.ctx)?.is_mark_locked(m); + self.int(i64::from(v)); + } + op::LOCK_NEW => { + self.drop_slot(s.slot)?; + let l = MarkLock::new(&mut self.ctxs, idx(s.ctx)?, s.m as i32).map_err(harness)?; + *self.slot(s.slot)? = Some(l); + self.int(i64::from(l.mark_type().code())); + } + op::LOCK_PAIR => { + self.drop_slot(s.slot)?; + let l = MarkLock::new_pair(&mut self.ctxs, idx(s.ctx)?, idx(s.ctx2)?) + .map_err(harness)?; + *self.slot(s.slot)? = Some(l); + self.int(i64::from(l.mark_type1().code())); + self.int(i64::from(l.mark_type2().code())); + } + op::LOCK_DEFAULT => { + self.drop_slot(s.slot)?; + *self.slot(s.slot)? = Some(MarkLock::default()); + } + op::LOCK_NEWMARK => match *self.slot(s.slot)? { + Some(l) if l.context().is_some() => { + l.new_mark(&mut self.ctxs).map_err(harness)?; + self.int(1); + } + _ => self.int(-1), + }, + op::LOCK_SETCTX | op::LOCK_SETCTX_PAIR => { + let mut l = self.slot(s.slot)?.unwrap_or_else(MarkLock::unbound); + let m = if s.op == op::LOCK_SETCTX { + l.set_context(&mut self.ctxs, idx(s.ctx)?, s.m as i32) + } else { + l.set_context_pair(&mut self.ctxs, idx(s.ctx)?, idx(s.ctx2)?) + } + .map_err(harness)?; + *self.slot(s.slot)? = Some(l); + self.int(i64::from(m.code())); + } + op::LOCK_DROP => self.drop_slot(s.slot)?, + op::LOCK_INFO => match *self.slot(s.slot)? { + None => self.int(-2), + Some(l) => { + let ix = |c: Option| c.map_or(-1, |c| c as i64); + self.int(i64::from(l.mark_type().code())); + self.int(i64::from(l.mark_type1().code())); + self.int(i64::from(l.mark_type2().code())); + self.int(ix(l.context())); + self.int(ix(l.context2())); + } + }, + op::DOING_BOOL => { + let c = self.ctx(s.ctx)?; + if s.flag != 0 { + *c.doing_boolean_mut() = s.m != 0; + } else { + c.set_doing_boolean(s.m != 0); + } + let v = c.doing_boolean(); + self.int(i64::from(v)); + } + op::GET_MODEL => { + let c = self.opt_ctx(s.ctx).ok_or_else(|| harness("context index"))?; + let a = c.this_model_size_estimate(&self.k); + let b = tol::context_model_size_estimate(&self.k, c); + self.float(a); + self.float(b); + } + op::SET_MODEL => { + let c = self.ctx(s.ctx)?; + let z = if s.flag != 0 { + tol::set_context_model_size_estimate(c, x[0]) + } else { + c.set_this_model_size_estimate(x[0]) + }; + self.float(z); + } + op::SET_RATIO => self.ctx(s.ctx)?.set_this_large_small_size_ratio(x[0]), + op::TOL_CTX => { + let small = i32::try_from(s.m) + .ok() + .and_then(SmallTopoType::from_code) + .ok_or_else(|| harness("small topology type"))?; + let c = self.opt_ctx(s.ctx); + let k = &self.k; + let v = [ + tol::context_zone_tol_3d(k, c, small), + tol::context_approx_tol_3d(k, c, small), + tol::context_xsect_tol_3d(k, c, small), + tol::calc_face_zone_tol_3d(k, c), + ]; + for f in v { + self.float(f); + } + } + op::CALC_EDGE | op::CALC_VERTEX => { + let c = self.opt_ctx(s.ctx); + let k = &self.k; + let max = (s.flag != 0).then(|| tol::zone_tol3d(k, x[2])); + let v = if s.op == op::CALC_EDGE { + tol::calc_edge_zone_tol_3d(k, x[0], x[1], max, c) + } else { + tol::calc_vertex_zone_tol_3d(k, x[0], x[1], max, c) + }; + self.float(v); + } + op::CALLBACK => { + let c = self.ctx(s.ctx)?; + let cb: Option> = if s.m != 0 { + Some(Box::new(Notify)) + } else { + None + }; + if s.flag != 0 { + c.set_user_notify_callback(cb); + } else { + c.set_sys_notify_callback(cb); + } + let a = c.sys_notify_callback().is_some(); + let b = c.user_notify_callback().is_some(); + self.int(i64::from(a)); + self.int(i64::from(b)); + } + op::MASS => { + let r = if s.slot != 0 { + MassPropertyBehavior::default() + } else { + MassPropertyBehavior::new(x[0], x[1], x[2], x[3], s.m as u64, s.flag as u64) + }; + self.float(r.density); + self.float(r.face_thickness); + self.float(r.edge_cross_section_radius); + self.float(r.vertex_sphere_radius); + self.int(r.face_area_behavior as i64); + self.int(r.face_volume_behavior as i64); + } + op::API => { + ctxmod::create_context(&mut self.api); + let p: *const Context = ctxmod::get_or_create_context(&mut self.api); + let q: *const Context = ctxmod::get_or_create_context(&mut self.api); + self.int(1); + self.int(i64::from(std::ptr::eq(p, q))); + } + other => return Err(harness(format!("op {other}"))), + } + Ok(()) + } +} + +fn rust(i: &Inputs) -> Result { + let steps = i.steps(); + // reject what the C++ wrapper rejects, so both sides fail alike + ffi::validate(i.contexts.len(), i.slots, &steps).map_err(harness)?; + let mut sim = Sim { + k: kernel(i.sys_model, i.sys_ratio), + ctxs: i.contexts.iter().map(|c| Context::new(c[0], c[1])).collect(), + slots: vec![None; i.slots], + out: Vec::new(), + api: None, + }; + for s in &steps { + sim.step(s)?; + sim.snapshot(); + } + for s in 0..i.slots { + sim.drop_slot(s as i64)?; + } + sim.snapshot(); + Ok(output(&sim.out)) +} + +// ---- generation -------------------------------------------------------------------- + +/// A model size estimate or ratio: the default sentinel, table boundaries, or +/// log-uniform values over many decades (sometimes negative). +fn size(rng: &mut Rng) -> f64 { + const EDGES: [f64; 9] = [0.00005, 0.005, 0.5, 500.0, 50000.0, 5e6, 50.0, 1000.0, 1.0]; + let r = rng.unit(); + if r < 0.35 { + tol::USE_DEFAULT + } else if r < 0.6 { + rng.choose(&EDGES).copied().unwrap_or(50.0) + } else { + let v = 10f64.powf(rng.uniform(-6.0, 8.0)); + if rng.chance(0.1) { + -v + } else { + v + } + } +} + +fn gen_step(rng: &mut Rng, n_ctx: i64, n_slots: i64) -> StepIn { + const WEIGHTS: [(i64, u64); 20] = [ + (op::CUR_MARK, 3), + (op::IS_LOCKED, 2), + (op::LOCK_NEW, 8), + (op::LOCK_PAIR, 4), + (op::LOCK_DEFAULT, 1), + (op::LOCK_NEWMARK, 4), + (op::LOCK_SETCTX, 3), + (op::LOCK_SETCTX_PAIR, 2), + (op::LOCK_DROP, 6), + (op::LOCK_INFO, 2), + (op::DOING_BOOL, 2), + (op::GET_MODEL, 2), + (op::SET_MODEL, 2), + (op::SET_RATIO, 1), + (op::TOL_CTX, 2), + (op::CALC_EDGE, 1), + (op::CALC_VERTEX, 1), + (op::CALLBACK, 1), + (op::MASS, 1), + (op::API, 1), + ]; + let total: u64 = WEIGHTS.iter().map(|w| w.1).sum(); + let mut r = rng.below(total); + let mut code = op::CUR_MARK; + for (c, w) in WEIGHTS { + if r < w { + code = c; + break; + } + r -= w; + } + let mut s = StepIn { + op: code, + slot: rng.range_i64(0, n_slots - 1), + ctx: rng.range_i64(0, n_ctx - 1), + ctx2: rng.range_i64(0, n_ctx - 1), + ..StepIn::default() + }; + let mark_type = |rng: &mut Rng| rng.choose(&ffi::MARK_TYPES).copied().unwrap_or(0); + match code { + op::CUR_MARK | op::IS_LOCKED | op::LOCK_SETCTX => s.m = mark_type(rng), + op::LOCK_NEW => { + s.m = if rng.chance(0.6) { + ctxmod::ALL_MARKS.into() + } else if rng.chance(0.1) { + rng.range_i64(-40, 100) + } else { + rng.range_i64(0, 31) + } + } + op::DOING_BOOL | op::CALLBACK => { + s.m = rng.range_i64(0, 1); + s.flag = rng.range_i64(0, 1); + } + op::SET_MODEL => { + s.flag = rng.range_i64(0, 1); + s.x[0] = size(rng); + } + op::SET_RATIO => s.x[0] = size(rng), + op::TOL_CTX | op::CALC_EDGE | op::CALC_VERTEX => { + if rng.chance(0.25) { + s.ctx = -1; + } + s.m = rng.range_i64(0, 4); + s.flag = rng.range_i64(0, 1); + s.x = [ + rng.uniform(0.0, 1e-3), + rng.uniform(0.0, 1e-3), + rng.uniform(-1e-4, 1e-3), + 0.0, + ]; + } + op::MASS => { + s.slot = i64::from(rng.chance(0.2)); + s.m = rng.range_i64(0, 2); + s.flag = rng.range_i64(0, 1); + s.x = [ + rng.uniform(0.0, 10.0), + rng.uniform(0.0, 1.0), + rng.uniform(0.0, 1.0), + rng.uniform(0.0, 1.0), + ]; + } + _ => {} + } + s +} + +impl UnitDiff for Runner { + fn id(&self) -> &'static str { + "geom.context" + } + + fn cases(&self, ctx: &CaseContext) -> Result, HarnessError> { + let ctx = CaseContext { + seeds: ctx.seeds.max(MIN_GENERATED), + ..ctx.clone() + }; + default_cases(self, &ctx) + } + + fn run_cpp(&self, case: &Case) -> Result { + cpp(&case.parse()?) + } + + fn run_rust(&self, case: &Case) -> Result { + rust(&case.parse()?) + } + + fn generate(&self, rng: &mut Rng) -> Option { + let n_ctx = rng.range_i64(1, 3); + let n_slots = rng.range_i64(1, 6); + let n_steps = rng.range_i64(1, 40); + let contexts = (0..n_ctx).map(|_| [size(rng), size(rng)]).collect(); + let steps = (0..n_steps) + .map(|_| gen_step(rng, n_ctx, n_slots)) + .collect(); + serde_json::to_value(Inputs { + sys_model: size(rng), + sys_ratio: size(rng), + contexts, + slots: n_slots as usize, + steps, + }) + .ok() + } +} diff --git a/crates/difftest/src/units/geom_tol.rs b/crates/difftest/src/units/geom_tol.rs index 4e0a97a4f2..a3fcbfabc8 100644 --- a/crates/difftest/src/units/geom_tol.rs +++ b/crates/difftest/src/units/geom_tol.rs @@ -269,18 +269,20 @@ fn rust_values(op: Op, i: &Inputs) -> Result>, Harnes Ok(match op { Op::SizeEstimate => v1(tol::size_estimate_to_zone_tol_3d(a(0))), Op::InTol => v1(flag(tol::in_tol(a(0), tol::tol3d(a(1))))), - Op::CalcFaceZone => v1(tol::calc_face_zone_tol_3d(&k)), + Op::CalcFaceZone => v1(tol::calc_face_zone_tol_3d(&k, None)), Op::CalcEdgeZone => v1(tol::calc_edge_zone_tol_3d( &k, a(0), a(1), i.flag.then(|| tol::zone_tol3d(&k, a(2))), + None, )), Op::CalcVertexZone => v1(tol::calc_vertex_zone_tol_3d( &k, a(0), a(1), i.flag.then(|| tol::zone_tol3d(&k, a(2))), + None, )), Op::EffZeros => Ok(vec![ tol::eff_zero(), @@ -313,11 +315,11 @@ fn rust_values(op: Op, i: &Inputs) -> Result>, Harnes ))), Op::GapGain => v1(tol::gap_gain(&k)), Op::ZoneSys => v1(tol::zone_tol_3d(&k, small)), - Op::ZoneCtx => v1(tol::context_zone_tol_3d(&k, small)), + Op::ZoneCtx => v1(tol::context_zone_tol_3d(&k, None, small)), Op::ApproxSys => v1(tol::approx_tol_3d(&k, small)), - Op::ApproxCtx => v1(tol::context_approx_tol_3d(&k, small)), + Op::ApproxCtx => v1(tol::context_approx_tol_3d(&k, None, small)), Op::XSectSys => v1(tol::xsect_tol_3d(&k, small)), - Op::XSectCtx => v1(tol::context_xsect_tol_3d(&k, small)), + Op::XSectCtx => v1(tol::context_xsect_tol_3d(&k, None, small)), Op::ScaledZeroSys => Ok(vec![ tol::scaled_zero(), tol::scaled_zero_sq(), diff --git a/crates/solidcore-ffi/src/units/geom_context.rs b/crates/solidcore-ffi/src/units/geom_context.rs new file mode 100644 index 0000000000..50042da0df --- /dev/null +++ b/crates/solidcore-ffi/src/units/geom_context.rs @@ -0,0 +1,208 @@ +//! FFI wrappers for unit `geom.context`. +//! +//! Shim: `harness/cpp/shim/geom_context.cpp`. +//! Upstream: `source/SMLib/inc/SmContext.h`, `source/SMLib/src/SmContext.cpp` +//! (`SmContext`, `SmNewMarkAndLock`), the `SmContext` overloads of `SmTol`, +//! `SmMassPropertyBehavior` (`SmTopoTypes.h`) and `SmApiCreateContext` / +//! `SmApiGetOrCreateContext` (`SmApiGeneral.cpp`). +//! +//! | Rust | shim | upstream | +//! |------------|--------------------------|--------------------------------------------| +//! | [`script`] | `sc_geom_context_script` | a script of `SmContext` / `SmNewMarkAndLock` calls | + +use crate::{call_with_buffer, FfiError}; + +mod sys { + extern "C" { + pub fn sc_geom_context_script( + sys_model: f64, + sys_ratio: f64, + ctx_params: *const f64, + n_ctx: i64, + ops: *const i64, + xs: *const f64, + n_ops: i64, + n_slots: i64, + out: *mut i64, + cap: i64, + out_len: *mut i64, + ) -> i32; + } +} + +/// Script operation codes (field use in brackets; see the shim for details). +pub mod op { + /// `GetCurrentMark(m)` [ctx, m]. + pub const CUR_MARK: i64 = 0; + /// `IsMarkLocked(m)` [ctx, m]. + pub const IS_LOCKED: i64 = 1; + /// `slot = new SmNewMarkAndLock(ctx, mask m)` [slot, ctx, m]. + pub const LOCK_NEW: i64 = 2; + /// `slot = new SmNewMarkAndLock(ctx, ctx2)` [slot, ctx, ctx2]. + pub const LOCK_PAIR: i64 = 3; + /// `slot = new SmNewMarkAndLock()` [slot]. + pub const LOCK_DEFAULT: i64 = 4; + /// `slot->NewMark()` when bound [slot]. + pub const LOCK_NEWMARK: i64 = 5; + /// `slot->SetContext(ctx, m)` [slot, ctx, m]. + pub const LOCK_SETCTX: i64 = 6; + /// `slot->SetContext(ctx, ctx2)` [slot, ctx, ctx2]. + pub const LOCK_SETCTX_PAIR: i64 = 7; + /// `delete slot` [slot]. + pub const LOCK_DROP: i64 = 8; + /// `GetMarkType*`, `GetContext*` [slot]. + pub const LOCK_INFO: i64 = 9; + /// `SetDoingBoolean(m)` or `GetDoingBooleanRef() = m` [ctx, m, flag]. + pub const DOING_BOOL: i64 = 10; + /// `GetThisModelSizeEstimate()`, `SmTol::GetModelSizeEstimate(ctx)` [ctx]. + pub const GET_MODEL: i64 = 11; + /// `SetThisModelSizeEstimate(x0)` or `SmTol::SetModelSizeEstimate(ctx, x0)` [ctx, flag]. + pub const SET_MODEL: i64 = 12; + /// `SetThisLargeSmallSizeRatio(x0)` [ctx]. + pub const SET_RATIO: i64 = 13; + /// `SmTol::GetZoneTol3d/GetApproxTol3d/GetXSectTol3d(ctx, m)`, `CalcFaceZoneTol3d(ctx)` [ctx|-1, m]. + pub const TOL_CTX: i64 = 14; + /// `SmTol::CalcEdgeZoneTol3d(x0, x1, flag ? &x2 : NULL, ctx)` [ctx|-1, flag]. + pub const CALC_EDGE: i64 = 15; + /// `SmTol::CalcVertexZoneTol3d(x0, x1, flag ? &x2 : NULL, ctx)` [ctx|-1, flag]. + pub const CALC_VERTEX: i64 = 16; + /// `SetSysNotifyCallback` (flag 0) / `SetUserNotifyCallback` (flag 1), non-null if m [ctx, m, flag]. + pub const CALLBACK: i64 = 17; + /// `SmMassPropertyBehavior(x0..x3, m, flag)`, or the default one if slot != 0. + pub const MASS: i64 = 18; + /// `SmApiCreateContext(); SmApiGetOrCreateContext()`. + pub const API: i64 = 19; + /// One past the last code. + pub const COUNT: i64 = 20; +} + +/// The `SmMarkType` values. +pub const MARK_TYPES: [i64; 7] = [0, 1, 2, 4, 8, 16, 31]; + +/// Maximum number of contexts in a script. +pub const MAX_CONTEXTS: usize = 8; +/// Maximum number of lock slots in a script. +pub const MAX_SLOTS: usize = 16; + +/// One script operation. +#[derive(Debug, Clone, Copy, Default, PartialEq)] +pub struct Step { + /// Operation code ([`op`]). + pub op: i64, + /// Lock slot (or the "default" switch of [`op::MASS`]). + pub slot: i64, + /// Context index (`-1` = null where allowed). + pub ctx: i64, + /// Second context index. + pub ctx2: i64, + /// Mark type / mask / small-topology type / boolean / count operand. + pub m: i64, + /// Variant switch. + pub flag: i64, + /// Float operands. + pub x: [f64; 4], +} + +/// One output item. +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum Item { + /// An integer result. + Int(i64), + /// A floating-point result. + Float(f64), +} + +/// Checks a script the way the shim does (anything it would reject or crash on). +pub fn validate(n_ctx: usize, n_slots: usize, steps: &[Step]) -> Result<(), FfiError> { + let bad = |m: &str| Err(FfiError::InvalidArgument(m.into())); + if !(1..=MAX_CONTEXTS).contains(&n_ctx) { + return bad("context count"); + } + if n_slots > MAX_SLOTS { + return bad("slot count"); + } + let n_ctx = n_ctx as i64; + let n_slots = n_slots as i64; + for s in steps { + let o = s.op; + if !(0..op::COUNT).contains(&o) { + return bad("op code"); + } + let need_slot = (op::LOCK_NEW..=op::LOCK_INFO).contains(&o); + let null_ok = matches!(o, op::TOL_CTX | op::CALC_EDGE | op::CALC_VERTEX); + let no_ctx = matches!( + o, + op::LOCK_DEFAULT | op::LOCK_NEWMARK | op::LOCK_DROP | op::LOCK_INFO | op::MASS | op::API + ); + if need_slot && !(0..n_slots).contains(&s.slot) { + return bad("slot index"); + } + let ctx_ok = (0..n_ctx).contains(&s.ctx) || (null_ok && s.ctx == -1); + if !no_ctx && !ctx_ok { + return bad("context index"); + } + if matches!(o, op::LOCK_PAIR | op::LOCK_SETCTX_PAIR) && !(0..n_ctx).contains(&s.ctx2) { + return bad("second context index"); + } + if matches!(o, op::CUR_MARK | op::IS_LOCKED | op::LOCK_SETCTX) && !MARK_TYPES.contains(&s.m) + { + return bad("mark type"); + } + if o == op::DOING_BOOL && !(0..=1).contains(&s.m) { + return bad("boolean"); + } + if o == op::TOL_CTX && !(0..=4).contains(&s.m) { + return bad("small topology type"); + } + if o == op::MASS && (s.m < 0 || s.flag < 0) { + return bad("behavior"); + } + } + Ok(()) +} + +/// Runs `steps` in upstream C++ on `contexts` (model size, ratio) with the system +/// tolerances set from (`sys_model`, `sys_ratio`) and reset afterwards. Returns per +/// step its results and a snapshot of every context, then a final snapshot after the +/// live locks are destroyed in slot order. +pub fn script( + sys_model: f64, + sys_ratio: f64, + contexts: &[(f64, f64)], + n_slots: usize, + steps: &[Step], +) -> Result, FfiError> { + validate(contexts.len(), n_slots, steps)?; + let params: Vec = contexts.iter().flat_map(|&(a, b)| [a, b]).collect(); + let ops: Vec = steps + .iter() + .flat_map(|s| [s.op, s.slot, s.ctx, s.ctx2, s.m, s.flag]) + .collect(); + let xs: Vec = steps.iter().flat_map(|s| s.x).collect(); + let raw = call_with_buffer(1024, |buf: &mut [i64], len| { + // SAFETY: params/ops/xs hold 2*n_ctx, 6*n_ops and 4*n_ops values; the script + // was validated above; buf is valid for buf.len() writes and len for one. + unsafe { + sys::sc_geom_context_script( + sys_model, + sys_ratio, + params.as_ptr(), + contexts.len() as i64, + ops.as_ptr(), + xs.as_ptr(), + steps.len() as i64, + n_slots as i64, + buf.as_mut_ptr(), + buf.len() as i64, + &raw mut *len, + ) + } + })?; + raw.chunks(2) + .map(|c| match c { + [0, v] => Ok(Item::Int(*v)), + [1, v] => Ok(Item::Float(f64::from_bits(*v as u64))), + _ => Err(FfiError::InvalidArgument("malformed shim output".into())), + }) + .collect() +} diff --git a/crates/solidcore/src/geom.rs b/crates/solidcore/src/geom.rs index 6731f1244d..4b21b9d022 100644 --- a/crates/solidcore/src/geom.rs +++ b/crates/solidcore/src/geom.rs @@ -6,6 +6,7 @@ //! `SmPseudoBox`, `SmTol`, `SmTransform`, `SmMatrix` and related `geom.*` units of //! `plan/modules.toml`. +pub mod context; pub mod extent3d; pub mod tol; pub mod vector2d; diff --git a/crates/solidcore/src/geom/context.rs b/crates/solidcore/src/geom/context.rs new file mode 100644 index 0000000000..3f92a0ae12 --- /dev/null +++ b/crates/solidcore/src/geom/context.rs @@ -0,0 +1,814 @@ +//! Per-session modeling context (`SmContext`): traversal marks and their locks, the +//! "doing a Boolean" flag, notify callbacks and the context's own model size estimate +//! and zone tolerance; plus the mark-locking helper `SmNewMarkAndLock`, the +//! `SmMassPropertyBehavior` options and the `SM_API` context accessors. +//! +//! Upstream: `source/SMLib/inc/SmContext.h`, `source/SMLib/src/SmContext.cpp`, +//! `source/SMLib/inc/SmTopoTypes.h` (`SmMassPropertyBehavior`), +//! `source/SM_API/src/SmApiGeneral.cpp` (`SmApiCreateContext`, `SmApiGetOrCreateContext`). +//! +//! | Rust | Upstream | +//! |-------------------------------------------|-------------------------------------------------| +//! | [`Context`] | `SmContext` | +//! | [`Context::new`], [`Context::default`] | `SmContext::SmContext(double, double)` (no `SM_USE_GLOBAL_CACHE`) | +//! | [`Context::doing_boolean`] | `SmContext::GetDoingBoolean` | +//! | [`Context::doing_boolean_mut`] | `SmContext::GetDoingBooleanRef` | +//! | [`Context::set_doing_boolean`] | `SmContext::SetDoingBoolean` | +//! | [`Context::user_notify_callback`] | `SmContext::GetUserNotifyCallback` | +//! | [`Context::set_user_notify_callback`] | `SmContext::SetUserNotifyCallback` (unused upstream) | +//! | [`Context::sys_notify_callback`] | `SmContext::GetSysNotifyCallback` | +//! | [`Context::set_sys_notify_callback`] | `SmContext::SetSysNotifyCallback` | +//! | [`Context::this_model_size_estimate`] | `SmContext::GetThisModelSizeEstimate` | +//! | [`Context::set_this_model_size_estimate`] | `SmContext::SetThisModelSizeEstimate` (inline, `SM_USE_OLDTOL` build) | +//! | [`Context::set_this_large_small_size_ratio`] | `SmContext::SetThisLargeSmallSizeRatio` | +//! | [`Context::this_zone_tol_3d`] | `SmContext::m_sThisZoneTol3d` (`GetThisZoneTol3d`, unused upstream) | +//! | [`Context::stored_model_size_estimate`], [`Context::stored_large_small_size_ratio`] | the raw members `m_dThisModelSizeEstimate`, `m_dThisLargeSmallSizeRatio` | +//! | [`Context::current_mark`] | `SmContext::GetCurrentMark` | +//! | [`Context::is_mark_locked`] | `SmContext::IsMarkLocked` | +//! | `Context::new_mark` (private) | `SmContext::NewMark` (private, friend `SmNewMarkAndLock`) | +//! | [`MarkType`] | `SmMarkType` | +//! | [`MarkLock`] | `SmNewMarkAndLock` | +//! | [`MarkLock::new`] | `SmNewMarkAndLock(const SmContext*, SmBitArray)` | +//! | [`MarkLock::new_pair`] | `SmNewMarkAndLock(SmContext*, SmContext*)` | +//! | [`MarkLock::unbound`], [`MarkLock::default`] | `SmNewMarkAndLock()` | +//! | [`MarkLock::release`] | `SmNewMarkAndLock::~SmNewMarkAndLock` | +//! | [`MarkLock::mark_type`], [`MarkLock::mark_type1`], [`MarkLock::mark_type2`] | `GetMarkType`, `GetMarkType1`, `GetMarkType2` | +//! | [`MarkLock::context`] | `SmNewMarkAndLock::GetContext` | +//! | [`MarkLock::new_mark`] | `SmNewMarkAndLock::NewMark` | +//! | [`MarkLock::set_context`] | `SmNewMarkAndLock::SetContext(SmContext*, SmMarkType)` | +//! | [`MarkLock::set_context_pair`] | `SmNewMarkAndLock::SetContext(SmContext*, SmContext*)` | +//! | `lock_mark`, `unlock_mark` (private) | `SmNewMarkAndLock::LockMark`, `UnlockMark` | +//! | `unlocked_mark` (private) | `SmNewMarkAndLock::GetUnlockedMark` | +//! | [`with_mark_lock`] | the scoped `{ SmNewMarkAndLock sMarkLock(pContext, mask); ... }` idiom | +//! | [`MassPropertyBehavior`] | `SmMassPropertyBehavior` (and its constructor) | +//! | [`create_context`] | `SmApiCreateContext` | +//! | [`get_or_create_context`] | `SmApiGetOrCreateContext` | +//! +//! Deviations: +//! - `SmNewMarkAndLock` holds `SmContext*` pointers and unlocks in its destructor. +//! [`MarkLock`] instead stores the *indices* of its contexts in a caller-owned slice +//! `&mut [Context]` (index equality plays pointer equality) and every method that +//! touches a context takes that slice; the destructor is the explicit +//! [`MarkLock::release`]. [`with_mark_lock`] gives the scoped form for a +//! [`Kernel`]'s own context. A method that upstream would run through a null +//! context pointer (a crash) returns [`SolidError::InvalidInput`], as does an index +//! outside the slice. +//! - The upstream two-context constructor locks the *first* context's mark type in the +//! second context and increments the first context's mark twice; this is ported +//! as is (see `plan/findings.md`). +//! - `SM_ASSERT*`, `SM_ASSERT_MSG_BREAK` and `SM_DBG_WARN` only print messages in the +//! release build and are not ported. `SmBoolean` flags are `bool`; `ULONG` marks are +//! `u64` incremented with wrapping arithmetic, as in C. +//! - Notify callbacks are boxed [`NotifyCallback`] trait objects owned by the context +//! (upstream stores borrowed raw pointers). `Execute` is added to the trait by the +//! unit that ports `SmObject::Notify`. +//! - `SmApiGeneral.cpp` keeps one process-global `SmContext*`; the port takes the slot +//! (`&mut Option`) from the caller. +//! - The attribute-callback list, global user data (`void*`), `operator new/delete`, +//! `Dump`, `GetTypeString` and `IsLockedMark` are unused upstream and not ported. + +use crate::error::{Result, SolidError}; +use crate::geom::tol; +use crate::kernel::Kernel; + +/// Which traversal mark of a context to use (`SmMarkType`). The discriminants are the +/// upstream bit values. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(i32)] +pub enum MarkType { + /// `SM_MT_NOMARK`: no mark (also the unset value of a [`MarkLock`]). + NoMark = 0, + /// `SM_MT_MARK`: the general mark. + Mark = 1, + /// `SM_MT_MARK2`: the second general mark. + Mark2 = 2, + /// `SM_MT_MARK3`: the third general mark. + Mark3 = 4, + /// `SM_MT_MARKIO`: the mark used by draw / IO methods. + MarkIo = 8, + /// `SM_MT_MARKASSERT`: the mark used by validity checks. + MarkAssert = 16, + /// `SM_MT_ALLMARKS`: all marks; as a single mark it behaves like an unknown + /// value (the `default:` branches upstream). + AllMarks = 31, +} + +impl MarkType { + /// The upstream enum value (also the bit of the mark in a mark mask). + #[must_use] + pub const fn code(self) -> i32 { + self as i32 + } + + /// The mark type with upstream value `code`, if any. + #[must_use] + pub const fn from_code(code: i32) -> Option { + match code { + 0 => Some(Self::NoMark), + 1 => Some(Self::Mark), + 2 => Some(Self::Mark2), + 4 => Some(Self::Mark3), + 8 => Some(Self::MarkIo), + 16 => Some(Self::MarkAssert), + 31 => Some(Self::AllMarks), + _ => None, + } + } + + /// Index of the mark's counter and lock in a [`Context`]; `None` for + /// [`MarkType::NoMark`] and [`MarkType::AllMarks`]. + const fn slot(self) -> Option { + match self { + Self::Mark => Some(0), + Self::Mark2 => Some(1), + Self::Mark3 => Some(2), + Self::MarkIo => Some(3), + Self::MarkAssert => Some(4), + Self::NoMark | Self::AllMarks => None, + } + } +} + +/// Mark mask selecting every mark (`SM_MT_ALLMARKS`). +pub const ALL_MARKS: i32 = MarkType::AllMarks as i32; + +/// Index of `SM_MT_MARKIO` in the mark arrays (the `default:` mark upstream). +const MARK_IO: usize = 3; + +/// Receiver of topology-change notifications (`SmNotifyCallback`). +/// +/// The notification method (`SmNotifyCallback::Execute`) is added by the unit that +/// ports `SmObject::Notify`. +pub trait NotifyCallback: std::fmt::Debug + Send {} + +/// Shared modeling state (`SmContext`): traversal marks, the Boolean flag, notify +/// callbacks and the context's model size estimate and zone tolerance. +#[derive(Debug)] +pub struct Context { + /// `m_lCurrentMark`, `m_lCurrentMark2`, `m_lCurrentMark3`, `m_lCurrentMarkIO`, + /// `m_lCurrentMarkAssert`. + current_marks: [u64; 5], + /// `m_bMarkLock`, `m_bMark2Lock`, `m_bMark3Lock`, `m_bMarkIOLock`, + /// `m_bMarkAssertLock`. + mark_locks: [bool; 5], + /// `m_bDoingBoolean`. + doing_boolean: bool, + /// `m_dThisModelSizeEstimate`. + model_size_estimate: f64, + /// `m_dThisLargeSmallSizeRatio`. + large_small_size_ratio: f64, + /// `m_sThisZoneTol3d`. + zone_tol_3d: f64, + /// `m_pUserNotifyCallback`. + user_notify_callback: Option>, + /// `m_pSysNotifyCallBack`. + sys_notify_callback: Option>, +} + +impl Default for Context { + /// `SmContext()`: both sizes [`tol::USE_DEFAULT`]. + fn default() -> Self { + Self::new(tol::USE_DEFAULT, tol::USE_DEFAULT) + } +} + +impl Context { + /// Creates a context (`SmContext::SmContext(double, double)`): every mark at 1 and + /// unlocked, not in a Boolean, no callbacks; the model size estimate and its zone + /// tolerance set by [`Context::set_this_model_size_estimate`]. Pass + /// [`tol::USE_DEFAULT`] for the system values. + #[must_use] + pub fn new(model_size_estimate: f64, large_small_size_ratio: f64) -> Self { + let mut c = Self { + current_marks: [1; 5], + mark_locks: [false; 5], + doing_boolean: false, + model_size_estimate: tol::USE_DEFAULT, + large_small_size_ratio: tol::USE_DEFAULT, + zone_tol_3d: tol::ZONE_TOL_3D, + user_notify_callback: None, + sys_notify_callback: None, + }; + c.large_small_size_ratio = large_small_size_ratio; + c.set_this_model_size_estimate(model_size_estimate); + c + } + + /// Whether a Boolean operation is running (`GetDoingBoolean`). + #[must_use] + pub const fn doing_boolean(&self) -> bool { + self.doing_boolean + } + + /// Mutable access to the Boolean flag (`GetDoingBooleanRef`). + pub fn doing_boolean_mut(&mut self) -> &mut bool { + &mut self.doing_boolean + } + + /// Sets the Boolean flag (`SetDoingBoolean`). + pub fn set_doing_boolean(&mut self, doing_boolean: bool) { + self.doing_boolean = doing_boolean; + } + + /// The application's notify callback (`GetUserNotifyCallback`). + #[must_use] + pub fn user_notify_callback(&self) -> Option<&dyn NotifyCallback> { + self.user_notify_callback.as_deref() + } + + /// Sets the application's notify callback (`SetUserNotifyCallback`). + pub fn set_user_notify_callback(&mut self, callback: Option>) { + self.user_notify_callback = callback; + } + + /// The system notify callback (`GetSysNotifyCallback`). + #[must_use] + pub fn sys_notify_callback(&self) -> Option<&dyn NotifyCallback> { + self.sys_notify_callback.as_deref() + } + + /// Sets the system notify callback (`SetSysNotifyCallback`; upstream only warns + /// in debug builds when one is already set). + pub fn set_sys_notify_callback(&mut self, callback: Option>) { + self.sys_notify_callback = callback; + } + + /// The context's model size estimate, or the system one when it is + /// [`tol::USE_DEFAULT`] (`GetThisModelSizeEstimate`). + #[must_use] + pub fn this_model_size_estimate(&self, k: &Kernel) -> f64 { + if self.model_size_estimate == tol::USE_DEFAULT { + tol::model_size_estimate(k) + } else { + self.model_size_estimate + } + } + + /// Stores a model size estimate and the zone tolerance it implies + /// ([`tol::size_estimate_to_zone_tol_3d`]); returns that zone tolerance + /// (`SetThisModelSizeEstimate`). + pub fn set_this_model_size_estimate(&mut self, model_size_estimate: f64) -> f64 { + self.model_size_estimate = model_size_estimate; + self.zone_tol_3d = tol::size_estimate_to_zone_tol_3d(self.model_size_estimate); + self.zone_tol_3d + } + + /// Stores the large/small size ratio (`SetThisLargeSmallSizeRatio`). + pub fn set_this_large_small_size_ratio(&mut self, large_small_size_ratio: f64) { + self.large_small_size_ratio = large_small_size_ratio; + } + + /// The stored model size estimate, possibly [`tol::USE_DEFAULT`] + /// (`m_dThisModelSizeEstimate`). + #[must_use] + pub const fn stored_model_size_estimate(&self) -> f64 { + self.model_size_estimate + } + + /// The stored large/small size ratio, possibly [`tol::USE_DEFAULT`] + /// (`m_dThisLargeSmallSizeRatio`). + #[must_use] + pub const fn stored_large_small_size_ratio(&self) -> f64 { + self.large_small_size_ratio + } + + /// The context's zone tolerance (`m_sThisZoneTol3d`). + #[must_use] + pub const fn this_zone_tol_3d(&self) -> f64 { + self.zone_tol_3d + } + + /// The current value of a mark (`GetCurrentMark`): an object is marked when its + /// mark equals this. [`MarkType::NoMark`] gives one more than the largest mark, so + /// nothing is marked; [`MarkType::AllMarks`] gives the IO mark. + #[must_use] + pub fn current_mark(&self, mark_type: MarkType) -> u64 { + match mark_type { + MarkType::NoMark => { + let [m1, m2, m3, mio, massert] = self.current_marks; + 1 + max5(m1, m2, m3, mio, massert) + } + _ => self + .current_marks + .get(mark_type.slot().unwrap_or(MARK_IO)) + .copied() + .unwrap_or(0), + } + } + + /// Advances a mark by two and returns the new value (`SmContext::NewMark`; the + /// lock check is a debug-only assertion upstream). [`MarkType::NoMark`] changes + /// nothing and returns [`Context::current_mark`] of it. + fn new_mark(&mut self, mark_type: MarkType) -> u64 { + if mark_type == MarkType::NoMark { + return self.current_mark(MarkType::NoMark); + } + match self + .current_marks + .get_mut(mark_type.slot().unwrap_or(MARK_IO)) + { + Some(m) => { + *m = m.wrapping_add(2); + *m + } + None => 0, + } + } + + /// Whether a mark is locked (`IsMarkLocked`); never for [`MarkType::NoMark`] or + /// [`MarkType::AllMarks`]. + #[must_use] + pub fn is_mark_locked(&self, mark_type: MarkType) -> bool { + mark_type + .slot() + .and_then(|s| self.mark_locks.get(s)) + .copied() + .unwrap_or(false) + } + + /// Sets a mark's lock flag (no-op for marks without a slot). + fn set_lock(&mut self, mark_type: MarkType, locked: bool) { + if let Some(l) = mark_type.slot().and_then(|s| self.mark_locks.get_mut(s)) { + *l = locked; + } + } +} + +/// `smos_5Max` = `smos_Max(smos_3Max(a, b, c), smos_Max(d, e))`. +fn max5(a: u64, b: u64, c: u64, d: u64, e: u64) -> u64 { + a.max(b).max(c).max(d.max(e)) +} + +/// `SmNewMarkAndLock::LockMark`. +fn lock_mark(ctx: &mut Context, mark_type: MarkType) { + ctx.set_lock(mark_type, true); +} + +/// `SmNewMarkAndLock::UnlockMark`. +fn unlock_mark(ctx: &mut Context, mark_type: MarkType) { + ctx.set_lock(mark_type, false); +} + +/// The first unlocked mark selected by `mask` in the order mark, mark2, mark3, IO, +/// assert; if all are locked, the mask itself when it names a single mark, else the IO +/// mark (`SmNewMarkAndLock::GetUnlockedMark`). +fn unlocked_mark(ctx: &Context, mask: i32) -> MarkType { + const ORDER: [MarkType; 5] = [ + MarkType::Mark, + MarkType::Mark2, + MarkType::Mark3, + MarkType::MarkIo, + MarkType::MarkAssert, + ]; + if let Some(m) = ORDER + .iter() + .find(|m| (mask & m.code()) != 0 && !ctx.is_mark_locked(**m)) + { + return *m; + } + ORDER + .iter() + .find(|m| mask == m.code()) + .copied() + .unwrap_or(MarkType::MarkIo) +} + +const OP_LOCK: &str = "geom::context::MarkLock"; + +/// The context at `index` in `contexts`. +fn ctx_at(contexts: &mut [Context], index: usize) -> Result<&mut Context> { + contexts.get_mut(index).ok_or(SolidError::InvalidInput { + operation: OP_LOCK, + reason: "context index out of range", + }) +} + +/// Fails when a bound context index is outside `contexts`. +fn check_index(contexts: &[Context], index: usize) -> Result<()> { + if index < contexts.len() { + Ok(()) + } else { + Err(SolidError::InvalidInput { + operation: OP_LOCK, + reason: "context index out of range", + }) + } +} + +/// A claimed traversal mark (`SmNewMarkAndLock`): advances an unlocked mark of one or +/// two contexts and locks it until [`MarkLock::release`]. +/// +/// Contexts are given as indices into a caller-owned `&mut [Context]` (see the module +/// deviations); pass the same slice to every method. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct MarkLock { + context1: Option, + context2: Option, + mark_type1: MarkType, + mark_type2: MarkType, +} + +impl Default for MarkLock { + fn default() -> Self { + Self::unbound() + } +} + +impl MarkLock { + /// A lock bound to no context (`SmNewMarkAndLock()`). + #[must_use] + pub const fn unbound() -> Self { + Self { + context1: None, + context2: None, + mark_type1: MarkType::NoMark, + mark_type2: MarkType::NoMark, + } + } + + /// Picks the first unlocked mark of `contexts[ctx]` allowed by `mask` (usually + /// [`ALL_MARKS`]), advances and locks it (`SmNewMarkAndLock(const SmContext*, + /// SmBitArray)`). + pub fn new(contexts: &mut [Context], ctx: usize, mask: i32) -> Result { + let c = ctx_at(contexts, ctx)?; + let mark_type1 = unlocked_mark(c, mask); + c.new_mark(mark_type1); + lock_mark(c, mark_type1); + Ok(Self { + context1: Some(ctx), + context2: None, + mark_type1, + mark_type2: MarkType::NoMark, + }) + } + + /// Claims a mark in each of two contexts, e.g. the two operands of a Boolean + /// (`SmNewMarkAndLock(SmContext*, SmContext*)`). When `ctx1 == ctx2` both marks + /// are the same. Otherwise, as upstream, the second mark type is picked from + /// `contexts[ctx2]` but the first mark is advanced again in `contexts[ctx1]` and + /// the *first* mark type is locked in `contexts[ctx2]`. + pub fn new_pair(contexts: &mut [Context], ctx1: usize, ctx2: usize) -> Result { + check_index(contexts, ctx2)?; + let c1 = ctx_at(contexts, ctx1)?; + let mark_type1 = unlocked_mark(c1, ALL_MARKS); + c1.new_mark(mark_type1); + lock_mark(c1, mark_type1); + let mark_type2 = if ctx1 == ctx2 { + mark_type1 + } else { + let m2 = unlocked_mark(ctx_at(contexts, ctx2)?, ALL_MARKS); + ctx_at(contexts, ctx1)?.new_mark(mark_type1); + lock_mark(ctx_at(contexts, ctx2)?, mark_type1); + m2 + }; + Ok(Self { + context1: Some(ctx1), + context2: Some(ctx2), + mark_type1, + mark_type2, + }) + } + + /// Unlocks the claimed marks that are still locked and unbinds the lock + /// (`~SmNewMarkAndLock`). + pub fn release(&mut self, contexts: &mut [Context]) -> Result<()> { + if let Some(i) = self.context1 { + let c = ctx_at(contexts, i)?; + if c.is_mark_locked(self.mark_type1) { + unlock_mark(c, self.mark_type1); + } + } + if let Some(i) = self.context2 { + let c = ctx_at(contexts, i)?; + if c.is_mark_locked(self.mark_type2) { + unlock_mark(c, self.mark_type2); + } + } + *self = Self::unbound(); + Ok(()) + } + + /// The (first) claimed mark (`GetMarkType`). + #[must_use] + pub const fn mark_type(&self) -> MarkType { + self.mark_type1 + } + + /// The mark claimed in the first context (`GetMarkType1`). + #[must_use] + pub const fn mark_type1(&self) -> MarkType { + self.mark_type1 + } + + /// The mark claimed in the second context (`GetMarkType2`). + #[must_use] + pub const fn mark_type2(&self) -> MarkType { + self.mark_type2 + } + + /// Index of the (first) bound context (`GetContext`). + #[must_use] + pub const fn context(&self) -> Option { + self.context1 + } + + /// Index of the second bound context, if any (`GetContext2`). + #[must_use] + pub const fn context2(&self) -> Option { + self.context2 + } + + /// Advances the claimed mark(s) while keeping them locked, invalidating every + /// mark set so far (`SmNewMarkAndLock::NewMark`). + pub fn new_mark(&self, contexts: &mut [Context]) -> Result<()> { + let i1 = self.context1.ok_or(SolidError::InvalidInput { + operation: "geom::context::MarkLock::new_mark", + reason: "no context bound", + })?; + ctx_at(contexts, i1)?.new_mark(self.mark_type1); + if let Some(i2) = self.context2 { + if i1 != i2 { + ctx_at(contexts, i2)?.new_mark(self.mark_type2); + } + } + Ok(()) + } + + /// Rebinds the first context: unlocks the old first mark, then claims and locks + /// (without advancing) the first unlocked mark of `contexts[ctx]` allowed by + /// `mask`; returns it (`SmNewMarkAndLock::SetContext(SmContext*, SmMarkType)`). + /// The second context binding is kept. + pub fn set_context( + &mut self, + contexts: &mut [Context], + ctx: usize, + mask: i32, + ) -> Result { + check_index(contexts, ctx)?; + if let Some(i) = self.context1 { + if self.mark_type1 != MarkType::NoMark { + unlock_mark(ctx_at(contexts, i)?, self.mark_type1); + } + } + self.context1 = Some(ctx); + let c = ctx_at(contexts, ctx)?; + self.mark_type1 = unlocked_mark(c, mask); + lock_mark(c, self.mark_type1); + Ok(self.mark_type1) + } + + /// Rebinds both contexts: unlocks the old marks, then claims and locks (without + /// advancing) the first unlocked mark of each new context; returns the first + /// (`SmNewMarkAndLock::SetContext(SmContext*, SmContext*)`). + pub fn set_context_pair( + &mut self, + contexts: &mut [Context], + ctx1: usize, + ctx2: usize, + ) -> Result { + check_index(contexts, ctx1)?; + check_index(contexts, ctx2)?; + if let Some(i) = self.context1 { + if self.mark_type1 != MarkType::NoMark { + unlock_mark(ctx_at(contexts, i)?, self.mark_type1); + } + } + if let Some(i2) = self.context2 { + if self.context1 != Some(i2) && self.mark_type2 != MarkType::NoMark { + unlock_mark(ctx_at(contexts, i2)?, self.mark_type2); + } + } + self.context1 = Some(ctx1); + self.context2 = Some(ctx2); + let c1 = ctx_at(contexts, ctx1)?; + self.mark_type1 = unlocked_mark(c1, ALL_MARKS); + lock_mark(c1, self.mark_type1); + if ctx1 == ctx2 { + self.mark_type2 = self.mark_type1; + } else { + let c2 = ctx_at(contexts, ctx2)?; + self.mark_type2 = unlocked_mark(c2, ALL_MARKS); + lock_mark(c2, self.mark_type2); + } + Ok(self.mark_type1) + } +} + +/// Runs `f` with a mark of the kernel's context claimed and locked, then releases it: +/// the scoped `{ SmNewMarkAndLock sMarkLock(pContext, mask); ... }` idiom. +pub fn with_mark_lock( + k: &mut Kernel, + mask: i32, + f: impl FnOnce(&mut Kernel, MarkType) -> R, +) -> Result { + let mut lock = MarkLock::new(std::slice::from_mut(&mut k.context), 0, mask)?; + let r = f(k, lock.mark_type()); + lock.release(std::slice::from_mut(&mut k.context))?; + Ok(r) +} + +/// How mass-property computations treat faces, edges and vertices +/// (`SmMassPropertyBehavior`). +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct MassPropertyBehavior { + /// Density of the material (`m_dDensity`, default 1). + pub density: f64, + /// Thickness given to faces (`m_dFaceThickness`, default 0). + pub face_thickness: f64, + /// Radius of the tube swept around edges (`m_dEdgeCrossSectionRadius`, default 0). + pub edge_cross_section_radius: f64, + /// Radius of the sphere around vertices (`m_dVertexSphereRadius`, default 0). + pub vertex_sphere_radius: f64, + /// Face area mode (`m_lFaceAreaBehavior`): 0 solid/void faces only, 1 every face + /// once, 2 every face twice. + pub face_area_behavior: u64, + /// Face volume mode (`m_lFaceVolumeBehavior`): 0 region volumes, 1 thin shells. + pub face_volume_behavior: u64, +} + +impl Default for MassPropertyBehavior { + fn default() -> Self { + Self::new(1.0, 0.0, 0.0, 0.0, 0, 0) + } +} + +impl MassPropertyBehavior { + /// Builds the options (`SmMassPropertyBehavior::SmMassPropertyBehavior`). + #[must_use] + pub const fn new( + density: f64, + face_thickness: f64, + edge_cross_section_radius: f64, + vertex_sphere_radius: f64, + face_area_behavior: u64, + face_volume_behavior: u64, + ) -> Self { + Self { + density, + face_thickness, + edge_cross_section_radius, + vertex_sphere_radius, + face_area_behavior, + face_volume_behavior, + } + } +} + +/// Creates the default context in `slot` unless one exists (`SmApiCreateContext`). +pub fn create_context(slot: &mut Option) { + if slot.is_none() { + *slot = Some(Context::default()); + } +} + +/// The context in `slot`, created with defaults first if empty +/// (`SmApiGetOrCreateContext`). +pub fn get_or_create_context(slot: &mut Option) -> &mut Context { + slot.get_or_insert_with(Context::default) +} + +#[cfg(test)] +mod tests { + use super::*; + + const ALL: [MarkType; 7] = [ + MarkType::NoMark, + MarkType::Mark, + MarkType::Mark2, + MarkType::Mark3, + MarkType::MarkIo, + MarkType::MarkAssert, + MarkType::AllMarks, + ]; + + #[test] + fn mark_type_codes_round_trip() { + for m in ALL { + assert_eq!(MarkType::from_code(m.code()), Some(m)); + } + assert_eq!(MarkType::from_code(3), None); + } + + #[test] + fn new_context_defaults() { + let k = Kernel::default(); + let c = Context::default(); + for m in ALL { + assert!(!c.is_mark_locked(m)); + } + assert_eq!(c.current_mark(MarkType::Mark), 1); + assert_eq!(c.current_mark(MarkType::NoMark), 2); + assert_eq!(c.current_mark(MarkType::AllMarks), 1); + assert!(!c.doing_boolean()); + assert_eq!(c.this_zone_tol_3d(), 1.0e-5); + assert_eq!(c.this_model_size_estimate(&k), 50.0); + assert!(c.user_notify_callback().is_none()); + assert!(c.sys_notify_callback().is_none()); + } + + #[test] + fn model_size_sets_zone_tol() { + let k = Kernel::default(); + let mut c = Context::new(1000.0, tol::USE_DEFAULT); + assert_eq!(c.this_zone_tol_3d(), 1.0e-4); + assert_eq!(c.this_model_size_estimate(&k), 1000.0); + assert_eq!(c.set_this_model_size_estimate(0.01), 1.0e-6); + assert_eq!(c.set_this_model_size_estimate(tol::USE_DEFAULT), 1.0e-5); + assert_eq!(c.this_model_size_estimate(&k), 50.0); + c.set_this_large_small_size_ratio(10.0); + *c.doing_boolean_mut() = true; + assert!(c.doing_boolean()); + } + + #[test] + fn single_lock_cycle() { + let mut cs = [Context::default()]; + let mut a = MarkLock::new(&mut cs, 0, ALL_MARKS).unwrap(); + assert_eq!(a.mark_type(), MarkType::Mark); + assert_eq!(cs[0].current_mark(MarkType::Mark), 3); + assert!(cs[0].is_mark_locked(MarkType::Mark)); + let mut b = MarkLock::new(&mut cs, 0, ALL_MARKS).unwrap(); + assert_eq!(b.mark_type(), MarkType::Mark2); + b.new_mark(&mut cs).unwrap(); + assert_eq!(cs[0].current_mark(MarkType::Mark2), 5); + b.release(&mut cs).unwrap(); + a.release(&mut cs).unwrap(); + assert!(!cs[0].is_mark_locked(MarkType::Mark)); + assert!(!cs[0].is_mark_locked(MarkType::Mark2)); + assert_eq!(cs[0].current_mark(MarkType::NoMark), 6); + assert!(MarkLock::unbound().new_mark(&mut cs).is_err()); + } + + #[test] + fn exhausted_marks_fall_back() { + let mut cs = [Context::default()]; + let locks: Vec = (0..5) + .map(|_| MarkLock::new(&mut cs, 0, ALL_MARKS).unwrap()) + .collect(); + assert_eq!(locks[4].mark_type(), MarkType::MarkAssert); + let x = MarkLock::new(&mut cs, 0, ALL_MARKS).unwrap(); + assert_eq!(x.mark_type(), MarkType::MarkIo); + let y = MarkLock::new(&mut cs, 0, MarkType::Mark3.code()).unwrap(); + assert_eq!(y.mark_type(), MarkType::Mark3); + } + + #[test] + fn pair_lock_upstream_quirk() { + let mut cs = [Context::default(), Context::default()]; + let _first = MarkLock::new(&mut cs, 1, ALL_MARKS).unwrap(); + let mut p = MarkLock::new_pair(&mut cs, 0, 1).unwrap(); + assert_eq!(p.mark_type1(), MarkType::Mark); + assert_eq!(p.mark_type2(), MarkType::Mark2); + // context 0's mark advanced twice; context 1 gets mark type 1 locked + assert_eq!(cs[0].current_mark(MarkType::Mark), 5); + assert!(cs[1].is_mark_locked(MarkType::Mark)); + assert!(!cs[1].is_mark_locked(MarkType::Mark2)); + p.release(&mut cs).unwrap(); + assert!(!cs[0].is_mark_locked(MarkType::Mark)); + assert!(cs[1].is_mark_locked(MarkType::Mark)); + let same = MarkLock::new_pair(&mut cs, 0, 0).unwrap(); + assert_eq!(same.mark_type2(), same.mark_type1()); + assert!(MarkLock::new_pair(&mut cs, 0, 2).is_err()); + } + + #[test] + fn set_context_rebinds() { + let mut cs = [Context::default(), Context::default()]; + let mut l = MarkLock::unbound(); + assert_eq!( + l.set_context(&mut cs, 1, ALL_MARKS).unwrap(), + MarkType::Mark + ); + assert_eq!(cs[1].current_mark(MarkType::Mark), 1); + assert_eq!(l.set_context_pair(&mut cs, 0, 1).unwrap(), MarkType::Mark); + assert!(cs[0].is_mark_locked(MarkType::Mark)); + assert!(cs[1].is_mark_locked(MarkType::Mark)); + l.release(&mut cs).unwrap(); + assert!(!cs[0].is_mark_locked(MarkType::Mark)); + assert!(!cs[1].is_mark_locked(MarkType::Mark)); + } + + #[test] + fn scoped_kernel_lock() { + let mut k = Kernel::default(); + let m = with_mark_lock(&mut k, ALL_MARKS, |k, m| { + assert!(k.context.is_mark_locked(m)); + m + }) + .unwrap(); + assert_eq!(m, MarkType::Mark); + assert!(!k.context.is_mark_locked(m)); + } + + #[test] + fn api_context_slot() { + let mut slot = None; + create_context(&mut slot); + get_or_create_context(&mut slot).set_doing_boolean(true); + create_context(&mut slot); + assert!(get_or_create_context(&mut slot).doing_boolean()); + let mp = MassPropertyBehavior::default(); + assert_eq!(mp.density, 1.0); + assert_eq!(mp.face_area_behavior, 0); + } +} diff --git a/crates/solidcore/src/geom/tol.rs b/crates/solidcore/src/geom/tol.rs index 5874164a28..9b2aa59c91 100644 --- a/crates/solidcore/src/geom/tol.rs +++ b/crates/solidcore/src/geom/tol.rs @@ -23,6 +23,8 @@ //! | [`xsect_tol_3d_from_zones`] | `SmTol::GetXSectTol3d(const SmZoneTol3d&, const SmZoneTol3d&)` | //! | [`ang_tol_rad`] | `SmTol::GetAngTolRad()` | //! | [`model_size_estimate`] | `SmTol::GetModelSizeEstimate()` | +//! | [`context_model_size_estimate`] | `SmTol::GetModelSizeEstimate(const SmContext&)` | +//! | [`set_context_model_size_estimate`] | `SmTol::SetModelSizeEstimate(SmContext&, double)` | //! | [`are_parallel`] | `SmTol::AreParallel` | //! | [`are_perpendicular`] | `SmTol::ArePerpendicular` | //! | [`is_zero_speed`] | `SmTol::IsZeroSpeed` | @@ -56,17 +58,15 @@ //! System state: upstream keeps the system tolerances in thread-local statics //! (`s_ZoneTol3d`, `s_TolGapGain`, `s_ModelSizeEstimate`, `s_LargeSmallSizeRatio`); //! here they are the [`Tolerances`] of the [`Kernel`] (`zone_tol_3d`, `tol_gap_gain`, -//! `model_size_estimate`, `large_small_size_ratio`). The kernel also plays the -//! `SmContext`, so the `const SmContext*` overloads are the `context_*` functions -//! with a null context (the context's own `m_sThisZoneTol3d` is the kernel's -//! `zone_tol_3d` as well). Note that the context overloads ignore the small-topology +//! `model_size_estimate`, `large_small_size_ratio`). The `const SmContext*` overloads +//! take an `Option<&`[`Context`]`>` (`None` = null pointer: the system value; usually +//! `Some(&k.context)`). Note that the context overloads ignore the small-topology //! flag, as upstream does. //! //! Not here yet (they need types of later units; see the `UNPORTED` markers below): //! every overload taking an `SmObject`, `SmCurve`, `SmSurface`, `SmVolume`, //! `SmPseudoBox`, `SmExtent1d`, `SmExtent2d`, `SmBrep`, `SmBrepData`, a topology -//! entity, a classification / interval object, `SmEvalNFunctionsObject`, or a -//! non-null `SmContext` with its own tolerances. +//! entity, a classification / interval object, or `SmEvalNFunctionsObject`. //! //! Deviations: //! - The tolerance classes (`SmTol3d`, `SmZoneTol3d`, ...) are plain `f64` values; their @@ -93,15 +93,12 @@ use std::collections::{BTreeMap, BTreeSet}; use crate::error::{Result, SolidError}; +use crate::geom::context::Context; use crate::geom::extent3d::Extent3d; use crate::geom::vector2d::Vec2; use crate::kernel::{Kernel, Tolerances}; use crate::math::{Vec3, EFF_ZERO, EFF_ZERO_PARAM, EFF_ZERO_RAD, EFF_ZERO_SQ, EFF_ZERO_SQRT, PI}; -// UNPORTED(geom.context): SmTol::GetModelSizeEstimate(const SmContext&), -// SmTol::SetModelSizeEstimate(SmContext&, double) and the non-null-context branch of -// SmTol::GetZoneTol3d(const SmContext*, ...) need a context with its own -// m_dThisModelSizeEstimate / m_sThisZoneTol3d (SmContext::SetThisModelSizeEstimate). // UNPORTED(topology.brep_p1): SmTol::GetModelSizeEstimate(const SmBrep&), // SmTol::SetModelSizeEstimate(SmBrep&, double), SmTol::GetZoneTol3d(const SmBrep*), // SmTol::GetApproxTol3d(const SmBrep*), SmTol::CalcFaceZoneTol3d(SmBrep*), @@ -361,6 +358,19 @@ pub fn model_size_estimate(k: &Kernel) -> f64 { k.tolerances.model_size_estimate } +/// A context's model size estimate, the system one if it has none +/// (`SmTol::GetModelSizeEstimate(const SmContext&)`). +#[must_use] +pub fn context_model_size_estimate(k: &Kernel, ctx: &Context) -> f64 { + ctx.this_model_size_estimate(k) +} + +/// Sets a context's model size estimate and returns its new zone tolerance +/// (`SmTol::SetModelSizeEstimate(SmContext&, double)`). +pub fn set_context_model_size_estimate(ctx: &mut Context, model_size_estimate: f64) -> f64 { + ctx.set_this_model_size_estimate(model_size_estimate) +} + /// The gap gain: the over-size factor that keeps an object's zone tolerance a little /// larger than half its largest gap (`SmTol::GetGapGain`). #[must_use] @@ -384,16 +394,16 @@ pub fn zone_tol_3d(k: &Kernel, small: SmallTopoType) -> f64 { } /// The context zone tolerance (`SmTol::GetZoneTol3d(const SmContext*, -/// SmSmallTopoType)` with a null context); `small` is ignored, as upstream. +/// SmSmallTopoType)`): the context's own zone tolerance, or the system one for `None` +/// (a null context); `small` is ignored, as upstream. #[must_use] -pub fn context_zone_tol_3d(k: &Kernel, small: SmallTopoType) -> f64 { +pub fn context_zone_tol_3d(k: &Kernel, ctx: Option<&Context>, small: SmallTopoType) -> f64 { let _ = small; let z = k.tolerances.zone_tol_3d; if z == UNINIT_TOL { zone_tol3d(k, UNINIT_TOL) } else { - // UNPORTED(geom.context): cpContext->m_sThisZoneTol3d for a non-null context. - z + ctx.map_or(z, Context::this_zone_tol_3d) } } @@ -405,10 +415,10 @@ pub fn approx_tol_3d(k: &Kernel, small: SmallTopoType) -> f64 { } /// The context approximation tolerance (`SmTol::GetApproxTol3d(const SmContext*, -/// SmSmallTopoType)` with a null context). +/// SmSmallTopoType)`; `None` = null context). #[must_use] -pub fn context_approx_tol_3d(k: &Kernel, small: SmallTopoType) -> f64 { - approx_tol3d(k, 0.5 * context_zone_tol_3d(k, small)) +pub fn context_approx_tol_3d(k: &Kernel, ctx: Option<&Context>, small: SmallTopoType) -> f64 { + approx_tol3d(k, 0.5 * context_zone_tol_3d(k, ctx, small)) } /// The system intersection tolerance, twice the zone tolerance @@ -419,10 +429,10 @@ pub fn xsect_tol_3d(k: &Kernel, small: SmallTopoType) -> f64 { } /// The context intersection tolerance (`SmTol::GetXSectTol3d(const SmContext*, -/// SmSmallTopoType)` with a null context). +/// SmSmallTopoType)`; `None` = null context). #[must_use] -pub fn context_xsect_tol_3d(k: &Kernel, small: SmallTopoType) -> f64 { - xsect_tol3d(k, 2.0 * context_zone_tol_3d(k, small)) +pub fn context_xsect_tol_3d(k: &Kernel, ctx: Option<&Context>, small: SmallTopoType) -> f64 { + xsect_tol3d(k, 2.0 * context_zone_tol_3d(k, ctx, small)) } /// The intersection tolerance of two objects with zone tolerances `zone1`, `zone2`: @@ -466,14 +476,15 @@ pub fn eff_zero_ang_rad() -> f64 { // ---- topology zone tolerances from gaps -------------------------------------------- /// A face's zone tolerance: the context zone tolerance -/// (`SmTol::CalcFaceZoneTol3d(const SmContext*)` with a null context). +/// (`SmTol::CalcFaceZoneTol3d(const SmContext*)`; `None` = null context). #[must_use] -pub fn calc_face_zone_tol_3d(k: &Kernel) -> f64 { - context_zone_tol_3d(k, SmallTopoType::NormalSize) +pub fn calc_face_zone_tol_3d(k: &Kernel, ctx: Option<&Context>) -> f64 { + context_zone_tol_3d(k, ctx, SmallTopoType::NormalSize) } /// An edge's zone tolerance from its largest edge/edge and edge/face gaps -/// (`SmTol::CalcEdgeZoneTol3d` with a null context): +/// (`SmTol::CalcEdgeZoneTol3d(double, double, SmZoneTol3d*, const SmContext*)`; +/// `None` = null context): /// `max(def, max_face_zone_tol?, gain * edge_edge_gap / 2, gain * edge_face_gap - def)` /// where `def` is the context zone tolerance and `gain` the [`gap_gain`]. #[must_use] @@ -482,12 +493,20 @@ pub fn calc_edge_zone_tol_3d( edge_edge_max_gap: f64, edge_face_max_gap: f64, max_face_zone_tol: Option, + ctx: Option<&Context>, ) -> f64 { - calc_gap_zone_tol(k, edge_edge_max_gap, edge_face_max_gap, max_face_zone_tol) + calc_gap_zone_tol( + k, + edge_edge_max_gap, + edge_face_max_gap, + max_face_zone_tol, + ctx, + ) } /// A vertex's zone tolerance from its largest vertex/edge and vertex/face gaps -/// (`SmTol::CalcVertexZoneTol3d` with a null context); same formula as +/// (`SmTol::CalcVertexZoneTol3d(double, double, SmZoneTol3d*, const SmContext*)`; +/// `None` = null context); same formula as /// [`calc_edge_zone_tol_3d`]. #[must_use] pub fn calc_vertex_zone_tol_3d( @@ -495,18 +514,26 @@ pub fn calc_vertex_zone_tol_3d( vertex_edge_max_gap: f64, vertex_face_max_gap: f64, max_edge_zone_tol: Option, + ctx: Option<&Context>, ) -> f64 { calc_gap_zone_tol( k, vertex_edge_max_gap, vertex_face_max_gap, max_edge_zone_tol, + ctx, ) } /// Shared body of `CalcEdgeZoneTol3d` / `CalcVertexZoneTol3d`. -fn calc_gap_zone_tol(k: &Kernel, gap_1d: f64, gap_2d: f64, max_up: Option) -> f64 { - let def = context_zone_tol_3d(k, SmallTopoType::NormalSize); +fn calc_gap_zone_tol( + k: &Kernel, + gap_1d: f64, + gap_2d: f64, + max_up: Option, + ctx: Option<&Context>, +) -> f64 { + let def = context_zone_tol_3d(k, ctx, SmallTopoType::NormalSize); let gain = gap_gain(k); let r = match max_up { Some(up) => smax4(def, up, gain * gap_1d / 2.0, gain * gap_2d - def), @@ -956,7 +983,7 @@ mod tests { assert_eq!(approx_tol_3d(&k, SmallTopoType::NormalSize), 5.0e-6); assert_eq!(zone_tol_3d(&k, SmallTopoType::SmallSize), 1000.0 * 1.0e-5); assert_eq!( - context_zone_tol_3d(&k, SmallTopoType::ForceSmallSize), + context_zone_tol_3d(&k, None, SmallTopoType::ForceSmallSize), 1.0e-5 ); assert_eq!(gap_gain(&k), 1.1); @@ -979,10 +1006,13 @@ mod tests { #[test] fn gap_zone_tolerances() { let k = Kernel::default(); - assert_eq!(calc_edge_zone_tol_3d(&k, 0.0, 0.0, None), 1.0e-5); - assert_eq!(calc_edge_zone_tol_3d(&k, 2.0, 0.0, None), 1.1); - assert_eq!(calc_vertex_zone_tol_3d(&k, 0.0, 0.0, Some(0.25)), 0.25); - assert_eq!(calc_face_zone_tol_3d(&k), 1.0e-5); + assert_eq!(calc_edge_zone_tol_3d(&k, 0.0, 0.0, None, None), 1.0e-5); + assert_eq!(calc_edge_zone_tol_3d(&k, 2.0, 0.0, None, None), 1.1); + assert_eq!( + calc_vertex_zone_tol_3d(&k, 0.0, 0.0, Some(0.25), None), + 0.25 + ); + assert_eq!(calc_face_zone_tol_3d(&k, None), 1.0e-5); } #[test] diff --git a/crates/solidcore/src/kernel.rs b/crates/solidcore/src/kernel.rs index 8986e855c7..0879c4c198 100644 --- a/crates/solidcore/src/kernel.rs +++ b/crates/solidcore/src/kernel.rs @@ -8,6 +8,7 @@ //! | Rust | Upstream | //! |----------------------------------------|-------------------------------------------| //! | [`Kernel`] | `SmContext` | +//! | [`Kernel::context`] | `SmContext` marks, flags and own tolerance (see [`crate::geom::context`]) | //! | [`Tolerances::zone_tol_3d`] | `SmContext::m_sThisZoneTol3d`, `SM_ZONE_TOL_3D` | //! | [`Tolerances::xsect_tol_3d`] | `SM_XSECT_TOL_3D` | //! | [`Tolerances::approx_tol_3d`] | `SM_APPROX_TOL_3D` | @@ -24,6 +25,8 @@ //! code must compare outcomes that are invariant to the draw (and say so in //! `plan/findings.md`). +use crate::geom::context::Context; + /// Geometric tolerances in model units (upstream defaults from `SmMath.h`). #[derive(Debug, Clone, Copy, PartialEq)] pub struct Tolerances { @@ -155,6 +158,9 @@ pub struct Kernel { pub rng: Rng, /// Memoisation caches. pub caches: Caches, + /// The session's modeling context (marks, Boolean flag, callbacks, its own + /// model size estimate); created with the defaults, as `SmApiGetOrCreateContext`. + pub context: Context, } impl Default for Kernel { @@ -171,6 +177,7 @@ impl Kernel { tolerances: options.tolerances, rng: Rng::new(options.seed), caches: Caches::default(), + context: Context::default(), } } } diff --git a/fixtures/geom.context/cases.json b/fixtures/geom.context/cases.json new file mode 100644 index 0000000000..59d91f1d87 --- /dev/null +++ b/fixtures/geom.context/cases.json @@ -0,0 +1,604 @@ +{ + "cases": [ + { + "name": "default_context", + "upstream_ref": "tests/prog_test/src/smFeatureTest.cpp:26 (SmContext sContext)", + "inputs": { + "steps": [ + { + "op": 0, + "ctx": 0, + "m": 0 + }, + { + "op": 0, + "ctx": 0, + "m": 1 + }, + { + "op": 0, + "ctx": 0, + "m": 2 + }, + { + "op": 0, + "ctx": 0, + "m": 4 + }, + { + "op": 0, + "ctx": 0, + "m": 8 + }, + { + "op": 0, + "ctx": 0, + "m": 16 + }, + { + "op": 0, + "ctx": 0, + "m": 31 + }, + { + "op": 1, + "ctx": 0, + "m": 0 + }, + { + "op": 1, + "ctx": 0, + "m": 1 + }, + { + "op": 1, + "ctx": 0, + "m": 2 + }, + { + "op": 1, + "ctx": 0, + "m": 4 + }, + { + "op": 1, + "ctx": 0, + "m": 8 + }, + { + "op": 1, + "ctx": 0, + "m": 16 + }, + { + "op": 1, + "ctx": 0, + "m": 31 + }, + { + "op": 11 + }, + { + "op": 14, + "m": 0 + }, + { + "op": 14, + "m": 2 + }, + { + "op": 14, + "ctx": -1, + "m": 0 + } + ] + } + }, + { + "name": "api_create_context", + "upstream_ref": "tests/SM_API_test/src/TestSmBrep.cpp:45 (SmApiCreateContext)", + "inputs": { + "steps": [ + { + "op": 19 + }, + { + "op": 19 + } + ] + } + }, + { + "name": "scoped_lock_all_marks", + "upstream_ref": "source/SMLib/src/SmAssembly.cpp:275 (SmNewMarkAndLock sMarkLock(GetContext(), SM_MT_ALLMARKS))", + "inputs": { + "steps": [ + { + "op": 2, + "slot": 0, + "m": 31 + }, + { + "op": 9, + "slot": 0 + }, + { + "op": 5, + "slot": 0 + }, + { + "op": 5, + "slot": 0 + }, + { + "op": 0, + "m": 1 + }, + { + "op": 8, + "slot": 0 + }, + { + "op": 1, + "m": 1 + } + ] + } + }, + { + "name": "nested_locks_exhaust", + "upstream_ref": "source/SMLib/inc/SmContext.h:496 (GetUnlockedMark: all marks locked -> SM_MT_MARKIO)", + "inputs": { + "slots": 8, + "steps": [ + { + "op": 2, + "slot": 0, + "m": 31 + }, + { + "op": 2, + "slot": 1, + "m": 31 + }, + { + "op": 2, + "slot": 2, + "m": 31 + }, + { + "op": 2, + "slot": 3, + "m": 31 + }, + { + "op": 2, + "slot": 4, + "m": 31 + }, + { + "op": 2, + "slot": 5, + "m": 31 + }, + { + "op": 2, + "slot": 6, + "m": 31 + }, + { + "op": 9, + "slot": 0 + }, + { + "op": 9, + "slot": 1 + }, + { + "op": 9, + "slot": 2 + }, + { + "op": 9, + "slot": 3 + }, + { + "op": 9, + "slot": 4 + }, + { + "op": 9, + "slot": 5 + }, + { + "op": 9, + "slot": 6 + }, + { + "op": 8, + "slot": 3 + }, + { + "op": 2, + "slot": 7, + "m": 31 + }, + { + "op": 9, + "slot": 7 + } + ] + } + }, + { + "name": "lock_single_mask_locked", + "upstream_ref": "source/SMLib/src/SmContext.cpp:516 (GetUnlockedMark returns the single-mark mask)", + "inputs": { + "steps": [ + { + "op": 2, + "slot": 0, + "m": 4 + }, + { + "op": 2, + "slot": 1, + "m": 4 + }, + { + "op": 9, + "slot": 1 + }, + { + "op": 2, + "slot": 2, + "m": 0 + }, + { + "op": 9, + "slot": 2 + }, + { + "op": 2, + "slot": 3, + "m": 3 + }, + { + "op": 9, + "slot": 3 + } + ] + } + }, + { + "name": "default_lock_set_context", + "upstream_ref": "source/SMLib/src/SmSphere.cpp:3600 (SmNewMarkAndLock sMarkLock; SetContext(GetContext()))", + "inputs": { + "steps": [ + { + "op": 4, + "slot": 0 + }, + { + "op": 9, + "slot": 0 + }, + { + "op": 5, + "slot": 0 + }, + { + "op": 6, + "slot": 0, + "m": 31 + }, + { + "op": 9, + "slot": 0 + }, + { + "op": 6, + "slot": 0, + "m": 2 + }, + { + "op": 9, + "slot": 0 + } + ] + } + }, + { + "name": "boolean_pair_same_context", + "upstream_ref": "source/SMLib/src/SmPrimitiveCreation.cpp:7745 (SmNewMarkAndLock(BrepA ctx, BrepB ctx))", + "inputs": { + "steps": [ + { + "op": 3, + "slot": 0, + "ctx": 0, + "ctx2": 0 + }, + { + "op": 9, + "slot": 0 + }, + { + "op": 5, + "slot": 0 + }, + { + "op": 10, + "m": 1 + }, + { + "op": 10, + "m": 0, + "flag": 1 + } + ] + } + }, + { + "name": "boolean_pair_two_contexts", + "upstream_ref": "source/SMLib/src/SmPrimitiveCreation.cpp:7745 (SmNewMarkAndLock with distinct contexts)", + "inputs": { + "contexts": [ + [ + 9876543.21, + 9876543.21 + ], + [ + 9876543.21, + 9876543.21 + ] + ], + "steps": [ + { + "op": 2, + "slot": 1, + "ctx": 1, + "m": 31 + }, + { + "op": 3, + "slot": 0, + "ctx": 0, + "ctx2": 1 + }, + { + "op": 9, + "slot": 0 + }, + { + "op": 5, + "slot": 0 + }, + { + "op": 8, + "slot": 0 + }, + { + "op": 7, + "slot": 2, + "ctx": 1, + "ctx2": 0 + }, + { + "op": 9, + "slot": 2 + } + ] + } + }, + { + "name": "set_context_pair_rebind", + "upstream_ref": "source/SMLib/inc/SmContext.h:600 (SmNewMarkAndLock::SetContext(ctx1, ctx2))", + "inputs": { + "contexts": [ + [ + 9876543.21, + 9876543.21 + ], + [ + 9876543.21, + 9876543.21 + ], + [ + 9876543.21, + 9876543.21 + ] + ], + "steps": [ + { + "op": 7, + "slot": 0, + "ctx": 0, + "ctx2": 1 + }, + { + "op": 7, + "slot": 0, + "ctx": 2, + "ctx2": 2 + }, + { + "op": 6, + "slot": 0, + "ctx": 1, + "m": 31 + }, + { + "op": 9, + "slot": 0 + }, + { + "op": 5, + "slot": 0 + } + ] + } + }, + { + "name": "model_size_1000", + "upstream_ref": "source/SMLib/src/SmContext.cpp:161 (SmContext(dThisModelSizeEstimate, dThisLargeSmallSizeRatio))", + "inputs": { + "contexts": [ + [ + 1000.0, + 50.0 + ], + [ + 0.01, + 9876543.21 + ] + ], + "steps": [ + { + "op": 11, + "ctx": 0 + }, + { + "op": 11, + "ctx": 1 + }, + { + "op": 14, + "ctx": 0, + "m": 1 + }, + { + "op": 14, + "ctx": 1, + "m": 3 + }, + { + "op": 15, + "ctx": 0, + "x": [ + 0.0002, + 0.0001, + 0.0003, + 0 + ], + "flag": 1 + }, + { + "op": 16, + "ctx": 1, + "x": [ + 2e-06, + 0, + 0, + 0 + ] + } + ] + } + }, + { + "name": "set_model_size", + "upstream_ref": "source/SMLib/src/SmTol.cpp:80 (SmTol::SetModelSizeEstimate(SmContext&, double))", + "inputs": { + "sys_model": 5000.0, + "steps": [ + { + "op": 11 + }, + { + "op": 12, + "x": [ + 0.001, + 0, + 0, + 0 + ] + }, + { + "op": 11 + }, + { + "op": 12, + "flag": 1, + "x": [ + 9876543.21, + 0, + 0, + 0 + ] + }, + { + "op": 11 + }, + { + "op": 13, + "x": [ + 10.0, + 0, + 0, + 0 + ] + }, + { + "op": 14, + "m": 4 + }, + { + "op": 14, + "ctx": -1, + "m": 2 + } + ] + } + }, + { + "name": "notify_callbacks", + "upstream_ref": "source/SMLib/inc/SmContext.h:372 (SetSysNotifyCallback / GetUserNotifyCallback)", + "inputs": { + "steps": [ + { + "op": 17, + "m": 1 + }, + { + "op": 17, + "m": 0 + }, + { + "op": 17, + "m": 1, + "flag": 1 + }, + { + "op": 17, + "m": 0, + "flag": 1 + } + ] + } + }, + { + "name": "mass_property_behavior", + "upstream_ref": "source/SMLib/inc/SmTopoTypes.h:280 (SmMassPropertyBehavior)", + "inputs": { + "steps": [ + { + "op": 18, + "slot": 1 + }, + { + "op": 18, + "x": [ + 7.8, + 0.1, + 0.2, + 0.3 + ], + "m": 2, + "flag": 1 + } + ] + } + } + ] +} \ No newline at end of file diff --git a/harness/cpp/shim/geom_context.cpp b/harness/cpp/shim/geom_context.cpp new file mode 100644 index 0000000000..f1426776f2 --- /dev/null +++ b/harness/cpp/shim/geom_context.cpp @@ -0,0 +1,328 @@ +// SPDX-License-Identifier: Apache-2.0 +// difftest shim for unit `geom.context`. Wraps upstream SmContext, SmNewMarkAndLock +// (source/SMLib/inc/SmContext.h, source/SMLib/src/SmContext.cpp), the SmContext +// overloads of SmTol (source/SMLib/src/SmTol.cpp), SmMassPropertyBehavior +// (source/SMLib/inc/SmTopoTypes.h) and SmApiCreateContext / SmApiGetOrCreateContext +// (source/SM_API/src/SmApiGeneral.cpp). +#include "sc_shim.h" +#include +#include +#include +#include + +#include +#include + +namespace +{ + +// Exposes SmContext's protected tolerance members and accessors. +struct ScCtx : public SmContext +{ + ScCtx(double dModel, double dRatio) : SmContext(dModel, dRatio) {} + using SmContext::GetThisModelSizeEstimate; + using SmContext::SetThisLargeSmallSizeRatio; + using SmContext::SetThisModelSizeEstimate; + double RawModel() const { return m_dThisModelSizeEstimate; } + double RawRatio() const { return m_dThisLargeSmallSizeRatio; } + double RawZone() const { return m_sThisZoneTol3d; } +}; + +// A concrete notify callback (only its address is observed). +struct ScNotify : public SmNotifyCallback +{ + SmStatus Execute(SmNotifyOperation, SmObject*, SmObject*, SmObject*, SmObject*) override + { + return 0; + } +}; + +// Sets the system tolerance statics, restoring the defaults on scope exit. +struct ScSystemTol +{ + ScSystemTol(double dModelSize, double dRatio) + { + SmTol::SetModelSizeEstimate(dModelSize); + SmTol::SetLargeSmallSizeRatio(dRatio); + } + ~ScSystemTol() + { + SmTol::SetModelSizeEstimate(SM_USE_DEFAULT); + SmTol::SetLargeSmallSizeRatio(SM_USE_DEFAULT); + } +}; + +enum +{ + OP_CUR_MARK = 0, + OP_IS_LOCKED = 1, + OP_LOCK_NEW = 2, + OP_LOCK_PAIR = 3, + OP_LOCK_DEFAULT = 4, + OP_LOCK_NEWMARK = 5, + OP_LOCK_SETCTX = 6, + OP_LOCK_SETCTX_PAIR = 7, + OP_LOCK_DROP = 8, + OP_LOCK_INFO = 9, + OP_DOING_BOOL = 10, + OP_GET_MODEL = 11, + OP_SET_MODEL = 12, + OP_SET_RATIO = 13, + OP_TOL_CTX = 14, + OP_CALC_EDGE = 15, + OP_CALC_VERTEX = 16, + OP_CALLBACK = 17, + OP_MASS = 18, + OP_API = 19, +}; + +const int64_t kMarkTypes[7] = {SM_MT_NOMARK, SM_MT_MARK, SM_MT_MARK2, SM_MT_MARK3, + SM_MT_MARKIO, SM_MT_MARKASSERT, SM_MT_ALLMARKS}; + +bool valid_mark(int64_t m) +{ + for (int64_t v : kMarkTypes) + if (v == m) + return true; + return false; +} + +int64_t f_bits(double d) +{ + int64_t i; + static_assert(sizeof(i) == sizeof(d), "f64 size"); + memcpy(&i, &d, sizeof(d)); + return i; +} + +} // namespace + +// Runs a script of SmContext / SmNewMarkAndLock operations. +// sys_model, sys_ratio : system SmTol::SetModelSizeEstimate / SetLargeSmallSizeRatio +// ctx_params[2*n_ctx] : (model size, ratio) of each SmContext constructed +// ops[6*n_ops] : per op (op, slot, ctx, ctx2, m, flag); ctx -1 = NULL where allowed +// xs[4*n_ops] : per op float operands +// n_slots : number of SmNewMarkAndLock slots +// Output: tagged (tag, payload) int64 pairs; tag 0 = integer, tag 1 = double bits. +// Per op: its results, then a snapshot of every context. At the end the live locks +// are destroyed in slot order and a final snapshot is written. +SC_EXPORT int32_t sc_geom_context_script(double sys_model, double sys_ratio, const double* ctx_params, + int64_t n_ctx, const int64_t* ops, const double* xs, + int64_t n_ops, int64_t n_slots, int64_t* out, int64_t cap, + int64_t* out_len) +{ + if (n_ctx < 1 || n_ctx > 8 || n_ops < 0 || n_slots < 0 || n_slots > 16) + return SC_ERR_ARG; + // validate everything before touching upstream + for (int64_t i = 0; i < n_ops; ++i) + { + const int64_t* o = ops + 6 * i; + int64_t op = o[0], s = o[1], c = o[2], c2 = o[3], m = o[4], fl = o[5]; + bool need_slot = op >= OP_LOCK_NEW && op <= OP_LOCK_INFO; + bool null_ok = op == OP_TOL_CTX || op == OP_CALC_EDGE || op == OP_CALC_VERTEX; + bool no_ctx = op == OP_LOCK_DEFAULT || op == OP_LOCK_NEWMARK || op == OP_LOCK_DROP || + op == OP_LOCK_INFO || op == OP_MASS || op == OP_API; + if (op < 0 || op > OP_API) + return SC_ERR_ARG; + if (need_slot && (s < 0 || s >= n_slots)) + return SC_ERR_ARG; + if (!no_ctx && !(c >= 0 && c < n_ctx) && !(null_ok && c == -1)) + return SC_ERR_ARG; + if ((op == OP_LOCK_PAIR || op == OP_LOCK_SETCTX_PAIR) && (c2 < 0 || c2 >= n_ctx)) + return SC_ERR_ARG; + if ((op == OP_CUR_MARK || op == OP_IS_LOCKED || op == OP_LOCK_SETCTX) && !valid_mark(m)) + return SC_ERR_ARG; + if (op == OP_DOING_BOOL && (m < 0 || m > 1)) + return SC_ERR_ARG; + if (op == OP_TOL_CTX && (m < 0 || m > 4)) + return SC_ERR_ARG; + if (op == OP_MASS && (m < 0 || fl < 0)) + return SC_ERR_ARG; + } + SC_TRY + ScSystemTol sSys(sys_model, sys_ratio); + static ScNotify s_Notify; + std::vector vCtx; + for (int64_t i = 0; i < n_ctx; ++i) + vCtx.push_back(new ScCtx(ctx_params[2 * i], ctx_params[2 * i + 1])); + std::vector vSlots((size_t)n_slots, nullptr); + std::vector res; + auto put_i = [&](int64_t v) { + res.push_back(0); + res.push_back(v); + }; + auto put_f = [&](double v) { + res.push_back(1); + res.push_back(f_bits(v)); + }; + auto ctx_index = [&](SmContext* p) -> int64_t { + for (int64_t i = 0; i < n_ctx; ++i) + if ((SmContext*)vCtx[(size_t)i] == p) + return i; + return -1; + }; + auto snapshot = [&]() { + for (ScCtx* p : vCtx) + { + for (int64_t m : kMarkTypes) + { + put_i((int64_t)p->GetCurrentMark((SmMarkType)m)); + put_i(p->IsMarkLocked((SmMarkType)m) ? 1 : 0); + } + put_i(p->GetDoingBoolean() ? 1 : 0); + put_i(p->GetSysNotifyCallback() ? 1 : 0); + put_i(p->GetUserNotifyCallback() ? 1 : 0); + put_f(p->RawModel()); + put_f(p->RawRatio()); + put_f(p->RawZone()); + } + }; + auto drop_slot = [&](int64_t s) { + delete vSlots[(size_t)s]; + vSlots[(size_t)s] = nullptr; + }; + for (int64_t i = 0; i < n_ops; ++i) + { + const int64_t* o = ops + 6 * i; + const double* x = xs + 4 * i; + int64_t op = o[0], s = o[1], fl = o[5]; + SmMarkType eM = (SmMarkType)o[4]; + ScCtx* pC = o[2] >= 0 && o[2] < n_ctx ? vCtx[(size_t)o[2]] : nullptr; + ScCtx* pC2 = o[3] >= 0 && o[3] < n_ctx ? vCtx[(size_t)o[3]] : nullptr; + switch (op) + { + case OP_CUR_MARK: put_i((int64_t)pC->GetCurrentMark(eM)); break; + case OP_IS_LOCKED: put_i(pC->IsMarkLocked(eM) ? 1 : 0); break; + case OP_LOCK_NEW: + drop_slot(s); + vSlots[(size_t)s] = new SmNewMarkAndLock(pC, (SmBitArray)o[4]); + put_i(vSlots[(size_t)s]->GetMarkType()); + break; + case OP_LOCK_PAIR: + drop_slot(s); + vSlots[(size_t)s] = new SmNewMarkAndLock((SmContext*)pC, (SmContext*)pC2); + put_i(vSlots[(size_t)s]->GetMarkType1()); + put_i(vSlots[(size_t)s]->GetMarkType2()); + break; + case OP_LOCK_DEFAULT: + drop_slot(s); + vSlots[(size_t)s] = new SmNewMarkAndLock(); + break; + case OP_LOCK_NEWMARK: + if (vSlots[(size_t)s] && vSlots[(size_t)s]->GetContext()) + { + vSlots[(size_t)s]->NewMark(); + put_i(1); + } + else + put_i(-1); + break; + case OP_LOCK_SETCTX: + if (!vSlots[(size_t)s]) + vSlots[(size_t)s] = new SmNewMarkAndLock(); + put_i(vSlots[(size_t)s]->SetContext(pC, eM)); + break; + case OP_LOCK_SETCTX_PAIR: + if (!vSlots[(size_t)s]) + vSlots[(size_t)s] = new SmNewMarkAndLock(); + put_i(vSlots[(size_t)s]->SetContext((SmContext*)pC, (SmContext*)pC2)); + break; + case OP_LOCK_DROP: drop_slot(s); break; + case OP_LOCK_INFO: + if (!vSlots[(size_t)s]) + { + put_i(-2); + break; + } + put_i(vSlots[(size_t)s]->GetMarkType()); + put_i(vSlots[(size_t)s]->GetMarkType1()); + put_i(vSlots[(size_t)s]->GetMarkType2()); + put_i(ctx_index(vSlots[(size_t)s]->GetContext())); + put_i(ctx_index(vSlots[(size_t)s]->GetContext2())); + break; + case OP_DOING_BOOL: + if (fl) + pC->GetDoingBooleanRef() = (SmBoolean)o[4]; + else + pC->SetDoingBoolean((SmBoolean)o[4]); + put_i(pC->GetDoingBoolean() ? 1 : 0); + break; + case OP_GET_MODEL: + put_f(pC->GetThisModelSizeEstimate()); + put_f(SmTol::GetModelSizeEstimate(*(const SmContext*)pC)); + break; + case OP_SET_MODEL: + if (fl) + put_f(SmTol::SetModelSizeEstimate(*(SmContext*)pC, x[0])); + else + put_f(pC->SetThisModelSizeEstimate(x[0])); + break; + case OP_SET_RATIO: pC->SetThisLargeSmallSizeRatio(x[0]); break; + case OP_TOL_CTX: + { + const SmContext* cp = pC; + SmSmallTopoType eS = (SmSmallTopoType)o[4]; + put_f(SmTol::GetZoneTol3d(cp, eS)); + put_f(SmTol::GetApproxTol3d(cp, eS)); + put_f(SmTol::GetXSectTol3d(cp, eS)); + put_f(SmTol::CalcFaceZoneTol3d(cp)); + break; + } + case OP_CALC_EDGE: + { + SmZoneTol3d sMax(x[2]); + put_f(SmTol::CalcEdgeZoneTol3d(x[0], x[1], fl ? &sMax : (SmZoneTol3d*)NULL, + (const SmContext*)pC)); + break; + } + case OP_CALC_VERTEX: + { + SmZoneTol3d sMax(x[2]); + put_f(SmTol::CalcVertexZoneTol3d(x[0], x[1], fl ? &sMax : (SmZoneTol3d*)NULL, + (const SmContext*)pC)); + break; + } + case OP_CALLBACK: + if (fl) + pC->SetUserNotifyCallback(o[4] ? &s_Notify : NULL); + else + pC->SetSysNotifyCallback(o[4] ? &s_Notify : NULL); + put_i(pC->GetSysNotifyCallback() ? 1 : 0); + put_i(pC->GetUserNotifyCallback() ? 1 : 0); + break; + case OP_MASS: + { + SmMassPropertyBehavior sDef; + SmMassPropertyBehavior sArg(x[0], x[1], x[2], x[3], (ULONG)o[4], (ULONG)fl); + const SmMassPropertyBehavior& r = s ? sDef : sArg; + put_f(r.m_dDensity); + put_f(r.m_dFaceThickness); + put_f(r.m_dEdgeCrossSectionRadius); + put_f(r.m_dVertexSphereRadius); + put_i((int64_t)r.m_lFaceAreaBehavior); + put_i((int64_t)r.m_lFaceVolumeBehavior); + break; + } + case OP_API: + { + SmApiCreateContext(); + SmContext* p = SmApiGetOrCreateContext(); + put_i(p != NULL ? 1 : 0); + put_i(p == SmApiGetOrCreateContext() ? 1 : 0); + break; + } + default: break; + } + snapshot(); + } + for (int64_t s = 0; s < n_slots; ++s) + drop_slot(s); + snapshot(); + for (ScCtx* p : vCtx) + { + p->SetSysNotifyCallback(NULL); + delete p; + } + return sc_copy_out(res.data(), (int64_t)res.size(), out, cap, out_len); + SC_CATCH +} diff --git a/plan/findings.md b/plan/findings.md index 9d6d29e742..1f344363c7 100644 --- a/plan/findings.md +++ b/plan/findings.md @@ -198,8 +198,8 @@ agents: - **System statics live in the `Kernel`.** `s_ZoneTol3d`, `s_TolGapGain`, `s_ModelSizeEstimate`, `s_LargeSmallSizeRatio` are `kernel.tolerances.{zone_tol_3d, tol_gap_gain, model_size_estimate, large_small_size_ratio}`. The kernel also stands in - for `SmContext`, so the `context_*` functions are the null-context overloads; a context - with its own `m_sThisZoneTol3d` is `UNPORTED(geom.context)`. The difftest shim sets the + for `SmContext`; since `geom.context` the `context_*` / `calc_*_zone_tol_3d` + functions take `Option<&Context>` (`None` = null pointer, `Some(&k.context)` usual). The difftest shim sets the statics with `SmTol::SetModelSizeEstimate` / `SetLargeSmallSizeRatio` per case and restores the defaults afterwards (the C++ statics are thread-local globals). - **Overloads needing later types are not in Rust yet** (markers at the top of @@ -218,3 +218,30 @@ agents: - **Co-ports.** `sm_sqrt` and `SmVector3d::GetMaxDimension` (unit `geom.vector3d`) are private helpers marked `// CO-PORT(geom.vector3d)`. The `SM_IS_ZERO_SQUARED` co-port in `geom/vector2d.rs` now calls `geom::tol` (vector2d difftest re-run: green, 4060 cases). + +## geom.context + +- **Two-context `SmNewMarkAndLock` constructor bug (ported as is).** In + `SmNewMarkAndLock(SmContext* p1, SmContext* p2)` with `p1 != p2`, upstream picks + `m_eMarkType2 = GetUnlockedMark(*p2)` but then calls `m_pContext1->NewMark(m_eMarkType1)` + (advancing context 1's mark a second time, not context 2's) and + `LockMark(m_pContext2, m_eMarkType1)` (locking mark type 1 in context 2, not type 2). + The destructor then unlocks `m_eMarkType2` in context 2, so when the types differ a + stray lock of type 1 stays on context 2. `geom::context::MarkLock::new_pair` reproduces + this exactly (difftest case `boolean_pair_two_contexts`). `SetContext(p1, p2)` is + correct (locks type 2 in context 2) and does not advance marks. +- **Release build ignores locks.** `NewMark`'s lock checks and `LockMark` / + `UnlockMark`'s state checks are `SM_ASSERT*` (messages only), so locked marks can still + be advanced and double locks are silent; the port drops the assertions. +- **`SmNewMarkAndLock` binds contexts by index.** Rust `MarkLock` stores indices into a + caller-owned `&mut [Context]` instead of pointers and its destructor is the explicit + `release`; `with_mark_lock(&mut Kernel, ..)` is the scoped form for the kernel's own + context (`Kernel::context`). Topology porters: use `k.context` for + `GetContext()->GetCurrentMark(..)` and `with_mark_lock` for `SmNewMarkAndLock`. +- **Build flags.** The reference build has neither `SM_USE_GLOBAL_CACHE` nor + `SM_USE_NEWTOL`, so the constructor is the two-double one and + `SetThisModelSizeEstimate` is the inline header version + (`m_sThisZoneTol3d = SizeEstimateToZoneTol3d(estimate)`, which maps `SM_USE_DEFAULT` to + `SM_MODEL_SIZE_ESTIMATE`, not to the system statics). +- **`SmApiGetOrCreateContext` global.** The SM_API keeps one process-global context; + the port takes the `Option` slot from the caller. diff --git a/reports/difftest/geom.context.json b/reports/difftest/geom.context.json new file mode 100644 index 0000000000..202307a32d --- /dev/null +++ b/reports/difftest/geom.context.json @@ -0,0 +1,16121 @@ +{ + "abs_floors": [], + "cases": [ + { + "max_rel_err": 0.0, + "name": "default_context", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#0 (upstream tests/prog_test/src/smFeatureTest.cpp:26 (SmContext sContext))", + "values_compared": 71 + }, + { + "max_rel_err": 0.0, + "name": "api_create_context", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#1 (upstream tests/SM_API_test/src/TestSmBrep.cpp:45 (SmApiCreateContext))", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "scoped_lock_all_marks", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#2 (upstream source/SMLib/src/SmAssembly.cpp:275 (SmNewMarkAndLock sMarkLock(GetContext(), SM_MT_ALLMARKS)))", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "nested_locks_exhaust", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#3 (upstream source/SMLib/inc/SmContext.h:496 (GetUnlockedMark: all marks locked -> SM_MT_MARKIO))", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "lock_single_mask_locked", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#4 (upstream source/SMLib/src/SmContext.cpp:516 (GetUnlockedMark returns the single-mark mask))", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "default_lock_set_context", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#5 (upstream source/SMLib/src/SmSphere.cpp:3600 (SmNewMarkAndLock sMarkLock; SetContext(GetContext())))", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "boolean_pair_same_context", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#6 (upstream source/SMLib/src/SmPrimitiveCreation.cpp:7745 (SmNewMarkAndLock(BrepA ctx, BrepB ctx)))", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "boolean_pair_two_contexts", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#7 (upstream source/SMLib/src/SmPrimitiveCreation.cpp:7745 (SmNewMarkAndLock with distinct contexts))", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "set_context_pair_rebind", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#8 (upstream source/SMLib/inc/SmContext.h:600 (SmNewMarkAndLock::SetContext(ctx1, ctx2)))", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "model_size_1000", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#9 (upstream source/SMLib/src/SmContext.cpp:161 (SmContext(dThisModelSizeEstimate, dThisLargeSmallSizeRatio)))", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "set_model_size", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#10 (upstream source/SMLib/src/SmTol.cpp:80 (SmTol::SetModelSizeEstimate(SmContext&, double)))", + "values_compared": 43 + }, + { + "max_rel_err": 0.0, + "name": "notify_callbacks", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#11 (upstream source/SMLib/inc/SmContext.h:372 (SetSysNotifyCallback / GetUserNotifyCallback))", + "values_compared": 15 + }, + { + "max_rel_err": 0.0, + "name": "mass_property_behavior", + "outcome": "pass", + "pass": true, + "source": "fixture:fixtures/geom.context/cases.json#12 (upstream source/SMLib/inc/SmTopoTypes.h:280 (SmMassPropertyBehavior))", + "values_compared": 17 + }, + { + "max_rel_err": 0.0, + "name": "gen0000", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042000", + "values_compared": 70 + }, + { + "max_rel_err": 0.0, + "name": "gen0001", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042001", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen0002", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042002", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0003", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042003", + "values_compared": 271 + }, + { + "max_rel_err": 0.0, + "name": "gen0004", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042004", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen0005", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042005", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen0006", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042006", + "values_compared": 167 + }, + { + "max_rel_err": 0.0, + "name": "gen0007", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042007", + "values_compared": 52 + }, + { + "max_rel_err": 0.0, + "name": "gen0008", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042008", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen0009", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042009", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen0010", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042010", + "values_compared": 386 + }, + { + "max_rel_err": 0.0, + "name": "gen0011", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042011", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0012", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042012", + "values_compared": 145 + }, + { + "max_rel_err": 0.0, + "name": "gen0013", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042013", + "values_compared": 332 + }, + { + "max_rel_err": 0.0, + "name": "gen0014", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042014", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen0015", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042015", + "values_compared": 364 + }, + { + "max_rel_err": 0.0, + "name": "gen0016", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042016", + "values_compared": 257 + }, + { + "max_rel_err": 0.0, + "name": "gen0017", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042017", + "values_compared": 368 + }, + { + "max_rel_err": 0.0, + "name": "gen0018", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042018", + "values_compared": 111 + }, + { + "max_rel_err": 0.0, + "name": "gen0019", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042019", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0020", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042020", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0021", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042021", + "values_compared": 59 + }, + { + "max_rel_err": 0.0, + "name": "gen0022", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042022", + "values_compared": 236 + }, + { + "max_rel_err": 0.0, + "name": "gen0023", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042023", + "values_compared": 177 + }, + { + "max_rel_err": 0.0, + "name": "gen0024", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042024", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen0025", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042025", + "values_compared": 267 + }, + { + "max_rel_err": 0.0, + "name": "gen0026", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042026", + "values_compared": 219 + }, + { + "max_rel_err": 0.0, + "name": "gen0027", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042027", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0028", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042028", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen0029", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042029", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen0030", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042030", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen0031", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042031", + "values_compared": 243 + }, + { + "max_rel_err": 0.0, + "name": "gen0032", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042032", + "values_compared": 244 + }, + { + "max_rel_err": 0.0, + "name": "gen0033", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042033", + "values_compared": 246 + }, + { + "max_rel_err": 0.0, + "name": "gen0034", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042034", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0035", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042035", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen0036", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042036", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen0037", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042037", + "values_compared": 228 + }, + { + "max_rel_err": 0.0, + "name": "gen0038", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042038", + "values_compared": 57 + }, + { + "max_rel_err": 0.0, + "name": "gen0039", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042039", + "values_compared": 16 + }, + { + "max_rel_err": 0.0, + "name": "gen0040", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042040", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0041", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042041", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen0042", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042042", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen0043", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042043", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen0044", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042044", + "values_compared": 300 + }, + { + "max_rel_err": 0.0, + "name": "gen0045", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042045", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen0046", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042046", + "values_compared": 43 + }, + { + "max_rel_err": 0.0, + "name": "gen0047", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042047", + "values_compared": 232 + }, + { + "max_rel_err": 0.0, + "name": "gen0048", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042048", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen0049", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042049", + "values_compared": 174 + }, + { + "max_rel_err": 0.0, + "name": "gen0050", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042050", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen0051", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042051", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen0052", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042052", + "values_compared": 162 + }, + { + "max_rel_err": 0.0, + "name": "gen0053", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042053", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0054", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042054", + "values_compared": 260 + }, + { + "max_rel_err": 0.0, + "name": "gen0055", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042055", + "values_compared": 299 + }, + { + "max_rel_err": 0.0, + "name": "gen0056", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042056", + "values_compared": 41 + }, + { + "max_rel_err": 0.0, + "name": "gen0057", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042057", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen0058", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042058", + "values_compared": 229 + }, + { + "max_rel_err": 0.0, + "name": "gen0059", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042059", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen0060", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042060", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0061", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042061", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen0062", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042062", + "values_compared": 218 + }, + { + "max_rel_err": 0.0, + "name": "gen0063", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042063", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0064", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042064", + "values_compared": 191 + }, + { + "max_rel_err": 0.0, + "name": "gen0065", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042065", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0066", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042066", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen0067", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042067", + "values_compared": 28 + }, + { + "max_rel_err": 0.0, + "name": "gen0068", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042068", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen0069", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042069", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen0070", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042070", + "values_compared": 71 + }, + { + "max_rel_err": 0.0, + "name": "gen0071", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042071", + "values_compared": 47 + }, + { + "max_rel_err": 0.0, + "name": "gen0072", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042072", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen0073", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042073", + "values_compared": 359 + }, + { + "max_rel_err": 0.0, + "name": "gen0074", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042074", + "values_compared": 77 + }, + { + "max_rel_err": 0.0, + "name": "gen0075", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042075", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0076", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042076", + "values_compared": 64 + }, + { + "max_rel_err": 0.0, + "name": "gen0077", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042077", + "values_compared": 21 + }, + { + "max_rel_err": 0.0, + "name": "gen0078", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042078", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen0079", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042079", + "values_compared": 17 + }, + { + "max_rel_err": 0.0, + "name": "gen0080", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042080", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen0081", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042081", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0082", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042082", + "values_compared": 193 + }, + { + "max_rel_err": 0.0, + "name": "gen0083", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042083", + "values_compared": 302 + }, + { + "max_rel_err": 0.0, + "name": "gen0084", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042084", + "values_compared": 137 + }, + { + "max_rel_err": 0.0, + "name": "gen0085", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042085", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen0086", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042086", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen0087", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042087", + "values_compared": 225 + }, + { + "max_rel_err": 0.0, + "name": "gen0088", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042088", + "values_compared": 261 + }, + { + "max_rel_err": 0.0, + "name": "gen0089", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042089", + "values_compared": 255 + }, + { + "max_rel_err": 0.0, + "name": "gen0090", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042090", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen0091", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042091", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen0092", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042092", + "values_compared": 26 + }, + { + "max_rel_err": 0.0, + "name": "gen0093", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042093", + "values_compared": 376 + }, + { + "max_rel_err": 0.0, + "name": "gen0094", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042094", + "values_compared": 133 + }, + { + "max_rel_err": 0.0, + "name": "gen0095", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042095", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen0096", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042096", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0097", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042097", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen0098", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042098", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen0099", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042099", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen0100", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042100", + "values_compared": 145 + }, + { + "max_rel_err": 0.0, + "name": "gen0101", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042101", + "values_compared": 283 + }, + { + "max_rel_err": 0.0, + "name": "gen0102", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042102", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0103", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042103", + "values_compared": 106 + }, + { + "max_rel_err": 0.0, + "name": "gen0104", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042104", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen0105", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042105", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0106", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042106", + "values_compared": 144 + }, + { + "max_rel_err": 0.0, + "name": "gen0107", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042107", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen0108", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042108", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen0109", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042109", + "values_compared": 35 + }, + { + "max_rel_err": 0.0, + "name": "gen0110", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042110", + "values_compared": 330 + }, + { + "max_rel_err": 0.0, + "name": "gen0111", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042111", + "values_compared": 362 + }, + { + "max_rel_err": 0.0, + "name": "gen0112", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042112", + "values_compared": 345 + }, + { + "max_rel_err": 0.0, + "name": "gen0113", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042113", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen0114", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042114", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen0115", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042115", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen0116", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042116", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0117", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042117", + "values_compared": 243 + }, + { + "max_rel_err": 0.0, + "name": "gen0118", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042118", + "values_compared": 174 + }, + { + "max_rel_err": 0.0, + "name": "gen0119", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042119", + "values_compared": 92 + }, + { + "max_rel_err": 0.0, + "name": "gen0120", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042120", + "values_compared": 41 + }, + { + "max_rel_err": 0.0, + "name": "gen0121", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042121", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen0122", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042122", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen0123", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042123", + "values_compared": 187 + }, + { + "max_rel_err": 0.0, + "name": "gen0124", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042124", + "values_compared": 167 + }, + { + "max_rel_err": 0.0, + "name": "gen0125", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042125", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen0126", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042126", + "values_compared": 161 + }, + { + "max_rel_err": 0.0, + "name": "gen0127", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042127", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0128", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042128", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen0129", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042129", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen0130", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042130", + "values_compared": 278 + }, + { + "max_rel_err": 0.0, + "name": "gen0131", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042131", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0132", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042132", + "values_compared": 349 + }, + { + "max_rel_err": 0.0, + "name": "gen0133", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042133", + "values_compared": 254 + }, + { + "max_rel_err": 0.0, + "name": "gen0134", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042134", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0135", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042135", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen0136", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042136", + "values_compared": 295 + }, + { + "max_rel_err": 0.0, + "name": "gen0137", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042137", + "values_compared": 338 + }, + { + "max_rel_err": 0.0, + "name": "gen0138", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042138", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0139", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042139", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen0140", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042140", + "values_compared": 332 + }, + { + "max_rel_err": 0.0, + "name": "gen0141", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042141", + "values_compared": 357 + }, + { + "max_rel_err": 0.0, + "name": "gen0142", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042142", + "values_compared": 111 + }, + { + "max_rel_err": 0.0, + "name": "gen0143", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042143", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen0144", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042144", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0145", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042145", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen0146", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042146", + "values_compared": 330 + }, + { + "max_rel_err": 0.0, + "name": "gen0147", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042147", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0148", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042148", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen0149", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042149", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen0150", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042150", + "values_compared": 196 + }, + { + "max_rel_err": 0.0, + "name": "gen0151", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042151", + "values_compared": 210 + }, + { + "max_rel_err": 0.0, + "name": "gen0152", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042152", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen0153", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042153", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0154", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042154", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen0155", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042155", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen0156", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042156", + "values_compared": 21 + }, + { + "max_rel_err": 0.0, + "name": "gen0157", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042157", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen0158", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042158", + "values_compared": 226 + }, + { + "max_rel_err": 0.0, + "name": "gen0159", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042159", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen0160", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042160", + "values_compared": 100 + }, + { + "max_rel_err": 0.0, + "name": "gen0161", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042161", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen0162", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042162", + "values_compared": 354 + }, + { + "max_rel_err": 0.0, + "name": "gen0163", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042163", + "values_compared": 174 + }, + { + "max_rel_err": 0.0, + "name": "gen0164", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042164", + "values_compared": 122 + }, + { + "max_rel_err": 0.0, + "name": "gen0165", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042165", + "values_compared": 212 + }, + { + "max_rel_err": 0.0, + "name": "gen0166", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042166", + "values_compared": 166 + }, + { + "max_rel_err": 0.0, + "name": "gen0167", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042167", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0168", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042168", + "values_compared": 324 + }, + { + "max_rel_err": 0.0, + "name": "gen0169", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042169", + "values_compared": 219 + }, + { + "max_rel_err": 0.0, + "name": "gen0170", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042170", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen0171", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042171", + "values_compared": 137 + }, + { + "max_rel_err": 0.0, + "name": "gen0172", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042172", + "values_compared": 193 + }, + { + "max_rel_err": 0.0, + "name": "gen0173", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042173", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen0174", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042174", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen0175", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042175", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen0176", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042176", + "values_compared": 255 + }, + { + "max_rel_err": 0.0, + "name": "gen0177", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042177", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen0178", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042178", + "values_compared": 288 + }, + { + "max_rel_err": 0.0, + "name": "gen0179", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042179", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0180", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042180", + "values_compared": 186 + }, + { + "max_rel_err": 0.0, + "name": "gen0181", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042181", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0182", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042182", + "values_compared": 84 + }, + { + "max_rel_err": 0.0, + "name": "gen0183", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042183", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen0184", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042184", + "values_compared": 239 + }, + { + "max_rel_err": 0.0, + "name": "gen0185", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042185", + "values_compared": 269 + }, + { + "max_rel_err": 0.0, + "name": "gen0186", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042186", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0187", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042187", + "values_compared": 234 + }, + { + "max_rel_err": 0.0, + "name": "gen0188", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042188", + "values_compared": 203 + }, + { + "max_rel_err": 0.0, + "name": "gen0189", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042189", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen0190", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042190", + "values_compared": 273 + }, + { + "max_rel_err": 0.0, + "name": "gen0191", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042191", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen0192", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042192", + "values_compared": 17 + }, + { + "max_rel_err": 0.0, + "name": "gen0193", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042193", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen0194", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042194", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen0195", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042195", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen0196", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042196", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0197", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042197", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen0198", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042198", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0199", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042199", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen0200", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042200", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen0201", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042201", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen0202", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042202", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0203", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042203", + "values_compared": 222 + }, + { + "max_rel_err": 0.0, + "name": "gen0204", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042204", + "values_compared": 162 + }, + { + "max_rel_err": 0.0, + "name": "gen0205", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042205", + "values_compared": 77 + }, + { + "max_rel_err": 0.0, + "name": "gen0206", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042206", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen0207", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042207", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen0208", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042208", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen0209", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042209", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen0210", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042210", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen0211", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042211", + "values_compared": 355 + }, + { + "max_rel_err": 0.0, + "name": "gen0212", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042212", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen0213", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042213", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen0214", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042214", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen0215", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042215", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen0216", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042216", + "values_compared": 189 + }, + { + "max_rel_err": 0.0, + "name": "gen0217", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042217", + "values_compared": 111 + }, + { + "max_rel_err": 0.0, + "name": "gen0218", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042218", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0219", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042219", + "values_compared": 217 + }, + { + "max_rel_err": 0.0, + "name": "gen0220", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042220", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen0221", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042221", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen0222", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042222", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0223", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042223", + "values_compared": 256 + }, + { + "max_rel_err": 0.0, + "name": "gen0224", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042224", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen0225", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042225", + "values_compared": 75 + }, + { + "max_rel_err": 0.0, + "name": "gen0226", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042226", + "values_compared": 19 + }, + { + "max_rel_err": 0.0, + "name": "gen0227", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042227", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen0228", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042228", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0229", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042229", + "values_compared": 173 + }, + { + "max_rel_err": 0.0, + "name": "gen0230", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042230", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen0231", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042231", + "values_compared": 139 + }, + { + "max_rel_err": 0.0, + "name": "gen0232", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042232", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0233", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042233", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen0234", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042234", + "values_compared": 339 + }, + { + "max_rel_err": 0.0, + "name": "gen0235", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042235", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0236", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042236", + "values_compared": 335 + }, + { + "max_rel_err": 0.0, + "name": "gen0237", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042237", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen0238", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042238", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen0239", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042239", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen0240", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042240", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0241", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042241", + "values_compared": 208 + }, + { + "max_rel_err": 0.0, + "name": "gen0242", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042242", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen0243", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042243", + "values_compared": 347 + }, + { + "max_rel_err": 0.0, + "name": "gen0244", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042244", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen0245", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042245", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen0246", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042246", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0247", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042247", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen0248", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042248", + "values_compared": 41 + }, + { + "max_rel_err": 0.0, + "name": "gen0249", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042249", + "values_compared": 261 + }, + { + "max_rel_err": 0.0, + "name": "gen0250", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042250", + "values_compared": 259 + }, + { + "max_rel_err": 0.0, + "name": "gen0251", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042251", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen0252", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042252", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen0253", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042253", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0254", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042254", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0255", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042255", + "values_compared": 176 + }, + { + "max_rel_err": 0.0, + "name": "gen0256", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042256", + "values_compared": 171 + }, + { + "max_rel_err": 0.0, + "name": "gen0257", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042257", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen0258", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042258", + "values_compared": 77 + }, + { + "max_rel_err": 0.0, + "name": "gen0259", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042259", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen0260", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042260", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen0261", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042261", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen0262", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042262", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen0263", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042263", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen0264", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042264", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen0265", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042265", + "values_compared": 205 + }, + { + "max_rel_err": 0.0, + "name": "gen0266", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042266", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0267", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042267", + "values_compared": 101 + }, + { + "max_rel_err": 0.0, + "name": "gen0268", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042268", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen0269", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042269", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen0270", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042270", + "values_compared": 146 + }, + { + "max_rel_err": 0.0, + "name": "gen0271", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042271", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen0272", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042272", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0273", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042273", + "values_compared": 374 + }, + { + "max_rel_err": 0.0, + "name": "gen0274", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042274", + "values_compared": 250 + }, + { + "max_rel_err": 0.0, + "name": "gen0275", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042275", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0276", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042276", + "values_compared": 200 + }, + { + "max_rel_err": 0.0, + "name": "gen0277", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042277", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen0278", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042278", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen0279", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042279", + "values_compared": 203 + }, + { + "max_rel_err": 0.0, + "name": "gen0280", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042280", + "values_compared": 283 + }, + { + "max_rel_err": 0.0, + "name": "gen0281", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042281", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen0282", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042282", + "values_compared": 236 + }, + { + "max_rel_err": 0.0, + "name": "gen0283", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042283", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0284", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042284", + "values_compared": 119 + }, + { + "max_rel_err": 0.0, + "name": "gen0285", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042285", + "values_compared": 265 + }, + { + "max_rel_err": 0.0, + "name": "gen0286", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042286", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen0287", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042287", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen0288", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042288", + "values_compared": 237 + }, + { + "max_rel_err": 0.0, + "name": "gen0289", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042289", + "values_compared": 206 + }, + { + "max_rel_err": 0.0, + "name": "gen0290", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042290", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen0291", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042291", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0292", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042292", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen0293", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042293", + "values_compared": 154 + }, + { + "max_rel_err": 0.0, + "name": "gen0294", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042294", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen0295", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042295", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen0296", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042296", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen0297", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042297", + "values_compared": 162 + }, + { + "max_rel_err": 0.0, + "name": "gen0298", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042298", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0299", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042299", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0300", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042300", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0301", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042301", + "values_compared": 258 + }, + { + "max_rel_err": 0.0, + "name": "gen0302", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042302", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen0303", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042303", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0304", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042304", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0305", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042305", + "values_compared": 286 + }, + { + "max_rel_err": 0.0, + "name": "gen0306", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042306", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen0307", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042307", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0308", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042308", + "values_compared": 70 + }, + { + "max_rel_err": 0.0, + "name": "gen0309", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042309", + "values_compared": 303 + }, + { + "max_rel_err": 0.0, + "name": "gen0310", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042310", + "values_compared": 155 + }, + { + "max_rel_err": 0.0, + "name": "gen0311", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042311", + "values_compared": 26 + }, + { + "max_rel_err": 0.0, + "name": "gen0312", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042312", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen0313", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042313", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen0314", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042314", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen0315", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042315", + "values_compared": 358 + }, + { + "max_rel_err": 0.0, + "name": "gen0316", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042316", + "values_compared": 233 + }, + { + "max_rel_err": 0.0, + "name": "gen0317", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042317", + "values_compared": 253 + }, + { + "max_rel_err": 0.0, + "name": "gen0318", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042318", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen0319", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042319", + "values_compared": 244 + }, + { + "max_rel_err": 0.0, + "name": "gen0320", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042320", + "values_compared": 212 + }, + { + "max_rel_err": 0.0, + "name": "gen0321", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042321", + "values_compared": 202 + }, + { + "max_rel_err": 0.0, + "name": "gen0322", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042322", + "values_compared": 176 + }, + { + "max_rel_err": 0.0, + "name": "gen0323", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042323", + "values_compared": 287 + }, + { + "max_rel_err": 0.0, + "name": "gen0324", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042324", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen0325", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042325", + "values_compared": 149 + }, + { + "max_rel_err": 0.0, + "name": "gen0326", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042326", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen0327", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042327", + "values_compared": 217 + }, + { + "max_rel_err": 0.0, + "name": "gen0328", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042328", + "values_compared": 16 + }, + { + "max_rel_err": 0.0, + "name": "gen0329", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042329", + "values_compared": 142 + }, + { + "max_rel_err": 0.0, + "name": "gen0330", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042330", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen0331", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042331", + "values_compared": 160 + }, + { + "max_rel_err": 0.0, + "name": "gen0332", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042332", + "values_compared": 194 + }, + { + "max_rel_err": 0.0, + "name": "gen0333", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042333", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen0334", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042334", + "values_compared": 100 + }, + { + "max_rel_err": 0.0, + "name": "gen0335", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042335", + "values_compared": 338 + }, + { + "max_rel_err": 0.0, + "name": "gen0336", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042336", + "values_compared": 191 + }, + { + "max_rel_err": 0.0, + "name": "gen0337", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042337", + "values_compared": 208 + }, + { + "max_rel_err": 0.0, + "name": "gen0338", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042338", + "values_compared": 230 + }, + { + "max_rel_err": 0.0, + "name": "gen0339", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042339", + "values_compared": 92 + }, + { + "max_rel_err": 0.0, + "name": "gen0340", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042340", + "values_compared": 320 + }, + { + "max_rel_err": 0.0, + "name": "gen0341", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042341", + "values_compared": 197 + }, + { + "max_rel_err": 0.0, + "name": "gen0342", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042342", + "values_compared": 138 + }, + { + "max_rel_err": 0.0, + "name": "gen0343", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042343", + "values_compared": 204 + }, + { + "max_rel_err": 0.0, + "name": "gen0344", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042344", + "values_compared": 243 + }, + { + "max_rel_err": 0.0, + "name": "gen0345", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042345", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0346", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042346", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen0347", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042347", + "values_compared": 378 + }, + { + "max_rel_err": 0.0, + "name": "gen0348", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042348", + "values_compared": 242 + }, + { + "max_rel_err": 0.0, + "name": "gen0349", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042349", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen0350", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042350", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0351", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042351", + "values_compared": 166 + }, + { + "max_rel_err": 0.0, + "name": "gen0352", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042352", + "values_compared": 43 + }, + { + "max_rel_err": 0.0, + "name": "gen0353", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042353", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0354", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042354", + "values_compared": 253 + }, + { + "max_rel_err": 0.0, + "name": "gen0355", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042355", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen0356", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042356", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen0357", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042357", + "values_compared": 144 + }, + { + "max_rel_err": 0.0, + "name": "gen0358", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042358", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0359", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042359", + "values_compared": 126 + }, + { + "max_rel_err": 0.0, + "name": "gen0360", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042360", + "values_compared": 175 + }, + { + "max_rel_err": 0.0, + "name": "gen0361", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042361", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen0362", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042362", + "values_compared": 198 + }, + { + "max_rel_err": 0.0, + "name": "gen0363", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042363", + "values_compared": 365 + }, + { + "max_rel_err": 0.0, + "name": "gen0364", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042364", + "values_compared": 154 + }, + { + "max_rel_err": 0.0, + "name": "gen0365", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042365", + "values_compared": 189 + }, + { + "max_rel_err": 0.0, + "name": "gen0366", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042366", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen0367", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042367", + "values_compared": 300 + }, + { + "max_rel_err": 0.0, + "name": "gen0368", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042368", + "values_compared": 229 + }, + { + "max_rel_err": 0.0, + "name": "gen0369", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042369", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen0370", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042370", + "values_compared": 14 + }, + { + "max_rel_err": 0.0, + "name": "gen0371", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042371", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen0372", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042372", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen0373", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042373", + "values_compared": 222 + }, + { + "max_rel_err": 0.0, + "name": "gen0374", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042374", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen0375", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042375", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0376", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042376", + "values_compared": 142 + }, + { + "max_rel_err": 0.0, + "name": "gen0377", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042377", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0378", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042378", + "values_compared": 299 + }, + { + "max_rel_err": 0.0, + "name": "gen0379", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042379", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0380", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042380", + "values_compared": 28 + }, + { + "max_rel_err": 0.0, + "name": "gen0381", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042381", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0382", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042382", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0383", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042383", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen0384", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042384", + "values_compared": 198 + }, + { + "max_rel_err": 0.0, + "name": "gen0385", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042385", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen0386", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042386", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen0387", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042387", + "values_compared": 137 + }, + { + "max_rel_err": 0.0, + "name": "gen0388", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042388", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen0389", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042389", + "values_compared": 365 + }, + { + "max_rel_err": 0.0, + "name": "gen0390", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042390", + "values_compared": 106 + }, + { + "max_rel_err": 0.0, + "name": "gen0391", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042391", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen0392", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042392", + "values_compared": 233 + }, + { + "max_rel_err": 0.0, + "name": "gen0393", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042393", + "values_compared": 263 + }, + { + "max_rel_err": 0.0, + "name": "gen0394", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042394", + "values_compared": 53 + }, + { + "max_rel_err": 0.0, + "name": "gen0395", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042395", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen0396", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042396", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0397", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042397", + "values_compared": 70 + }, + { + "max_rel_err": 0.0, + "name": "gen0398", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042398", + "values_compared": 182 + }, + { + "max_rel_err": 0.0, + "name": "gen0399", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042399", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen0400", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042400", + "values_compared": 203 + }, + { + "max_rel_err": 0.0, + "name": "gen0401", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042401", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen0402", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042402", + "values_compared": 258 + }, + { + "max_rel_err": 0.0, + "name": "gen0403", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042403", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen0404", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042404", + "values_compared": 202 + }, + { + "max_rel_err": 0.0, + "name": "gen0405", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042405", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen0406", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042406", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen0407", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042407", + "values_compared": 222 + }, + { + "max_rel_err": 0.0, + "name": "gen0408", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042408", + "values_compared": 243 + }, + { + "max_rel_err": 0.0, + "name": "gen0409", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042409", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen0410", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042410", + "values_compared": 262 + }, + { + "max_rel_err": 0.0, + "name": "gen0411", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042411", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen0412", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042412", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen0413", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042413", + "values_compared": 154 + }, + { + "max_rel_err": 0.0, + "name": "gen0414", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042414", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen0415", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042415", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0416", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042416", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen0417", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042417", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen0418", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042418", + "values_compared": 169 + }, + { + "max_rel_err": 0.0, + "name": "gen0419", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042419", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen0420", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042420", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0421", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042421", + "values_compared": 240 + }, + { + "max_rel_err": 0.0, + "name": "gen0422", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042422", + "values_compared": 157 + }, + { + "max_rel_err": 0.0, + "name": "gen0423", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042423", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen0424", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042424", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen0425", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042425", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen0426", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042426", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen0427", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042427", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0428", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042428", + "values_compared": 239 + }, + { + "max_rel_err": 0.0, + "name": "gen0429", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042429", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0430", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042430", + "values_compared": 148 + }, + { + "max_rel_err": 0.0, + "name": "gen0431", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042431", + "values_compared": 261 + }, + { + "max_rel_err": 0.0, + "name": "gen0432", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042432", + "values_compared": 267 + }, + { + "max_rel_err": 0.0, + "name": "gen0433", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042433", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen0434", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042434", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen0435", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042435", + "values_compared": 92 + }, + { + "max_rel_err": 0.0, + "name": "gen0436", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042436", + "values_compared": 151 + }, + { + "max_rel_err": 0.0, + "name": "gen0437", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042437", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0438", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042438", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen0439", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042439", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0440", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042440", + "values_compared": 107 + }, + { + "max_rel_err": 0.0, + "name": "gen0441", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042441", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen0442", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042442", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen0443", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042443", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen0444", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042444", + "values_compared": 294 + }, + { + "max_rel_err": 0.0, + "name": "gen0445", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042445", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen0446", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042446", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen0447", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042447", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen0448", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042448", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0449", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042449", + "values_compared": 77 + }, + { + "max_rel_err": 0.0, + "name": "gen0450", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042450", + "values_compared": 193 + }, + { + "max_rel_err": 0.0, + "name": "gen0451", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042451", + "values_compared": 133 + }, + { + "max_rel_err": 0.0, + "name": "gen0452", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042452", + "values_compared": 50 + }, + { + "max_rel_err": 0.0, + "name": "gen0453", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042453", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen0454", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042454", + "values_compared": 257 + }, + { + "max_rel_err": 0.0, + "name": "gen0455", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042455", + "values_compared": 238 + }, + { + "max_rel_err": 0.0, + "name": "gen0456", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042456", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen0457", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042457", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0458", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042458", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen0459", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042459", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0460", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042460", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen0461", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042461", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen0462", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042462", + "values_compared": 231 + }, + { + "max_rel_err": 0.0, + "name": "gen0463", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042463", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0464", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042464", + "values_compared": 201 + }, + { + "max_rel_err": 0.0, + "name": "gen0465", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042465", + "values_compared": 329 + }, + { + "max_rel_err": 0.0, + "name": "gen0466", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042466", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen0467", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042467", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen0468", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042468", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0469", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042469", + "values_compared": 138 + }, + { + "max_rel_err": 0.0, + "name": "gen0470", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042470", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0471", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042471", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0472", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042472", + "values_compared": 211 + }, + { + "max_rel_err": 0.0, + "name": "gen0473", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042473", + "values_compared": 384 + }, + { + "max_rel_err": 0.0, + "name": "gen0474", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042474", + "values_compared": 277 + }, + { + "max_rel_err": 0.0, + "name": "gen0475", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042475", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0476", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042476", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0477", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042477", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0478", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042478", + "values_compared": 182 + }, + { + "max_rel_err": 0.0, + "name": "gen0479", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042479", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen0480", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042480", + "values_compared": 161 + }, + { + "max_rel_err": 0.0, + "name": "gen0481", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042481", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen0482", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042482", + "values_compared": 53 + }, + { + "max_rel_err": 0.0, + "name": "gen0483", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042483", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen0484", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042484", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen0485", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042485", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen0486", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042486", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen0487", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042487", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen0488", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042488", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen0489", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042489", + "values_compared": 246 + }, + { + "max_rel_err": 0.0, + "name": "gen0490", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042490", + "values_compared": 41 + }, + { + "max_rel_err": 0.0, + "name": "gen0491", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042491", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0492", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042492", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0493", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042493", + "values_compared": 308 + }, + { + "max_rel_err": 0.0, + "name": "gen0494", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042494", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen0495", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042495", + "values_compared": 221 + }, + { + "max_rel_err": 0.0, + "name": "gen0496", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042496", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen0497", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042497", + "values_compared": 267 + }, + { + "max_rel_err": 0.0, + "name": "gen0498", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042498", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0499", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042499", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen0500", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042500", + "values_compared": 106 + }, + { + "max_rel_err": 0.0, + "name": "gen0501", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042501", + "values_compared": 338 + }, + { + "max_rel_err": 0.0, + "name": "gen0502", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042502", + "values_compared": 201 + }, + { + "max_rel_err": 0.0, + "name": "gen0503", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042503", + "values_compared": 385 + }, + { + "max_rel_err": 0.0, + "name": "gen0504", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042504", + "values_compared": 154 + }, + { + "max_rel_err": 0.0, + "name": "gen0505", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042505", + "values_compared": 164 + }, + { + "max_rel_err": 0.0, + "name": "gen0506", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042506", + "values_compared": 163 + }, + { + "max_rel_err": 0.0, + "name": "gen0507", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042507", + "values_compared": 190 + }, + { + "max_rel_err": 0.0, + "name": "gen0508", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042508", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0509", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042509", + "values_compared": 321 + }, + { + "max_rel_err": 0.0, + "name": "gen0510", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042510", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0511", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042511", + "values_compared": 272 + }, + { + "max_rel_err": 0.0, + "name": "gen0512", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042512", + "values_compared": 111 + }, + { + "max_rel_err": 0.0, + "name": "gen0513", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042513", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen0514", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042514", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0515", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042515", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0516", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042516", + "values_compared": 189 + }, + { + "max_rel_err": 0.0, + "name": "gen0517", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042517", + "values_compared": 203 + }, + { + "max_rel_err": 0.0, + "name": "gen0518", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042518", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0519", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042519", + "values_compared": 302 + }, + { + "max_rel_err": 0.0, + "name": "gen0520", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042520", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen0521", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042521", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen0522", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042522", + "values_compared": 126 + }, + { + "max_rel_err": 0.0, + "name": "gen0523", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042523", + "values_compared": 82 + }, + { + "max_rel_err": 0.0, + "name": "gen0524", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042524", + "values_compared": 169 + }, + { + "max_rel_err": 0.0, + "name": "gen0525", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042525", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen0526", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042526", + "values_compared": 19 + }, + { + "max_rel_err": 0.0, + "name": "gen0527", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042527", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen0528", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042528", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0529", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042529", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen0530", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042530", + "values_compared": 83 + }, + { + "max_rel_err": 0.0, + "name": "gen0531", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042531", + "values_compared": 161 + }, + { + "max_rel_err": 0.0, + "name": "gen0532", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042532", + "values_compared": 318 + }, + { + "max_rel_err": 0.0, + "name": "gen0533", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042533", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen0534", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042534", + "values_compared": 215 + }, + { + "max_rel_err": 0.0, + "name": "gen0535", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042535", + "values_compared": 217 + }, + { + "max_rel_err": 0.0, + "name": "gen0536", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042536", + "values_compared": 316 + }, + { + "max_rel_err": 0.0, + "name": "gen0537", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042537", + "values_compared": 108 + }, + { + "max_rel_err": 0.0, + "name": "gen0538", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042538", + "values_compared": 206 + }, + { + "max_rel_err": 0.0, + "name": "gen0539", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042539", + "values_compared": 69 + }, + { + "max_rel_err": 0.0, + "name": "gen0540", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042540", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen0541", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042541", + "values_compared": 368 + }, + { + "max_rel_err": 0.0, + "name": "gen0542", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042542", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0543", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042543", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0544", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042544", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen0545", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042545", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen0546", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042546", + "values_compared": 75 + }, + { + "max_rel_err": 0.0, + "name": "gen0547", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042547", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0548", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042548", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen0549", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042549", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0550", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042550", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0551", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042551", + "values_compared": 94 + }, + { + "max_rel_err": 0.0, + "name": "gen0552", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042552", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen0553", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042553", + "values_compared": 238 + }, + { + "max_rel_err": 0.0, + "name": "gen0554", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042554", + "values_compared": 263 + }, + { + "max_rel_err": 0.0, + "name": "gen0555", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042555", + "values_compared": 122 + }, + { + "max_rel_err": 0.0, + "name": "gen0556", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042556", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen0557", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042557", + "values_compared": 154 + }, + { + "max_rel_err": 0.0, + "name": "gen0558", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042558", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0559", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042559", + "values_compared": 29 + }, + { + "max_rel_err": 0.0, + "name": "gen0560", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042560", + "values_compared": 247 + }, + { + "max_rel_err": 0.0, + "name": "gen0561", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042561", + "values_compared": 170 + }, + { + "max_rel_err": 0.0, + "name": "gen0562", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042562", + "values_compared": 181 + }, + { + "max_rel_err": 0.0, + "name": "gen0563", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042563", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen0564", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042564", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0565", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042565", + "values_compared": 59 + }, + { + "max_rel_err": 0.0, + "name": "gen0566", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042566", + "values_compared": 53 + }, + { + "max_rel_err": 0.0, + "name": "gen0567", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042567", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0568", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042568", + "values_compared": 229 + }, + { + "max_rel_err": 0.0, + "name": "gen0569", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042569", + "values_compared": 31 + }, + { + "max_rel_err": 0.0, + "name": "gen0570", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042570", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen0571", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042571", + "values_compared": 148 + }, + { + "max_rel_err": 0.0, + "name": "gen0572", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042572", + "values_compared": 361 + }, + { + "max_rel_err": 0.0, + "name": "gen0573", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042573", + "values_compared": 225 + }, + { + "max_rel_err": 0.0, + "name": "gen0574", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042574", + "values_compared": 342 + }, + { + "max_rel_err": 0.0, + "name": "gen0575", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042575", + "values_compared": 64 + }, + { + "max_rel_err": 0.0, + "name": "gen0576", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042576", + "values_compared": 197 + }, + { + "max_rel_err": 0.0, + "name": "gen0577", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042577", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0578", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042578", + "values_compared": 10 + }, + { + "max_rel_err": 0.0, + "name": "gen0579", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042579", + "values_compared": 35 + }, + { + "max_rel_err": 0.0, + "name": "gen0580", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042580", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen0581", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042581", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen0582", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042582", + "values_compared": 53 + }, + { + "max_rel_err": 0.0, + "name": "gen0583", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042583", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen0584", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042584", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen0585", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042585", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0586", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042586", + "values_compared": 28 + }, + { + "max_rel_err": 0.0, + "name": "gen0587", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042587", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen0588", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042588", + "values_compared": 233 + }, + { + "max_rel_err": 0.0, + "name": "gen0589", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042589", + "values_compared": 159 + }, + { + "max_rel_err": 0.0, + "name": "gen0590", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042590", + "values_compared": 206 + }, + { + "max_rel_err": 0.0, + "name": "gen0591", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042591", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen0592", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042592", + "values_compared": 16 + }, + { + "max_rel_err": 0.0, + "name": "gen0593", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042593", + "values_compared": 100 + }, + { + "max_rel_err": 0.0, + "name": "gen0594", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042594", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen0595", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042595", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0596", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042596", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0597", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042597", + "values_compared": 376 + }, + { + "max_rel_err": 0.0, + "name": "gen0598", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042598", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen0599", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042599", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen0600", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042600", + "values_compared": 262 + }, + { + "max_rel_err": 0.0, + "name": "gen0601", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042601", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0602", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042602", + "values_compared": 182 + }, + { + "max_rel_err": 0.0, + "name": "gen0603", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042603", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen0604", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042604", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen0605", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042605", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0606", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042606", + "values_compared": 47 + }, + { + "max_rel_err": 0.0, + "name": "gen0607", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042607", + "values_compared": 372 + }, + { + "max_rel_err": 0.0, + "name": "gen0608", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042608", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen0609", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042609", + "values_compared": 134 + }, + { + "max_rel_err": 0.0, + "name": "gen0610", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042610", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen0611", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042611", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0612", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042612", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen0613", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042613", + "values_compared": 142 + }, + { + "max_rel_err": 0.0, + "name": "gen0614", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042614", + "values_compared": 267 + }, + { + "max_rel_err": 0.0, + "name": "gen0615", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042615", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen0616", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042616", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen0617", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042617", + "values_compared": 248 + }, + { + "max_rel_err": 0.0, + "name": "gen0618", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042618", + "values_compared": 344 + }, + { + "max_rel_err": 0.0, + "name": "gen0619", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042619", + "values_compared": 260 + }, + { + "max_rel_err": 0.0, + "name": "gen0620", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042620", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen0621", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042621", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen0622", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042622", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0623", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042623", + "values_compared": 259 + }, + { + "max_rel_err": 0.0, + "name": "gen0624", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042624", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen0625", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042625", + "values_compared": 126 + }, + { + "max_rel_err": 0.0, + "name": "gen0626", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042626", + "values_compared": 196 + }, + { + "max_rel_err": 0.0, + "name": "gen0627", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042627", + "values_compared": 68 + }, + { + "max_rel_err": 0.0, + "name": "gen0628", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042628", + "values_compared": 209 + }, + { + "max_rel_err": 0.0, + "name": "gen0629", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042629", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen0630", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042630", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0631", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042631", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0632", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042632", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen0633", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042633", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen0634", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042634", + "values_compared": 181 + }, + { + "max_rel_err": 0.0, + "name": "gen0635", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042635", + "values_compared": 92 + }, + { + "max_rel_err": 0.0, + "name": "gen0636", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042636", + "values_compared": 71 + }, + { + "max_rel_err": 0.0, + "name": "gen0637", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042637", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0638", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042638", + "values_compared": 15 + }, + { + "max_rel_err": 0.0, + "name": "gen0639", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042639", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0640", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042640", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen0641", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042641", + "values_compared": 100 + }, + { + "max_rel_err": 0.0, + "name": "gen0642", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042642", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0643", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042643", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0644", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042644", + "values_compared": 26 + }, + { + "max_rel_err": 0.0, + "name": "gen0645", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042645", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "gen0646", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042646", + "values_compared": 106 + }, + { + "max_rel_err": 0.0, + "name": "gen0647", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042647", + "values_compared": 300 + }, + { + "max_rel_err": 0.0, + "name": "gen0648", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042648", + "values_compared": 190 + }, + { + "max_rel_err": 0.0, + "name": "gen0649", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042649", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen0650", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042650", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen0651", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042651", + "values_compared": 298 + }, + { + "max_rel_err": 0.0, + "name": "gen0652", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042652", + "values_compared": 270 + }, + { + "max_rel_err": 0.0, + "name": "gen0653", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042653", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen0654", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042654", + "values_compared": 236 + }, + { + "max_rel_err": 0.0, + "name": "gen0655", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042655", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen0656", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042656", + "values_compared": 245 + }, + { + "max_rel_err": 0.0, + "name": "gen0657", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042657", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen0658", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042658", + "values_compared": 51 + }, + { + "max_rel_err": 0.0, + "name": "gen0659", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042659", + "values_compared": 297 + }, + { + "max_rel_err": 0.0, + "name": "gen0660", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042660", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0661", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042661", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen0662", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042662", + "values_compared": 216 + }, + { + "max_rel_err": 0.0, + "name": "gen0663", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042663", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0664", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042664", + "values_compared": 247 + }, + { + "max_rel_err": 0.0, + "name": "gen0665", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042665", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen0666", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042666", + "values_compared": 119 + }, + { + "max_rel_err": 0.0, + "name": "gen0667", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042667", + "values_compared": 246 + }, + { + "max_rel_err": 0.0, + "name": "gen0668", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042668", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0669", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042669", + "values_compared": 320 + }, + { + "max_rel_err": 0.0, + "name": "gen0670", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042670", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0671", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042671", + "values_compared": 92 + }, + { + "max_rel_err": 0.0, + "name": "gen0672", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042672", + "values_compared": 167 + }, + { + "max_rel_err": 0.0, + "name": "gen0673", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042673", + "values_compared": 332 + }, + { + "max_rel_err": 0.0, + "name": "gen0674", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042674", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen0675", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042675", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen0676", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042676", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen0677", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042677", + "values_compared": 129 + }, + { + "max_rel_err": 0.0, + "name": "gen0678", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042678", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0679", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042679", + "values_compared": 133 + }, + { + "max_rel_err": 0.0, + "name": "gen0680", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042680", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen0681", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042681", + "values_compared": 20 + }, + { + "max_rel_err": 0.0, + "name": "gen0682", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042682", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "gen0683", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042683", + "values_compared": 242 + }, + { + "max_rel_err": 0.0, + "name": "gen0684", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042684", + "values_compared": 29 + }, + { + "max_rel_err": 0.0, + "name": "gen0685", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042685", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen0686", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042686", + "values_compared": 59 + }, + { + "max_rel_err": 0.0, + "name": "gen0687", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042687", + "values_compared": 79 + }, + { + "max_rel_err": 0.0, + "name": "gen0688", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042688", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen0689", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042689", + "values_compared": 303 + }, + { + "max_rel_err": 0.0, + "name": "gen0690", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042690", + "values_compared": 13 + }, + { + "max_rel_err": 0.0, + "name": "gen0691", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042691", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0692", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042692", + "values_compared": 194 + }, + { + "max_rel_err": 0.0, + "name": "gen0693", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042693", + "values_compared": 166 + }, + { + "max_rel_err": 0.0, + "name": "gen0694", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042694", + "values_compared": 329 + }, + { + "max_rel_err": 0.0, + "name": "gen0695", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042695", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen0696", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042696", + "values_compared": 178 + }, + { + "max_rel_err": 0.0, + "name": "gen0697", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042697", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0698", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042698", + "values_compared": 206 + }, + { + "max_rel_err": 0.0, + "name": "gen0699", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042699", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen0700", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042700", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen0701", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042701", + "values_compared": 240 + }, + { + "max_rel_err": 0.0, + "name": "gen0702", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042702", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0703", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042703", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen0704", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042704", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen0705", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042705", + "values_compared": 238 + }, + { + "max_rel_err": 0.0, + "name": "gen0706", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042706", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen0707", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042707", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen0708", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042708", + "values_compared": 381 + }, + { + "max_rel_err": 0.0, + "name": "gen0709", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042709", + "values_compared": 301 + }, + { + "max_rel_err": 0.0, + "name": "gen0710", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042710", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen0711", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042711", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0712", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042712", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen0713", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042713", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen0714", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042714", + "values_compared": 164 + }, + { + "max_rel_err": 0.0, + "name": "gen0715", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042715", + "values_compared": 226 + }, + { + "max_rel_err": 0.0, + "name": "gen0716", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042716", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen0717", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042717", + "values_compared": 169 + }, + { + "max_rel_err": 0.0, + "name": "gen0718", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042718", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen0719", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042719", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen0720", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042720", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0721", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042721", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen0722", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042722", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0723", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042723", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0724", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042724", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen0725", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042725", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen0726", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042726", + "values_compared": 249 + }, + { + "max_rel_err": 0.0, + "name": "gen0727", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042727", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen0728", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042728", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0729", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042729", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0730", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042730", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen0731", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042731", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen0732", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042732", + "values_compared": 318 + }, + { + "max_rel_err": 0.0, + "name": "gen0733", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042733", + "values_compared": 349 + }, + { + "max_rel_err": 0.0, + "name": "gen0734", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042734", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen0735", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042735", + "values_compared": 185 + }, + { + "max_rel_err": 0.0, + "name": "gen0736", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042736", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen0737", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042737", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0738", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042738", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen0739", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042739", + "values_compared": 245 + }, + { + "max_rel_err": 0.0, + "name": "gen0740", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042740", + "values_compared": 43 + }, + { + "max_rel_err": 0.0, + "name": "gen0741", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042741", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen0742", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042742", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen0743", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042743", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0744", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042744", + "values_compared": 235 + }, + { + "max_rel_err": 0.0, + "name": "gen0745", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042745", + "values_compared": 295 + }, + { + "max_rel_err": 0.0, + "name": "gen0746", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042746", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen0747", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042747", + "values_compared": 51 + }, + { + "max_rel_err": 0.0, + "name": "gen0748", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042748", + "values_compared": 108 + }, + { + "max_rel_err": 0.0, + "name": "gen0749", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042749", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0750", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042750", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0751", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042751", + "values_compared": 150 + }, + { + "max_rel_err": 0.0, + "name": "gen0752", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042752", + "values_compared": 199 + }, + { + "max_rel_err": 0.0, + "name": "gen0753", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042753", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen0754", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042754", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0755", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042755", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0756", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042756", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen0757", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042757", + "values_compared": 70 + }, + { + "max_rel_err": 0.0, + "name": "gen0758", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042758", + "values_compared": 204 + }, + { + "max_rel_err": 0.0, + "name": "gen0759", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042759", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0760", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042760", + "values_compared": 204 + }, + { + "max_rel_err": 0.0, + "name": "gen0761", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042761", + "values_compared": 187 + }, + { + "max_rel_err": 0.0, + "name": "gen0762", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042762", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen0763", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042763", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0764", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042764", + "values_compared": 293 + }, + { + "max_rel_err": 0.0, + "name": "gen0765", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042765", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0766", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042766", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0767", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042767", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0768", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042768", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen0769", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042769", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen0770", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042770", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen0771", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042771", + "values_compared": 283 + }, + { + "max_rel_err": 0.0, + "name": "gen0772", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042772", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0773", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042773", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen0774", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042774", + "values_compared": 242 + }, + { + "max_rel_err": 0.0, + "name": "gen0775", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042775", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen0776", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042776", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen0777", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042777", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0778", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042778", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0779", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042779", + "values_compared": 145 + }, + { + "max_rel_err": 0.0, + "name": "gen0780", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042780", + "values_compared": 158 + }, + { + "max_rel_err": 0.0, + "name": "gen0781", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042781", + "values_compared": 20 + }, + { + "max_rel_err": 0.0, + "name": "gen0782", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042782", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0783", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042783", + "values_compared": 188 + }, + { + "max_rel_err": 0.0, + "name": "gen0784", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042784", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0785", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042785", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0786", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042786", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0787", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042787", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen0788", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042788", + "values_compared": 83 + }, + { + "max_rel_err": 0.0, + "name": "gen0789", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042789", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen0790", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042790", + "values_compared": 79 + }, + { + "max_rel_err": 0.0, + "name": "gen0791", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042791", + "values_compared": 174 + }, + { + "max_rel_err": 0.0, + "name": "gen0792", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042792", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0793", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042793", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen0794", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042794", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0795", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042795", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0796", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042796", + "values_compared": 380 + }, + { + "max_rel_err": 0.0, + "name": "gen0797", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042797", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen0798", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042798", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen0799", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042799", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen0800", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042800", + "values_compared": 83 + }, + { + "max_rel_err": 0.0, + "name": "gen0801", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042801", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0802", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042802", + "values_compared": 152 + }, + { + "max_rel_err": 0.0, + "name": "gen0803", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042803", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen0804", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042804", + "values_compared": 82 + }, + { + "max_rel_err": 0.0, + "name": "gen0805", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042805", + "values_compared": 297 + }, + { + "max_rel_err": 0.0, + "name": "gen0806", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042806", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0807", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042807", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen0808", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042808", + "values_compared": 172 + }, + { + "max_rel_err": 0.0, + "name": "gen0809", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042809", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen0810", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042810", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0811", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042811", + "values_compared": 287 + }, + { + "max_rel_err": 0.0, + "name": "gen0812", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042812", + "values_compared": 348 + }, + { + "max_rel_err": 0.0, + "name": "gen0813", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042813", + "values_compared": 334 + }, + { + "max_rel_err": 0.0, + "name": "gen0814", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042814", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0815", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042815", + "values_compared": 174 + }, + { + "max_rel_err": 0.0, + "name": "gen0816", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042816", + "values_compared": 282 + }, + { + "max_rel_err": 0.0, + "name": "gen0817", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042817", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0818", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042818", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen0819", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042819", + "values_compared": 378 + }, + { + "max_rel_err": 0.0, + "name": "gen0820", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042820", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen0821", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042821", + "values_compared": 348 + }, + { + "max_rel_err": 0.0, + "name": "gen0822", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042822", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0823", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042823", + "values_compared": 289 + }, + { + "max_rel_err": 0.0, + "name": "gen0824", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042824", + "values_compared": 238 + }, + { + "max_rel_err": 0.0, + "name": "gen0825", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042825", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen0826", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042826", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0827", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042827", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0828", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042828", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0829", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042829", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen0830", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042830", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0831", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042831", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0832", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042832", + "values_compared": 146 + }, + { + "max_rel_err": 0.0, + "name": "gen0833", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042833", + "values_compared": 159 + }, + { + "max_rel_err": 0.0, + "name": "gen0834", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042834", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen0835", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042835", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen0836", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042836", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen0837", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042837", + "values_compared": 182 + }, + { + "max_rel_err": 0.0, + "name": "gen0838", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042838", + "values_compared": 367 + }, + { + "max_rel_err": 0.0, + "name": "gen0839", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042839", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen0840", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042840", + "values_compared": 198 + }, + { + "max_rel_err": 0.0, + "name": "gen0841", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042841", + "values_compared": 197 + }, + { + "max_rel_err": 0.0, + "name": "gen0842", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042842", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0843", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042843", + "values_compared": 195 + }, + { + "max_rel_err": 0.0, + "name": "gen0844", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042844", + "values_compared": 181 + }, + { + "max_rel_err": 0.0, + "name": "gen0845", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042845", + "values_compared": 13 + }, + { + "max_rel_err": 0.0, + "name": "gen0846", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042846", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen0847", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042847", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0848", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042848", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen0849", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042849", + "values_compared": 150 + }, + { + "max_rel_err": 0.0, + "name": "gen0850", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042850", + "values_compared": 159 + }, + { + "max_rel_err": 0.0, + "name": "gen0851", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042851", + "values_compared": 165 + }, + { + "max_rel_err": 0.0, + "name": "gen0852", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042852", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen0853", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042853", + "values_compared": 150 + }, + { + "max_rel_err": 0.0, + "name": "gen0854", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042854", + "values_compared": 281 + }, + { + "max_rel_err": 0.0, + "name": "gen0855", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042855", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0856", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042856", + "values_compared": 169 + }, + { + "max_rel_err": 0.0, + "name": "gen0857", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042857", + "values_compared": 133 + }, + { + "max_rel_err": 0.0, + "name": "gen0858", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042858", + "values_compared": 176 + }, + { + "max_rel_err": 0.0, + "name": "gen0859", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042859", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen0860", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042860", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen0861", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042861", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen0862", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042862", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen0863", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042863", + "values_compared": 388 + }, + { + "max_rel_err": 0.0, + "name": "gen0864", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042864", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen0865", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042865", + "values_compared": 83 + }, + { + "max_rel_err": 0.0, + "name": "gen0866", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042866", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen0867", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042867", + "values_compared": 77 + }, + { + "max_rel_err": 0.0, + "name": "gen0868", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042868", + "values_compared": 68 + }, + { + "max_rel_err": 0.0, + "name": "gen0869", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042869", + "values_compared": 167 + }, + { + "max_rel_err": 0.0, + "name": "gen0870", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042870", + "values_compared": 43 + }, + { + "max_rel_err": 0.0, + "name": "gen0871", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042871", + "values_compared": 138 + }, + { + "max_rel_err": 0.0, + "name": "gen0872", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042872", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen0873", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042873", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen0874", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042874", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen0875", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042875", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen0876", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042876", + "values_compared": 139 + }, + { + "max_rel_err": 0.0, + "name": "gen0877", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042877", + "values_compared": 259 + }, + { + "max_rel_err": 0.0, + "name": "gen0878", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042878", + "values_compared": 286 + }, + { + "max_rel_err": 0.0, + "name": "gen0879", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042879", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "gen0880", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042880", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen0881", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042881", + "values_compared": 209 + }, + { + "max_rel_err": 0.0, + "name": "gen0882", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042882", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0883", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042883", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen0884", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042884", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0885", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042885", + "values_compared": 138 + }, + { + "max_rel_err": 0.0, + "name": "gen0886", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042886", + "values_compared": 167 + }, + { + "max_rel_err": 0.0, + "name": "gen0887", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042887", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen0888", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042888", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen0889", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042889", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0890", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042890", + "values_compared": 348 + }, + { + "max_rel_err": 0.0, + "name": "gen0891", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042891", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0892", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042892", + "values_compared": 342 + }, + { + "max_rel_err": 0.0, + "name": "gen0893", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042893", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0894", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042894", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen0895", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042895", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen0896", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042896", + "values_compared": 285 + }, + { + "max_rel_err": 0.0, + "name": "gen0897", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042897", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0898", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042898", + "values_compared": 191 + }, + { + "max_rel_err": 0.0, + "name": "gen0899", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042899", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen0900", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042900", + "values_compared": 234 + }, + { + "max_rel_err": 0.0, + "name": "gen0901", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042901", + "values_compared": 228 + }, + { + "max_rel_err": 0.0, + "name": "gen0902", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042902", + "values_compared": 214 + }, + { + "max_rel_err": 0.0, + "name": "gen0903", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042903", + "values_compared": 101 + }, + { + "max_rel_err": 0.0, + "name": "gen0904", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042904", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen0905", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042905", + "values_compared": 289 + }, + { + "max_rel_err": 0.0, + "name": "gen0906", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042906", + "values_compared": 205 + }, + { + "max_rel_err": 0.0, + "name": "gen0907", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042907", + "values_compared": 83 + }, + { + "max_rel_err": 0.0, + "name": "gen0908", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042908", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0909", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042909", + "values_compared": 20 + }, + { + "max_rel_err": 0.0, + "name": "gen0910", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042910", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen0911", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042911", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen0912", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042912", + "values_compared": 214 + }, + { + "max_rel_err": 0.0, + "name": "gen0913", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042913", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0914", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042914", + "values_compared": 283 + }, + { + "max_rel_err": 0.0, + "name": "gen0915", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042915", + "values_compared": 190 + }, + { + "max_rel_err": 0.0, + "name": "gen0916", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042916", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0917", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042917", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen0918", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042918", + "values_compared": 111 + }, + { + "max_rel_err": 0.0, + "name": "gen0919", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042919", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen0920", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042920", + "values_compared": 19 + }, + { + "max_rel_err": 0.0, + "name": "gen0921", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042921", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen0922", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042922", + "values_compared": 15 + }, + { + "max_rel_err": 0.0, + "name": "gen0923", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042923", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0924", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042924", + "values_compared": 82 + }, + { + "max_rel_err": 0.0, + "name": "gen0925", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042925", + "values_compared": 312 + }, + { + "max_rel_err": 0.0, + "name": "gen0926", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042926", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0927", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042927", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen0928", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042928", + "values_compared": 316 + }, + { + "max_rel_err": 0.0, + "name": "gen0929", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042929", + "values_compared": 144 + }, + { + "max_rel_err": 0.0, + "name": "gen0930", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042930", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen0931", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042931", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0932", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042932", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen0933", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042933", + "values_compared": 175 + }, + { + "max_rel_err": 0.0, + "name": "gen0934", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042934", + "values_compared": 165 + }, + { + "max_rel_err": 0.0, + "name": "gen0935", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042935", + "values_compared": 208 + }, + { + "max_rel_err": 0.0, + "name": "gen0936", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042936", + "values_compared": 159 + }, + { + "max_rel_err": 0.0, + "name": "gen0937", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042937", + "values_compared": 119 + }, + { + "max_rel_err": 0.0, + "name": "gen0938", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042938", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen0939", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042939", + "values_compared": 31 + }, + { + "max_rel_err": 0.0, + "name": "gen0940", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042940", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0941", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042941", + "values_compared": 365 + }, + { + "max_rel_err": 0.0, + "name": "gen0942", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042942", + "values_compared": 182 + }, + { + "max_rel_err": 0.0, + "name": "gen0943", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042943", + "values_compared": 106 + }, + { + "max_rel_err": 0.0, + "name": "gen0944", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042944", + "values_compared": 370 + }, + { + "max_rel_err": 0.0, + "name": "gen0945", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042945", + "values_compared": 77 + }, + { + "max_rel_err": 0.0, + "name": "gen0946", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042946", + "values_compared": 195 + }, + { + "max_rel_err": 0.0, + "name": "gen0947", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042947", + "values_compared": 260 + }, + { + "max_rel_err": 0.0, + "name": "gen0948", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042948", + "values_compared": 126 + }, + { + "max_rel_err": 0.0, + "name": "gen0949", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042949", + "values_compared": 21 + }, + { + "max_rel_err": 0.0, + "name": "gen0950", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042950", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen0951", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042951", + "values_compared": 233 + }, + { + "max_rel_err": 0.0, + "name": "gen0952", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042952", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0953", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042953", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen0954", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042954", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen0955", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042955", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen0956", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042956", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen0957", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042957", + "values_compared": 129 + }, + { + "max_rel_err": 0.0, + "name": "gen0958", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042958", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen0959", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042959", + "values_compared": 53 + }, + { + "max_rel_err": 0.0, + "name": "gen0960", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042960", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen0961", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042961", + "values_compared": 33 + }, + { + "max_rel_err": 0.0, + "name": "gen0962", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042962", + "values_compared": 227 + }, + { + "max_rel_err": 0.0, + "name": "gen0963", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042963", + "values_compared": 329 + }, + { + "max_rel_err": 0.0, + "name": "gen0964", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042964", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen0965", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042965", + "values_compared": 28 + }, + { + "max_rel_err": 0.0, + "name": "gen0966", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042966", + "values_compared": 71 + }, + { + "max_rel_err": 0.0, + "name": "gen0967", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042967", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen0968", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042968", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen0969", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042969", + "values_compared": 129 + }, + { + "max_rel_err": 0.0, + "name": "gen0970", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042970", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen0971", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042971", + "values_compared": 126 + }, + { + "max_rel_err": 0.0, + "name": "gen0972", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042972", + "values_compared": 144 + }, + { + "max_rel_err": 0.0, + "name": "gen0973", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042973", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen0974", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042974", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen0975", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042975", + "values_compared": 75 + }, + { + "max_rel_err": 0.0, + "name": "gen0976", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042976", + "values_compared": 361 + }, + { + "max_rel_err": 0.0, + "name": "gen0977", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042977", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen0978", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042978", + "values_compared": 64 + }, + { + "max_rel_err": 0.0, + "name": "gen0979", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042979", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen0980", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042980", + "values_compared": 172 + }, + { + "max_rel_err": 0.0, + "name": "gen0981", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042981", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen0982", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042982", + "values_compared": 142 + }, + { + "max_rel_err": 0.0, + "name": "gen0983", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042983", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen0984", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042984", + "values_compared": 244 + }, + { + "max_rel_err": 0.0, + "name": "gen0985", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042985", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen0986", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042986", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen0987", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042987", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen0988", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042988", + "values_compared": 138 + }, + { + "max_rel_err": 0.0, + "name": "gen0989", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042989", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen0990", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042990", + "values_compared": 295 + }, + { + "max_rel_err": 0.0, + "name": "gen0991", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042991", + "values_compared": 244 + }, + { + "max_rel_err": 0.0, + "name": "gen0992", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042992", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen0993", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042993", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen0994", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042994", + "values_compared": 198 + }, + { + "max_rel_err": 0.0, + "name": "gen0995", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042995", + "values_compared": 354 + }, + { + "max_rel_err": 0.0, + "name": "gen0996", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042996", + "values_compared": 377 + }, + { + "max_rel_err": 0.0, + "name": "gen0997", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042997", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen0998", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042998", + "values_compared": 19 + }, + { + "max_rel_err": 0.0, + "name": "gen0999", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898042999", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen1000", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043000", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen1001", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043001", + "values_compared": 41 + }, + { + "max_rel_err": 0.0, + "name": "gen1002", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043002", + "values_compared": 133 + }, + { + "max_rel_err": 0.0, + "name": "gen1003", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043003", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen1004", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043004", + "values_compared": 13 + }, + { + "max_rel_err": 0.0, + "name": "gen1005", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043005", + "values_compared": 262 + }, + { + "max_rel_err": 0.0, + "name": "gen1006", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043006", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen1007", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043007", + "values_compared": 259 + }, + { + "max_rel_err": 0.0, + "name": "gen1008", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043008", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen1009", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043009", + "values_compared": 29 + }, + { + "max_rel_err": 0.0, + "name": "gen1010", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043010", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen1011", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043011", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen1012", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043012", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen1013", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043013", + "values_compared": 204 + }, + { + "max_rel_err": 0.0, + "name": "gen1014", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043014", + "values_compared": 355 + }, + { + "max_rel_err": 0.0, + "name": "gen1015", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043015", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen1016", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043016", + "values_compared": 162 + }, + { + "max_rel_err": 0.0, + "name": "gen1017", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043017", + "values_compared": 169 + }, + { + "max_rel_err": 0.0, + "name": "gen1018", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043018", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen1019", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043019", + "values_compared": 329 + }, + { + "max_rel_err": 0.0, + "name": "gen1020", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043020", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen1021", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043021", + "values_compared": 243 + }, + { + "max_rel_err": 0.0, + "name": "gen1022", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043022", + "values_compared": 196 + }, + { + "max_rel_err": 0.0, + "name": "gen1023", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043023", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen1024", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043024", + "values_compared": 161 + }, + { + "max_rel_err": 0.0, + "name": "gen1025", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043025", + "values_compared": 161 + }, + { + "max_rel_err": 0.0, + "name": "gen1026", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043026", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen1027", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043027", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen1028", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043028", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen1029", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043029", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen1030", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043030", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen1031", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043031", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen1032", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043032", + "values_compared": 159 + }, + { + "max_rel_err": 0.0, + "name": "gen1033", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043033", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1034", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043034", + "values_compared": 43 + }, + { + "max_rel_err": 0.0, + "name": "gen1035", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043035", + "values_compared": 70 + }, + { + "max_rel_err": 0.0, + "name": "gen1036", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043036", + "values_compared": 21 + }, + { + "max_rel_err": 0.0, + "name": "gen1037", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043037", + "values_compared": 246 + }, + { + "max_rel_err": 0.0, + "name": "gen1038", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043038", + "values_compared": 248 + }, + { + "max_rel_err": 0.0, + "name": "gen1039", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043039", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen1040", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043040", + "values_compared": 337 + }, + { + "max_rel_err": 0.0, + "name": "gen1041", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043041", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen1042", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043042", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1043", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043043", + "values_compared": 250 + }, + { + "max_rel_err": 0.0, + "name": "gen1044", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043044", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1045", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043045", + "values_compared": 380 + }, + { + "max_rel_err": 0.0, + "name": "gen1046", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043046", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen1047", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043047", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen1048", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043048", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1049", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043049", + "values_compared": 308 + }, + { + "max_rel_err": 0.0, + "name": "gen1050", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043050", + "values_compared": 68 + }, + { + "max_rel_err": 0.0, + "name": "gen1051", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043051", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen1052", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043052", + "values_compared": 212 + }, + { + "max_rel_err": 0.0, + "name": "gen1053", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043053", + "values_compared": 79 + }, + { + "max_rel_err": 0.0, + "name": "gen1054", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043054", + "values_compared": 280 + }, + { + "max_rel_err": 0.0, + "name": "gen1055", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043055", + "values_compared": 317 + }, + { + "max_rel_err": 0.0, + "name": "gen1056", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043056", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1057", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043057", + "values_compared": 172 + }, + { + "max_rel_err": 0.0, + "name": "gen1058", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043058", + "values_compared": 19 + }, + { + "max_rel_err": 0.0, + "name": "gen1059", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043059", + "values_compared": 57 + }, + { + "max_rel_err": 0.0, + "name": "gen1060", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043060", + "values_compared": 326 + }, + { + "max_rel_err": 0.0, + "name": "gen1061", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043061", + "values_compared": 314 + }, + { + "max_rel_err": 0.0, + "name": "gen1062", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043062", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen1063", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043063", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen1064", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043064", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen1065", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043065", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen1066", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043066", + "values_compared": 293 + }, + { + "max_rel_err": 0.0, + "name": "gen1067", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043067", + "values_compared": 216 + }, + { + "max_rel_err": 0.0, + "name": "gen1068", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043068", + "values_compared": 100 + }, + { + "max_rel_err": 0.0, + "name": "gen1069", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043069", + "values_compared": 371 + }, + { + "max_rel_err": 0.0, + "name": "gen1070", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043070", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen1071", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043071", + "values_compared": 82 + }, + { + "max_rel_err": 0.0, + "name": "gen1072", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043072", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen1073", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043073", + "values_compared": 139 + }, + { + "max_rel_err": 0.0, + "name": "gen1074", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043074", + "values_compared": 10 + }, + { + "max_rel_err": 0.0, + "name": "gen1075", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043075", + "values_compared": 83 + }, + { + "max_rel_err": 0.0, + "name": "gen1076", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043076", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen1077", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043077", + "values_compared": 221 + }, + { + "max_rel_err": 0.0, + "name": "gen1078", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043078", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen1079", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043079", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen1080", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043080", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen1081", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043081", + "values_compared": 15 + }, + { + "max_rel_err": 0.0, + "name": "gen1082", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043082", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen1083", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043083", + "values_compared": 146 + }, + { + "max_rel_err": 0.0, + "name": "gen1084", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043084", + "values_compared": 153 + }, + { + "max_rel_err": 0.0, + "name": "gen1085", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043085", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen1086", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043086", + "values_compared": 68 + }, + { + "max_rel_err": 0.0, + "name": "gen1087", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043087", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen1088", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043088", + "values_compared": 134 + }, + { + "max_rel_err": 0.0, + "name": "gen1089", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043089", + "values_compared": 100 + }, + { + "max_rel_err": 0.0, + "name": "gen1090", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043090", + "values_compared": 338 + }, + { + "max_rel_err": 0.0, + "name": "gen1091", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043091", + "values_compared": 195 + }, + { + "max_rel_err": 0.0, + "name": "gen1092", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043092", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen1093", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043093", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen1094", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043094", + "values_compared": 192 + }, + { + "max_rel_err": 0.0, + "name": "gen1095", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043095", + "values_compared": 29 + }, + { + "max_rel_err": 0.0, + "name": "gen1096", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043096", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen1097", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043097", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1098", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043098", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen1099", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043099", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen1100", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043100", + "values_compared": 251 + }, + { + "max_rel_err": 0.0, + "name": "gen1101", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043101", + "values_compared": 369 + }, + { + "max_rel_err": 0.0, + "name": "gen1102", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043102", + "values_compared": 256 + }, + { + "max_rel_err": 0.0, + "name": "gen1103", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043103", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen1104", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043104", + "values_compared": 224 + }, + { + "max_rel_err": 0.0, + "name": "gen1105", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043105", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen1106", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043106", + "values_compared": 198 + }, + { + "max_rel_err": 0.0, + "name": "gen1107", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043107", + "values_compared": 229 + }, + { + "max_rel_err": 0.0, + "name": "gen1108", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043108", + "values_compared": 150 + }, + { + "max_rel_err": 0.0, + "name": "gen1109", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043109", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1110", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043110", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen1111", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043111", + "values_compared": 252 + }, + { + "max_rel_err": 0.0, + "name": "gen1112", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043112", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1113", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043113", + "values_compared": 265 + }, + { + "max_rel_err": 0.0, + "name": "gen1114", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043114", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen1115", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043115", + "values_compared": 354 + }, + { + "max_rel_err": 0.0, + "name": "gen1116", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043116", + "values_compared": 145 + }, + { + "max_rel_err": 0.0, + "name": "gen1117", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043117", + "values_compared": 145 + }, + { + "max_rel_err": 0.0, + "name": "gen1118", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043118", + "values_compared": 176 + }, + { + "max_rel_err": 0.0, + "name": "gen1119", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043119", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen1120", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043120", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen1121", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043121", + "values_compared": 256 + }, + { + "max_rel_err": 0.0, + "name": "gen1122", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043122", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen1123", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043123", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen1124", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043124", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen1125", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043125", + "values_compared": 195 + }, + { + "max_rel_err": 0.0, + "name": "gen1126", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043126", + "values_compared": 165 + }, + { + "max_rel_err": 0.0, + "name": "gen1127", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043127", + "values_compared": 39 + }, + { + "max_rel_err": 0.0, + "name": "gen1128", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043128", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1129", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043129", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen1130", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043130", + "values_compared": 240 + }, + { + "max_rel_err": 0.0, + "name": "gen1131", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043131", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "gen1132", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043132", + "values_compared": 281 + }, + { + "max_rel_err": 0.0, + "name": "gen1133", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043133", + "values_compared": 129 + }, + { + "max_rel_err": 0.0, + "name": "gen1134", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043134", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen1135", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043135", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen1136", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043136", + "values_compared": 227 + }, + { + "max_rel_err": 0.0, + "name": "gen1137", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043137", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen1138", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043138", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen1139", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043139", + "values_compared": 242 + }, + { + "max_rel_err": 0.0, + "name": "gen1140", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043140", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1141", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043141", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1142", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043142", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen1143", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043143", + "values_compared": 94 + }, + { + "max_rel_err": 0.0, + "name": "gen1144", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043144", + "values_compared": 122 + }, + { + "max_rel_err": 0.0, + "name": "gen1145", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043145", + "values_compared": 138 + }, + { + "max_rel_err": 0.0, + "name": "gen1146", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043146", + "values_compared": 101 + }, + { + "max_rel_err": 0.0, + "name": "gen1147", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043147", + "values_compared": 180 + }, + { + "max_rel_err": 0.0, + "name": "gen1148", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043148", + "values_compared": 201 + }, + { + "max_rel_err": 0.0, + "name": "gen1149", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043149", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen1150", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043150", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen1151", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043151", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen1152", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043152", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen1153", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043153", + "values_compared": 138 + }, + { + "max_rel_err": 0.0, + "name": "gen1154", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043154", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen1155", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043155", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1156", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043156", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen1157", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043157", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1158", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043158", + "values_compared": 147 + }, + { + "max_rel_err": 0.0, + "name": "gen1159", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043159", + "values_compared": 385 + }, + { + "max_rel_err": 0.0, + "name": "gen1160", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043160", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen1161", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043161", + "values_compared": 351 + }, + { + "max_rel_err": 0.0, + "name": "gen1162", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043162", + "values_compared": 200 + }, + { + "max_rel_err": 0.0, + "name": "gen1163", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043163", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen1164", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043164", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen1165", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043165", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1166", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043166", + "values_compared": 204 + }, + { + "max_rel_err": 0.0, + "name": "gen1167", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043167", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen1168", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043168", + "values_compared": 28 + }, + { + "max_rel_err": 0.0, + "name": "gen1169", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043169", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen1170", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043170", + "values_compared": 202 + }, + { + "max_rel_err": 0.0, + "name": "gen1171", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043171", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1172", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043172", + "values_compared": 206 + }, + { + "max_rel_err": 0.0, + "name": "gen1173", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043173", + "values_compared": 161 + }, + { + "max_rel_err": 0.0, + "name": "gen1174", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043174", + "values_compared": 291 + }, + { + "max_rel_err": 0.0, + "name": "gen1175", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043175", + "values_compared": 108 + }, + { + "max_rel_err": 0.0, + "name": "gen1176", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043176", + "values_compared": 101 + }, + { + "max_rel_err": 0.0, + "name": "gen1177", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043177", + "values_compared": 195 + }, + { + "max_rel_err": 0.0, + "name": "gen1178", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043178", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen1179", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043179", + "values_compared": 239 + }, + { + "max_rel_err": 0.0, + "name": "gen1180", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043180", + "values_compared": 119 + }, + { + "max_rel_err": 0.0, + "name": "gen1181", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043181", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1182", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043182", + "values_compared": 298 + }, + { + "max_rel_err": 0.0, + "name": "gen1183", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043183", + "values_compared": 243 + }, + { + "max_rel_err": 0.0, + "name": "gen1184", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043184", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen1185", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043185", + "values_compared": 268 + }, + { + "max_rel_err": 0.0, + "name": "gen1186", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043186", + "values_compared": 129 + }, + { + "max_rel_err": 0.0, + "name": "gen1187", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043187", + "values_compared": 23 + }, + { + "max_rel_err": 0.0, + "name": "gen1188", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043188", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen1189", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043189", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen1190", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043190", + "values_compared": 165 + }, + { + "max_rel_err": 0.0, + "name": "gen1191", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043191", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen1192", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043192", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen1193", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043193", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen1194", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043194", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1195", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043195", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1196", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043196", + "values_compared": 175 + }, + { + "max_rel_err": 0.0, + "name": "gen1197", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043197", + "values_compared": 84 + }, + { + "max_rel_err": 0.0, + "name": "gen1198", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043198", + "values_compared": 47 + }, + { + "max_rel_err": 0.0, + "name": "gen1199", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043199", + "values_compared": 69 + }, + { + "max_rel_err": 0.0, + "name": "gen1200", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043200", + "values_compared": 146 + }, + { + "max_rel_err": 0.0, + "name": "gen1201", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043201", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen1202", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043202", + "values_compared": 207 + }, + { + "max_rel_err": 0.0, + "name": "gen1203", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043203", + "values_compared": 176 + }, + { + "max_rel_err": 0.0, + "name": "gen1204", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043204", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen1205", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043205", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen1206", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043206", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen1207", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043207", + "values_compared": 381 + }, + { + "max_rel_err": 0.0, + "name": "gen1208", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043208", + "values_compared": 167 + }, + { + "max_rel_err": 0.0, + "name": "gen1209", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043209", + "values_compared": 212 + }, + { + "max_rel_err": 0.0, + "name": "gen1210", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043210", + "values_compared": 264 + }, + { + "max_rel_err": 0.0, + "name": "gen1211", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043211", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1212", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043212", + "values_compared": 250 + }, + { + "max_rel_err": 0.0, + "name": "gen1213", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043213", + "values_compared": 289 + }, + { + "max_rel_err": 0.0, + "name": "gen1214", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043214", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen1215", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043215", + "values_compared": 276 + }, + { + "max_rel_err": 0.0, + "name": "gen1216", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043216", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen1217", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043217", + "values_compared": 68 + }, + { + "max_rel_err": 0.0, + "name": "gen1218", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043218", + "values_compared": 158 + }, + { + "max_rel_err": 0.0, + "name": "gen1219", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043219", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen1220", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043220", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen1221", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043221", + "values_compared": 258 + }, + { + "max_rel_err": 0.0, + "name": "gen1222", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043222", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen1223", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043223", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1224", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043224", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen1225", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043225", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen1226", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043226", + "values_compared": 173 + }, + { + "max_rel_err": 0.0, + "name": "gen1227", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043227", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1228", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043228", + "values_compared": 356 + }, + { + "max_rel_err": 0.0, + "name": "gen1229", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043229", + "values_compared": 144 + }, + { + "max_rel_err": 0.0, + "name": "gen1230", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043230", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen1231", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043231", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen1232", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043232", + "values_compared": 174 + }, + { + "max_rel_err": 0.0, + "name": "gen1233", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043233", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1234", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043234", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen1235", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043235", + "values_compared": 181 + }, + { + "max_rel_err": 0.0, + "name": "gen1236", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043236", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen1237", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043237", + "values_compared": 83 + }, + { + "max_rel_err": 0.0, + "name": "gen1238", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043238", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen1239", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043239", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen1240", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043240", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen1241", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043241", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen1242", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043242", + "values_compared": 39 + }, + { + "max_rel_err": 0.0, + "name": "gen1243", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043243", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen1244", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043244", + "values_compared": 274 + }, + { + "max_rel_err": 0.0, + "name": "gen1245", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043245", + "values_compared": 166 + }, + { + "max_rel_err": 0.0, + "name": "gen1246", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043246", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen1247", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043247", + "values_compared": 232 + }, + { + "max_rel_err": 0.0, + "name": "gen1248", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043248", + "values_compared": 194 + }, + { + "max_rel_err": 0.0, + "name": "gen1249", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043249", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1250", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043250", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen1251", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043251", + "values_compared": 11 + }, + { + "max_rel_err": 0.0, + "name": "gen1252", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043252", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1253", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043253", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen1254", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043254", + "values_compared": 192 + }, + { + "max_rel_err": 0.0, + "name": "gen1255", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043255", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen1256", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043256", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen1257", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043257", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen1258", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043258", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen1259", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043259", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen1260", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043260", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen1261", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043261", + "values_compared": 84 + }, + { + "max_rel_err": 0.0, + "name": "gen1262", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043262", + "values_compared": 150 + }, + { + "max_rel_err": 0.0, + "name": "gen1263", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043263", + "values_compared": 68 + }, + { + "max_rel_err": 0.0, + "name": "gen1264", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043264", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen1265", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043265", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen1266", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043266", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen1267", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043267", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen1268", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043268", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1269", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043269", + "values_compared": 191 + }, + { + "max_rel_err": 0.0, + "name": "gen1270", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043270", + "values_compared": 402 + }, + { + "max_rel_err": 0.0, + "name": "gen1271", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043271", + "values_compared": 306 + }, + { + "max_rel_err": 0.0, + "name": "gen1272", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043272", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen1273", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043273", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen1274", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043274", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen1275", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043275", + "values_compared": 151 + }, + { + "max_rel_err": 0.0, + "name": "gen1276", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043276", + "values_compared": 50 + }, + { + "max_rel_err": 0.0, + "name": "gen1277", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043277", + "values_compared": 202 + }, + { + "max_rel_err": 0.0, + "name": "gen1278", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043278", + "values_compared": 202 + }, + { + "max_rel_err": 0.0, + "name": "gen1279", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043279", + "values_compared": 106 + }, + { + "max_rel_err": 0.0, + "name": "gen1280", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043280", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen1281", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043281", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen1282", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043282", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen1283", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043283", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1284", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043284", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen1285", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043285", + "values_compared": 378 + }, + { + "max_rel_err": 0.0, + "name": "gen1286", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043286", + "values_compared": 29 + }, + { + "max_rel_err": 0.0, + "name": "gen1287", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043287", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen1288", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043288", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen1289", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043289", + "values_compared": 221 + }, + { + "max_rel_err": 0.0, + "name": "gen1290", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043290", + "values_compared": 106 + }, + { + "max_rel_err": 0.0, + "name": "gen1291", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043291", + "values_compared": 107 + }, + { + "max_rel_err": 0.0, + "name": "gen1292", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043292", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen1293", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043293", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen1294", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043294", + "values_compared": 278 + }, + { + "max_rel_err": 0.0, + "name": "gen1295", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043295", + "values_compared": 17 + }, + { + "max_rel_err": 0.0, + "name": "gen1296", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043296", + "values_compared": 254 + }, + { + "max_rel_err": 0.0, + "name": "gen1297", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043297", + "values_compared": 164 + }, + { + "max_rel_err": 0.0, + "name": "gen1298", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043298", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen1299", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043299", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen1300", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043300", + "values_compared": 19 + }, + { + "max_rel_err": 0.0, + "name": "gen1301", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043301", + "values_compared": 107 + }, + { + "max_rel_err": 0.0, + "name": "gen1302", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043302", + "values_compared": 137 + }, + { + "max_rel_err": 0.0, + "name": "gen1303", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043303", + "values_compared": 212 + }, + { + "max_rel_err": 0.0, + "name": "gen1304", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043304", + "values_compared": 144 + }, + { + "max_rel_err": 0.0, + "name": "gen1305", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043305", + "values_compared": 263 + }, + { + "max_rel_err": 0.0, + "name": "gen1306", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043306", + "values_compared": 304 + }, + { + "max_rel_err": 0.0, + "name": "gen1307", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043307", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen1308", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043308", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1309", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043309", + "values_compared": 241 + }, + { + "max_rel_err": 0.0, + "name": "gen1310", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043310", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen1311", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043311", + "values_compared": 189 + }, + { + "max_rel_err": 0.0, + "name": "gen1312", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043312", + "values_compared": 168 + }, + { + "max_rel_err": 0.0, + "name": "gen1313", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043313", + "values_compared": 338 + }, + { + "max_rel_err": 0.0, + "name": "gen1314", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043314", + "values_compared": 149 + }, + { + "max_rel_err": 0.0, + "name": "gen1315", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043315", + "values_compared": 23 + }, + { + "max_rel_err": 0.0, + "name": "gen1316", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043316", + "values_compared": 237 + }, + { + "max_rel_err": 0.0, + "name": "gen1317", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043317", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen1318", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043318", + "values_compared": 173 + }, + { + "max_rel_err": 0.0, + "name": "gen1319", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043319", + "values_compared": 69 + }, + { + "max_rel_err": 0.0, + "name": "gen1320", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043320", + "values_compared": 47 + }, + { + "max_rel_err": 0.0, + "name": "gen1321", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043321", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen1322", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043322", + "values_compared": 51 + }, + { + "max_rel_err": 0.0, + "name": "gen1323", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043323", + "values_compared": 291 + }, + { + "max_rel_err": 0.0, + "name": "gen1324", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043324", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1325", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043325", + "values_compared": 320 + }, + { + "max_rel_err": 0.0, + "name": "gen1326", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043326", + "values_compared": 251 + }, + { + "max_rel_err": 0.0, + "name": "gen1327", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043327", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen1328", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043328", + "values_compared": 289 + }, + { + "max_rel_err": 0.0, + "name": "gen1329", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043329", + "values_compared": 16 + }, + { + "max_rel_err": 0.0, + "name": "gen1330", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043330", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen1331", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043331", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen1332", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043332", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen1333", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043333", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen1334", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043334", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen1335", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043335", + "values_compared": 144 + }, + { + "max_rel_err": 0.0, + "name": "gen1336", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043336", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen1337", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043337", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen1338", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043338", + "values_compared": 151 + }, + { + "max_rel_err": 0.0, + "name": "gen1339", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043339", + "values_compared": 98 + }, + { + "max_rel_err": 0.0, + "name": "gen1340", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043340", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen1341", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043341", + "values_compared": 287 + }, + { + "max_rel_err": 0.0, + "name": "gen1342", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043342", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen1343", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043343", + "values_compared": 186 + }, + { + "max_rel_err": 0.0, + "name": "gen1344", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043344", + "values_compared": 361 + }, + { + "max_rel_err": 0.0, + "name": "gen1345", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043345", + "values_compared": 167 + }, + { + "max_rel_err": 0.0, + "name": "gen1346", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043346", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen1347", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043347", + "values_compared": 206 + }, + { + "max_rel_err": 0.0, + "name": "gen1348", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043348", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen1349", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043349", + "values_compared": 17 + }, + { + "max_rel_err": 0.0, + "name": "gen1350", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043350", + "values_compared": 17 + }, + { + "max_rel_err": 0.0, + "name": "gen1351", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043351", + "values_compared": 344 + }, + { + "max_rel_err": 0.0, + "name": "gen1352", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043352", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1353", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043353", + "values_compared": 351 + }, + { + "max_rel_err": 0.0, + "name": "gen1354", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043354", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen1355", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043355", + "values_compared": 259 + }, + { + "max_rel_err": 0.0, + "name": "gen1356", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043356", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen1357", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043357", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen1358", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043358", + "values_compared": 214 + }, + { + "max_rel_err": 0.0, + "name": "gen1359", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043359", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen1360", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043360", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen1361", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043361", + "values_compared": 111 + }, + { + "max_rel_err": 0.0, + "name": "gen1362", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043362", + "values_compared": 139 + }, + { + "max_rel_err": 0.0, + "name": "gen1363", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043363", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen1364", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043364", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen1365", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043365", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen1366", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043366", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen1367", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043367", + "values_compared": 367 + }, + { + "max_rel_err": 0.0, + "name": "gen1368", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043368", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen1369", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043369", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen1370", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043370", + "values_compared": 82 + }, + { + "max_rel_err": 0.0, + "name": "gen1371", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043371", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen1372", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043372", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen1373", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043373", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen1374", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043374", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1375", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043375", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen1376", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043376", + "values_compared": 196 + }, + { + "max_rel_err": 0.0, + "name": "gen1377", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043377", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen1378", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043378", + "values_compared": 244 + }, + { + "max_rel_err": 0.0, + "name": "gen1379", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043379", + "values_compared": 139 + }, + { + "max_rel_err": 0.0, + "name": "gen1380", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043380", + "values_compared": 259 + }, + { + "max_rel_err": 0.0, + "name": "gen1381", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043381", + "values_compared": 279 + }, + { + "max_rel_err": 0.0, + "name": "gen1382", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043382", + "values_compared": 329 + }, + { + "max_rel_err": 0.0, + "name": "gen1383", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043383", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen1384", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043384", + "values_compared": 134 + }, + { + "max_rel_err": 0.0, + "name": "gen1385", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043385", + "values_compared": 210 + }, + { + "max_rel_err": 0.0, + "name": "gen1386", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043386", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1387", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043387", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen1388", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043388", + "values_compared": 192 + }, + { + "max_rel_err": 0.0, + "name": "gen1389", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043389", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen1390", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043390", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen1391", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043391", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen1392", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043392", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen1393", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043393", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen1394", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043394", + "values_compared": 193 + }, + { + "max_rel_err": 0.0, + "name": "gen1395", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043395", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1396", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043396", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1397", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043397", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1398", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043398", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen1399", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043399", + "values_compared": 154 + }, + { + "max_rel_err": 0.0, + "name": "gen1400", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043400", + "values_compared": 222 + }, + { + "max_rel_err": 0.0, + "name": "gen1401", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043401", + "values_compared": 129 + }, + { + "max_rel_err": 0.0, + "name": "gen1402", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043402", + "values_compared": 126 + }, + { + "max_rel_err": 0.0, + "name": "gen1403", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043403", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen1404", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043404", + "values_compared": 231 + }, + { + "max_rel_err": 0.0, + "name": "gen1405", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043405", + "values_compared": 70 + }, + { + "max_rel_err": 0.0, + "name": "gen1406", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043406", + "values_compared": 239 + }, + { + "max_rel_err": 0.0, + "name": "gen1407", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043407", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen1408", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043408", + "values_compared": 51 + }, + { + "max_rel_err": 0.0, + "name": "gen1409", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043409", + "values_compared": 262 + }, + { + "max_rel_err": 0.0, + "name": "gen1410", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043410", + "values_compared": 196 + }, + { + "max_rel_err": 0.0, + "name": "gen1411", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043411", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen1412", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043412", + "values_compared": 167 + }, + { + "max_rel_err": 0.0, + "name": "gen1413", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043413", + "values_compared": 279 + }, + { + "max_rel_err": 0.0, + "name": "gen1414", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043414", + "values_compared": 376 + }, + { + "max_rel_err": 0.0, + "name": "gen1415", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043415", + "values_compared": 128 + }, + { + "max_rel_err": 0.0, + "name": "gen1416", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043416", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen1417", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043417", + "values_compared": 224 + }, + { + "max_rel_err": 0.0, + "name": "gen1418", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043418", + "values_compared": 122 + }, + { + "max_rel_err": 0.0, + "name": "gen1419", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043419", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1420", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043420", + "values_compared": 28 + }, + { + "max_rel_err": 0.0, + "name": "gen1421", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043421", + "values_compared": 31 + }, + { + "max_rel_err": 0.0, + "name": "gen1422", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043422", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1423", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043423", + "values_compared": 107 + }, + { + "max_rel_err": 0.0, + "name": "gen1424", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043424", + "values_compared": 291 + }, + { + "max_rel_err": 0.0, + "name": "gen1425", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043425", + "values_compared": 162 + }, + { + "max_rel_err": 0.0, + "name": "gen1426", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043426", + "values_compared": 107 + }, + { + "max_rel_err": 0.0, + "name": "gen1427", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043427", + "values_compared": 356 + }, + { + "max_rel_err": 0.0, + "name": "gen1428", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043428", + "values_compared": 382 + }, + { + "max_rel_err": 0.0, + "name": "gen1429", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043429", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen1430", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043430", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen1431", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043431", + "values_compared": 180 + }, + { + "max_rel_err": 0.0, + "name": "gen1432", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043432", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1433", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043433", + "values_compared": 35 + }, + { + "max_rel_err": 0.0, + "name": "gen1434", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043434", + "values_compared": 69 + }, + { + "max_rel_err": 0.0, + "name": "gen1435", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043435", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen1436", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043436", + "values_compared": 168 + }, + { + "max_rel_err": 0.0, + "name": "gen1437", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043437", + "values_compared": 210 + }, + { + "max_rel_err": 0.0, + "name": "gen1438", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043438", + "values_compared": 28 + }, + { + "max_rel_err": 0.0, + "name": "gen1439", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043439", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1440", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043440", + "values_compared": 197 + }, + { + "max_rel_err": 0.0, + "name": "gen1441", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043441", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen1442", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043442", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen1443", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043443", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen1444", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043444", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1445", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043445", + "values_compared": 353 + }, + { + "max_rel_err": 0.0, + "name": "gen1446", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043446", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen1447", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043447", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen1448", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043448", + "values_compared": 23 + }, + { + "max_rel_err": 0.0, + "name": "gen1449", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043449", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen1450", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043450", + "values_compared": 196 + }, + { + "max_rel_err": 0.0, + "name": "gen1451", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043451", + "values_compared": 206 + }, + { + "max_rel_err": 0.0, + "name": "gen1452", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043452", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen1453", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043453", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen1454", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043454", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen1455", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043455", + "values_compared": 50 + }, + { + "max_rel_err": 0.0, + "name": "gen1456", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043456", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen1457", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043457", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1458", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043458", + "values_compared": 26 + }, + { + "max_rel_err": 0.0, + "name": "gen1459", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043459", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen1460", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043460", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen1461", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043461", + "values_compared": 237 + }, + { + "max_rel_err": 0.0, + "name": "gen1462", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043462", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen1463", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043463", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen1464", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043464", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen1465", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043465", + "values_compared": 50 + }, + { + "max_rel_err": 0.0, + "name": "gen1466", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043466", + "values_compared": 198 + }, + { + "max_rel_err": 0.0, + "name": "gen1467", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043467", + "values_compared": 248 + }, + { + "max_rel_err": 0.0, + "name": "gen1468", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043468", + "values_compared": 155 + }, + { + "max_rel_err": 0.0, + "name": "gen1469", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043469", + "values_compared": 237 + }, + { + "max_rel_err": 0.0, + "name": "gen1470", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043470", + "values_compared": 359 + }, + { + "max_rel_err": 0.0, + "name": "gen1471", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043471", + "values_compared": 336 + }, + { + "max_rel_err": 0.0, + "name": "gen1472", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043472", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen1473", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043473", + "values_compared": 15 + }, + { + "max_rel_err": 0.0, + "name": "gen1474", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043474", + "values_compared": 269 + }, + { + "max_rel_err": 0.0, + "name": "gen1475", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043475", + "values_compared": 134 + }, + { + "max_rel_err": 0.0, + "name": "gen1476", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043476", + "values_compared": 383 + }, + { + "max_rel_err": 0.0, + "name": "gen1477", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043477", + "values_compared": 333 + }, + { + "max_rel_err": 0.0, + "name": "gen1478", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043478", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen1479", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043479", + "values_compared": 31 + }, + { + "max_rel_err": 0.0, + "name": "gen1480", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043480", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen1481", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043481", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen1482", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043482", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "gen1483", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043483", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen1484", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043484", + "values_compared": 134 + }, + { + "max_rel_err": 0.0, + "name": "gen1485", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043485", + "values_compared": 295 + }, + { + "max_rel_err": 0.0, + "name": "gen1486", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043486", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen1487", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043487", + "values_compared": 172 + }, + { + "max_rel_err": 0.0, + "name": "gen1488", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043488", + "values_compared": 173 + }, + { + "max_rel_err": 0.0, + "name": "gen1489", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043489", + "values_compared": 52 + }, + { + "max_rel_err": 0.0, + "name": "gen1490", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043490", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen1491", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043491", + "values_compared": 299 + }, + { + "max_rel_err": 0.0, + "name": "gen1492", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043492", + "values_compared": 71 + }, + { + "max_rel_err": 0.0, + "name": "gen1493", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043493", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen1494", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043494", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen1495", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043495", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen1496", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043496", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen1497", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043497", + "values_compared": 353 + }, + { + "max_rel_err": 0.0, + "name": "gen1498", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043498", + "values_compared": 288 + }, + { + "max_rel_err": 0.0, + "name": "gen1499", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043499", + "values_compared": 23 + }, + { + "max_rel_err": 0.0, + "name": "gen1500", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043500", + "values_compared": 112 + }, + { + "max_rel_err": 0.0, + "name": "gen1501", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043501", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen1502", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043502", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen1503", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043503", + "values_compared": 94 + }, + { + "max_rel_err": 0.0, + "name": "gen1504", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043504", + "values_compared": 47 + }, + { + "max_rel_err": 0.0, + "name": "gen1505", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043505", + "values_compared": 270 + }, + { + "max_rel_err": 0.0, + "name": "gen1506", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043506", + "values_compared": 111 + }, + { + "max_rel_err": 0.0, + "name": "gen1507", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043507", + "values_compared": 98 + }, + { + "max_rel_err": 0.0, + "name": "gen1508", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043508", + "values_compared": 172 + }, + { + "max_rel_err": 0.0, + "name": "gen1509", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043509", + "values_compared": 142 + }, + { + "max_rel_err": 0.0, + "name": "gen1510", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043510", + "values_compared": 188 + }, + { + "max_rel_err": 0.0, + "name": "gen1511", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043511", + "values_compared": 15 + }, + { + "max_rel_err": 0.0, + "name": "gen1512", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043512", + "values_compared": 211 + }, + { + "max_rel_err": 0.0, + "name": "gen1513", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043513", + "values_compared": 195 + }, + { + "max_rel_err": 0.0, + "name": "gen1514", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043514", + "values_compared": 197 + }, + { + "max_rel_err": 0.0, + "name": "gen1515", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043515", + "values_compared": 34 + }, + { + "max_rel_err": 0.0, + "name": "gen1516", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043516", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1517", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043517", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen1518", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043518", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen1519", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043519", + "values_compared": 75 + }, + { + "max_rel_err": 0.0, + "name": "gen1520", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043520", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen1521", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043521", + "values_compared": 38 + }, + { + "max_rel_err": 0.0, + "name": "gen1522", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043522", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen1523", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043523", + "values_compared": 59 + }, + { + "max_rel_err": 0.0, + "name": "gen1524", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043524", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen1525", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043525", + "values_compared": 239 + }, + { + "max_rel_err": 0.0, + "name": "gen1526", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043526", + "values_compared": 195 + }, + { + "max_rel_err": 0.0, + "name": "gen1527", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043527", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen1528", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043528", + "values_compared": 148 + }, + { + "max_rel_err": 0.0, + "name": "gen1529", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043529", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen1530", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043530", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen1531", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043531", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen1532", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043532", + "values_compared": 119 + }, + { + "max_rel_err": 0.0, + "name": "gen1533", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043533", + "values_compared": 92 + }, + { + "max_rel_err": 0.0, + "name": "gen1534", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043534", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1535", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043535", + "values_compared": 188 + }, + { + "max_rel_err": 0.0, + "name": "gen1536", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043536", + "values_compared": 385 + }, + { + "max_rel_err": 0.0, + "name": "gen1537", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043537", + "values_compared": 151 + }, + { + "max_rel_err": 0.0, + "name": "gen1538", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043538", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1539", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043539", + "values_compared": 371 + }, + { + "max_rel_err": 0.0, + "name": "gen1540", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043540", + "values_compared": 64 + }, + { + "max_rel_err": 0.0, + "name": "gen1541", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043541", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1542", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043542", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1543", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043543", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen1544", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043544", + "values_compared": 101 + }, + { + "max_rel_err": 0.0, + "name": "gen1545", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043545", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen1546", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043546", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1547", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043547", + "values_compared": 323 + }, + { + "max_rel_err": 0.0, + "name": "gen1548", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043548", + "values_compared": 108 + }, + { + "max_rel_err": 0.0, + "name": "gen1549", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043549", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1550", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043550", + "values_compared": 74 + }, + { + "max_rel_err": 0.0, + "name": "gen1551", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043551", + "values_compared": 282 + }, + { + "max_rel_err": 0.0, + "name": "gen1552", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043552", + "values_compared": 198 + }, + { + "max_rel_err": 0.0, + "name": "gen1553", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043553", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen1554", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043554", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen1555", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043555", + "values_compared": 139 + }, + { + "max_rel_err": 0.0, + "name": "gen1556", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043556", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "gen1557", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043557", + "values_compared": 16 + }, + { + "max_rel_err": 0.0, + "name": "gen1558", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043558", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen1559", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043559", + "values_compared": 227 + }, + { + "max_rel_err": 0.0, + "name": "gen1560", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043560", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen1561", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043561", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen1562", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043562", + "values_compared": 205 + }, + { + "max_rel_err": 0.0, + "name": "gen1563", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043563", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1564", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043564", + "values_compared": 193 + }, + { + "max_rel_err": 0.0, + "name": "gen1565", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043565", + "values_compared": 154 + }, + { + "max_rel_err": 0.0, + "name": "gen1566", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043566", + "values_compared": 166 + }, + { + "max_rel_err": 0.0, + "name": "gen1567", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043567", + "values_compared": 151 + }, + { + "max_rel_err": 0.0, + "name": "gen1568", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043568", + "values_compared": 185 + }, + { + "max_rel_err": 0.0, + "name": "gen1569", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043569", + "values_compared": 212 + }, + { + "max_rel_err": 0.0, + "name": "gen1570", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043570", + "values_compared": 150 + }, + { + "max_rel_err": 0.0, + "name": "gen1571", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043571", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen1572", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043572", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen1573", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043573", + "values_compared": 53 + }, + { + "max_rel_err": 0.0, + "name": "gen1574", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043574", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen1575", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043575", + "values_compared": 204 + }, + { + "max_rel_err": 0.0, + "name": "gen1576", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043576", + "values_compared": 145 + }, + { + "max_rel_err": 0.0, + "name": "gen1577", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043577", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen1578", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043578", + "values_compared": 273 + }, + { + "max_rel_err": 0.0, + "name": "gen1579", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043579", + "values_compared": 189 + }, + { + "max_rel_err": 0.0, + "name": "gen1580", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043580", + "values_compared": 173 + }, + { + "max_rel_err": 0.0, + "name": "gen1581", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043581", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen1582", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043582", + "values_compared": 173 + }, + { + "max_rel_err": 0.0, + "name": "gen1583", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043583", + "values_compared": 359 + }, + { + "max_rel_err": 0.0, + "name": "gen1584", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043584", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen1585", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043585", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen1586", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043586", + "values_compared": 377 + }, + { + "max_rel_err": 0.0, + "name": "gen1587", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043587", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen1588", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043588", + "values_compared": 119 + }, + { + "max_rel_err": 0.0, + "name": "gen1589", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043589", + "values_compared": 251 + }, + { + "max_rel_err": 0.0, + "name": "gen1590", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043590", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1591", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043591", + "values_compared": 297 + }, + { + "max_rel_err": 0.0, + "name": "gen1592", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043592", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1593", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043593", + "values_compared": 331 + }, + { + "max_rel_err": 0.0, + "name": "gen1594", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043594", + "values_compared": 82 + }, + { + "max_rel_err": 0.0, + "name": "gen1595", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043595", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen1596", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043596", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1597", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043597", + "values_compared": 20 + }, + { + "max_rel_err": 0.0, + "name": "gen1598", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043598", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen1599", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043599", + "values_compared": 141 + }, + { + "max_rel_err": 0.0, + "name": "gen1600", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043600", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen1601", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043601", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen1602", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043602", + "values_compared": 79 + }, + { + "max_rel_err": 0.0, + "name": "gen1603", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043603", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen1604", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043604", + "values_compared": 108 + }, + { + "max_rel_err": 0.0, + "name": "gen1605", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043605", + "values_compared": 84 + }, + { + "max_rel_err": 0.0, + "name": "gen1606", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043606", + "values_compared": 159 + }, + { + "max_rel_err": 0.0, + "name": "gen1607", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043607", + "values_compared": 10 + }, + { + "max_rel_err": 0.0, + "name": "gen1608", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043608", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen1609", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043609", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen1610", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043610", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1611", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043611", + "values_compared": 209 + }, + { + "max_rel_err": 0.0, + "name": "gen1612", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043612", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen1613", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043613", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen1614", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043614", + "values_compared": 190 + }, + { + "max_rel_err": 0.0, + "name": "gen1615", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043615", + "values_compared": 24 + }, + { + "max_rel_err": 0.0, + "name": "gen1616", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043616", + "values_compared": 322 + }, + { + "max_rel_err": 0.0, + "name": "gen1617", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043617", + "values_compared": 232 + }, + { + "max_rel_err": 0.0, + "name": "gen1618", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043618", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen1619", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043619", + "values_compared": 59 + }, + { + "max_rel_err": 0.0, + "name": "gen1620", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043620", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen1621", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043621", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen1622", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043622", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1623", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043623", + "values_compared": 362 + }, + { + "max_rel_err": 0.0, + "name": "gen1624", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043624", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen1625", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043625", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1626", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043626", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen1627", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043627", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen1628", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043628", + "values_compared": 249 + }, + { + "max_rel_err": 0.0, + "name": "gen1629", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043629", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1630", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043630", + "values_compared": 216 + }, + { + "max_rel_err": 0.0, + "name": "gen1631", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043631", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen1632", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043632", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen1633", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043633", + "values_compared": 129 + }, + { + "max_rel_err": 0.0, + "name": "gen1634", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043634", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen1635", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043635", + "values_compared": 216 + }, + { + "max_rel_err": 0.0, + "name": "gen1636", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043636", + "values_compared": 17 + }, + { + "max_rel_err": 0.0, + "name": "gen1637", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043637", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen1638", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043638", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen1639", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043639", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen1640", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043640", + "values_compared": 154 + }, + { + "max_rel_err": 0.0, + "name": "gen1641", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043641", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen1642", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043642", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen1643", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043643", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen1644", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043644", + "values_compared": 353 + }, + { + "max_rel_err": 0.0, + "name": "gen1645", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043645", + "values_compared": 169 + }, + { + "max_rel_err": 0.0, + "name": "gen1646", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043646", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen1647", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043647", + "values_compared": 59 + }, + { + "max_rel_err": 0.0, + "name": "gen1648", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043648", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen1649", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043649", + "values_compared": 83 + }, + { + "max_rel_err": 0.0, + "name": "gen1650", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043650", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen1651", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043651", + "values_compared": 256 + }, + { + "max_rel_err": 0.0, + "name": "gen1652", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043652", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen1653", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043653", + "values_compared": 350 + }, + { + "max_rel_err": 0.0, + "name": "gen1654", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043654", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen1655", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043655", + "values_compared": 46 + }, + { + "max_rel_err": 0.0, + "name": "gen1656", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043656", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen1657", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043657", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen1658", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043658", + "values_compared": 119 + }, + { + "max_rel_err": 0.0, + "name": "gen1659", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043659", + "values_compared": 15 + }, + { + "max_rel_err": 0.0, + "name": "gen1660", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043660", + "values_compared": 7 + }, + { + "max_rel_err": 0.0, + "name": "gen1661", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043661", + "values_compared": 17 + }, + { + "max_rel_err": 0.0, + "name": "gen1662", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043662", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen1663", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043663", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen1664", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043664", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen1665", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043665", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen1666", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043666", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen1667", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043667", + "values_compared": 178 + }, + { + "max_rel_err": 0.0, + "name": "gen1668", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043668", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen1669", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043669", + "values_compared": 239 + }, + { + "max_rel_err": 0.0, + "name": "gen1670", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043670", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen1671", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043671", + "values_compared": 152 + }, + { + "max_rel_err": 0.0, + "name": "gen1672", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043672", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen1673", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043673", + "values_compared": 171 + }, + { + "max_rel_err": 0.0, + "name": "gen1674", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043674", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1675", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043675", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen1676", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043676", + "values_compared": 126 + }, + { + "max_rel_err": 0.0, + "name": "gen1677", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043677", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen1678", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043678", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1679", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043679", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen1680", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043680", + "values_compared": 336 + }, + { + "max_rel_err": 0.0, + "name": "gen1681", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043681", + "values_compared": 134 + }, + { + "max_rel_err": 0.0, + "name": "gen1682", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043682", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1683", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043683", + "values_compared": 378 + }, + { + "max_rel_err": 0.0, + "name": "gen1684", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043684", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen1685", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043685", + "values_compared": 149 + }, + { + "max_rel_err": 0.0, + "name": "gen1686", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043686", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen1687", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043687", + "values_compared": 129 + }, + { + "max_rel_err": 0.0, + "name": "gen1688", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043688", + "values_compared": 19 + }, + { + "max_rel_err": 0.0, + "name": "gen1689", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043689", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1690", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043690", + "values_compared": 25 + }, + { + "max_rel_err": 0.0, + "name": "gen1691", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043691", + "values_compared": 365 + }, + { + "max_rel_err": 0.0, + "name": "gen1692", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043692", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen1693", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043693", + "values_compared": 97 + }, + { + "max_rel_err": 0.0, + "name": "gen1694", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043694", + "values_compared": 22 + }, + { + "max_rel_err": 0.0, + "name": "gen1695", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043695", + "values_compared": 289 + }, + { + "max_rel_err": 0.0, + "name": "gen1696", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043696", + "values_compared": 291 + }, + { + "max_rel_err": 0.0, + "name": "gen1697", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043697", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen1698", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043698", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1699", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043699", + "values_compared": 123 + }, + { + "max_rel_err": 0.0, + "name": "gen1700", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043700", + "values_compared": 374 + }, + { + "max_rel_err": 0.0, + "name": "gen1701", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043701", + "values_compared": 271 + }, + { + "max_rel_err": 0.0, + "name": "gen1702", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043702", + "values_compared": 43 + }, + { + "max_rel_err": 0.0, + "name": "gen1703", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043703", + "values_compared": 40 + }, + { + "max_rel_err": 0.0, + "name": "gen1704", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043704", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen1705", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043705", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen1706", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043706", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen1707", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043707", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen1708", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043708", + "values_compared": 255 + }, + { + "max_rel_err": 0.0, + "name": "gen1709", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043709", + "values_compared": 161 + }, + { + "max_rel_err": 0.0, + "name": "gen1710", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043710", + "values_compared": 191 + }, + { + "max_rel_err": 0.0, + "name": "gen1711", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043711", + "values_compared": 94 + }, + { + "max_rel_err": 0.0, + "name": "gen1712", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043712", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen1713", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043713", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen1714", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043714", + "values_compared": 216 + }, + { + "max_rel_err": 0.0, + "name": "gen1715", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043715", + "values_compared": 98 + }, + { + "max_rel_err": 0.0, + "name": "gen1716", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043716", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen1717", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043717", + "values_compared": 193 + }, + { + "max_rel_err": 0.0, + "name": "gen1718", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043718", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen1719", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043719", + "values_compared": 68 + }, + { + "max_rel_err": 0.0, + "name": "gen1720", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043720", + "values_compared": 295 + }, + { + "max_rel_err": 0.0, + "name": "gen1721", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043721", + "values_compared": 256 + }, + { + "max_rel_err": 0.0, + "name": "gen1722", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043722", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen1723", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043723", + "values_compared": 78 + }, + { + "max_rel_err": 0.0, + "name": "gen1724", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043724", + "values_compared": 147 + }, + { + "max_rel_err": 0.0, + "name": "gen1725", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043725", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen1726", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043726", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen1727", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043727", + "values_compared": 71 + }, + { + "max_rel_err": 0.0, + "name": "gen1728", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043728", + "values_compared": 75 + }, + { + "max_rel_err": 0.0, + "name": "gen1729", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043729", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen1730", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043730", + "values_compared": 177 + }, + { + "max_rel_err": 0.0, + "name": "gen1731", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043731", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1732", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043732", + "values_compared": 257 + }, + { + "max_rel_err": 0.0, + "name": "gen1733", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043733", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen1734", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043734", + "values_compared": 7 + }, + { + "max_rel_err": 0.0, + "name": "gen1735", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043735", + "values_compared": 71 + }, + { + "max_rel_err": 0.0, + "name": "gen1736", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043736", + "values_compared": 184 + }, + { + "max_rel_err": 0.0, + "name": "gen1737", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043737", + "values_compared": 262 + }, + { + "max_rel_err": 0.0, + "name": "gen1738", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043738", + "values_compared": 114 + }, + { + "max_rel_err": 0.0, + "name": "gen1739", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043739", + "values_compared": 98 + }, + { + "max_rel_err": 0.0, + "name": "gen1740", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043740", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1741", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043741", + "values_compared": 137 + }, + { + "max_rel_err": 0.0, + "name": "gen1742", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043742", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen1743", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043743", + "values_compared": 252 + }, + { + "max_rel_err": 0.0, + "name": "gen1744", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043744", + "values_compared": 108 + }, + { + "max_rel_err": 0.0, + "name": "gen1745", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043745", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen1746", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043746", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen1747", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043747", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen1748", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043748", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1749", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043749", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen1750", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043750", + "values_compared": 31 + }, + { + "max_rel_err": 0.0, + "name": "gen1751", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043751", + "values_compared": 60 + }, + { + "max_rel_err": 0.0, + "name": "gen1752", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043752", + "values_compared": 9 + }, + { + "max_rel_err": 0.0, + "name": "gen1753", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043753", + "values_compared": 248 + }, + { + "max_rel_err": 0.0, + "name": "gen1754", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043754", + "values_compared": 209 + }, + { + "max_rel_err": 0.0, + "name": "gen1755", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043755", + "values_compared": 48 + }, + { + "max_rel_err": 0.0, + "name": "gen1756", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043756", + "values_compared": 127 + }, + { + "max_rel_err": 0.0, + "name": "gen1757", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043757", + "values_compared": 274 + }, + { + "max_rel_err": 0.0, + "name": "gen1758", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043758", + "values_compared": 146 + }, + { + "max_rel_err": 0.0, + "name": "gen1759", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043759", + "values_compared": 173 + }, + { + "max_rel_err": 0.0, + "name": "gen1760", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043760", + "values_compared": 66 + }, + { + "max_rel_err": 0.0, + "name": "gen1761", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043761", + "values_compared": 174 + }, + { + "max_rel_err": 0.0, + "name": "gen1762", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043762", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1763", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043763", + "values_compared": 118 + }, + { + "max_rel_err": 0.0, + "name": "gen1764", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043764", + "values_compared": 69 + }, + { + "max_rel_err": 0.0, + "name": "gen1765", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043765", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen1766", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043766", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1767", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043767", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen1768", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043768", + "values_compared": 212 + }, + { + "max_rel_err": 0.0, + "name": "gen1769", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043769", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1770", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043770", + "values_compared": 222 + }, + { + "max_rel_err": 0.0, + "name": "gen1771", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043771", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen1772", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043772", + "values_compared": 105 + }, + { + "max_rel_err": 0.0, + "name": "gen1773", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043773", + "values_compared": 165 + }, + { + "max_rel_err": 0.0, + "name": "gen1774", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043774", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen1775", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043775", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1776", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043776", + "values_compared": 119 + }, + { + "max_rel_err": 0.0, + "name": "gen1777", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043777", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1778", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043778", + "values_compared": 71 + }, + { + "max_rel_err": 0.0, + "name": "gen1779", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043779", + "values_compared": 192 + }, + { + "max_rel_err": 0.0, + "name": "gen1780", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043780", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen1781", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043781", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen1782", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043782", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen1783", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043783", + "values_compared": 239 + }, + { + "max_rel_err": 0.0, + "name": "gen1784", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043784", + "values_compared": 63 + }, + { + "max_rel_err": 0.0, + "name": "gen1785", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043785", + "values_compared": 121 + }, + { + "max_rel_err": 0.0, + "name": "gen1786", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043786", + "values_compared": 266 + }, + { + "max_rel_err": 0.0, + "name": "gen1787", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043787", + "values_compared": 160 + }, + { + "max_rel_err": 0.0, + "name": "gen1788", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043788", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1789", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043789", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen1790", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043790", + "values_compared": 224 + }, + { + "max_rel_err": 0.0, + "name": "gen1791", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043791", + "values_compared": 161 + }, + { + "max_rel_err": 0.0, + "name": "gen1792", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043792", + "values_compared": 252 + }, + { + "max_rel_err": 0.0, + "name": "gen1793", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043793", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1794", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043794", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen1795", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043795", + "values_compared": 131 + }, + { + "max_rel_err": 0.0, + "name": "gen1796", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043796", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen1797", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043797", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen1798", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043798", + "values_compared": 31 + }, + { + "max_rel_err": 0.0, + "name": "gen1799", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043799", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen1800", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043800", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen1801", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043801", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen1802", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043802", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1803", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043803", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen1804", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043804", + "values_compared": 223 + }, + { + "max_rel_err": 0.0, + "name": "gen1805", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043805", + "values_compared": 213 + }, + { + "max_rel_err": 0.0, + "name": "gen1806", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043806", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1807", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043807", + "values_compared": 200 + }, + { + "max_rel_err": 0.0, + "name": "gen1808", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043808", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1809", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043809", + "values_compared": 208 + }, + { + "max_rel_err": 0.0, + "name": "gen1810", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043810", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen1811", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043811", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen1812", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043812", + "values_compared": 229 + }, + { + "max_rel_err": 0.0, + "name": "gen1813", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043813", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen1814", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043814", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen1815", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043815", + "values_compared": 245 + }, + { + "max_rel_err": 0.0, + "name": "gen1816", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043816", + "values_compared": 101 + }, + { + "max_rel_err": 0.0, + "name": "gen1817", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043817", + "values_compared": 95 + }, + { + "max_rel_err": 0.0, + "name": "gen1818", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043818", + "values_compared": 37 + }, + { + "max_rel_err": 0.0, + "name": "gen1819", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043819", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen1820", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043820", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen1821", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043821", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen1822", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043822", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen1823", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043823", + "values_compared": 338 + }, + { + "max_rel_err": 0.0, + "name": "gen1824", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043824", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen1825", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043825", + "values_compared": 126 + }, + { + "max_rel_err": 0.0, + "name": "gen1826", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043826", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen1827", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043827", + "values_compared": 117 + }, + { + "max_rel_err": 0.0, + "name": "gen1828", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043828", + "values_compared": 166 + }, + { + "max_rel_err": 0.0, + "name": "gen1829", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043829", + "values_compared": 35 + }, + { + "max_rel_err": 0.0, + "name": "gen1830", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043830", + "values_compared": 61 + }, + { + "max_rel_err": 0.0, + "name": "gen1831", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043831", + "values_compared": 246 + }, + { + "max_rel_err": 0.0, + "name": "gen1832", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043832", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen1833", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043833", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen1834", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043834", + "values_compared": 190 + }, + { + "max_rel_err": 0.0, + "name": "gen1835", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043835", + "values_compared": 307 + }, + { + "max_rel_err": 0.0, + "name": "gen1836", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043836", + "values_compared": 144 + }, + { + "max_rel_err": 0.0, + "name": "gen1837", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043837", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen1838", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043838", + "values_compared": 47 + }, + { + "max_rel_err": 0.0, + "name": "gen1839", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043839", + "values_compared": 143 + }, + { + "max_rel_err": 0.0, + "name": "gen1840", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043840", + "values_compared": 374 + }, + { + "max_rel_err": 0.0, + "name": "gen1841", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043841", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen1842", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043842", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen1843", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043843", + "values_compared": 140 + }, + { + "max_rel_err": 0.0, + "name": "gen1844", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043844", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen1845", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043845", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen1846", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043846", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen1847", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043847", + "values_compared": 133 + }, + { + "max_rel_err": 0.0, + "name": "gen1848", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043848", + "values_compared": 258 + }, + { + "max_rel_err": 0.0, + "name": "gen1849", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043849", + "values_compared": 67 + }, + { + "max_rel_err": 0.0, + "name": "gen1850", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043850", + "values_compared": 51 + }, + { + "max_rel_err": 0.0, + "name": "gen1851", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043851", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1852", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043852", + "values_compared": 266 + }, + { + "max_rel_err": 0.0, + "name": "gen1853", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043853", + "values_compared": 317 + }, + { + "max_rel_err": 0.0, + "name": "gen1854", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043854", + "values_compared": 96 + }, + { + "max_rel_err": 0.0, + "name": "gen1855", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043855", + "values_compared": 103 + }, + { + "max_rel_err": 0.0, + "name": "gen1856", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043856", + "values_compared": 278 + }, + { + "max_rel_err": 0.0, + "name": "gen1857", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043857", + "values_compared": 130 + }, + { + "max_rel_err": 0.0, + "name": "gen1858", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043858", + "values_compared": 108 + }, + { + "max_rel_err": 0.0, + "name": "gen1859", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043859", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1860", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043860", + "values_compared": 297 + }, + { + "max_rel_err": 0.0, + "name": "gen1861", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043861", + "values_compared": 87 + }, + { + "max_rel_err": 0.0, + "name": "gen1862", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043862", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen1863", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043863", + "values_compared": 137 + }, + { + "max_rel_err": 0.0, + "name": "gen1864", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043864", + "values_compared": 171 + }, + { + "max_rel_err": 0.0, + "name": "gen1865", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043865", + "values_compared": 255 + }, + { + "max_rel_err": 0.0, + "name": "gen1866", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043866", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen1867", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043867", + "values_compared": 220 + }, + { + "max_rel_err": 0.0, + "name": "gen1868", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043868", + "values_compared": 226 + }, + { + "max_rel_err": 0.0, + "name": "gen1869", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043869", + "values_compared": 54 + }, + { + "max_rel_err": 0.0, + "name": "gen1870", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043870", + "values_compared": 73 + }, + { + "max_rel_err": 0.0, + "name": "gen1871", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043871", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen1872", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043872", + "values_compared": 42 + }, + { + "max_rel_err": 0.0, + "name": "gen1873", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043873", + "values_compared": 236 + }, + { + "max_rel_err": 0.0, + "name": "gen1874", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043874", + "values_compared": 12 + }, + { + "max_rel_err": 0.0, + "name": "gen1875", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043875", + "values_compared": 72 + }, + { + "max_rel_err": 0.0, + "name": "gen1876", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043876", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen1877", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043877", + "values_compared": 134 + }, + { + "max_rel_err": 0.0, + "name": "gen1878", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043878", + "values_compared": 80 + }, + { + "max_rel_err": 0.0, + "name": "gen1879", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043879", + "values_compared": 100 + }, + { + "max_rel_err": 0.0, + "name": "gen1880", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043880", + "values_compared": 216 + }, + { + "max_rel_err": 0.0, + "name": "gen1881", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043881", + "values_compared": 10 + }, + { + "max_rel_err": 0.0, + "name": "gen1882", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043882", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen1883", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043883", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1884", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043884", + "values_compared": 227 + }, + { + "max_rel_err": 0.0, + "name": "gen1885", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043885", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen1886", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043886", + "values_compared": 234 + }, + { + "max_rel_err": 0.0, + "name": "gen1887", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043887", + "values_compared": 134 + }, + { + "max_rel_err": 0.0, + "name": "gen1888", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043888", + "values_compared": 36 + }, + { + "max_rel_err": 0.0, + "name": "gen1889", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043889", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen1890", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043890", + "values_compared": 341 + }, + { + "max_rel_err": 0.0, + "name": "gen1891", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043891", + "values_compared": 94 + }, + { + "max_rel_err": 0.0, + "name": "gen1892", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043892", + "values_compared": 101 + }, + { + "max_rel_err": 0.0, + "name": "gen1893", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043893", + "values_compared": 49 + }, + { + "max_rel_err": 0.0, + "name": "gen1894", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043894", + "values_compared": 186 + }, + { + "max_rel_err": 0.0, + "name": "gen1895", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043895", + "values_compared": 317 + }, + { + "max_rel_err": 0.0, + "name": "gen1896", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043896", + "values_compared": 218 + }, + { + "max_rel_err": 0.0, + "name": "gen1897", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043897", + "values_compared": 389 + }, + { + "max_rel_err": 0.0, + "name": "gen1898", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043898", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen1899", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043899", + "values_compared": 261 + }, + { + "max_rel_err": 0.0, + "name": "gen1900", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043900", + "values_compared": 295 + }, + { + "max_rel_err": 0.0, + "name": "gen1901", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043901", + "values_compared": 94 + }, + { + "max_rel_err": 0.0, + "name": "gen1902", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043902", + "values_compared": 77 + }, + { + "max_rel_err": 0.0, + "name": "gen1903", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043903", + "values_compared": 182 + }, + { + "max_rel_err": 0.0, + "name": "gen1904", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043904", + "values_compared": 102 + }, + { + "max_rel_err": 0.0, + "name": "gen1905", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043905", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen1906", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043906", + "values_compared": 146 + }, + { + "max_rel_err": 0.0, + "name": "gen1907", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043907", + "values_compared": 90 + }, + { + "max_rel_err": 0.0, + "name": "gen1908", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043908", + "values_compared": 344 + }, + { + "max_rel_err": 0.0, + "name": "gen1909", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043909", + "values_compared": 92 + }, + { + "max_rel_err": 0.0, + "name": "gen1910", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043910", + "values_compared": 56 + }, + { + "max_rel_err": 0.0, + "name": "gen1911", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043911", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen1912", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043912", + "values_compared": 86 + }, + { + "max_rel_err": 0.0, + "name": "gen1913", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043913", + "values_compared": 242 + }, + { + "max_rel_err": 0.0, + "name": "gen1914", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043914", + "values_compared": 183 + }, + { + "max_rel_err": 0.0, + "name": "gen1915", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043915", + "values_compared": 226 + }, + { + "max_rel_err": 0.0, + "name": "gen1916", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043916", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1917", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043917", + "values_compared": 354 + }, + { + "max_rel_err": 0.0, + "name": "gen1918", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043918", + "values_compared": 15 + }, + { + "max_rel_err": 0.0, + "name": "gen1919", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043919", + "values_compared": 315 + }, + { + "max_rel_err": 0.0, + "name": "gen1920", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043920", + "values_compared": 62 + }, + { + "max_rel_err": 0.0, + "name": "gen1921", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043921", + "values_compared": 274 + }, + { + "max_rel_err": 0.0, + "name": "gen1922", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043922", + "values_compared": 57 + }, + { + "max_rel_err": 0.0, + "name": "gen1923", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043923", + "values_compared": 92 + }, + { + "max_rel_err": 0.0, + "name": "gen1924", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043924", + "values_compared": 135 + }, + { + "max_rel_err": 0.0, + "name": "gen1925", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043925", + "values_compared": 91 + }, + { + "max_rel_err": 0.0, + "name": "gen1926", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043926", + "values_compared": 45 + }, + { + "max_rel_err": 0.0, + "name": "gen1927", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043927", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen1928", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043928", + "values_compared": 125 + }, + { + "max_rel_err": 0.0, + "name": "gen1929", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043929", + "values_compared": 158 + }, + { + "max_rel_err": 0.0, + "name": "gen1930", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043930", + "values_compared": 44 + }, + { + "max_rel_err": 0.0, + "name": "gen1931", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043931", + "values_compared": 160 + }, + { + "max_rel_err": 0.0, + "name": "gen1932", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043932", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1933", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043933", + "values_compared": 120 + }, + { + "max_rel_err": 0.0, + "name": "gen1934", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043934", + "values_compared": 55 + }, + { + "max_rel_err": 0.0, + "name": "gen1935", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043935", + "values_compared": 210 + }, + { + "max_rel_err": 0.0, + "name": "gen1936", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043936", + "values_compared": 81 + }, + { + "max_rel_err": 0.0, + "name": "gen1937", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043937", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen1938", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043938", + "values_compared": 345 + }, + { + "max_rel_err": 0.0, + "name": "gen1939", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043939", + "values_compared": 76 + }, + { + "max_rel_err": 0.0, + "name": "gen1940", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043940", + "values_compared": 6 + }, + { + "max_rel_err": 0.0, + "name": "gen1941", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043941", + "values_compared": 386 + }, + { + "max_rel_err": 0.0, + "name": "gen1942", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043942", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen1943", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043943", + "values_compared": 47 + }, + { + "max_rel_err": 0.0, + "name": "gen1944", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043944", + "values_compared": 344 + }, + { + "max_rel_err": 0.0, + "name": "gen1945", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043945", + "values_compared": 30 + }, + { + "max_rel_err": 0.0, + "name": "gen1946", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043946", + "values_compared": 360 + }, + { + "max_rel_err": 0.0, + "name": "gen1947", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043947", + "values_compared": 286 + }, + { + "max_rel_err": 0.0, + "name": "gen1948", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043948", + "values_compared": 272 + }, + { + "max_rel_err": 0.0, + "name": "gen1949", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043949", + "values_compared": 142 + }, + { + "max_rel_err": 0.0, + "name": "gen1950", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043950", + "values_compared": 52 + }, + { + "max_rel_err": 0.0, + "name": "gen1951", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043951", + "values_compared": 324 + }, + { + "max_rel_err": 0.0, + "name": "gen1952", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043952", + "values_compared": 256 + }, + { + "max_rel_err": 0.0, + "name": "gen1953", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043953", + "values_compared": 290 + }, + { + "max_rel_err": 0.0, + "name": "gen1954", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043954", + "values_compared": 214 + }, + { + "max_rel_err": 0.0, + "name": "gen1955", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043955", + "values_compared": 33 + }, + { + "max_rel_err": 0.0, + "name": "gen1956", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043956", + "values_compared": 109 + }, + { + "max_rel_err": 0.0, + "name": "gen1957", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043957", + "values_compared": 156 + }, + { + "max_rel_err": 0.0, + "name": "gen1958", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043958", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1959", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043959", + "values_compared": 225 + }, + { + "max_rel_err": 0.0, + "name": "gen1960", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043960", + "values_compared": 124 + }, + { + "max_rel_err": 0.0, + "name": "gen1961", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043961", + "values_compared": 115 + }, + { + "max_rel_err": 0.0, + "name": "gen1962", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043962", + "values_compared": 369 + }, + { + "max_rel_err": 0.0, + "name": "gen1963", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043963", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen1964", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043964", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen1965", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043965", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen1966", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043966", + "values_compared": 113 + }, + { + "max_rel_err": 0.0, + "name": "gen1967", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043967", + "values_compared": 253 + }, + { + "max_rel_err": 0.0, + "name": "gen1968", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043968", + "values_compared": 32 + }, + { + "max_rel_err": 0.0, + "name": "gen1969", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043969", + "values_compared": 233 + }, + { + "max_rel_err": 0.0, + "name": "gen1970", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043970", + "values_compared": 132 + }, + { + "max_rel_err": 0.0, + "name": "gen1971", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043971", + "values_compared": 85 + }, + { + "max_rel_err": 0.0, + "name": "gen1972", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043972", + "values_compared": 168 + }, + { + "max_rel_err": 0.0, + "name": "gen1973", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043973", + "values_compared": 116 + }, + { + "max_rel_err": 0.0, + "name": "gen1974", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043974", + "values_compared": 110 + }, + { + "max_rel_err": 0.0, + "name": "gen1975", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043975", + "values_compared": 58 + }, + { + "max_rel_err": 0.0, + "name": "gen1976", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043976", + "values_compared": 160 + }, + { + "max_rel_err": 0.0, + "name": "gen1977", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043977", + "values_compared": 65 + }, + { + "max_rel_err": 0.0, + "name": "gen1978", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043978", + "values_compared": 157 + }, + { + "max_rel_err": 0.0, + "name": "gen1979", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043979", + "values_compared": 99 + }, + { + "max_rel_err": 0.0, + "name": "gen1980", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043980", + "values_compared": 89 + }, + { + "max_rel_err": 0.0, + "name": "gen1981", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043981", + "values_compared": 27 + }, + { + "max_rel_err": 0.0, + "name": "gen1982", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043982", + "values_compared": 354 + }, + { + "max_rel_err": 0.0, + "name": "gen1983", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043983", + "values_compared": 88 + }, + { + "max_rel_err": 0.0, + "name": "gen1984", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043984", + "values_compared": 53 + }, + { + "max_rel_err": 0.0, + "name": "gen1985", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043985", + "values_compared": 136 + }, + { + "max_rel_err": 0.0, + "name": "gen1986", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043986", + "values_compared": 345 + }, + { + "max_rel_err": 0.0, + "name": "gen1987", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043987", + "values_compared": 221 + }, + { + "max_rel_err": 0.0, + "name": "gen1988", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043988", + "values_compared": 326 + }, + { + "max_rel_err": 0.0, + "name": "gen1989", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043989", + "values_compared": 93 + }, + { + "max_rel_err": 0.0, + "name": "gen1990", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043990", + "values_compared": 108 + }, + { + "max_rel_err": 0.0, + "name": "gen1991", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043991", + "values_compared": 330 + }, + { + "max_rel_err": 0.0, + "name": "gen1992", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043992", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1993", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043993", + "values_compared": 175 + }, + { + "max_rel_err": 0.0, + "name": "gen1994", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043994", + "values_compared": 104 + }, + { + "max_rel_err": 0.0, + "name": "gen1995", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043995", + "values_compared": 107 + }, + { + "max_rel_err": 0.0, + "name": "gen1996", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043996", + "values_compared": 29 + }, + { + "max_rel_err": 0.0, + "name": "gen1997", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043997", + "values_compared": 18 + }, + { + "max_rel_err": 0.0, + "name": "gen1998", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043998", + "values_compared": 179 + }, + { + "max_rel_err": 0.0, + "name": "gen1999", + "outcome": "pass", + "pass": true, + "source": "generated:seed=4669390220898043999", + "values_compared": 170 + } + ], + "cases_both_errored": 0, + "cases_deferred": 0, + "cases_failed": 0, + "cases_passed": 2013, + "cases_total": 2013, + "deferred_by_unit": {}, + "max_rel_err": 0.0, + "pass": true, + "rel_tol": 1e-9, + "seeds": 16, + "status": "green", + "unit": "geom.context" +}