Implements regulators for the Euclidean coordinates of Point entities,
  automatically creating all three of them for each added point entity. When
  such a regulator is set, it freezes the corresponding representation
  coordinate to the set point. In addition, if all three coordinates of a
  given Point are set, the coradius coordinate (which holds the norm of the
  point) is frozen as well.

  Note that a PointCoordinateRegulator must be created with a Point as the
  subject. This commit modifies HalfCurvatureRegulator analogously, so that
  it can only be created with a Sphere.

  A couple of prospective issues that should be filed in association with
  this commit:
  * The new coordinate regulators create redundant display information with
    the raw representation coordinates of a point that are already shown in
    the outline view.
  * The optimization status of these regulators together with HalfCurvature
    regulators (i.e., the ones implemented by freezing coordinates) is different
    from InversiveDistance regulators when an Assembly is unrealizable: the
    frozen-coordinate constraints will be "hard" in that they will be forced
    to precisely equal their set point, whereas the distance regulators are
    "soft" in that they can be relaxed from their set points in an effort to
    minimize the loss function of the configuration as compared to the values
    of the constraints. Perhaps at some point we should/will have a mechanism
    to specify the softness/hardness of constraints, but in the meantime,
    there should not be two different categories of constraints. Suppose we
    decide that by default that all constraints are soft. Then the optimizer
    should be able to search changing, for example, the radius of a
    curvature-constrained sphere, so as to minimize the loss function (for a
    loss that would therefore presumably have a term akin to the square of the
    difference between the specified and actual half-curvature of the sphere).
    For example, suppose you specify that the half-curvature of a sphere is 1
    (so it has radius 1/2) but that its distance to a point is -1. These
    constraints cannot be satisfied, so the optimization fails, presumably
    with the point at the sphere center, and the sphere with radius 1/2.
    So all of the loss is concentrated in the difference between the actual
    point-sphere distance being -1/2, not -1. It would be more appropriate
    (in the all-soft constraint regime) to end up at something like a sphere of
    half-curvature 1/√2 with the point at the center, so that the loss is split
    between both the half-curvature and the distance to the sphere being off by
    1 - 1/√2. (At a guess, that would minimize the sum of the squares of the
    two differences.)

@@ -359,2 +368,3 @@
     const FOCAL_SLOPE: f64 = 0.3;
-
+    let horizontal = f64::from(event.client_x()) - rect.left();
+    let vertical = rect.bottom() - f64::from(event.client_y());

