FFT class first test

TODO.md

@@ -6,16 +6,16 @@
 - [DONE] finish physical layer example
 - finish data link layer simple example
 - move all modules to main NPM package
-    - switch all examples to the one lib file instead of development mode that loads all scripts
+- [DONE for all examples related to NPM package] switch all examples to the one lib file instead of development mode that loads all scripts
 - finish transport layer example
     - DataChunk listeners
     - segment listeners
     - example page itself
-- finish Audio Chat example 
-- replace Gulp by WebPack
-- configure unit tests from console
+- finish Audio Chat example
+- [DONE in PR] replace Gulp by WebPack
+- [DONE in PR] configure unit tests from console
 - [DONE] remove external google fonts
-    - improove website loading time in general
+    - [DONE] improove website loading time in general
 
 ## Physical Layer, Web Audio API and DSP stuff
 
@@ -32,16 +32,16 @@
     - SYNC setting 48/44.1 will no longer be needed in the Layers above Physical like Data Link Layer
     - custom FFT implementation
     - resampler
-    - FIR filter     
+    - FIR filter
 
 ## Data Link Layer
 
 - remove two way sync
     - look for frames in two FSK streams
-    - SYNC will not be required 
+    - SYNC will not be required
 
 ## Old todos (might be not valid anymore)
- 
+
 - DFT simple fix (code refactor)
 - full example DFT fix
     - add sampleRate input

src/common/list/list.interface.ts

@@ -12,7 +12,7 @@ interface IList<T> {
   // appendArrayEvenIfFull(value: T): IList<T>;
   takeFirst(): T;
   takeLast(): T;
-  fillWith(value: T, size: number): IList<T>;
+  fillWith(value: T, size?: number): IList<T>;
   isFull(): boolean;
   isEmpty(): boolean;
   setSizeMax(sizeMax: number): IList<T>;

src/common/list/list.spec.ts

@@ -226,9 +226,8 @@ describe('List', () => {
     expect(list.getSize()).toBe(3);
     try {
       list.append(4);
-    } catch (e) {
-      /* tslint:disable:no-empty */
-    }
+      /* tslint:disable-next-line:no-empty */
+    } catch (e) { }
     expect(list.getSize()).toBe(3);
   });
 

src/dependency-injection.config.ts

@@ -8,6 +8,8 @@ import { LIST_FACTORY } from './common/list/di-token';
 import ListFactory from './common/list/list-factory';
 import { SIMPLE_MATH } from './common/simple-math/di-token';
 import SimpleMath from './common/simple-math/simple-math';
+import ComplexListUtil from './dsp/complex-list-util/complex-list-util';
+import { COMPLEX_LIST_UTIL } from './dsp/complex-list-util/di-token';
 import ComplexFactory from './dsp/complex/complex-factory';
 import { COMPLEX_FACTORY } from './dsp/complex/di-token';
 import { DSP_MODULE } from './dsp/di-token';
@@ -22,6 +24,7 @@ injector.registerService(SIMPLE_MATH, SimpleMath);
 injector.registerService(COMMON_MODULE, CommonModule);
 
 injector.registerService(COMPLEX_FACTORY, ComplexFactory);
+injector.registerService(COMPLEX_LIST_UTIL, ComplexListUtil);
 injector.registerService(FOURIER_TRANSFORM, Fft);
 injector.registerService(DSP_MODULE, DspModule);
 

src/dsp/complex-list-util/complex-list-util.interface.ts

@@ -0,0 +1,29 @@
+// Copyright (c) 2015-2018 Robert Rypuła - https://audio-network.rypula.pl
+
+import { IListFactory } from '../../common/list/list-factory.interface';
+import { IList } from '../../common/list/list.interface';
+import { IComplexFactory } from '../complex/complex-factory.interface';
+import { IComplex, IComplexDto } from '../complex/complex.interface';
+
+type IComplexListDto = IComplexDto[];
+
+interface IComplexListUtil {
+  fromDto(complexListDto: IComplexListDto): IList<IComplex>;
+  // fromRawIQ(dto: number[]): IList<IComplex>;
+  toDto(complexList: IList<IComplex>): IComplexListDto;
+  // toRawIQ(list: IList<IComplex>): number[];
+  // isEqual(a: IList<IComplex>, b: IList<IComplex>): boolean;
+}
+
+interface IComplexListUtilStatic {
+  new(
+    complexFactory: IComplexFactory,
+    listFactory: IListFactory
+  ): IComplexListUtil;
+}
+
+export {
+  IComplexListDto,
+  IComplexListUtil,
+  IComplexListUtilStatic
+};

