isEqualTo at Complex class

src/common/simple-math/simple-math.interface.ts

@@ -10,6 +10,7 @@ interface ISimpleMath {
   random(): number;
   max(a: number, b: number): number;
   min(a: number, b: number): number;
+  abs(x: number): number;
 }
 
 interface ISimpleMathStatic {

src/common/simple-math/simple-math.spec.ts

@@ -49,4 +49,9 @@ describe('List', () => {
     expect(simpleMath.max(0.123456, 0.654321)).toBeCloseTo(0.654321, precisionDigits);
     expect(simpleMath.min(0.123456, 0.654321)).toBeCloseTo(0.123456, precisionDigits);
   });
+
+  it('should properly return absolute value', () => {
+    expect(simpleMath.abs(0.123456)).toBeCloseTo(0.123456, precisionDigits);
+    expect(simpleMath.abs(-0.123456)).toBeCloseTo(0.123456, precisionDigits);
+  });
 });

src/common/simple-math/simple-math.ts

@@ -41,4 +41,8 @@ export class SimpleMath implements ISimpleMath {
   public min(a: number, b: number): number {
     return Math.min(a, b);
   }
+
+  public abs(x: number): number {
+    return Math.abs(x);
+  }
 }

src/dsp/complex/complex-dependency-bag.interface.ts

@@ -5,6 +5,7 @@ import { ISimpleMath } from './../../common';
 interface IComplexDependencyBag {
   simpleMath: ISimpleMath;
   precisionDigits: number;
+  epsilon: number;
 }
 
 interface IComplexDependencyBagStatic {

src/dsp/complex/complex-dependency-bag.spec.ts

@@ -25,5 +25,6 @@ describe('ComplexDependencyBag', () => {
     expect(complexDependencyBag).toBeInstanceOf(ComplexDependencyBag);
     expect(complexDependencyBag.simpleMath).toBeInstanceOf(SimpleMath);
     expect(complexDependencyBag.precisionDigits).toBe(precisionDigits);
+    expect(complexDependencyBag.epsilon).toBe(0.000001);
   });
 });

src/dsp/complex/complex-dependency-bag.ts

@@ -15,9 +15,12 @@ export class ComplexDependencyBag implements IComplexDependencyBag {
     PRECISION_DIGITS
   ];
 
+  public epsilon: number;
+
   constructor(
     public simpleMath: ISimpleMath,
     public precisionDigits: number
   ) {
+    this.epsilon = simpleMath.pow(10, -precisionDigits);
   }
 }

src/dsp/complex/complex.interface.ts

@@ -21,6 +21,7 @@ interface IComplex {
   getMagnitude(): number;
   getUnitAngle(): number;
   normalize(): IComplex;
+  isEqualTo(b: IComplex): boolean;
   toDto(): IComplexDto;
   toRawIQ(): number[];
 }

src/dsp/complex/complex.spec.ts

@@ -178,6 +178,18 @@ describe('Complex', () => {
     expect(complex).toBe(complexNormalized);
   });
 
+  it('should properly indicate that two complex numbers are equal', () => {
+    const complexA = new Complex(complexDependencyBag, REAL, IMAGINARY);
+    const complexB = new Complex(
+      complexDependencyBag,
+      REAL + 0.000001,
+      IMAGINARY + 0.000001
+    );
+
+    expect(complex.isEqualTo(complexA)).toBe(true);
+    expect(complex.isEqualTo(complexB)).toBe(false);
+  });
+
   it('should properly return DTO', () => {
     const complexDto: IComplexDto = complex.toDto();
 

src/dsp/complex/complex.ts

@@ -146,6 +146,14 @@ export class Complex implements IComplex {
     return this;
   }
 
+  public isEqualTo(b: IComplex): boolean {
+    const simpleMath: ISimpleMath = this.complexDependencyBag.simpleMath;
+    const epsilon: number = this.complexDependencyBag.epsilon;
+
+    return (simpleMath.abs(this.real - b.getReal()) < epsilon) &&
+      (simpleMath.abs(this.imaginary - b.getImaginary()) < epsilon);
+  }
+
   public toDto(): IComplexDto {
     /* tslint:disable:object-literal-sort-keys */
     return {