enhanced functionality in V01 vs. V00, V02 finished, conversion to double precsision in V03

Dependencies:   mbed

Files at this revision

API Documentation at this revision

Comitter:
pmic
Date:
Mon Apr 09 17:50:45 2018 +0000
Parent:
21:55b11670959e
Commit message:
all in float!

Changed in this revision

GPA.cpp Show annotated file Show diff for this revision Revisions of this file
diff -r 55b11670959e -r c895fa4d7319 GPA.cpp
--- a/GPA.cpp	Mon Apr 09 15:10:33 2018 +0000
+++ b/GPA.cpp	Mon Apr 09 17:50:45 2018 +0000
@@ -82,7 +82,7 @@
 #include "GPA.h"
 #include "mbed.h"
 #include "math.h"
-#define   pi 3.141592653589793
+#define   pi 3.1415927f
 
 using namespace std;
 
@@ -91,23 +91,23 @@
     this->NfexcDes = NfexcDes;
     this->NperMin = NperMin;
     this->NmeasMin = NmeasMin;
-    this->Ts = (double)Ts;
+    this->Ts = Ts;
 
     // calculate logarithmic spaced frequency points
-    fexcDes = (double*)malloc(NfexcDes*sizeof(double));
-    fexcDesLogspace((double)fMin, (double)fMax, NfexcDes);
+    fexcDes = (float*)malloc(NfexcDes*sizeof(float));
+    fexcDesLogspace(fMin, fMax, NfexcDes);
 
     // calculate coefficients for decreasing amplitude (1/fexc)
-    this->aAexcDes = ((double)Aexc1 - (double)Aexc0)/(1.0/fexcDes[NfexcDes-1] - 1.0/fexcDes[0]);
-    this->bAexcDes = (double)Aexc0 - aAexcDes/fexcDes[0];
+    this->aAexcDes = (Aexc1 - Aexc0)/(1.0f/fexcDes[NfexcDes-1] - 1.0f/fexcDes[0]);
+    this->bAexcDes = Aexc0 - aAexcDes/fexcDes[0];
 
-    fnyq = 1.0/2.0/(double)Ts;
-    pi2 = 2.0*pi;
-    pi2Ts = pi2*(double)Ts;
-    piDiv2 = pi/2.0;
+    fnyq = 1/2.0f/Ts;
+    pi2 = 2.0f*pi;
+    pi2Ts = pi2*Ts;
+    piDiv2 = pi/2.0f;
 
-    sU = (double*)malloc(3*sizeof(double));
-    sY = (double*)malloc(3*sizeof(double));
+    sU = (float*)malloc(3*sizeof(float));
+    sY = (float*)malloc(3*sizeof(float));
     reset();
 }
 
@@ -117,24 +117,24 @@
 {
     Nmeas = 0;
     Nper = 0;
-    fexc = 0.0;
-    fexcPast = 0.0;
+    fexc = 0.0f;
+    fexcPast = 0.0f;
     ii = 1; // iterating through desired frequency points
     jj = 1; // iterating through measurement points w.r.t. reachable frequency
-    scaleG = 0.0;
-    cr = 0.0;
-    ci = 0.0;
+    scaleG = 0.0f;
+    cr = 0.0f;
+    ci = 0.0f;
     for(int i = 0; i < 3; i++) {
-        sU[i] = 0.0;
-        sY[i] = 0.0;
+        sU[i] = 0.0f;
+        sY[i] = 0.0f;
     }
-    sinarg = 0.0;
+    sinarg = 0.0f;
     NmeasTotal = 0;
-    Aexc = 0.0;
-    pi2Tsfexc = 0.0;
+    Aexc = 0.0f;
+    pi2Tsfexc = 0.0f;
 }
 
-float GPA::update(double inp, double out)
+float GPA::update(float inp, float out)
 {
     // a new frequency point has been reached
     if(jj == 1) {
@@ -158,24 +158,24 @@
             }
         }
         // secure sinarg starts at 0 (numerically maybe not given)
-        sinarg = 0.0;
+        sinarg = 0.0f;
         // filter scaling
-        scaleG = 1.0/sqrt((double)Nmeas);
+        scaleG = 1.0f/sqrt((float)Nmeas);
         // filter coefficients
         cr = cos(pi2Tsfexc);
         ci = sin(pi2Tsfexc);
         // filter storage
         for(int i = 0; i < 3; i++) {
-            sU[i] = 0.0;
-            sY[i] = 0.0;
+            sU[i] = 0.0f;
+            sY[i] = 0.0f;
         }
     }
     // filter step for signal su
-    sU[0] = scaleG*inp + 2.0*cr*sU[1] - sU[2];
+    sU[0] = scaleG*inp + 2.0f*cr*sU[1] - sU[2];
     sU[2] = sU[1];
     sU[1] = sU[0];
     // filter step for signal sy
-    sY[0] = scaleG*out + 2.0*cr*sY[1] - sY[2];
+    sY[0] = scaleG*out + 2.0f*cr*sY[1] - sY[2];
     sY[2] = sY[1];
     sY[1] = sY[0];
     // measurement of frequencypoint is finished
@@ -184,56 +184,56 @@
         ii += 1;
         fexcPast = fexc;
         // calculate the one point dft
-        double Ureal = 2.0*scaleG*(cr*sU[1] - sU[2]);
-        double Uimag = 2.0*scaleG*ci*sU[1];
-        double Yreal = 2.0*scaleG*(cr*sY[1] - sY[2]);
-        double Yimag = 2.0*scaleG*ci*sY[1];
+        float Ureal = 2.0f*scaleG*(cr*sU[1] - sU[2]);
+        float Uimag = 2.0f*scaleG*ci*sU[1];
+        float Yreal = 2.0f*scaleG*(cr*sY[1] - sY[2]);
+        float Yimag = 2.0f*scaleG*ci*sY[1];
         // calculate magnitude and angle
