algebra-group
defines an algebra group structure
Table Of Contents
Installation
With npm do
npm install algebra-group
Examples
All code in the examples below is intended to be contained into a single file.
Integer additive group
Create the Integer additive group.
const algebraGroup = require('algebra-group')
const zero = 0
function isInteger (a) {
return (typeof n === 'number') && isFinite(n) && (n % 1 === 0)
}
function integerEquality (a, b) { return a === b }
function addition (a, b) { return a + b }
function negation (a) { return -a }
const Z = algebraGroup({
identity: zero,
contains: isInteger,
equality: integerEquality,
compositionLaw: addition,
inversion: negation
})
You get a group object with zero as identity and the following group operators:
- contains
- notContains
- equality
- disequality
- addition
- subtraction
- negation
Z.contains(2)
Z.contains(2.5)
Z.contains('xxx')
Z.notContains(false)
Z.notContains(Math.PI)
Z.contains(-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
Z.contains(1, 2, 3, 4.5)
Z.addition(1, 2)
Z.addition(1, 2, 3, 4)
Z.negation(5)
Z.subtraction(5, 1)
Z.subtraction(5, 1, 1, 1, 1, 1)
Z.equality(Z.subtraction(2, 2), Z.zero)
R\{0}
multiplicative group
Consider R\{0}
, the set of Real numbers minus 0, with multiplication as composition law.
It is necessary to remove 0, otherwise there is an element which inverse does
not belong to the group, which breaks group laws.
It makes sense to customize group props, which defaults to additive group naming.
function isRealAndNotZero (n) {
return (typeof n === 'number') && (n !== 0) && isFinite(n)
}
function multiplication (a, b) { return a * b }
function inversion (a) { return 1 / a }
function realEquality (a, b) {
return Math.abs(a - b) < Number.EPSILON
}
const R = algebraGroup({
identity: 1,
contains: isRealAndNotZero,
equality: realEquality,
compositionLaw : multiplication,
inversion: inversion
}, {
compositionLaw: 'multiplication',
identity: 'one',
inverseCompositionLaw: 'division',
inversion: 'inversion'
})
You get a group object with one as identity and the following group operators:
- contains
- notContains
- equality
- disequality
- multiplication
- division
- inversion
R.contains(10)
R.contains(Math.PI, Math.E, 1.7, -100)
R.notContains(Infinity)
R.inversion(2)
R.equality(R.multiplication(2, 3, 5), R.division(60, 2))
R+
multiplicative group
Create the multiplicative group of positive real numbers (0,∞)
.
It is a well defined group, since
- it has an indentity
- it is close respect to its composition law
- for every element, its inverse belongs to the set
Let's customize group props, with a shorter naming.
function isRealAndPositive (n) {
return (typeof n === 'number') && (n > 0) && isFinite(n)
}
const Rp = algebraGroup({
identity: 1,
contains: isRealAndPositive,
equality: realEquality,
compositionLaw: multiplication,
inversion: inversion
}, {
compositionLaw: 'mul',
equality: 'eq',
disequality: 'ne',
identity: 'one',
inverseCompositionLaw: 'div',
inversion: 'inv'
})
You get a group object with one identity and the following group operators:
- contains
- notContains
- eq
- ne
- mul
- div
- inv
Rp.contains(Math.PI)
Rp.notContains(-1)
Rp.eq(Rp.inv(4), Rp.div(Rp.one, 4))
Rp.mul(2, 4)
API
algebraGroup(identity, operator)
- @param
{Object}
given identity and operators - @param
{*}
given.identity a.k.a. neutral element - @param
{Function}
given.contains - @param
{Function}
given.equality - @param
{Function}
given.compositionLaw - @param
{Function}
given.inversion - @param
{Object}
[naming] - @param
{String}
[naming.identity=zero] - @param
{String}
[naming.contains=contains] - @param
{String}
[naming.equality=equality] - @param
{String}
[naming.compositionLaw=addition] - @param
{String}
[naming.inversion=negation] - @param
{String}
[naming.inverseCompositionLaw=subtraction] - @param
{String}
[naming.notContains=notContains] - @returns
{Object}
groups
algebraGroup.errors
An object exposing the following errors:
const {
ArgumentIsNotInGroupError,
EqualityIsNotReflexiveError,
IdentityIsNotInGroupError,
IdentityIsNotNeutralError
} = algebraGroup.errors
You can then do something like this
try {
} catch (error) {
switch (error) {
case instanceof ArgumentIsNotInGroupError:
break
case instanceof IdentityIsNotInGroupError:
break
default: throw error
}
}
For example, the following snippets will throw the corresponding error.
ArgumentIsNotInGroupError
R.inversion(0)
Rp.mul(1, -1)
EqualityIsNotReflexiveError
algebraGroup({
identity: 1,
contains: isRealAndNotZero,
equality: function (a, b) { return a > b },
compositionLaw: multiplication,
inversion: inversion
})
IdentityIsNotInGroupError
algebraGroup({
identity: -1,
contains: isRealAndPositive,
equality: equality,
compositionLaw: multiplication,
inversion: inversion
})
IdentityIsNotNeutralError
algebraGroup({
identity: 2,
contains: isRealAndNotZero,
equality: equality,
compositionLaw: multiplication,
inversion: inversion
})
License
MIT
Contributors