Security News
tea.xyz Spam Plagues npm and RubyGems Package Registries
Tea.xyz, a crypto project aimed at rewarding open source contributions, is once again facing backlash due to an influx of spam packages flooding public package registries.
algebra-group
Advanced tools
Readme
defines an algebra group structure
With npm do
npm install algebra-group
All code in the examples below is intended to be contained into a single file.
Create the Integer additive group.
const algebraGroup = require('algebra-group')
// Define identity element.
const zero = 0
// Define operators.
function isInteger (a) {
// NaN, Infinity and -Infinity are not allowed
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 }
// Create Integer additive group a.k.a (Z, +).
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:
Z.contains(2) // true
Z.contains(2.5) // false
Z.contains('xxx') // false
Z.notContains(false) // true
Z.notContains(Math.PI) // true
Z.contains(-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9) // true
Z.contains(1, 2, 3, 4.5) // false, 4.5 is not an integer
Z.addition(1, 2) // 3
Z.addition(1, 2, 3, 4) // 10
Z.negation(5) // -5
Z.subtraction(5, 1) // 4
Z.subtraction(5, 1, 1, 1, 1, 1) // 0
Z.equality(Z.subtraction(2, 2), Z.zero) // true
R\{0}
multiplicative groupConsider 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) {
// NaN, Infinity and -Infinity are not allowed
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) {
// Consider
//
// 0.1 + 0.2 === 0.3
//
// It evaluates to false. Actually the expression
//
// 0.1 + 0.2
//
// will return
//
// 0.30000000000000004
//
// Hence we need to approximate equality with an epsilon.
return Math.abs(a - b) < Number.EPSILON
}
// Create Real multiplicative group a.k.a (R, *).
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:
R.contains(10) // true
R.contains(Math.PI, Math.E, 1.7, -100) // true
R.notContains(Infinity) // true
R.inversion(2) // 0.5
// 2 * 3 * 5 = 30 = 60 / 2
R.equality(R.multiplication(2, 3, 5), R.division(60, 2)) // true
R+
multiplicative groupCreate the multiplicative group of positive real numbers (0,∞)
.
It is a well defined group, since
Let's customize group props, with a shorter naming.
function isRealAndPositive (n) {
// NaN, Infinity are not allowed
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:
Rp.contains(Math.PI) // true
Rp.notContains(-1) // true
Rp.eq(Rp.inv(4), Rp.div(Rp.one, 4)) // true
Rp.mul(2, 4) // 8
algebraGroup(identity, operator)
{Object}
given identity and operators{*}
given.identity a.k.a. neutral element{Function}
given.contains{Function}
given.equality{Function}
given.compositionLaw{Function}
given.inversion{Object}
[naming]{String}
[naming.identity=zero]{String}
[naming.contains=contains]{String}
[naming.equality=equality]{String}
[naming.compositionLaw=addition]{String}
[naming.inversion=negation]{String}
[naming.inverseCompositionLaw=subtraction]{String}
[naming.notContains=notContains]{Object}
groupsalgebraGroup.errors
An object exposing the following errors:
const {
ArgumentIsNotInGroupError,
EqualityIsNotReflexiveError,
IdentityIsNotInGroupError,
IdentityIsNotNeutralError
} = algebraGroup.errors
You can then do something like this
try {
// Some code that could raise an error.
} catch (error) {
switch (error) {
case instanceof ArgumentIsNotInGroupError:
// Handle error
break
case instanceof IdentityIsNotInGroupError:
// Handle error
break
default: throw error
}
}
For example, the following snippets will throw the corresponding error.
R.inversion(0) // 0 is not in group R\{0}
Rp.mul(1, -1) // -1 is not in R+
algebraGroup({
identity: 1,
contains: isRealAndNotZero,
equality: function (a, b) { return a > b }, // not well defined
compositionLaw: multiplication,
inversion: inversion
})
algebraGroup({
identity: -1,
contains: isRealAndPositive,
equality: equality,
compositionLaw: multiplication,
inversion: inversion
})
algebraGroup({
identity: 2,
contains: isRealAndNotZero,
equality: equality,
compositionLaw: multiplication,
inversion: inversion
})
FAQs
defines and algebra group structure
The npm package algebra-group receives a total of 12 weekly downloads. As such, algebra-group popularity was classified as not popular.
We found that algebra-group demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Tea.xyz, a crypto project aimed at rewarding open source contributions, is once again facing backlash due to an influx of spam packages flooding public package registries.
Security News
As cyber threats become more autonomous, AI-powered defenses are crucial for businesses to stay ahead of attackers who can exploit software vulnerabilities at scale.
Security News
UnitedHealth Group disclosed that the ransomware attack on Change Healthcare compromised protected health information for millions in the U.S., with estimated costs to the company expected to reach $1 billion.