Chris X Edwards

Counting significant figures

* Nonzero digits always count.
* Zeros between nonzero digits count (1005 has 4).
* Leading zeros never count (0.0045 has 2).
* Trailing zeros count only if there's a decimal point (100. has 3,
  1.50 has 3). In 100 they're placeholders, which is the ambiguous
  case. Scientific notation resolves it: 1.00E2.
* Exact numbers (counts, defined conversions like 100 cm/m) have
  infinitely many.

Arithmetic

* Multiply/divide: the result gets as many sig figs as the input with the fewest.
* Add/subtract: the result is rounded to the least precise decimal
  position among the inputs.
* Round only at the end, carrying extra guard digits in the middle.
* Logs: the digits after the decimal point in pH (the mantissa) equal
  the sig figs in [H⁺]. So pH 4.74 means [H⁺] has 2 sig figs.

from decimal import Decimal, ROUND_HALF_UP
import re

class Val:
    """A number plus the position of its last significant digit."""
    def __init__(self, d, pos): self.d, self.pos = d, pos
    def n(self): return self.d.adjusted() - self.pos + 1      # sig figs

    def _prod(self, d, other):
        n = min(self.n(), other.n())
        return Val(d, d.adjusted() - n + 1)
    def __mul__(a, b):     return a._prod(a.d * b.d, b)
    def __truediv__(a, b): return a._prod(a.d / b.d, b)
    def __add__(a, b):     return Val(a.d + b.d, max(a.pos, b.pos))
    def __sub__(a, b):     return Val(a.d - b.d, max(a.pos, b.pos))

    def __str__(self):
        if self.pos < -50: return str(self.d)                # exact
        q = self.d.quantize(Decimal(1).scaleb(self.pos), ROUND_HALF_UP)
        if q.adjusted() > self.d.adjusted():                 # 9.99 -> 10, not 10.0
            q = self.d.quantize(Decimal(1).scaleb(self.pos + 1), ROUND_HALF_UP)
        return str(q)

def S(s):
    """Parse a number as written, e.g. S('0.0450'), S('100.'), S('1.5E3')."""
    d = Decimal(s)
    mant = re.split('[eE]', s)[0].lstrip('+-')
    digits = mant.replace('.', '').lstrip('0')
    if '.' not in mant: digits = digits.rstrip('0')          # trailing-zero convention
    return Val(d, d.adjusted() - max(len(digits), 1) + 1)

def E(s): return Val(Decimal(s), -999)                       # exact number

# Some tests...
print(S('12.11') + S('18.0') + S('1.013'))   # 31.1   (limited by 18.0)
print(S('4.2') * S('3.14159'))               # 13     (2 s.f.)
print(E('2') * S('3.14'))                    # 6.28

* The 1.0 vs 9.9 cliff, now in logarithms - [H⁺] = 1.0×10⁻³ and [H⁺] =
  9.9×10⁻³ both have 2 sig figs, so both pH values get 2 decimals: pH
  3.00 and pH 2.00. But 1.0 is ±5%, which is ±0.02 in pH, so "3.00"
  overclaims by 4×. And 9.9 is ±0.5%, which is ±0.002 in pH, so "2.00"
  underclaims by 2×. Same rule, wildly different honesty.

* The rules violate the distributive law - (12.5 − 12.0) × 3.000: the
  subtraction gives 0.5 (1 sf), and times 3.000 gives 1.5, which
  rounds to 2. Distribute it instead: 12.5×3.000 − 12.0×3.000 = 37.5 −
  36.0 = 1.5. Same arithmetic, two different answers. The true value
  is about 1.50 ± 0.02, so the first answer is off by a factor of 25
  in its implied tolerance.

* Round trips don't return home (the xkcd effect) - 5 mph → 2 m/s
  (2.235, rounded to 1 sf) → 4 mph (4.47, rounded). One unit
  conversion each way and you've lost 20% of the value, even though
  both conversion factors are exact. The sig-fig interval for "5 mph"
  is 4.5–5.5 mph, but the interval for "2 m/s" is 1.5–2.5 m/s, which
  is 3.4–5.6 mph. The rule changes the implied tolerance every time
  the unit changes.

* It can't recognize that x − x = 0 or x/x = 1 - A sample is weighed
  once as 0.250 g. The mass fraction of Mg in pure Mg is 0.250/0.250 =
  "1.00 (±0.5%)", when it is exactly 1. Any quantity appearing in both
  numerator and denominator (or subtracted from itself) is perfectly
  correlated. Errors cancel exactly, and ICSF has no way to say so.

