Discuss
  • p-norms, Vector

p-norms, Vector

# kdex (9 years ago)

In mathematics, the p-norm of a vector is defined as in [1].

For p = 1, we get the taxicab norm, for p = 2 we get the Euclidean norm, and for the limit as p → ±∞ we get the maximum/minimum norm.

Particularly the Euclidean norm is pretty common in graphics-related code.

This could be implemented as an addition toTypedArray.prototype.

A rough sketch might look like so:

TypedArray.prototype.norm = function(p) {
	if (Number.isNaN(p)) {
		return p;
	}
	const { abs, min, max, sign } = Math;
	if (Number.isFinite(p)) {
		return this.map(x => abs(x) ** p).reduce((a, b) => a + b, 0) ** (1 / p);
	}
	return abs((sign(p) === 1 ? max : min)(...this));
};

Since norms are a little too specific for Array (as they don't necessarily contain numerical values), it might be worth pondering about a nativeVector implementation.

Any opinions?

[1] en.wikipedia.org/wiki/Norm_(mathematics)#p

# peter miller (8 years ago)

In mathematics, the p-norm of a vector is defined as in [1].

For p = 1, we get the taxicab norm,

array.reduce( (a,b)=>a+b ) (Although I wouldn't object to Math.sum())

for p = 2 we get the Euclidean norm,

Math.hypot(...array)

and for the limit as p → ±∞ we get the maximum/minimum norm.

Math.max(...array)

Particularly the Euclidean norm is pretty common in graphics-related
code.

This could be implemented as an addition toTypedArray.prototype.

A rough sketch might look like so:

TypedArray.prototype.norm = function(p) {
	if (Number.isNaN(p)) {
		return p;
	}
	const { abs, min, max, sign } = Math;
	if (Number.isFinite(p)) {
		return this.map(x => abs(x) ** p).reduce((a, b) => a + b, 0) ** (1 /  
p);
	}
	return abs((sign(p) === 1 ? max : min)(...this));
};

Since norms are a little too specific for Array (as they don't
necessarily contain numerical values), it might be worth pondering about a
nativeVector implementation.

Will DOMPoint solve your use cases? (Personal annoyance: you can't index
DOMPoint numerically.)

Peter

# kdex (8 years ago)

Thanks for the pointers!

array.reduce( (a,b)=>a+b ) (Although I wouldn't object to Math.sum())

Yes; no objections here.

Math.hypot(...array)

I'm aware of Math.hypot, but it only covers p = 2. The important thing about Math.hypot is that it doesn't demolish numbers with high magnitudes in the process of raising them to the power of two.

It would be great to have the same safety for other cases (i.e. p = 3) as well. The idea was to generalize the concept for every p.

Will DOMPoint solve your use cases? (Personal annoyance: you can't index DOMPoint numerically.)

Unfortunately, DOMPoint would be a Web API, which might (and probably will) not be available in other environments.

Essentially, what I'm suggesting is an environment-indepdendent Vector class, though I'm reluctant to go into more detail, as I feel that hardly anyone would want a Vector without proper operator overloading.

# Isiah Meadows (8 years ago)

This really seems like a good use case for WASM + SIMD (and a small static heap), given the number-heavy nature of it.