From 9986cf80d8e2b3e72211cc3fa9952fe8df0f7443 Mon Sep 17 00:00:00 2001 From: "S. Gilles" Date: Tue, 9 Mar 2021 22:01:05 -0500 Subject: [PATCH] handle x-coordinates better --- quiver.myr | 101 +++++++++++++++++++++++++++++++++++---------- test/quiver.myr | 126 ++++++++++++++++++++++++++++++-------------------------- 2 files changed, 148 insertions(+), 79 deletions(-) diff --git a/quiver.myr b/quiver.myr index a94d089..5195181 100644 --- a/quiver.myr +++ b/quiver.myr @@ -18,8 +18,8 @@ pkg quiver = color : (uint8, uint8, uint8) /* TODO: yakmo.polynomial(@a)#, and then genericize everything that follows */ - acoord : yakmo.polynomial# - xcoord : yakmo.ratfunc# + acoord : std.option(yakmo.polynomial#) + xcoord : std.option(yakmo.ratfunc#) ;; impl disposable vertex /* TODO: types */ @@ -149,19 +149,39 @@ const __init__ = { /* TODO: types */ impl disposable vertex = __dispose__ = {v : vertex - __dispose__(v.acoord) + match v.acoord + | `std.Some a: __dispose__(a) + | _: + ;; + match v.xcoord + | `std.Some x: __dispose__(x) + | _: + ;; std.slfree(v.name) } ;; impl t.dupable vertex = dup = {v : vertex + var da + match v.acoord + | `std.None: da = `std.None + | `std.Some a: da = `std.Some t.dup(a) + ;; + + var dx + match v.xcoord + | `std.None: dx = `std.None + | `std.Some x: dx = `std.Some t.dup(x) + ;; + -> [ .name = std.sldup(v.name), .d = v.d, .x_pos = v.x_pos, .y_pos = v.y_pos, .color = v.color, - .acoord = t.dup(v.acoord), + .acoord = da, + .xcoord = dx, ] } ;; @@ -235,8 +255,23 @@ impl std.equatable quiver# = if v1.color.2 != v2.color.2 -> false ;; - if !std.eq(v1.acoord, v2.acoord) - -> false + match (v1.acoord, v2.acoord) + | (`std.None, `std.None): + | (`std.Some _, `std.None): -> false + | (`std.None, `std.Some _): -> false + | (`std.Some a1, `std.Some a2): + if !std.eq(a1, a2) + -> false + ;; + ;; + match (v1.xcoord, v2.xcoord) + | (`std.None, `std.None): + | (`std.Some _, `std.None): -> false + | (`std.None, `std.Some _): -> false + | (`std.Some x1, `std.Some x2): + if !std.eq(x1, x2) + -> false + ;; ;; ;; ;; @@ -279,12 +314,12 @@ const add_vertex = {q, name, weight ;; ;; - /* Start out the A-coord as some dummy value in C^{x} */ + /* Start out the A-coord and X-coord as trivial */ var v : vertex = [ .name = std.sldup(name), .d = weight, - .acoord = yakmo.rid(), - .xcoord = yakmo.rid(), + .acoord = `std.None, + .xcoord = `std.None, ] /* Add each epsilon(-, v) */ @@ -428,26 +463,37 @@ const mutate_ip_i = {q, k var coords_plus = yakmo.rid() var coords_minus = yakmo.rid() + var qvka + match q.v[k].acoord + | `std.None: -> `std.Err std.fmt("Quiver has A-coordinates enabled, but {} has no A-coordinate set", q.v[k].name) + | `std.Some a: qvka = a + ;; + for var j = 0; j < q.v.len; ++j var eps = q.epsilon[k][j] + var qvja + match q.v[j].acoord + | `std.None: -> `std.Err std.fmt("Quiver has A-coordinates enabled, but {} has no A-coordinate set", q.v[j].name) + | `std.Some a: qvja = a + ;; if eps.p.sign > 0 - match good_rpowr_poly(q.v[j].acoord, eps) + match good_rpowr_poly(qvja, eps) | `std.Ok x: yakmo.rmul_ip(coords_plus, x) __dispose__(x) | `std.Err e: auto (e : t.doomed_str) - -> `std.Err std.fmt("good_rpowr_poly({}, {}): {}", q.v[j].acoord, eps, e) + -> `std.Err std.fmt("good_rpowr_poly({}, {}): {}", qvja, eps, e) ;; elif eps.p.sign < 0 var neps = yakmo.gneg(eps) - match good_rpowr_poly(q.v[j].acoord, neps) + match good_rpowr_poly(qvja, neps) | `std.Ok x: yakmo.rmul_ip(coords_minus, x) __dispose__(x) | `std.Err e: auto (e : t.doomed_str) - -> `std.Err std.fmt("good_rpowr_poly({}, {}): {}", q.v[j].acoord, neps, e) + -> `std.Err std.fmt("good_rpowr_poly({}, {}): {}", qvja, neps, e) ;; __dispose__(neps) ;; @@ -457,18 +503,24 @@ const mutate_ip_i = {q, k __dispose__(coords_plus) __dispose__(coords_minus) - match yakmo.div_maybe(sum, q.v[k].acoord) - | `std.None: -> `std.Err std.fmt("Laurent phenomenon fails when mutating at {}: cannot divide {} by {}", q.v[k].name, sum, q.v[k].acoord) + match yakmo.div_maybe(sum, qvka) + | `std.None: -> `std.Err std.fmt("Laurent phenomenon fails when mutating at {}: cannot divide {} by {}", q.v[k].name, sum, qvka) | `std.Some new_acoord: - var old_acoord = q.v[k].acoord - q.v[k].acoord = new_acoord + var old_acoord = qvka + q.v[k].acoord = `std.Some new_acoord __dispose__(old_acoord) ;; ;; /* Now the X-coordinates */ if q.use_x_coords - var xk = t.dup(q.v[k].xcoord) + var qvkx + match q.v[k].xcoord + | `std.None: -> `std.Err std.fmt("Quiver has X-coordinates enabled, but {} has no X-coordinate set", q.v[k].name) + | `std.Some x: qvkx = x + ;; + + var xk = t.dup(qvkx) var xki match yakmo.finv(xk) | `std.Some y: @@ -482,6 +534,12 @@ const mutate_ip_i = {q, k continue ;; + var qvjx + match q.v[j].xcoord + | `std.None: -> `std.Err std.fmt("Quiver has X-coordinates enabled, but {} has no X-coordinate set", q.v[j].name) + | `std.Some x: qvjx = x + ;; + var prod = yakmo.rid() var exp = yakmo.gneg(q.epsilon[j][k]) @@ -506,7 +564,8 @@ const mutate_ip_i = {q, k match good_rpowr_ratfunc(prod, exp) | `std.Ok y: - yakmo.rmul_ip(q.v[j].xcoord, y) + yakmo.rmul_ip(qvjx, y) + q.v[j].xcoord = `std.Some qvjx __dispose__(y) | `std.Err e: auto (e : t.doomed_str) @@ -518,8 +577,8 @@ const mutate_ip_i = {q, k ;; __dispose__(xk) - __dispose__(q.v[k].xcoord) - q.v[k].xcoord = xki + __dispose__(qvkx) + q.v[k].xcoord = `std.Some xki ;; /* Finally, get the quiver right. First, complete all triangles */ diff --git a/test/quiver.myr b/test/quiver.myr index 23ef0a6..21e0afb 100644 --- a/test/quiver.myr +++ b/test/quiver.myr @@ -869,14 +869,14 @@ const acoords_01 = {c | `std.Err e: testr.fail(c, "cannot add edge x->y: {}", e) ;; - q.v[xi].acoord = t.dup(x) - q.v[yi].acoord = t.dup(y) + q.v[xi].acoord = `std.Some t.dup(x) + q.v[yi].acoord = `std.Some t.dup(y) /* start: x -----> y */ xexp = x yexp = y - if !std.eq(q.v[xi].acoord, xexp) || !std.eq(q.v[yi].acoord, yexp) + if !std.eq(std.get(q.v[xi].acoord), xexp) || !std.eq(std.get(q.v[yi].acoord), yexp) testr.fail(c, "At position 0, coordinates should be ({}, {}), they are ({}, {})", xexp, yexp, q.v[xi].acoord, q.v[yi].acoord) ;; @@ -889,7 +889,7 @@ const acoords_01 = {c xexp = auto yakmo.rmul(auto yakmo.gadd(one, y), xinv) yexp = y - if !std.eq(q.v[xi].acoord, xexp) || !std.eq(q.v[yi].acoord, yexp) + if !std.eq(std.get(q.v[xi].acoord), xexp) || !std.eq(std.get(q.v[yi].acoord), yexp) testr.fail(c, "At position 1, coordinates should be ({}, {}), they are ({}, {})", xexp, yexp, q.v[xi].acoord, q.v[yi].acoord) ;; @@ -902,7 +902,7 @@ const acoords_01 = {c xexp = auto yakmo.rmul(auto yakmo.gadd(one, y), xinv) yexp = auto yakmo.rmul(auto yakmo.gadd(one, auto yakmo.gadd(y, x)), auto yakmo.rmul(xinv, yinv)) - if !std.eq(q.v[xi].acoord, xexp) || !std.eq(q.v[yi].acoord, yexp) + if !std.eq(std.get(q.v[xi].acoord), xexp) || !std.eq(std.get(q.v[yi].acoord), yexp) testr.fail(c, "At position 2, coordinates should be ({}, {}), they are ({}, {})", xexp, yexp, q.v[xi].acoord, q.v[yi].acoord) ;; @@ -915,7 +915,7 @@ const acoords_01 = {c xexp = auto yakmo.rmul(auto yakmo.gadd(one, x), yinv) yexp = auto yakmo.rmul(auto yakmo.gadd(one, auto yakmo.gadd(y, x)), auto yakmo.rmul(xinv, yinv)) - if !std.eq(q.v[xi].acoord, xexp) || !std.eq(q.v[yi].acoord, yexp) + if !std.eq(std.get(q.v[xi].acoord), xexp) || !std.eq(std.get(q.v[yi].acoord), yexp) testr.fail(c, "At position 3, coordinates should be ({}, {}), they are ({}, {})", xexp, yexp, q.v[xi].acoord, q.v[yi].acoord) ;; @@ -928,7 +928,7 @@ const acoords_01 = {c xexp = auto yakmo.rmul(auto yakmo.gadd(one, x), yinv) yexp = x - if !std.eq(q.v[xi].acoord, xexp) || !std.eq(q.v[yi].acoord, yexp) + if !std.eq(std.get(q.v[xi].acoord), xexp) || !std.eq(std.get(q.v[yi].acoord), yexp) testr.fail(c, "At position 4, coordinates should be ({}, {}), they are ({}, {})", xexp, yexp, q.v[xi].acoord, q.v[yi].acoord) ;; @@ -941,7 +941,7 @@ const acoords_01 = {c xexp = y yexp = x - if !std.eq(q.v[xi].acoord, xexp) || !std.eq(q.v[yi].acoord, yexp) + if !std.eq(std.get(q.v[xi].acoord), xexp) || !std.eq(std.get(q.v[yi].acoord), yexp) testr.fail(c, "At position 5, coordinates should be ({}, {}), they are ({}, {})", xexp, yexp, q.v[xi].acoord, q.v[yi].acoord) ;; } @@ -994,14 +994,14 @@ const acoords_02 = {c __dispose__(q.v[6].acoord) __dispose__(q.v[7].acoord) */ - q.v[0].acoord = yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(1, 2))) - q.v[1].acoord = yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(2, 3))) - q.v[2].acoord = yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(2, 1))) - q.v[3].acoord = yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(2, 5))) - q.v[4].acoord = yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(5, 1))) - q.v[5].acoord = yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(-1, 1))) - q.v[6].acoord = yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(-1, 9))) - q.v[7].acoord = yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(1, 3))) + q.v[0].acoord = `std.Some yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(1, 2))) + q.v[1].acoord = `std.Some yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(2, 3))) + q.v[2].acoord = `std.Some yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(2, 1))) + q.v[3].acoord = `std.Some yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(2, 5))) + q.v[4].acoord = `std.Some yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(5, 1))) + q.v[5].acoord = `std.Some yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(-1, 1))) + q.v[6].acoord = `std.Some yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(-1, 9))) + q.v[7].acoord = `std.Some yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(1, 3))) quiver.mutate_ip(q, "v1;1") quiver.mutate_ip(q, "v2;1") @@ -1017,21 +1017,21 @@ const acoords_02 = {c var a6exp = auto yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(-1, 9))) var a7exp = auto yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(1, 3))) - testr.check(c, std.eq(q.v[0].acoord, a0exp), + testr.check(c, std.eq(std.get(q.v[0].acoord), a0exp), "{} should be {}, was {}", q.v[0].name, a0exp, q.v[0].acoord) - testr.check(c, std.eq(q.v[1].acoord, a1exp), + testr.check(c, std.eq(std.get(q.v[1].acoord), a1exp), "{} should be {}, was {}", q.v[1].name, a1exp, q.v[1].acoord) - testr.check(c, std.eq(q.v[2].acoord, a2exp), + testr.check(c, std.eq(std.get(q.v[2].acoord), a2exp), "{} should be {}, was {}", q.v[2].name, a2exp, q.v[2].acoord) - testr.check(c, std.eq(q.v[3].acoord, a3exp), + testr.check(c, std.eq(std.get(q.v[3].acoord), a3exp), "{} should be {}, was {}", q.v[3].name, a3exp, q.v[3].acoord) - testr.check(c, std.eq(q.v[4].acoord, a4exp), + testr.check(c, std.eq(std.get(q.v[4].acoord), a4exp), "{} should be {}, was {}", q.v[4].name, a4exp, q.v[4].acoord) - testr.check(c, std.eq(q.v[5].acoord, a5exp), + testr.check(c, std.eq(std.get(q.v[5].acoord), a5exp), "{} should be {}, was {}", q.v[5].name, a5exp, q.v[5].acoord) - testr.check(c, std.eq(q.v[6].acoord, a6exp), + testr.check(c, std.eq(std.get(q.v[6].acoord), a6exp), "{} should be {}, was {}", q.v[6].name, a6exp, q.v[6].acoord) - testr.check(c, std.eq(q.v[7].acoord, a7exp), + testr.check(c, std.eq(std.get(q.v[7].acoord), a7exp), "{} should be {}, was {}", q.v[7].name, a7exp, q.v[7].acoord) } @@ -1078,10 +1078,10 @@ const acoords_03 = {c var p3 = auto yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom( 281, 32))) var p4 = auto yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom( 283, 32))) var p5 = auto yakmo.polynomialfromQ(auto std.try(yakmo.Qfrom(8646523, 128))) - q.v[0].acoord = t.dup(p1) - q.v[1].acoord = t.dup(p2) - q.v[2].acoord = t.dup(p3) - q.v[3].acoord = t.dup(p4) + q.v[0].acoord = `std.Some t.dup(p1) + q.v[1].acoord = `std.Some t.dup(p2) + q.v[2].acoord = `std.Some t.dup(p3) + q.v[3].acoord = `std.Some t.dup(p4) var q_orig = t.dup(q) match quiver.mutate_ip(q, "v3;2") @@ -1089,10 +1089,10 @@ const acoords_03 = {c | `std.Ok void: ;; - testr.check(c, std.eq(q.v[0].acoord, p1), "q.v[0].acoord was {}, expected {}", q.v[0].acoord, p1) - testr.check(c, std.eq(q.v[1].acoord, p2), "q.v[1].acoord was {}, expected {}", q.v[1].acoord, p2) - testr.check(c, std.eq(q.v[2].acoord, p3), "q.v[2].acoord was {}, expected {}", q.v[2].acoord, p3) - testr.check(c, std.eq(q.v[3].acoord, p5), "q.v[3].acoord was {}, expected {}", q.v[3].acoord, p5) + testr.check(c, std.eq(std.get(q.v[0].acoord), p1), "q.v[0].acoord was {}, expected {}", q.v[0].acoord, p1) + testr.check(c, std.eq(std.get(q.v[1].acoord), p2), "q.v[1].acoord was {}, expected {}", q.v[1].acoord, p2) + testr.check(c, std.eq(std.get(q.v[2].acoord), p3), "q.v[2].acoord was {}, expected {}", q.v[2].acoord, p3) + testr.check(c, std.eq(std.get(q.v[3].acoord), p5), "q.v[3].acoord was {}, expected {}", q.v[3].acoord, p5) var actual_full : byte[:] = quiver.to_bytes(q) var actual : byte[:][:] = std.strsplit(actual_full, "\n") @@ -1108,13 +1108,16 @@ const acoords_03 = {c } const xcoords_01 = {c - var q : quiver.quiver# = auto quiver.mk_with_opts([.use_a_coords = true, .use_x_coords = false]) - var dummy : yakmo.ratfunc# = std.try(yakmo.ratfuncfromS("3 x + 2", "-19")) - auto dummy + var q : quiver.quiver# = auto quiver.mk_with_opts([.use_a_coords = false, .use_x_coords = true]) var xi : std.size = -1 var yi : std.size = -1 + var exp_x = "" + var exp_y = "" + var act_x = "" + var act_y = "" + match quiver.add_vertex(q, "x", 1) | `std.Ok n: xi = n | `std.Err e: testr.fail(c, "cannot add vertex x: {}", e) @@ -1130,13 +1133,16 @@ const xcoords_01 = {c | `std.Err e: testr.fail(c, "cannot add edge x->y: {}", e) ;; - q.v[xi].xcoord = t.dup(dummy) - q.v[yi].xcoord = t.dup(dummy) + q.v[xi].xcoord = `std.Some std.try(yakmo.ratfuncfromS("3 x + 2", "-19")) + q.v[yi].xcoord = `std.Some std.try(yakmo.ratfuncfromS("x^2 - 1", "6")) /* start */ - - if !std.eq(q.v[xi].xcoord, dummy) || !std.eq(q.v[yi].xcoord, dummy) - testr.fail(c, "At position 0, coordinates should be ({}, {}), they are ({}, {})", dummy, dummy, q.v[xi].xcoord, q.v[yi].xcoord) + exp_x = "-2/19 - 3/19 x" + act_x = std.fmt("{}", std.get(q.v[xi].xcoord)) + exp_y = "-1/6 + 1/6 x^2" + act_y = std.fmt("{}", std.get(q.v[yi].xcoord)) + if !std.eq(exp_x, act_x) || !std.eq(exp_y, act_y) + testr.fail(c, "At position 0, coordinates should be ({}, {}), they are ({}, {})", exp_x, exp_y, act_x, act_y) ;; /* one mutation */ @@ -1146,8 +1152,12 @@ const xcoords_01 = {c | `std.Err e: testr.fail(c, "cannot mutate[1] at x: {}", e) ;; - if !std.eq(q.v[xi].xcoord, dummy) || !std.eq(q.v[yi].xcoord, dummy) - testr.fail(c, "At position 0, coordinates should be ({}, {}), they are ({}, {})", dummy, dummy, q.v[xi].xcoord, q.v[yi].xcoord) + exp_x = "19 / (-2 - 3 x)" + act_x = std.fmt("{}", std.get(q.v[xi].xcoord)) + exp_y = "-17/114 + 1/38 x + 17/114 x^2 - 1/38 x^3" + act_y = std.fmt("{}", std.get(q.v[yi].xcoord)) + if !std.eq(exp_x, act_x) || !std.eq(exp_y, act_y) + testr.fail(c, "At position 1, coordinates should be ({}, {}), they are ({}, {})", exp_x, exp_y, act_x, act_y) ;; } @@ -1174,7 +1184,7 @@ const xcoords_02 = {c var q = std.try(quiver.from_bytes(std.strjoin(QG2, "\n"), [.use_x_coords = true])) for var j = 0; j < q.v.len; ++j - q.v[j].xcoord = std.try(yakmo.ratfuncfromS(std.fmt("{}", j * j + 3), std.fmt("{}", j + 2))) + q.v[j].xcoord = `std.Some std.try(yakmo.ratfuncfromS(std.fmt("{}", j * j + 3), std.fmt("{}", j + 2))) ;; const expect_xcoord_batch = {prefix, c, q, a @@ -1184,8 +1194,8 @@ const xcoords_02 = {c for var j = 0; j < q.v.len; ++j var exp = a[j] - yakmo.reduceratfunc(q.v[j].xcoord) - var act = std.fmt("{}", q.v[j].xcoord) + yakmo.reduceratfunc(std.get(q.v[j].xcoord)) + var act = std.fmt("{}", std.get(q.v[j].xcoord)) testr.check(c, std.eq(exp, act), "{}: {}'s xcoord should have been {}, was {}", prefix, q.v[j].name, exp, act) ;; } @@ -1240,8 +1250,8 @@ const xcoords_03 = {c ][:] var q = std.try(quiver.from_bytes(std.strjoin(QDG2, "\n"), [.use_x_coords = true])) - q.v[0].xcoord = std.try(yakmo.ratfuncfromS("a2", "1")) - q.v[1].xcoord = std.try(yakmo.ratfuncfromS("a1^-3", "1")) + q.v[0].xcoord = `std.Some std.try(yakmo.ratfuncfromS("a2", "1")) + q.v[1].xcoord = `std.Some std.try(yakmo.ratfuncfromS("a1^-3", "1")) const expect_xcoord_batch = {prefix, c, q, a if q.v.len != a.len @@ -1250,8 +1260,8 @@ const xcoords_03 = {c for var j = 0; j < q.v.len; ++j var exp = a[j] - yakmo.reduceratfunc(q.v[j].xcoord) - var act = std.fmt("{}", q.v[j].xcoord) + yakmo.reduceratfunc(std.get(q.v[j].xcoord)) + var act = std.fmt("{}", std.get(q.v[j].xcoord)) testr.check(c, std.eq(exp, act), "{}: {}'s xcoord should have been {}, was {}", prefix, q.v[j].name, exp, act) ;; } @@ -1288,7 +1298,7 @@ const axcoords_01 = {c var q = std.try(quiver.from_bytes(std.strjoin(QG2, "\n"), [.use_a_coords = true, .use_x_coords = true])) for var j = 0; j < q.v.len; ++j - q.v[j].acoord = std.try(yakmo.polynomialfromS(std.fmt("{}/{}", j * j + 3, j + 2))) + q.v[j].acoord = `std.Some std.try(yakmo.polynomialfromS(std.fmt("{}/{}", j * j + 3, j + 2))) ;; const guess_xcoord = {q, j @@ -1303,7 +1313,7 @@ const axcoords_01 = {c ;; var t : int = 0 - var asratfunc : yakmo.ratfunc# = yakmo.ratfuncfrompoly(q.v[k].acoord) + var asratfunc : yakmo.ratfunc# = yakmo.ratfuncfrompoly(std.get(q.v[k].acoord)) match yakmo.cmp_zero(eps) | `std.Equal: | `std.After: @@ -1331,7 +1341,7 @@ const axcoords_01 = {c for var j = 0; j < q.v.len; ++j //__dispose__(q.v[j].xcoord) - q.v[j].xcoord = std.try(guess_xcoord(q, j)) + q.v[j].xcoord = `std.Some std.try(guess_xcoord(q, j)) ;; match quiver.mutate_ip(q, "v1;1") @@ -1340,42 +1350,42 @@ const axcoords_01 = {c ;; for var j = 0; j < q.v.len; ++j var exp = std.try(guess_xcoord(q, j)) - var act = q.v[j].xcoord + var act = std.get(q.v[j].xcoord) testr.check(c, std.eq(exp, act), "mu-1: {}'s X-coord should be {}, was {}", q.v[j].name, exp, act) ;; quiver.mutate_ip(q, "v2;1") for var j = 0; j < q.v.len; ++j var exp = std.try(guess_xcoord(q, j)) - var act = q.v[j].xcoord + var act = std.get(q.v[j].xcoord) testr.check(c, std.eq(exp, act), "mu-1: {}'s X-coord should be {}, was {}", q.v[j].name, exp, act) ;; quiver.mutate_ip(q, "v1;2") for var j = 0; j < q.v.len; ++j var exp = std.try(guess_xcoord(q, j)) - var act = q.v[j].xcoord + var act = std.get(q.v[j].xcoord) testr.check(c, std.eq(exp, act), "mu-1: {}'s X-coord should be {}, was {}", q.v[j].name, exp, act) ;; quiver.mutate_ip(q, "v2;2") for var j = 0; j < q.v.len; ++j var exp = std.try(guess_xcoord(q, j)) - var act = q.v[j].xcoord + var act = std.get(q.v[j].xcoord) testr.check(c, std.eq(exp, act), "mu-1: {}'s X-coord should be {}, was {}", q.v[j].name, exp, act) ;; quiver.mutate_ip(q, "v1;1") for var j = 0; j < q.v.len; ++j var exp = std.try(guess_xcoord(q, j)) - var act = q.v[j].xcoord + var act = std.get(q.v[j].xcoord) testr.check(c, std.eq(exp, act), "mu-1: {}'s X-coord should be {}, was {}", q.v[j].name, exp, act) ;; quiver.mutate_ip(q, "v2;1") for var j = 0; j < q.v.len; ++j var exp = std.try(guess_xcoord(q, j)) - var act = q.v[j].xcoord + var act = std.get(q.v[j].xcoord) testr.check(c, std.eq(exp, act), "mu-1: {}'s X-coord should be {}, was {}", q.v[j].name, exp, act) ;; -- 2.11.4.GIT