@compute.ts/number
Version:
Provide number operators for the computeTS package
446 lines (279 loc) • 12.3 kB
Markdown
## Presentation
The engine is based on incremental computation algorithms. When a calculation is submitted to the engine, all the computed values are memorized. So, if you change some variable and query an evaluation, the engine is able to compute the result very fast because it recomputes only what has changed.
[compute.ts](https://www.npmjs.com/package/compute.ts)
## Libraries
The project provides several libraries that each comes with dozens of operators. Please note the cross-compatibility of the libraries.
- [@compute.ts/boolean](https://www.npmjs.com/package/@compute.ts/boolean)
- [@compute.ts/string](https://www.npmjs.com/package/@compute.ts/string)
- [@compute.ts/date](https://www.npmjs.com/package/@compute.ts/date)
- [@compute.ts/dictionary](https://www.npmjs.com/package/@compute.ts/dictionary)
- [@compute.ts/function](https://www.npmjs.com/package/@compute.ts/function)
- [@compute.ts/array](https://www.npmjs.com/package/@compute.ts/array)
- [@compute.ts/math](https://www.npmjs.com/package/@compute.ts/math)
- [@compute.ts/structural](https://www.npmjs.com/package/@compute.ts/structural)
## Imports
### Typescript
```typescript
import {/* required operators */} from '@compute.ts/number';
```
### Javascript
```javascript
const {/* required operators */} = require('@compute.ts/number');
```
## Operators
### number
<code>number(value) ➜ x<sub>number</sub></code>
<code>number() ➜ x<sub>number</sub></code>
The **number** operator allows to create a number expression which evals to the given value. If no value is provided the expression is a variable and can be affected
```typescript
import {number} from "@compute.ts/number";
const x = number(5) | number();
x.affect(8);
```
* * *
### randomNumber
<code>randomNumber(x<sub>number</sub>, y<sub>number</sub>) ➜ z<sub>number</sub></code>
The **randomNumber** operator allows to create a number expression which evals to a random number between the given boundaries
```typescript
import {number, randomNumber} from "@compute.ts/number";
const x = number();
const y = number();
const z = randomNumber(x, y);
const value = z.eval();
```
* * *
### zero
<code>zero ➜ x<sub>number</sub></code>
The **zero** operator allows to create a number expression which evals to `0`
```typescript
import {zero} from "@compute.ts/number";
const x = zero;
x.affect(2);
```
* * *
### one
<code>one ➜ x<sub>number</sub></code>
The **one** operator allows to create a number expression which evals to `1`
```typescript
import {one} from "@compute.ts/number";
const x = one;
x.affect(2);
```
* * *
### opposite
<code>opposite(x<sub>number</sub>) ➜ y<sub>number</sub></code>
<code>x<sub>number</sub>.opposite() ➜ y<sub>number</sub></code>
The **opposite** operator allows to create a number expression which evals to the opposite of the given expression
```typescript
import {number, opposite} from "@compute.ts/number";
const x = number();
const y = opposite(x) | x.opposite() ;
const value = y.eval();
```
* * *
### plus
<code>plus(x<sup>0</sup><sub>number</sub>, x<sup>1</sup><sub>number</sub>, ..., x<sup>n</sup><sub>number</sub>) ➜ y<sub>number</sub></code>
<code>x<sub>number</sub>.plus(x<sup>0</sup><sub>number</sub>, x<sup>1</sup><sub>number</sub>, ..., x<sup>n</sup><sub>number</sub>) ➜ y<sub>number</sub></code>
The **plus** operator allows to create a number expression which evals to the sum of all the given expressions
```typescript
import {number, plus} from "@compute.ts/number";
const x0 = number();
const x1 = number();
// ....
const xn = number();
const y = plus(x0, x1, ..., xn) | x0.plus(x1, ..., xn);
const value = y.eval();
```
* * *
### multiply
<code>multiply(x<sup>0</sup><sub>number</sub>, x<sup>1</sup><sub>number</sub>, ..., x<sup>n</sup><sub>number</sub>) ➜ y<sub>number</sub></code>
<code>x<sub>number</sub>.multiply(x<sup>0</sup><sub>number</sub>, x<sup>1</sup><sub>number</sub>, ..., x<sup>n</sup><sub>number</sub>) ➜ y<sub>number</sub></code>
The **multiply** operator allows to create a number expression which evals to the multiplication of all the given expressions
```typescript
import {number, multiply} from "@compute.ts/number";
const x0 = number();
const x1 = number();
// ....
const xn = number();
const y = multiply(x0, x1, ..., xn) | x0.multiply(x1, ..., xn);
const value = y.eval();
```
* * *
### minus
<code>minus(x<sup>0</sup><sub>number</sub>, x<sup>1</sup><sub>number</sub>, ..., x<sup>n</sup><sub>number</sub>) ➜ y<sub>number</sub></code>
<code>x<sub>number</sub>.minus(x<sup>0</sup><sub>number</sub>, x<sup>1</sup><sub>number</sub>, ..., x<sup>n</sup><sub>number</sub>) ➜ y<sub>number</sub></code>
The **minus** operator allows to create a number expression which evals to the first given element minus all the elements which comes after
```typescript
import {number, minus} from "@compute.ts/number";
const x0 = number();
const x1 = number();
// ....
const xn = number();
const y = minus(x0, x1, ..., xn) | x0.minus(x1, ..., xn);
const value = y.eval();
```
* * *
### divide
<code>divide(x<sub>number</sub>, y<sub>number</sub>) ➜ z<sub>number</sub></code>
<code>x<sub>number</sub>.divide(y<sub>number</sub>) ➜ z<sub>number</sub></code>
The **divide** operator allows to create a number expression which evals to the division of x by y
```typescript
import {number} from "@compute.ts/number";
const x = number();
const y = number();
const z = divide(x, y) | x.divide(y);
const value = z.eval();
```
* * *
### modulo
<code>modulo(x<sub>number</sub>, y<sub>number</sub>) ➜ z<sub>number</sub></code>
<code>x<sub>number</sub>.modulo(y<sub>number</sub>) ➜ z<sub>number</sub></code>
The **modulo** operator allows to create a number expression which evals to the rest of the division of x by y
```typescript
import {number, modulo} from "@compute.ts/number";
const x = number();
const y = number();
const z = modulo(x, y) | x.modulo(y);
const value = z.eval();
```
* * *
### lessThan
<code>lessThan(x<sub>number</sub>, y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
<code>x<sub>number</sub>.lessThan(y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
The **lessThan** operator allows to create a boolean expression which evals to `true` if x is less than y
```typescript
import {number, lessThan} from "@compute.ts/number";
const x = number();
const y = number();
const z = lessThan(x, y) | x.lessThan(y);
const value = z.eval();
```
* * *
### lessOrEqualThan
<code>lessOrEqualThan(x<sub>number</sub>, y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
<code>x<sub>number</sub>.lessOrEqualThan(y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
The **lessOrEqualThan** operator allows to create a boolean expression which evals to `true` if x is less or equal than y
```typescript
import {number, lessOrEqualThan} from "@compute.ts/number";
const x = number();
const y = number();
const z = lessOrEqualThan(x, y) | x.lessOrEqualThan(y);
const value = z.eval();
```
* * *
### greaterThan
<code>greaterThan(x<sub>number</sub>, y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
<code>x<sub>number</sub>.greaterThan(y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
The **greaterOrEqualThan** operator allows to create a boolean expression which evals to `true` if x is greater y
```typescript
import {number, greaterThan} from "@compute.ts/number";
const x = number();
const y = number();
const z = greaterThan(x, y) | x.greaterThan(y);
const value = z.eval();
```
* * *
### greaterOrEqualThan
<code>greaterOrEqualThan(x<sub>number</sub>, y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
<code>x<sub>number</sub>.greaterOrEqualThan(y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
The **greaterOrEqualThan** operator allows to create a boolean expression which evals to `true` if x is greater or equal y
```typescript
import {number, greaterOrEqualThan} from "@compute.ts/number";
const x = number();
const y = number();
const z = greaterOrEqualThan(x, y) | x.greaterOrEqualThan(y);
const value = z.eval();
```
* * *
### equal
<code>equal(x<sub>number</sub>, y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
<code>x<sub>number</sub>.equal(y<sub>number</sub>) ➜ z<sub>boolean</sub></code>
The **equals** operator allows to create a boolean expression which evals to `true` if x and y are the same equals
```typescript
import {number, equal} from "@compute.ts/number";
const x = number();
const y = number();
const z = equal(x, y) | x.equal(y);
const value = z.eval();
```
* * *
### isZero
<code>isZero(x<sub>number</sub>) ➜ y<sub>boolean</sub></code>
<code>x<sub>number</sub>.isZero() ➜ y<sub>boolean</sub></code>
The **isZero** operator allows to create a boolean expression which evals to `true` if x is zero
```typescript
import {number, isZero} from "@compute.ts/number";
const x = number();
const y = isZero(x) | x.isZero();
const value = y.eval();
```
* * *
### isPositive
<code>isPositive(x<sub>number</sub>) ➜ y<sub>boolean</sub></code>
<code>x<sub>number</sub>.isPositive() ➜ y<sub>boolean</sub></code>
The **isPositive** operator allows to create a boolean expression which evals to `true` if x is positive
```typescript
import {number, isPositive} from "@compute.ts/number";
const x = number();
const y = isPositive(x) | x.isPositive();
const value = y.eval();
```
* * *
### isNegative
<code>isNegative(x<sub>number</sub>) ➜ y<sub>boolean</sub></code>
<code>x<sub>number</sub>.isNegative() ➜ y<sub>boolean</sub></code>
The **isNegative** operator allows to create a boolean expression which evals to `true` if x is negative
```typescript
import {number, isNegative} from "@compute.ts/number";
const x = number();
const y = isNegative(x) | x.isNegative();
const value = y.eval();
```
* * *
### isEven
<code>isEven(x<sub>number</sub>) ➜ y<sub>boolean</sub></code>
<code>x<sub>number</sub>.isEven() ➜ y<sub>boolean</sub></code>
The **isEven** operator allows to create a boolean expression which evals to `true` if x is even
```typescript
import {number, isEven} from "@compute.ts/number";
const x = number();
const y = isEven(x) | x.isEven();
const value = y.eval();
`````
* * *
### isOdd
<code>isOdd(x<sub>number</sub>) ➜ y<sub>boolean</sub></code>
<code>x<sub>number</sub>.isOdd() ➜ y<sub>boolean</sub></code>
The **isOdd** operator allows to create a boolean expression which evals to `true` if x is odd
```typescript
import {number, isOdd} from "@compute.ts/number";
const x = number();
const y = isOdd(x) | x.isOdd();
const value = y.eval();
```
* * *
### isPrime
<code>isPrime(x<sub>number</sub>) ➜ y<sub>boolean</sub></code>
<code>x<sub>number</sub>.isPrime() ➜ y<sub>boolean</sub></code>
The **isPrime** operator allows to create a boolean expression which evals to `true` if x is prime
```typescript
import {number, isPrime} from "@compute.ts/number";
const x = number();
const y = isPrime(x) | x.isPrime();
const value = y.eval();
```
## About the author
I am a software developer with 4 years of project specializing in the development of web solutions. Digital Nomad, I work while traveling. After 3 years into the french industry, I've started to work as a freelance software architect or fullstack developer.
Based on state-of-the-art web technologies, I offer you to architect & develop the best version of your project. My experience in the web app development assure you to build a nice looking, performant and stable product.
Minimalist, I like to travel, to meet people, learn new things and handmade stuff. Scuba & sky diving licenced. I like also hamburgers, Kinder chocolate and crepes. Karate black belt.
https://berthellemy.com/
* * *
