) => (x: T) => e(x) && !f(x)```
Running the code below:
-
+```js
console.log('\nComplement:')
const c = core.complement(numbers.multipleOfThree, numbers.multipleOfFive)
console.log('Is 15 in MultipleOfThree \\ MultipleOfFive set? ', c(15))
console.log('Is 9 in MultipleOfThree \\ MultipleOfFive set? ', c(9))
-
+```
gives the following results:
-#### Symmetric Difference
+### Symmetric Difference
@@ -455,20 +463,20 @@ Let `E` and `F` be two sets. The _symmetric difference_ of `E` and `F`, denoted
Let `SymmetricDifference` be the _symmetric difference_ operation. Thus, the `SymmetricDifference` operation can be implemented in two ways in TypeScript. A trivial way is to use the union and complement operations as follows:
-
+```js
const symmetricDifferenceWithoutXor = (e: Set, f: Set) =>
(x: T) => union(complement(e, f), complement(f, e))(x)
-
+```
Another way is to use the `XOR` binary operation as follows:
-
+```js
const symmetricDifferenceWithXor = (e: Set, f: Set) => (x: T) => e(x) !== f(x)
-
+```
Running the code below:
-
+```js
console.log('\nSymmetricDifference without XOR:')
const sdWithoutXor = core.symmetricDifferenceWithoutXor(numbers.prime, numbers.even)
console.log('Is 2 in the symetric difference of prime and even Sets? ', sdWithoutXor(2))
@@ -480,78 +488,78 @@ const sdWithXor = core.symmetricDifferenceWithXor(numbers.prime, numbers.even)
console.log('Is 2 in the symetric difference of prime and even Sets? ', sdWithXor(2))
console.log('Is 4 in the symetric difference of prime and even Sets? ', sdWithXor(4))
console.log('Is 7 in the symetric difference of prime and even Sets? ', sdWithXor(7))
-
+```
gives the following results:
-#### Other Operations
+### Other Operations
This section presents other useful binary operations on sets.
-##### Contains
+#### Contains
Let `Contains` be the operation that checks whether or not an element is in a set. This operation is a function that takes as parameter an element and returns `true` if the element is in the set, `false` otherwise.
Thus, this operation is defined as follows in TypeScript:
-
+```js
const contains = (e: Set, x: T) => e(x)
-
+```
Therefore, running the code below:
-
+```js
console.log('\nContains:')
console.log('Is 7 in the singleton {0}? ', core.contains(common.singleton(0), 7))
console.log('Is 7 in the singleton {7}? ', core.contains(common.singleton(7), 7))
-
+```
gives the following result:
-##### Add
+#### Add
Let `Add` be the operation that adds an element to a set. This operation is a function that takes as parameter an element and adds it to the set.
Thus, this operation is defined as follows in TypeScript:
-
+```js
const add = (e: Set, y: T) => (x: T) => x === y || e(x)
-
+```
Therefore, running the code below:
-
+```js
console.log('\nAdd:')
console.log('Is 7 in {0, 7}? ', core.add(common.singleton(0), 7)(7))
console.log('Is 0 in {1, 0}? ', core.add(common.singleton(1), 0)(0))
console.log('Is 7 in {19, 0}? ', core.add(common.singleton(19), 0)(7))
-
+```
gives the following result:
-##### Remove
+#### Remove
Let `Remove` be the operation that removes an element from a set. This operations is a function that takes as parameter an element and removes it from the set.
Thus, this operation is defined as follows in TypeScript:
-
+```js
const remove = (e: Set, y: T) => (x: T) => x !== y && e(x)
-
+```
Therefore, running the code below:
-
+```js
console.log('\nRemove:')
console.log('Is 7 in {}? ', core.remove(common.singleton(0), 0)(7))
console.log('Is 0 in {}? ', core.remove(common.singleton(7), 7)(0))
-
+```
gives the following result:
@@ -583,15 +591,15 @@ In this section, we will set up the _Characterstic function_ of the _Closed_ dis
To set up the _Characterstic function_, we first need a function that calculates the _Euclidean Distance_ between two points in the plane. This function is implemented as follows:
-
+```js
function distance(p1: Point, p2: Point) {
return Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2)
}
-
+```
where `Point` is defined below:
-
+```js
class Point {
x: number
y: number
@@ -601,7 +609,7 @@ class Point {
this.y = y
}
}
-
+```
This formula is based on Pythagoras' Theorem.
@@ -617,9 +625,9 @@ where `a` and `b` are the coordinates of the center and `R` the radius.
Thus, the implementation of `Disk` in TypeScript is as follows:
-
+```js
const disk = (center: Point, radius: number) => (p: Point) => distance(p, center) <= radius
-
+```
In order to view the set in a HTML5 page, I decided to implement a function `draw` that draws a set in the _Euclidean plane_. I chose _HTML5_ and thus used the `canvas` element for drawing.
@@ -629,7 +637,7 @@ Thus, I've built the _Euclidean plane_ illustrated below through the method `dra
Below the implementation of the plane.
-
+```js
class Plane {
width: number
height: number
@@ -667,22 +675,22 @@ class Plane {
context.clearRect(0, 0, this.width, this.height)
}
}
-
+```
In the `draw` function, a `canvas` having the same width and the same height as the _Euclidean plane_ container is created. Then each point in pixels `(x,y)` of the `canvas` is replaced by a black point if it belongs to the `set`. `xMin`, `xMax`, `yMin` and `yMax` are the bounding values illustrated in the figure of the _Euclidean plane_ above.
Running the code below:
-
+```js
euclideanPlane = new Plane(200, 200)
euclideanPlane.draw(disk(new Point(0, 0), 50), 'disk')
-
+```
where `disk` is the `id` of the canvas:
-
+```html
-
+```
gives the following result:
@@ -698,22 +706,22 @@ In this section, we will set up the _Characteristic functions_ of the _horizonta
Let `HorizontalHalfPlane` be the _Characteristic function_ of a _horizontal_ half-plane. The implementation of `HorizontalHalfPlane` in TypeScript is as follows:
-
+```js
const horizontalHalfPlane = (y: number, isLowerThan: boolean) =>
(p: Point) => (isLowerThan ? p.y <= y : p.y >= y)
-
+```
Thus, running the code below:
-
+```js
euclideanPlane.draw(horizontalHalfPlane(0, true),'hhp')
-
+```
where `hhp` is the `id` of the canvas:
-
+```html
-
+```
gives the following result:
@@ -721,20 +729,20 @@ gives the following result:
Let `VerticalHalfPlane` be the _Characteristic function_ of a _vertical_ half-plane. The implementation of `VerticalHalfPlane` in TypeScript is as follows:
-const verticalHalfPlane = (x: number, isLowerThan: boolean) =>
- (p: Point) => (isLowerThan ? p.x <= x : p.x >= x)
+```jsconst verticalHalfPlane = (x: number, isLowerThan: boolean) =>
+ (p: Point) => (isLowerThan ? p.x <= x : p.x >= x)```
Thus, running the code below:
-
+```js
euclideanPlane.draw(verticalHalfPlane(0, false),'vhp')
-
+```
where `vhd` is the `id` of the canvas:
-
+```html
-
+```
gives the following result:
@@ -744,16 +752,16 @@ In the first section of the article, we set up basic binary operations on sets.
Therefore, running the sample below:
-
+```js
euclideanPlane.draw(set.intersection(disk(new Point(0, 0), 50),
verticalHalfPlane(0, false)), 'hd')
-
+```
where `hd` is the `id` of the canvas:
-
+```html
-
+```
gives the following result:
@@ -763,30 +771,31 @@ gives the following result:
This section presents functions on the sets in the Euclidean plane.
-#### Translate
+### Translate
Let `translatePoint` be the function that translates a point in the plane. In Euclidean geometry, `translatePoint` is a function that moves a given point a constant distance in a specified direction. Thus the implementation in TypeScript is as follows:
-
+```js
const translatePoint = (deltax: number, deltay: number) =>
(p: Point) => new Point(p.x + deltax, p.y + deltay)
-
+```
where `(deltax, deltay)` is the constant vector of the translation.
Let `translate` be the function that translates a set in the plane. This function is simply implemented as follows in TypeScript:
-
+```js
const translate = (e: PlaneSet, deltax: number, deltay: number) =>
- (p: Point) => e(translatePoint(-deltax, -deltay)(p))
+ (p: Point) => e(translatePoint(-deltax, -deltay)(p))
+```
`translate` takes as parameters `deltax` which is the delta distance in the first Euclidean dimension and `deltay` which is the delta distance in the second Euclidean dimension. If a point _P (x, y)_ is translated in a set _S_, then its coordinates will change to _(x', y') = (x, delatx, y, deltay)_. Thus, the point _(x' - delatx, y' - deltay)_ will always belong to the set _S_. In set algebra, `translate` is called isomorph, in other words, the set of all translations forms the _translation group T_, which is isomorphic to the space itself. This explains the main logic of the function.
Thus, running the code below in our HTML5 page:
-
+```js
let translate_timer: ReturnType
function translate_op() {
let deltay = 0
@@ -797,19 +806,19 @@ function translate_op() {
euclideanPlane.draw(translate(disk(new Point(0, -50), 50), 0, deltay), 'ep_op')
}, 1000)
}
-
+```
where `ep_op` is the `id` of the canvas:
-
+```html
-
+```
gives the following result:
-#### Homothety
+### Homothety
@@ -819,26 +828,26 @@ Let `scalePoint` be the function that sends any point _M_ to another point _N_ s
Thus the implementation in TypeScript is as follows:
-
+```js
const scalePoint = (lambdax: number, lambday: number, deltax: number, deltay: number)
=> (p: Point) => new Point(lambdax * p.x + deltax, lambday * p.y + deltay)
-
+```
where `(deltax, deltay)` is the constant vector of the translation and `(lambdax, lambday)` is the lambda vector.
Let `scale` be the function that applies an homothety on a set in the plan. This function is simply implemented as follows in TypeScript:
-
+```js
const scale = (e: PlaneSet, lambdax: number, lambday: number, deltax: number,
deltay: number) => (p: Point) => e(scalePoint(1 / lambdax, 1 / lambday,
-deltax / lambdax, -deltay / lambday)(p))
-
+```
`scale` takes as parameters `deltax` which is the delta distance in the first Euclidean dimension, `deltay` which is the delta distance in the second Euclidean dimension and `(lambdax, lambday)` which is the constant factor vector λ. If a point _P (x, y)_ is transformed through `scale` in a set _S_, then its coordinates will change to _(x', y') = (lambdax * x, delatx, lambday * y, deltay)_. Thus, the point _((x'- delatx)/lambdax, (y' - deltay)/lambday)_ will always belong to the set _S_, If lambda is different from the vector 0, of course. In algebra of sets, `scale` is called isomorph, in other words, the set of all homotheties forms the _Homothety group H_, which is isomorphic to the space itself \ {0}. This explains the main logic of the function.
Thus, running the code below in our HTML5 page:
-
+```js
let scale_timer: ReturnType
function scale_op() {
let deltay = 0
@@ -851,13 +860,13 @@ function scale_op() {
euclideanPlane.draw(scale(disk(new Point(0, -50), 50), 1, lambday, 0, deltay), 'ep_op')
}, 1000)
}
-
+```
gives the following result:
-#### Rotate
+### Rotate
@@ -879,22 +888,22 @@ Below the demonstration:
Thus the implementation in TypeScript is as follows:
-
+```js
const rotatePoint = (theta: number) => (p: Point) => new Point(p.x * Math.cos(theta)
- p.y * Math.sin(theta), p.x * Math.sin(theta) + p.y * Math.cos(theta))
-
+```
Let `rotate` be the function that applies a rotation on a set in the plane with the angle θ. This function is simply implemented as follows in TypeScript.
-
+```js
const rotate = (e: PlaneSet, theta: number) => (p: Point) => e(rotatePoint(-theta)(p))
-
+```
`rotate` is a function that takes as parameter `theta` which is the angle of the rotation. If a point _P (x, y)_ is transformed through `rotate` in a set _S_, then its coordinates will change to _(x', y') = (x * cos(theta) - y * sin(theta), x * sin(theta), y * cos(theta))_. Thus, the point _(x' * cos(theta), y' * sin(theta), y' * cos(theta) - x' * sin(theta))_ will always belong to the set _S_. In algebra of sets, `rotate` is called isomorph, in other words, the set of all rotations forms the _Rotation group R_, which is isomorphic to the space itself. This explains the main logic of the function.
Thus, running the code below in our HTML5 page:
-
+```js
let rotate_timer: ReturnType
function rotate_op() {
let theta = 0
@@ -905,7 +914,7 @@ function rotate_op() {
theta = (theta + Math.PI / 2) % (2 * Math.PI)
}, 1000)
}
-
+```
gives the following result:
@@ -942,15 +951,15 @@ where `c` is a complex. The _Mandelbrot_ fractal is defined as the set of all po
Fractals (abstract data type) can always be represented as follows in TypeScript:
-
+```js
type Fractal = (z: Complex, c: Complex) => Complex
-
+```
### Complex Numbers and Drawing
In order to be able to draw fractals, I needed to manipulate _Complex_ numbers. Thus, I created the `Complex` class below:
-
+```js
class Complex {
x: number
y: number
@@ -981,18 +990,19 @@ function substract(z1: Complex, z2: Complex) {
function multiply(z1: Complex, z2: Complex) {
return new Complex(z1.x * z2.x - z1.y * z2.y, z1.x * z2.y + z1.y * z2.x)
}
-
+```
### Mandelbrot Fractal
I created a _Mandelbrot Fractal_ (abstract data type representation) `P(z) = z^2 + c` that is available below.
-
-const mandelbrot = (z: Complex, c: Complex) => add(multiply(z, z), c)
+```js
+const mandelbrot = (z: Complex, c: Complex) => add(multiply(z, z), c)
+```
In order to be able to draw _Complex_ numbers, I created a `ComplexPlane` class. Below is the implementation in TypeScript.
-
+```js
class ComplexPlane {
width: number
height: number
@@ -1057,11 +1067,11 @@ class ComplexPlane {
context.fillText('Please wait...', this.width / 2 - 30, this.height / 2)
}
}
-
+```
Thus, running the code below:
-
+```js
const complexPlane = new ComplexPlane(300, 300, -1.5, 1.5, -1.5, 1.5, 1.5, 20, 'fractal')
const mandelbrot = (z: Complex, c: Complex) => add(multiply(z, z), c)
@@ -1069,13 +1079,13 @@ const mandelbrot = (z: Complex, c: Complex) => add(multiply(z, z), c)
complexPlane.pleaseWait()
setTimeout(() => complexPlane.draw(mandelbrot), 500)
-
+```
where `fractal` is the `id` of the canvas:
-
+```html
-
+```
gives the following result: