Duplicate axes in one region: Make variable quantities (coordinates, metrics) a ring

NOTE: To understand this you need basic abstract algebra knowledge.

Currently, point coordinates or metrics in a variable font (we call these values "Variable Quantity", abbr. VQ) can be proved forming a module, where you can define addition and scalar multiplication of VQs.

However, currently you cannot define multiplication of VQs (which means that VQs do not form a ring), which may cause problem when manipulating complex fonts.

However, by extending the current definition of variation region, we can achieve this and enable non-linear variations with minimal changes of the interpolation logic.

Status Quo

Mathematically, a VQ could be defined in this form:

$X(v)=x+\sum_{R\in\mathfrak{R}[X]}\delta_X[R]W(R,v)$

$W(R,v)=\prod_{a\in\mathfrak{A}} \Lambda(R[a], v[a])$

where:

X: VQ X;
v: Variation instance tuple;
x: Non-variable part of X;
$\mathfrak{R}[X]$ : Region set of X;
R: One variation region;
$\delta_X[R]$ : Delta value in VQ X associated to region R (if R is not in the region list of X then the $\delta_X[R]$ is 0);
$\mathfrak{A}$ : Font axes set;
$\Lambda(R[a], v[a])$ : per-axis weight value of region R and instance tuple v under axis a.

From the mathematical form we can easily prove that VQs form a module and we can define the addition and scalar multiplication as follows:

$(X+Y)(v)=(x+y)+\sum_{R\in\mathfrak{R}[X]\cup\mathfrak{R}[Y]} (\delta_X[R]+\delta_Y[R])W(R,v)$
$(s\cdot X)(v)=(sx)+\sum_{R\in\mathfrak{R}[X]} (s\cdot\delta_X[R])W(R,v)$

However we cannot define multiplication of VQs, since we may produce terms like $\Lambda(R_1[a],v[a])\cdot\Lambda(R_2[a],v[a])$ in the product, and the old definiton of W does not support factors like this: in the original W definition, each region can only assign one "tent" to one axis.

Purposed change

We will change the definition of variation regions: each region will be able to associate multiple "tent"s to one region, the W function will be redefined as follows:

$W'(R,v)=\prod_{(T,a)\in\mathfrak{T}[R]} \Lambda(T,v[a])$

where:

$\mathfrak{T}[R]$ : the tent list of a given region R. Each item will be a tent T and an axis a;

Allowing multiple tents associated to one axis gives us the ability to define the product of two VQs:

$\begin{align*} (X \times Y )(v) & = xy \\ & + \sum_{R\in\mathfrak{R}[Y]}(x\cdot \delta_Y[R]) W'(R,v) \\ & + \sum_{R\in\mathfrak{R}[X]}(y\cdot \delta_X[R]) W'(R,v) \\ & + \sum_{R_X\in\mathfrak{R}[Y]}\sum_{R_Y\in\mathfrak{R}[X]} \delta_X[R_X]\delta_Y[R_Y]W'(R_X,v)W'(R_Y,v) \end{align*}$

where $W'(R_X,v)W'(R_Y,v)=\prod_{(T,a)\in\mathfrak{T}[R_X]\mathfrak{T}[R_Y]}\Lambda(T,v[a])$

DISCLAIMER: This is NOT a proposal from Microsoft, just from me.

Purposed data type:

interface VQ {
    neutral: number;
    variant: Array<[Region, number]>;
}
type Region = Array<[AxisTag, Tent]>;
interface Tent {
    min: number;
    peak: number;
    max: number;
}

Old Region type definition

type RegionOld = Map<AxisTag, Tent>;

Evaluation algorithm

function evalVQ(vq: VQ, instance: Map<AxisTag, number>){
    let result = vq.neutral;
    for(const [region, delta] of vq.variant) {
        result += delta * weightRegion(region, instance);
    }
    return result;
}
function weightRegion(region: Region, instance: Map<AxisTag, number>) {
    let weight = 1;
    for(const [axis, tent] of region) {
        weight *= weightTent(tent, instance.get(axis) || 0);
    }
    return weight;
}
function weightTent(t: Tent, coord: number) { ... }

Scaling algorithm.

function scale(scalar: number, vq: VQ) {
    return {
        neutral: vq.neutral * scalar,
        variant: vq.variant.map(([region, delta]) => [region, delta * scalar])
    };
}

Sum algorithm.

function add(a: VQ, b: VQ) {
    return { neutral: a.neutral + b.neutral, variant: [...a.variant, ...b.variant] };
}

Multiplication algorithm.

function multiply(a: VQ, b: VQ) {
    let variant : [Region, number][] = [];
    for(const [r, d] of a.variant) variant.push([r, d * b.neutral]);
    for(const [r, d] of b.variant) variant.push([r, d * a.neutral]);
    for(const [ra, da] of a.variant) for(const [rb, db] of b.variant) {
        variant.push([[...ra, ...rb], da * db]);
    }
    return { neutral: a.neutral * b.neutral, variant };
}

OpenType / opentype-variations

Duplicate axes in one region: Make variable quantities (coordinates, metrics) a ring #3

Status Quo

Purposed change