diff --git a/MMS24-25.c b/MMS24-25.c
index 72ece9d..14dd5ba 100644
--- a/MMS24-25.c
+++ b/MMS24-25.c
@@ -228,9 +228,9 @@ double interpolateLine(
  * \[ \forall i, j \in (0,\dots,iLen-1):
  *        (pdOut_i - pdOut_j) = (pdIn_i - pdIn_j)  *dFactor \],
  * which naturally results from:
- * $ pdOut_i = pdIn_i  *dFactor + (dMin - min(pdIn)) $.
+ * $ pdOut_i = (pdIn_i + min(pdIn)) * dFactor + dMin $.
  */
-void rescaleDoubleArray(
+ void rescaleDoubleArray(
         double *pdIn,
         int iLen,
         double dMin,
@@ -242,30 +242,19 @@ void rescaleDoubleArray(
         return;
     }
 
+    // First find the old minimum
+    double dOldMin = pdIn[0];
+    for (int i = 1; i < iLen; i++) {
+        if (pdIn[i] < dOldMin)
+            dOldMin = pdIn[i];
+    }
+
+    _debug("dOldMin: %lf", dOldMin);
+
     // Rescale the array
     for (int i = 0; i < iLen; i++) {
-        pdOut[i] = pdIn[i] * dFactor;
+        pdOut[i] = (pdIn[i] - dOldMin) * dFactor + dMin;
     }
-
-    // First find the minimum
-    double dOldMin = pdOut[0];
-    for (int i = 1; i < iLen; i++) {
-        if (pdOut[i] < dOldMin)
-            dOldMin = pdOut[i];
-    }
-
-    // Calculate the offset
-    double dOffset = dMin - dOldMin;
-
-    // Move the values to the new minimum
-    for (int i = 0; i < iLen; i++) {
-        pdOut[i] += dOffset;
-    }
-
-#ifdef _DEBUG
-    _debug("rescaleDoubleArray: dOldMin = %lf", dOldMin);
-    _debug("rescaleDoubleArray: dOffset = %lf", dOffset);
-#endif
 }
 
 /*
diff --git a/Makefile b/Makefile
index 600c731..d733fb8 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,8 @@
 CC=gcc
 SOURCE_FILE=MMS24-25.c
-OPTS=-lm -D _DEBUG -std=c99
+OPTS=-lm -std=c99
+
+FCC=afl-cc
 
 all: clean tests run
 
@@ -12,3 +14,7 @@ tests:
 
 run:
 	./tests
+
+fuzz:
+	$(FCC) $(SOURCE_FILE) -o fuzz $(OPTS)
+	afl-fuzz -i in -o out ./fuzz
diff --git a/tests.c b/tests.c
index 3141940..5b0c68a 100644
--- a/tests.c
+++ b/tests.c
@@ -678,6 +678,99 @@ void testInitMMSignalFeatures() {
     success("testInitMMSignalFeatures");
 }
 
+int eqToNDecimals(double dValueA, double dValueB, int iDecimals) {
+    return round(dValueA * pow(10, iDecimals)) == round(dValueB * pow(10, iDecimals));
+}
+
+void testRescaleDoubleArraySingle(
+    double *pdValues,
+    double *pdExpectedValues,
+    int iNumValues,
+    double dMin,
+    double dFactor
+) {
+    double pdOut[10];
+
+    rescaleDoubleArray(pdValues, iNumValues, dMin, dFactor, pdOut);
+
+    for (int i=0; i<iNumValues; i++) {
+        if (pdOut[i] != pdExpectedValues[i]) {
+            error("Failed to rescale the correct value at index %d: %lf != %lf", i, pdOut[i], pdExpectedValues[i]);
+        }
+    }
+
+    for (int i=1; i<iNumValues; i++) {
+        if (!eqToNDecimals(pdOut[i] - pdOut[i-1], (pdValues[i] - pdValues[i-1]) * dFactor, 6)) {
+            error("Failed scaling at index %d->%d: %lf != %lf", i-1, i, pdOut[i] - pdOut[i-1], (pdValues[i] - pdValues[i-1]) * dFactor);
+        }
+    }
+
+    int minIndex = 0;
+    for (int i=1; i<iNumValues; i++) {
+        if (pdOut[i] < pdOut[minIndex]) {
+            minIndex = i;
+        }
+    }
+
+    if (pdOut[minIndex] != dMin) {
+        error("Failed to rescale the minimum value: %lf != %lf", pdOut[minIndex], dMin);
+    }
+
+    success("testRescaleDoubleArraySingle");
+}
+
+void testRescaleDoubleArray() {
+    // void rescaleDoubleArray(double *pdIn, int iLen, double dMin, double dFactor, double *pdOut);
+    /* Rescales an array of double values so that the minimum value is dMin and
+     * the difference between any two values is scaled by dFactor.
+     * The result is stored in pdOut.
+     */
+    info("testRescaleDoubleArray");
+
+    double pdValues[] = {17, 4, -8, 0, 3, 5, 2, 1, 9, 6};
+    double pdOut[10];
+
+    double pdExpectedValues[] = {50, 24, 0, 16, 22, 26, 20, 18, 34, 28};
+    testRescaleDoubleArraySingle(pdValues, pdExpectedValues, 10, 0, 2);
+
+    double pdExpectedValues2[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    testRescaleDoubleArraySingle(pdValues, pdExpectedValues2, 10, 0, 0);
+
+    double pdExpectedValues3[] = {12.5, 6, 0, 4, 5.5, 6.5, 5, 4.5, 8.5, 7};
+    testRescaleDoubleArraySingle(pdValues, pdExpectedValues3, 10, 0, 0.5);
+
+    double pdExpectedValues4[] = {22.5, 16, 10, 14, 15.5, 16.5, 15, 14.5, 18.5, 17};
+    testRescaleDoubleArraySingle(pdValues, pdExpectedValues4, 10, 10, 0.5);
+
+    double pdValues2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    double pdExpectedValues2_4[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    testRescaleDoubleArraySingle(pdValues2, pdExpectedValues2_4, 10, 0, 1);
+
+    double pdExpectedValues2_5[] = {0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5};
+    testRescaleDoubleArraySingle(pdValues2, pdExpectedValues2_5, 10, 0, 0.5);
+
+    // 1 element
+    double pdValues3[] = {1};
+    double pdExpectedValues3_1[] = {0};
+    testRescaleDoubleArraySingle(pdValues3, pdExpectedValues3_1, 1, 0, 1);
+
+    double pdExpectedValues3_2[] = {5};
+    testRescaleDoubleArraySingle(pdValues3, pdExpectedValues3_2, 1, 5, 1);
+
+    double pdExpectedValues3_3[] = {5};
+    testRescaleDoubleArraySingle(pdValues3, pdExpectedValues3_3, 1, 5, 0);
+
+    // 2 elements
+    double pdValues4[] = {1, 2};
+    double pdExpectedValues4_1[] = {0, 1};
+    testRescaleDoubleArraySingle(pdValues4, pdExpectedValues4_1, 2, 0, 1);
+
+    double pdExpectedValues4_2[] = {0, 5};
+    testRescaleDoubleArraySingle(pdValues4, pdExpectedValues4_2, 2, 0, 5);
+
+    success("testRescaleDoubleArray");
+}
+
 int main (int iArgC, char** ppcArgV){
     testInterpolation();
     testSineAndReadWriteDoubleArray();
@@ -698,6 +791,7 @@ int main (int iArgC, char** ppcArgV){
     testApplyPascalConvForSeriesGT40();
     testCalcExtrema();
     testInitMMSignalFeatures();
+    testRescaleDoubleArray();
 
     return 0;
 }