* Adding many terms understates uncertainty - Add 100 readings from a
  balance that resolves 0.1 g. ICSF says the total is good to 0.1 g
  (implied ±0.05). In reality each reading carries about 0.03 g of
  standard uncertainty. The sum's uncertainty is √100 × 0.03 ≈ 0.3 g,
  six times the implied tolerance, and in the worst case ±5 g.

* Averaging many terms overstates uncertainty - Ten titrations read
  12.3, 12.4, 12.3, 12.2, 12.3, 12.4, 12.3, 12.3, 12.4, 12.3 mL. The
  mean is 12.32, the standard deviation is 0.063, and the standard
  error of the mean is 0.02. ICSF says to report 12.3 and throw away
  the extra digit, which discards real information. (This works only
  because the readings actually scatter; identical readings can't be
  averaged past the resolution.) Examples 5 and 6 together show the
  rule is wrong in both directions depending on the operation.

* Digits are not accuracy - A Class A 100 mL volumetric flask is
  certified to ±0.08 mL. Writing "100.00 mL" implies ±0.005 mL, which
  is a 16× overclaim. Conversely, the rule would give a 100 mL
  graduated cylinder reading of "100. mL" a clean bill of health it
  hasn't earned. ICSF reads the number of digits you wrote down, not
  the instrument, calibration, or certificate.

* "100" means anything from ±0.5 to ±50 - Is "100 mL" 1, 2, or 3 sf?
  Textbooks disagree. At 1 sf the implied range is 50–150 mL. Multiply
  by a density of 1.234 g/mL and you get either 1×10² g or 123 g, a
  23% spread caused entirely by an unwritten convention.

* Half-up rounding builds in a bias - Instrument readings 0.5, 1.5,
  2.5, 3.5, 4.5 sum to 12.5. Rounded half-up, that's 1+2+3+4+5 = 15
  (+20%). Round-half-even gives 0+2+2+4+4 = 12 (−4%), and unbiased on
  average. Many ICSF courses teach half-up as the rule, and the
  instructor may or may not know that other conventions exist.

* Zero has no significant figures - By rule 3, leading zeros never
  count, so a balance reading "0.000 g" after taring has zero sig
  figs. Yet it is a precise statement: the mass is within ±0.0005 g of
  zero. Multiply it by anything and the rules give you an answer with
  no defined precision. Meanwhile 0.0010 g and 0.001000 g are
  described as having 2 and 4 sig figs, but nothing in the rules
  explains why "less than a milligram" should be treated as a
  different kind of number from "nothing."

p1= C.scene.cursor_location.copy()
p2= C.scene.cursor_location.copy()
print(p2-p1)

bl_info = {
    "name": "Xed Dist",
    "author": "Chris X Edwards and robot friend Claude",
    "version": (1, 0, 0),
    "blender": (5, 2, 0),
    "location": "View3D > Sidebar (N-panel) > Xed Dist",
    "description": "Replaces the built-in Measure tool with typed-in vertex "
                   "coordinate boxes, live distance/axis-delta/angle output, buttons to:"
                   "swap A/B and to load point from: 3d cursor, origin, and active vertex.",
                   "Also load a custom axes by setting A to X=0, B to X+ value, and the",
                   "3d Cursor somewhere on the XY plane."
    "category": "3D View",
}

import bpy
import bmesh
import math
from mathutils import Vector
from bpy.props import FloatVectorProperty, PointerProperty, EnumProperty
from bpy.types import PropertyGroup, Operator, Panel

# == Helpers ==
def get_active_vertex_world_co(context):
    """Return world-space coordinates of the active vertex in edit mode, or None."""
    obj = context.edit_object
    if obj is None or obj.type != 'MESH':
        return None
    bm = bmesh.from_edit_mesh(obj.data)
    bm.verts.ensure_lookup_table()
    active_vert = None
    # Prefer the true "active" element from the selection history.
    if bm.select_history:
        elem = bm.select_history[-1]
        if isinstance(elem, bmesh.types.BMVert):
            active_vert = elem
        elif hasattr(elem, "verts") and elem.verts:
            # Active edge/face selected: fall back to its last vertex.
            active_vert = elem.verts[-1]
    if active_vert is None:
        # Fall back to the last selected vertex found.
        selected = [v for v in bm.verts if v.select]
        if selected:
            active_vert = selected[-1]
    if active_vert is None:
        return None
    return obj.matrix_world @ active_vert.co

def _wrapped_degrees(angle_rad):
    deg = math.degrees(angle_rad)
    if deg < 0:
        deg += 360.0
    return deg