-        float Umag = (float)(sqrt(Ureal*Ureal + Uimag*Uimag));
-        float Ymag = (float)(sqrt(Yreal*Yreal + Yimag*Yimag));
-        float absGyu = (float)(Ymag/Umag);
-        float angGyu = (float)(atan2(Yimag, Yreal) - atan2(Uimag, Ureal));
-        float absGye = (float)(Ymag/Aexc);
-        float angGye = (float)(atan2(Yimag, Yreal) + piDiv2);
+        float Umag = sqrt(Ureal*Ureal + Uimag*Uimag);
+        float Ymag = sqrt(Yreal*Yreal + Yimag*Yimag);
+        float absGyu = Ymag/Umag;
+        float angGyu = atan2(Yimag, Yreal) - atan2(Uimag, Ureal);
+        float absGye = Ymag/Aexc;
+        float angGye = (atan2(Yimag, Yreal) + piDiv2);
         // user info
         if(ii == 2) {
             printLine();
             printf("   fexc[Hz]    |Gyu|     ang(Gyu)    |Gye|     ang(Gye)     |E|        |U|        |Y|\r\n");
             printLine();
         }
-        printf("%11.3e %10.3e %10.3e %10.3e %10.3e %10.3e %10.3e %10.3e\r\n", (float)fexc, absGyu, angGyu, absGye, angGye, (float)Aexc, Umag, Ymag);
+        printf("%11.3e %10.3e %10.3e %10.3e %10.3e %10.3e %10.3e %10.3e\r\n", fexc, absGyu, angGyu, absGye, angGye, Aexc, Umag, Ymag);
     } else {
         jj += 1;
     }
     sinarg = fmod(sinarg + pi2Tsfexc, pi2);
     NmeasTotal += 1;
-    return (float)(Aexc*sin(sinarg));
+    return Aexc*sin(sinarg);
 }
 
-void GPA::fexcDesLogspace(double fMin, double fMax, int NfexcDes)
+void GPA::fexcDesLogspace(float fMin, float fMax, int NfexcDes)
 {
     // calculate logarithmic spaced frequency points
-    double Gain = log10(fMax/fMin)/((double)NfexcDes - 1.0);
-    double expon = 0.0;
+    float Gain = log10(fMax/fMin)/((float)NfexcDes - 1.0f);
+    float expon = 0.0f;
     for(int i = 0; i < NfexcDes; i++) {
-        fexcDes[i] = fMin*pow(10.0, expon);
+        fexcDes[i] = fMin*pow(10.0f, expon);
         expon += Gain;
     }
 }
 
-void GPA::calcGPAmeasPara(double fexcDes_i)
+void GPA::calcGPAmeasPara(float fexcDes_i)
 {
     // Nmeas has to be an integer
     Nper = NperMin;
-    Nmeas = (int)floor((double)Nper/fexcDes_i/Ts + 0.5);
+    Nmeas = (int)floor((float)Nper/fexcDes_i/Ts + 0.5f);
     //  secure that the minimal number of measurements is fullfilled
     int Ndelta = NmeasMin - Nmeas;
     if(Ndelta > 0) {
-        Nper = (int)ceil((double)NmeasMin*fexcDes_i*Ts);
-        Nmeas = (int)floor((double)Nper/fexcDes_i/Ts + 0.5);
+        Nper = (int)ceil((float)NmeasMin*fexcDes_i*Ts);
+        Nmeas = (int)floor((float)Nper/fexcDes_i/Ts + 0.5f);
     }
     // evaluating reachable frequency
-    fexc = (double)Nper/(double)Nmeas/Ts;
+    fexc = (float)Nper/(float)Nmeas/Ts;
 }
 
 void GPA::printLine()
@@ -245,7 +245,7 @@
 {
     printLine();
     for(int i = 0; i < NfexcDes; i++) {
-        printf("%9.4f\r\n", (float)fexcDes[i]);
+        printf("%9.4f\r\n", fexcDes[i]);
     }
 }
 
@@ -257,16 +257,16 @@
     for(int i = 0; i < NfexcDes; i++) {
         calcGPAmeasPara(fexcDes[i]);
         if(fexc == fexcPast || fexc >= fnyq) {
-            fexc = 0.0;
+            fexc = 0.0f;
             Nmeas = 0;
             Nper = 0;
-            Aexc = 0.0;
+            Aexc = 0;
         } else {
             Aexc = aAexcDes/fexc + bAexcDes;
             fexcPast = fexc;
         }
         NmeasTotal += Nmeas;
-        printf("%12.2e %9.2e %10.2e %7i %6i \r\n", (float)fexcDes[i], (float)fexc, (float)Aexc, Nmeas, Nper);
+        printf("%12.2e %9.2e %10.2e %7i %6i \r\n", fexcDes[i], fexc, Aexc, Nmeas, Nper);
     }
     printGPAmeasTime();
     reset();
@@ -276,5 +276,5 @@
 {
     printLine();
     printf(" number of data points:  %9i\r\n", NmeasTotal);
-    printf(" measurment time in sec: %9.2f\r\n", (float)((double)NmeasTotal*Ts));
+    printf(" measurment time in sec: %9.2f\r\n", (float)NmeasTotal*Ts);
 }
\ No newline at end of file