src/dsp/complex-list-util/complex-list-util.ts

@@ -0,0 +1,50 @@
+// Copyright (c) 2015-2018 Robert Rypuła - https://audio-network.rypula.pl
+
+import { staticImplements } from 'rr-tsdi';
+
+import { LIST_FACTORY } from '../../common/list/di-token';
+import { IListFactory } from '../../common/list/list-factory.interface';
+import { IList } from '../../common/list/list.interface';
+import { IComplexFactory } from '../complex/complex-factory.interface';
+import { IComplex, IComplexDto } from '../complex/complex.interface';
+import { COMPLEX_FACTORY } from '../complex/di-token';
+import { IComplexListDto, IComplexListUtil, IComplexListUtilStatic } from './complex-list-util.interface';
+
+@staticImplements<IComplexListUtilStatic>()
+class ComplexListUtil implements IComplexListUtil {
+  public static $inject: string[] = [
+    COMPLEX_FACTORY,
+    LIST_FACTORY
+  ];
+
+  constructor(
+    protected complexFactory: IComplexFactory,
+    protected listFactory: IListFactory
+  ) {
+  }
+
+  public fromDto(complexListDto: IComplexListDto): IList<IComplex> {
+    const tmp = complexListDto.map((complexDto: IComplexDto) => {
+      return this.complexFactory.createFromDto(complexDto);
+    });
+
+    return this.listFactory.createFromArray<IComplex>(tmp);
+  }
+
+  public toDto(complexList: IList<IComplex>): IComplexListDto {
+    return complexList
+      .toArray()
+      .map(
+        (value: IComplex): IComplexDto => {
+          /* tslint:disable:object-literal-sort-keys */
+          return {
+            real: value.getReal(),
+            imaginary: value.getImaginary()
+          };
+          /* tslint:enable:object-literal-sort-keys */
+        }
+      );
+  }
+}
+
+export default ComplexListUtil;

src/dsp/complex-list-util/di-token.ts

@@ -0,0 +1,3 @@
+// Copyright (c) 2015-2018 Robert Rypuła - https://audio-network.rypula.pl
+
+export const COMPLEX_LIST_UTIL = 'COMPLEX_LIST_UTIL';

src/dsp/complex/complex-factory.interface.ts

@@ -1,15 +1,18 @@
 // Copyright (c) 2015-2018 Robert Rypuła - https://audio-network.rypula.pl
 
 import { ISimpleMath } from '../../common/simple-math/simple-math.interface';
-import { IComplex } from './complex.interface';
+import { IComplex, IComplexDto } from './complex.interface';
 
 interface IComplexFactory {
   create(real?: number, imaginary?: number): IComplex;
   createPolar(unitAngle?: number, magnitude?: number): IComplex;
+  createFromDto(complexDto: IComplexDto): IComplex;
 }
 
 interface IComplexFactoryStatic {
-  new(simpleMath: ISimpleMath): IComplexFactory;
+  new(
+    simpleMath: ISimpleMath
+  ): IComplexFactory;
 }
 
 export {

src/dsp/complex/complex-factory.spec.ts

@@ -6,7 +6,7 @@ import { SIMPLE_MATH } from '../../common/simple-math/di-token';
 import SimpleMath from '../../common/simple-math/simple-math';
 import Complex from './complex';
 import ComplexFactory from './complex-factory';
-
+import { IComplexDto } from './complex.interface';
 import { COMPLEX_FACTORY } from './di-token';
 
 describe('ComplexFactory', () => {
@@ -52,4 +52,12 @@ describe('ComplexFactory', () => {
     expect(complex.getImaginary()).toBeCloseTo(1.414214, NUMBER_OF_DIGITS);
   });
 
+  it('should create instance of Complex class basing on dto', () => {
+    const dto: IComplexDto = { real: 12, imaginary: -32 };
+    const complex: Complex = complexFactory.createFromDto(dto);
+
+    expect(complex).toBeInstanceOf(Complex);
+    expect(complex.getReal()).toBe(dto.real);
+    expect(complex.getImaginary()).toBe(dto.imaginary);
+  });
 });

src/dsp/complex/complex-factory.ts

@@ -6,6 +6,7 @@ import { SIMPLE_MATH } from '../../common/simple-math/di-token';
 import { ISimpleMath } from './../../common/simple-math/simple-math.interface';
 import Complex from './complex';
 import { IComplexFactory, IComplexFactoryStatic } from './complex-factory.interface';
+import { IComplexDto } from './complex.interface';
 
 @staticImplements<IComplexFactoryStatic>()
 class ComplexFactory implements IComplexFactory {
@@ -19,7 +20,11 @@ class ComplexFactory implements IComplexFactory {
   }
 
   public create(real: number = 0, imaginary: number = 0): Complex {
-    return new Complex(this.simpleMath, real, imaginary);
+    return new Complex(
+      this.simpleMath,
+      real,
+      imaginary
+    );
   }
 
   public createPolar(unitAngle: number = 0, magnitude: number = 1): Complex {
@@ -30,6 +35,14 @@ class ComplexFactory implements IComplexFactory {
       magnitude * this.simpleMath.sin(radian)
     );
   }
+
+  public createFromDto(complexDto: IComplexDto): Complex {
+    return new Complex(
+      this.simpleMath,
+      complexDto.real,
+      complexDto.imaginary
+    );
+  }
 }
 
 export default ComplexFactory;

src/dsp/complex/complex.interface.ts

@@ -2,6 +2,11 @@
 
 import { ISimpleMath } from './../../common/simple-math/simple-math.interface';
 
+interface IComplexDto {
+  real: number;
+  imaginary: number;
+}
+
 interface IComplex {
   clone(): IComplex;
   swap(): IComplex;
@@ -16,13 +21,19 @@ interface IComplex {
   getMagnitude(): number;
   getUnitAngle(): number;
   normalize(): IComplex;
+  toDto(): IComplexDto;
 }
 
 interface IComplexStatic {
-  new(simpleMath: ISimpleMath, real: number, imaginary: number): IComplex;
+  new(
+    simpleMath: ISimpleMath,
+    real: number,
+    imaginary: number
+  ): IComplex;
 }
 
 export {
+  IComplexDto,
   IComplex,
   IComplexStatic
 };

src/dsp/complex/complex.spec.ts

@@ -2,6 +2,7 @@
 
 import SimpleMath from './../../common/simple-math/simple-math';
 import Complex from './complex';
+import { IComplexDto } from './complex.interface';
 
 describe('Complex', () => {
   const NUMBER_OF_DIGITS = 6;
@@ -154,4 +155,11 @@ describe('Complex', () => {
     expect(complexNormalized.getMagnitude()).toBeCloseTo(UNIT, NUMBER_OF_DIGITS);
     expect(complex).toBe(complexNormalized);
   });
+
+  it('should properly return DTO', () => {
+    const complexDto: IComplexDto = complex.toDto();
+
+    expect(complexDto.real).toBe(complex.getReal());
+    expect(complexDto.imaginary).toBe(complex.getImaginary());
+  });
 });

src/dsp/complex/complex.ts

@@ -3,7 +3,7 @@
 import { staticImplements } from 'rr-tsdi';
 
 import { ISimpleMath } from './../../common/simple-math/simple-math.interface';
-import { IComplex, IComplexStatic } from './complex.interface';
+import { IComplex, IComplexDto, IComplexStatic } from './complex.interface';
 
 @staticImplements<IComplexStatic>()
 class Complex implements IComplex {
@@ -137,6 +137,15 @@ class Complex implements IComplex {
 
     return this;
   }
+
+  public toDto(): IComplexDto {
+    /* tslint:disable:object-literal-sort-keys */
+    return {
+      real: this.real,
+      imaginary: this.imaginary
+    };
+    /* tslint:enable:object-literal-sort-keys */
+  }
 }
 
 export default Complex;