# == Property Group ==
class MEASURETOOL_Properties(PropertyGroup):
    point_a: FloatVectorProperty(
        name="Point A",
        description="First measurement point. Accepts normal Blender typed "
                    "math in each field (e.g. click in, type '-1.5', Enter)",
        subtype='XYZ',
        unit='LENGTH',
        size=3,
    )
    point_b: FloatVectorProperty(
        name="Point B",
        description="Second measurement point. Accepts normal Blender typed "
                    "math in each field (e.g. click in, type '-1.5', Enter)",
        subtype='XYZ',
        unit='LENGTH',
        size=3,
    )
    local_x_axis: FloatVectorProperty(size=3, subtype='XYZ', default=(1.0, 0.0, 0.0))
    local_y_axis: FloatVectorProperty(size=3, subtype='XYZ', default=(0.0, 1.0, 0.0))
    local_z_axis: FloatVectorProperty(size=3, subtype='XYZ', default=(0.0, 0.0, 1.0))
    use_local_frame: bpy.props.BoolProperty(default=False)

# == Operators ==
class MEASURETOOL_OT_assign_active(Operator):
    bl_idname = "measuretool.assign_active"
    bl_label = "Assign Active Vertex"
    bl_description = "Copy the active vertex's world-space position into this point"
    bl_options = {'REGISTER', 'UNDO'}
    target: EnumProperty(items=[('A', "A", ""), ('B', "B", "")], default='A')
    @classmethod
    def poll(cls, context):
        return context.mode == 'EDIT_MESH' and context.edit_object is not None
    def execute(self, context):
        co = get_active_vertex_world_co(context)
        if co is None:
            self.report({'WARNING'}, "No active vertex found")
            return {'CANCELLED'}
        props = context.scene.measuretool_props
        if self.target == 'A':
            props.point_a = co
        else:
            props.point_b = co
        return {'FINISHED'}

class MEASURETOOL_OT_zero(Operator):
    bl_idname = "measuretool.zero"
    bl_label = "Zero to Origin"
    bl_description = "Set this point to the world origin (0, 0, 0)"
    bl_options = {'REGISTER', 'UNDO'}
    target: EnumProperty(items=[('A', "A", ""), ('B', "B", "")], default='A')
    def execute(self, context):
        props = context.scene.measuretool_props
        if self.target == 'A':
            props.point_a = (0.0, 0.0, 0.0)
        else:
            props.point_b = (0.0, 0.0, 0.0)
        return {'FINISHED'}

class MEASURETOOL_OT_swap(Operator):
    bl_idname = "measuretool.swap"
    bl_label = "Swap A / B"
    bl_description = "Swap the values of Point A and Point B"
    bl_options = {'REGISTER', 'UNDO'}
    def execute(self, context):
        props = context.scene.measuretool_props
        a = tuple(props.point_a)
        b = tuple(props.point_b)
        props.point_a = b
        props.point_b = a
        return {'FINISHED'}

class MEASURETOOL_OT_cursor_to_point(Operator):
    bl_idname = "measuretool.cursor_to_point"
    bl_label = "3D Cursor to Point"
    bl_description = "Copy the 3D cursor's location into this point"
    bl_options = {'REGISTER', 'UNDO'}
    target: EnumProperty(items=[('A', "A", ""), ('B', "B", "")], default='A')
    def execute(self, context):
        props = context.scene.measuretool_props
        cursor_co = context.scene.cursor.location
        if self.target == 'A':
            props.point_a = cursor_co
        else:
            props.point_b = cursor_co
        return {'FINISHED'}

class MEASURETOOL_OT_custom_axes(Operator):
    bl_idname = "measuretool.custom_axes"
    bl_label = "Custom Axes (A->B = +X, Cursor on XY)"
    bl_description = ("Build a local frame where A->B is +X and the 3D cursor "
                       "lies in the XY plane. Delta values then read in this "
                       "frame instead of world space. Zero A, zero B, and "
                       "click again to reset to world axes.")
    bl_options = {'REGISTER', 'UNDO'}
    EPS = 1e-8
    def execute(self, context):
        props = context.scene.measuretool_props
        a = Vector(props.point_a)
        b = Vector(props.point_b)
        cursor = context.scene.cursor.location
        ab = b - a
        if ab.length < self.EPS:
            props.use_local_frame = False
            self.report({'INFO'}, "Reset to world axes")
            return {'FINISHED'}
        local_x = ab.normalized()
        ac = cursor - a
        proj = ac - ac.dot(local_x) * local_x
        if proj.length < self.EPS:
            self.report({'ERROR'}, "3D cursor is colinear with A-B; can't define a plane")
            return {'CANCELLED'}
        local_y = proj.normalized()
        local_z = local_x.cross(local_y)
        props.local_x_axis = local_x
        props.local_y_axis = local_y
        props.local_z_axis = local_z
        props.use_local_frame = True
        return {'FINISHED'}

