@@ -0,0 +10,4 @@
+import space.kscience.plotly.models.Scatter
+import kotlin.math.sin
+
+fun main(): Unit = with(Double.seriesAlgebra()) {

@@ -0,0 +36,4 @@
+    private val maxSiftIterations: Int = 20,
+    private val siftingDelta: Double = 1e-2,
+    private val nModes: Int = 6
+) where BA: BufferAlgebra<Double, *>,  BA: RingOps<Buffer<Double>>,  L : Number {

@@ -0,0 +39,4 @@
+) where BA: BufferAlgebra<Double, *>,  BA: RingOps<Buffer<Double>>,  L : Number {
+
+    /**
+     * Take a signal, construct an upper and a lower envelope, find the mean value of two,

@@ -0,0 +43,4 @@
+     * represented as a series.
+     * @param signal Signal to compute on
+     *
+     * @return null is returned if the signal has not enough extrema to construct envelopes.

@@ -0,0 +45,4 @@
+     *
+     * @return null is returned if the signal has not enough extrema to construct envelopes.
+     */
+    private fun findMean(signal: Series<Double>): Series<Double>? = with(seriesAlgebra) {

@@ -0,0 +64,4 @@
+        return if (maxima.size < 3 || minima.size < 3) null else {
+            val upperEnvelope = generateEnvelope(maxima)
+            val lowerEnvelope = generateEnvelope(minima)
+            return (upperEnvelope + lowerEnvelope).map { it * 0.5 }

@@ -0,0 +76,4 @@
+     * @return [SiftingResult.NotEnoughExtrema] is returned if the signal has too few extrema to extract a mode.
+     * Success of an appropriate type (See [SiftingResult.Success] class) is returned otherwise.
+     */
+    private fun sift(signal: Series<Double>): SiftingResult = with(seriesAlgebra) {

@@ -0,0 +98,4 @@
+        val mean = findMean(prevMode) ?: return SiftingResult.SignalFlattened(prevMode)
+        val mode = prevMode.zip(mean) { p, m -> p - m }
+        val newSNumber = if (mode.sCondition()) sNumber + 1 else sNumber
+        return if (iterationNumber >= maxSiftIterations) SiftingResult.MaxIterationsReached(mode)

@@ -0,0 +100,4 @@
+        val newSNumber = if (mode.sCondition()) sNumber + 1 else sNumber
+        return if (iterationNumber >= maxSiftIterations) SiftingResult.MaxIterationsReached(mode)
+        else if (sNumber >= sConditionThreshold) SiftingResult.SNumberReached(mode)
+        else if (relativeDifference(prevMode, mode) < siftingDelta * mode.size) SiftingResult.DeltaReached(mode)

@@ -0,0 +112,4 @@
+     * Modes returned in a list which contains as many modes as it was possible
+     * to extract before triggering one of the termination conditions.
+     */
+    public fun decompose(signal: Series<Double>): EMDecompositionResult = with(seriesAlgebra) {

@@ -0,0 +121,4 @@
+        }
+        modes.add(mode)
+
+        var residual = signal.zip(mode) { l, r -> l - r }

@@ -0,0 +168,4 @@
+ */
+private fun Series<Double>.countZeros(): Int {
+    require(size >= 2) { "Expected series with at least 2 elements, but got $size elements" }
+    return fold(Pair(get(0), 0)) { acc: Pair<Double, Int>, it: Double ->

@@ -0,0 +169,4 @@
+private fun Series<Double>.countZeros(): Int {
+    require(size >= 2) { "Expected series with at least 2 elements, but got $size elements" }
+    return fold(Pair(get(0), 0)) { acc: Pair<Double, Int>, it: Double ->
+        if (sign(acc.first) != sign(it)) Pair(it, acc.second + 1) else Pair(it, acc.second)

@@ -0,0 +179,4 @@
+private fun <L, BA> SeriesAlgebra<Double, *, BA, L>.relativeDifference(
+    current: Series<Double>,
+    previous: Series<Double>
+):Double where BA: BufferAlgebra<Double, *>, BA: RingOps<Buffer<Double>>, L: Number {

@@ -0,0 +193,4 @@
+ */
+private fun Series<Double>.countExtrema(): Int {
+    require(size >= 3) { "Expected series with at least 3 elements, but got $size elements" }
+    return slice(1..< size - 1).asIterable().foldIndexed(0) { index, acc, it ->

@@ -0,0 +203,4 @@
+ * Retrieve indices of knot points used to construct an upper envelope,
+ * namely maxima together with the first last point in a series.
+ */
+private fun<T> Series<T>.maxima(): List<Int> where T: Comparable<T> {

@@ -0,0 +206,4 @@
+private fun<T> Series<T>.maxima(): List<Int> where T: Comparable<T> {
+    require(size >= 3) { "Expected series with at least 3 elements, but got $size elements" }
+    val maxima = mutableListOf(0)
+    slice(1..< size - 1).asIterable().forEachIndexed { index, it ->

@@ -0,0 +207,4 @@
+    require(size >= 3) { "Expected series with at least 3 elements, but got $size elements" }
+    val maxima = mutableListOf(0)
+    slice(1..< size - 1).asIterable().forEachIndexed { index, it ->
+        if (it > get(index) && it > get(index + 2)) { // weird offset, is there a way to do it better?

@@ -0,0 +219,4 @@
+ * Retrieve indices of knot points used to construct a lower envelope,
+ * namely minima together with the first last point in a series.
+ */
+private fun<T> Series<T>.minima(): List<Int> where T: Comparable<T> {

@@ -0,0 +222,4 @@
+private fun<T> Series<T>.minima(): List<Int> where T: Comparable<T> {
+    require(size >= 3) { "Expected series with at least 3 elements, but got $size elements" }
+    val minima = mutableListOf(0)
+    slice(1..< size - 1).asIterable().forEachIndexed { index, it ->

@@ -0,0 +243,4 @@
+     * Represents a condition when a mode has been successfully
+     * extracted in a sifting process.
+     */
+    open class Success(val result: Series<Double>): SiftingResult