Merging upstream version 1.32.0.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 140 insertions, 0 deletions

diff --git a/ml/kmeans/SamplesBuffer.h b/ml/kmeans/SamplesBuffer.h
new file mode 100644
index 000000000..fccd216d5
--- /dev/null
+++ b/ml/kmeans/SamplesBuffer.h
@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef SAMPLES_BUFFER_H
+#define SAMPLES_BUFFER_H
+
+#include <iostream>
+#include <vector>
+
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+
+#include <dlib/matrix.h>
+
+typedef double CalculatedNumber;
+typedef dlib::matrix<CalculatedNumber, 0, 1> DSample;
+
+class Sample {
+public:
+    Sample(CalculatedNumber *Buf, size_t N) : CNs(Buf), NumDims(N) {}
+
+    void initDSample(DSample &DS) const {
+        for (size_t Idx = 0; Idx != NumDims; Idx++)
+            DS(Idx) = CNs[Idx];
+    }
+
+    void add(const Sample &RHS) const {
+        assert(NumDims == RHS.NumDims);
+
+        for (size_t Idx = 0; Idx != NumDims; Idx++)
+            CNs[Idx] += RHS.CNs[Idx];
+    };
+
+    void diff(const Sample &RHS) const {
+        assert(NumDims == RHS.NumDims);
+
+        for (size_t Idx = 0; Idx != NumDims; Idx++)
+            CNs[Idx] -= RHS.CNs[Idx];
+    };
+
+    void copy(const Sample &RHS) const {
+        assert(NumDims == RHS.NumDims);
+
+        std::memcpy(CNs, RHS.CNs, NumDims * sizeof(CalculatedNumber));
+    }
+
+    void scale(CalculatedNumber Factor) {
+        for (size_t Idx = 0; Idx != NumDims; Idx++)
+            CNs[Idx] *= Factor;
+    }
+
+    void lag(const Sample &S, size_t LagN) {
+        size_t N = S.NumDims;
+
+        for (size_t Idx = 0; Idx != (LagN + 1); Idx++) {
+            Sample Src(S.CNs - (Idx * N), N);
+            Sample Dst(CNs + (Idx * N), N);
+            Dst.copy(Src);
+        }
+    }
+
+    const CalculatedNumber *getCalculatedNumbers() const {
+        return CNs;
+    };
+
+    void print(std::ostream &OS) const;
+
+private:
+    CalculatedNumber *CNs;
+    size_t NumDims;
+};
+
+inline std::ostream& operator<<(std::ostream &OS, const Sample &S) {
+    S.print(OS);
+    return OS;
+}
+
+class SamplesBuffer {
+public:
+    SamplesBuffer(CalculatedNumber *CNs,
+                  size_t NumSamples, size_t NumDimsPerSample,
+                  size_t DiffN = 1, size_t SmoothN = 3, size_t LagN = 3) :
+        CNs(CNs), NumSamples(NumSamples), NumDimsPerSample(NumDimsPerSample),
+        DiffN(DiffN), SmoothN(SmoothN), LagN(LagN),
+        BytesPerSample(NumDimsPerSample * sizeof(CalculatedNumber)),
+        Preprocessed(false) {};
+
+    std::vector<DSample> preprocess();
+    std::vector<Sample> getPreprocessedSamples() const;
+
+    size_t capacity() const { return NumSamples; }
+    void print(std::ostream &OS) const;
+
+private:
+    size_t getSampleOffset(size_t Index) const {
+        assert(Index < NumSamples);
+        return Index * NumDimsPerSample;
+    }
+
+    size_t getPreprocessedSampleOffset(size_t Index) const {
+        assert(Index < NumSamples);
+        return getSampleOffset(Index) * (LagN + 1);
+    }
+
+    void setSample(size_t Index, const Sample &S) const {
+        size_t Offset = getSampleOffset(Index);
+        std::memcpy(&CNs[Offset], S.getCalculatedNumbers(), BytesPerSample);
+    }
+
+    const Sample getSample(size_t Index) const {
+        size_t Offset = getSampleOffset(Index);
+        return Sample(&CNs[Offset], NumDimsPerSample);
+    };
+
+    const Sample getPreprocessedSample(size_t Index) const {
+        size_t Offset = getPreprocessedSampleOffset(Index);
+        return Sample(&CNs[Offset], NumDimsPerSample * (LagN + 1));
+    };
+
+    void diffSamples();
+    void smoothSamples();
+    void lagSamples();
+
+private:
+    CalculatedNumber *CNs;
+    size_t NumSamples;
+    size_t NumDimsPerSample;
+    size_t DiffN;
+    size_t SmoothN;
+    size_t LagN;
+    size_t BytesPerSample;
+    bool Preprocessed;
+};
+
+inline std::ostream& operator<<(std::ostream& OS, const SamplesBuffer &SB) {
+    SB.print(OS);
+    return OS;
+}
+
+#endif /* SAMPLES_BUFFER_H */