# == Panel ==
class MEASURETOOL_PT_panel(Panel):
    bl_label = "Xed Dist"
    bl_idname = "MEASURETOOL_PT_panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = "Measure"

    def draw(self, context):
        layout = self.layout
        props = context.scene.measuretool_props
        # === Point A ===
        box = layout.box()
        box.label(text="Point A")
        box.column().prop(props, "point_a", text="")
        row = box.row(align=True)
        row.operator("measuretool.assign_active", text="Active Vertex").target = 'A'
        row.operator("measuretool.zero", text="Zero").target = 'A'
        row.operator("measuretool.cursor_to_point", text="Cursor", icon='CURSOR').target = 'A'
        layout.operator("measuretool.swap", icon='ARROW_LEFTRIGHT')
        layout.operator("measuretool.custom_axes", icon='ORIENTATION_LOCAL')
        # === Point B ===
        box = layout.box()
        box.label(text="Point B")
        box.column().prop(props, "point_b", text="")
        row = box.row(align=True)
        row.operator("measuretool.assign_active", text="Active Vertex").target = 'B'
        row.operator("measuretool.zero", text="Zero").target = 'B'
        row.operator("measuretool.cursor_to_point", text="Cursor", icon='CURSOR').target = 'B'
        # === Results ===
        a = Vector(props.point_a)
        b = Vector(props.point_b)
        d = b - a
        distance = d.length
        dx, dy, dz = abs(d.x), abs(d.y), abs(d.z)
        # Angles: for the plane perpendicular to a given axis, measured CCW
        # starting at the first of the two remaining axes in the cyclic
        # order X -> Y -> Z -> X, so a positive angle sweeps toward the
        # second axis (right-hand rule about the axis you're "looking
        # down"). E.g. looking down Z: 0deg = +X, 90deg = +Y (matches spec).
        angle_z = _wrapped_degrees(math.atan2(d.y, d.x))  # look down Z, 0=+X, 90=+Y
        angle_y = _wrapped_degrees(math.atan2(d.x, d.z))  # look down Y, 0=+Z, 90=+X
        angle_x = _wrapped_degrees(math.atan2(d.z, d.y))  # look down X, 0=+Y, 90=+Z
        box = layout.box()
        box.label(text="Results", icon='DRIVER_DISTANCE')
        col = box.column(align=True)
        col.label(text=f"Dist: {distance:.6f} ({distance/0.0254:.6f}\")")
        if props.use_local_frame:
            lx = Vector(props.local_x_axis)
            ly = Vector(props.local_y_axis)
            lz = Vector(props.local_z_axis)
            dx, dy, dz = abs(d.dot(lx)), abs(d.dot(ly)), abs(d.dot(lz))
            axis_label = "Local! A-B ("
        else:
            dx, dy, dz = abs(d.x), abs(d.y), abs(d.z)
            axis_label = "A-B ("
        col.label(text=f"{axis_label} X): {dx:.7f} ({dx/0.0254:.6F}\")")
        col.label(text=f"{axis_label} Y): {dy:.7f} ({dy/0.0254:.6F}\")")
        col.label(text=f"{axis_label} Z): {dz:.7f} ({dz/0.0254:.6F}\")")
        col = box.column(align=True)
        col.separator()
        col.label(text=f"Angle (down Z, 0°=+X→+Y): {angle_z:.6f}°")
        col.label(text=f"Angle (down Y, 0°=+Z→+X): {angle_y:.6f}°")
        col.label(text=f"Angle (down X, 0°=+Y→+Z): {angle_x:.6f}°")

# == Registration ==
classes = (
    MEASURETOOL_Properties,
    MEASURETOOL_OT_assign_active,
    MEASURETOOL_OT_zero,
    MEASURETOOL_OT_swap,
    MEASURETOOL_PT_panel,
    MEASURETOOL_OT_cursor_to_point,
    MEASURETOOL_OT_custom_axes,
)

def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.Scene.measuretool_props = PointerProperty(type=MEASURETOOL_Properties)

def unregister():
    del bpy.types.Scene.measuretool_props
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)

if __name__ == "__main__":
    register()

Chris X Edwards

Colorful Trees

The Error Of Significant Figures

The Problem

ICSF Precisely Defined

The Problem With The Solution

Better Solutions

Why This Bugs Me

Chimneysweep

My Second Favorite Game Of All TIme

Blender Measurement Fixed