@@ -918,1 +960,3 @@
-                    match assembly_to_world.with(|asm_to_world| elt.cast(dir, asm_to_world, pixel_size)) {
+                    let target = assembly_to_world.with(
+                        |asm_to_world| elt.cast(dir, asm_to_world, pixel_size));
+                    match target {

@@ -221,0 +227,4 @@
+            let x32 = x as f32;
+            let y32 = y as f32;
+            let coords =
+                [0.5*(1.0 + x32), 0.5*(1.0 + y32), 0.5*(1.0 - x32*y32)];

@@ -509,2 +533,3 @@
     // set up the tangencies that define the packing
-    for [long_edge_plane, short_edge_plane] in [["a", "b"], ["b", "c"], ["c", "a"]] {
+    for [long_edge_plane, short_edge_plane]
+            in [["a", "b"], ["b", "c"], ["c", "a"]] {

@@ -862,2 +898,3 @@
     );
-    for (chain_sphere, chain_sphere_next) in chain.clone().zip(chain.cycle().skip(1)) {
+    for (chain_sphere, chain_sphere_next)
+            in chain.clone().zip(chain.cycle().skip(1)) {

@@ -26,1 +29,3 @@
-pub fn sphere_with_offset(dir_x: f64, dir_y: f64, dir_z: f64, off: f64, curv: f64) -> DVector<f64> {
+pub fn sphere_with_offset(
+    dir_x: f64, dir_y: f64, dir_z: f64, off: f64, curv: f64) -> DVector<f64>
+{

@@ -512,1 +526,3 @@
-        Ok(ConfigNeighborhood { #[cfg(feature = "dev")] config: state.config, nbhd: tangent })
+        Ok(ConfigNeighborhood {
+            #[cfg(feature = "dev")] config: state.config, nbhd: tangent
+        })

@@ -941,0 +971,4 @@
+        let Realization { result: result_tfm, history: history_tfm } =
+            realize_gram(&problem_tfm, SCALED_TOL, 0.5, 0.9, 1.1, 200, 110);
+        let ConfigNeighborhood { config: config_tfm, nbhd: tangent_tfm } =
+            result_tfm.unwrap();

@@ -582,1 +588,3 @@
-                        Point::NORM_COMPONENT, col, point(x,y,z)[Point::NORM_COMPONENT]);
+                        Point::NORM_COMPONENT,
+                        col,
+                        point(x,y,z)[Point::NORM_COMPONENT]

@@ -929,1 +939,3 @@
-                        console_log!("No velocity to unpack for fresh element \"{}\"", elt.id())
+                        console_log!(
+                            "No velocity to unpack for fresh element \"{}\"",
+                            elt.id()

@@ -965,1 +976,3 @@
-            );
+            let subjects = [0, 1]
+                .map(|k| Rc::new(Sphere::default(format!("sphere{k}"), k))
+                    as Rc<dyn Element>);

@@ -132,0 +135,4 @@
+        };
+        let opacity = if self.ghost.get() {
+            GHOST_OPACITY
+        } else { DEFAULT_OPACITY };

@@ -189,1 +197,3 @@
-        let color = if selected { self.color.map(|channel| 0.2 + 0.8*channel) } else { self.color };
+        let color = if selected {
+            self.color.map(|channel| 0.2 + 0.8*channel)
+        } else { self.color };

@@ -608,2 +638,3 @@
                 || realization_successful && on_last_step;
-            if on_manipulable_step && state.selection.with(|sel| sel.len() == 1) {
+            if on_manipulable_step
+               && state.selection.with(|sel| sel.len() == 1)

@@ -653,2 +685,3 @@
                 if frames_since_last_sample >= SAMPLE_PERIOD {
-                    mean_frame_interval.set((time - last_sample_time) / (SAMPLE_PERIOD as f64));
+                    let SP64 = SAMPLE_PERIOD as f64;
+                    mean_frame_interval.set((time - last_sample_time) / SP64);

@@ -697,0 +728,4 @@
+                let sphere_reps_world: Vec<_> = scene.spheres.representations
+                    .into_iter().map(
+                        |rep| (&asm_to_world * rep).cast::<f32>()
+                    ).collect();

@@ -767,0 +805,4 @@
+                    );
+                    bind_new_buffer_to_attribute(&ctx, point_color_attr,
+                        (COLOR_SIZE + 1) as i32,
+                        scene.points.colors_with_opacity.concat().as_slice());

@@ -64,2 +64,4 @@
             bind:value = value,
             on:change = move |_| {
+                let specification
+                    = SpecifiedValue::try_from(value.get_clone_untracked());

@@ -323,1 +334,3 @@
-            engine::sphere_with_offset(frac_2_sqrt_6, -frac_1_sqrt_6, -frac_1_sqrt_6, -frac_1_sqrt_6, 0.0),
+            engine::sphere_with_offset(
+                frac_2_sqrt_6, -frac_1_sqrt_6, -frac_1_sqrt_6,
+                -frac_1_sqrt_6, 0.0

@@ -329,1 +343,3 @@
-            engine::sphere_with_offset(-frac_1_sqrt_6, frac_2_sqrt_6, -frac_1_sqrt_6, -frac_1_sqrt_6, 0.0),
+            engine::sphere_with_offset(
+                -frac_1_sqrt_6, frac_2_sqrt_6, -frac_1_sqrt_6,
+                -frac_1_sqrt_6, 0.0

@@ -335,1 +352,3 @@
-            engine::sphere_with_offset(-frac_1_sqrt_6, -frac_1_sqrt_6, frac_2_sqrt_6, -frac_1_sqrt_6, 0.0),
+            engine::sphere_with_offset(
+                -frac_1_sqrt_6, -frac_1_sqrt_6, frac_2_sqrt_6,
+                -frac_1_sqrt_6, 0.0

@@ -14,0 +12,4 @@
+pub fn sphere(center_x: f64, center_y: f64, center_z: f64, radius: f64)
+-> DVector<f64> {
+    let center_norm_sq
+        = center_x * center_x + center_y * center_y + center_z * center_z;

@@ -202,2 +204,3 @@
     // projection inner product
-    pub fn proj(&self, v: &DVectorView<f64>, column_index: usize) -> DMatrix<f64> {
+    pub fn proj(&self, v: &DVectorView<f64>, column_index: usize)
+    -> DMatrix<f64> {

@@ -294,1 +297,3 @@
-fn basis_matrix(index: (usize, usize), nrows: usize, ncols: usize) -> DMatrix<f64> {
+fn basis_matrix(index: (usize, usize), nrows: usize, ncols: usize)
+    -> DMatrix<f64>
+{

@@ -612,0 +624,4 @@
+                    problem.gram.push_sym(
+                        block + j,
+                        block + k,
+                        if j == k { 0.0 } else { -0.5 }

@@ -705,1 +722,3 @@
-                problem.gram.push_sym(j, k, if (j, k) == (1, 1) { 1.0 } else { 0.0 });
+                problem.gram.push_sym(
+                    j, k,
+                    if (j, k) == (1, 1) { 1.0 } else { 0.0 }

@@ -805,2 +831,3 @@
 
-    fn translation_motion_unif(vel: &Vector3<f64>, assembly_dim: usize) -> Vec<DVector<f64>> {
+    fn translation_motion_unif(vel: &Vector3<f64>, assembly_dim: usize)
+    -> Vec<DVector<f64>> {

@@ -582,1 +588,3 @@
-                        Point::NORM_COMPONENT, col, point(x,y,z)[Point::NORM_COMPONENT]);
+                        Point::NORM_COMPONENT,
+                        col,
+                        point(x,y,z)[Point::NORM_COMPONENT],