@compute.ts/boolean

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

Libraries

The project provides several libraries that each comes with dozens of operators. Please note the cross-compatibility of the libraries.

Imports

Typescript

import {/* required operators */} from '@compute.ts/boolean';

Javascript

const {/* required operators */} = require('@compute.ts/boolean');

Operators

boolean

boolean(value) ➜ x_boolean

boolean() ➜ x_boolean

The boolean operator allows you to create a boolean expression which evals to the given value. If no value is provided the expression is a variable of the model

import {boolean} from "@compute.ts/boolean";

const x0 = boolean(true);
x0.affect(false);

const x1 = boolean();
x1.affect(false);

True

True() ➜ x_boolean

The True operator allows to create a boolean expression which evals to true

import {True} from "@compute.ts/boolean";

const x = True;
x.affect(false);

False

False() ➜ x_boolean

The False operator allows to create a boolean expression which evals to false

import {False} from "@compute.ts/boolean";

const x = False;
x.affect(true);

isTrue

isTrue(x_boolean) ➜ y_boolean

x_boolean.isTrue() ➜ y_boolean

The isTrue operator allows to create a boolean expression which evals to true if the given boolean expression evals to true

import {boolean, isTrue} from "@compute.ts/boolean";

const x = boolean();  
const y = isTrue(x) | x.isTrue();

const value = y.eval();

isFalse

isFalse(x_boolean) ➜ y_boolean

x_boolean.isFalse() ➜ y_boolean

The isFalse operator allows to create a boolean expression which evals to true if the given boolean expression evals to false

import {boolean, isFalse} from "@compute.ts/boolean";

const x = boolean();  
const y = isFalse(x) | x.isFalse();

const value = y.eval();

not

not(x_boolean) ➜ y_boolean

x_boolean.not() ➜ y_boolean

The not operator allows to create a boolean expression which evals to true if the given boolean expression evals to false

import {boolean, not} from "@compute.ts/boolean";

const x = boolean();  
const y = not(x) | x.not();

const value = y.eval();

implies

implies(x_boolean, y_boolean) ➜ z_boolean

x_boolean.implies(y_boolean) ➜ z_boolean

The implies operator allows to create a boolean expression which evals to true if the given boolean expressions match the implies truth table

import {boolean, implies} from "@compute.ts/boolean";

const x = boolean();  
const y = boolean();  
const z = implies(x, y) | x.implies(y);

const value = z.eval();

equals

equals(x_boolean, y_boolean) ➜ z_boolean

x_boolean.equals(y_boolean) ➜ z_boolean

The equals operator allows you to create a boolean expression which evals to true if the given expressions evals to the same boolean value

import {boolean, equals} from "@compute.ts/boolean";

const x = boolean();  
const y = boolean();  
const z = equals(x, y) | x.equals(y);

const value = z.eval();

and

and(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

x_boolean.and(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

The and operator allows to create a boolean expression which evals to true if the given boolean expressions match the AND truth table

import {boolean, and} from "@compute.ts/boolean";

const x0 = boolean();  
const x1 = boolean();  
// ...  
const xn = boolean();

const y = and(x0, x1, ..., xn) | x0.and(x1, ..., xn);

const value = y.eval();

or

or(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

x_boolean.or(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

The or operator allows to create a boolean expression which evals to true if the given boolean expressions match the OR truth table

import {boolean, or} from "@compute.ts/boolean";

const x0 = boolean();  
const x1 = boolean();  
// ...  
const xn = boolean();

const y = or(x0, x1, ..., xn) | x0.or(x1, ..., xn);

const value = y.eval();

xand

or(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

x_boolean.or(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

The xand operator allows to create a boolean expression which evals to true if the given boolean expressions match the XAND truth table

import {boolean, xand} from "@compute.ts/boolean";

const x0 = boolean();  
const x1 = boolean();  
// ...  
const xn = boolean();

const y = xand(x0, x1, ..., xn) | x0.xand(x1, ..., xn);

const value = y.eval();

xor

xor(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

x_boolean.xor(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

The xor operator allows to create a boolean expression which evals to true if the given boolean expressions match the XOR truth table

import {boolean, xor} from "@compute.ts/boolean";

const x0 = boolean();  
const x1 = boolean();  
// ...  
const xn = boolean();

const y = xor(x0, x1, ..., xn) | x0.xor(x1, ..., xn);

const value = y.eval();

nand

nand(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

x_boolean.nand(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

The nand operator allows to create a boolean expression which evals to true if the given boolean expressions match the NAND truth table

import {boolean, nand} from "@compute.ts/boolean";

const x0 = boolean();  
const x1 = boolean();  
// ...  
const xn = boolean();

const y = nand(x0, x1, ..., xn) | x0.nand(x1, ..., xn);

const value = y.eval();

nor

nor(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

x_boolean.nor(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

The nor operator allows to create a boolean expression which evals to true if the given boolean expressions match the NOR truth table

import {boolean, nor} from "@compute.ts/boolean";

const x0 = boolean();  
const x1 = boolean();  
// ...  
const xn = boolean();

const y = nor(x0, x1, ..., xn) | x0.nor(x1, ..., xn);

const value = y.eval();

xnand

xnand(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

x_boolean.xnand(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

The xnand operator allows to create a boolean expression which evals to true if the given boolean expressions match the XNAND truth table

import {boolean, xnand} from "@compute.ts/boolean";

const x0 = boolean();  
const x1 = boolean();  
// ...  
const xn = boolean();

const y = xnand(x0, x1, ..., xn) `|` x0.xnand(x1, ..., xn);

const value = y.eval();

xnor

xnor(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

x_boolean.xnor(x⁰_boolean, x¹_boolean, ..., xⁿ_boolean) ➜ y_boolean

The xnor operator allows to create a boolean expression which evals to true if the given boolean expressions match the XNOR truth table

import {boolean, xnor} from "@compute.ts/boolean";

const x0 = boolean();  
const x1 = boolean();  
// ...  
const xn = boolean();

const y = xnor(x0, x1, ..., xn) | x0.xnor(x1, ..., xn);

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/