splinekit 0.2.1__tar.gz → 0.2.3__tar.gz

{splinekit-0.2.1 → splinekit-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splinekit
-Version: 0.2.1
+Version: 0.2.3
 Summary: A set of functions and classes to handle periodic 1D polynomial splines
 Author-Email: =?utf-8?q?Philippe_Th=C3=A9venaz?= <philippe.thevenaz@icloud.com>
 Maintainer-Email: =?utf-8?q?Philippe_Th=C3=A9venaz?= <philippe.thevenaz@icloud.com>
@@ -52,8 +52,10 @@ Description-Content-Type: text/markdown
 <!-- splinekit/README.md -->
 
 # splinekit: Spline Operations
-`splinekit` is a Python-based open-source software library aimed at the
-manipulation of one-dimensional periodic splines.
+`splinekit` is a Python-based open-source software library aimed at the manipulation of one-dimensional periodic splines.
+
+| ***<div style="background-color:aliceblue">&#160;&#160;Full documentation at https://splinekit.github.io/ &#160;&#160;</div>*** |
+| - |
 
 ## Installation
 You need at least `Python 3.11` to install `splinekit`.
@@ -109,3 +111,14 @@ Install `splinekit` development environment in editable mode
 ```shell
 pip install -e .[dev]
 ```
+
+## Release Notes
+
+### 0.1.0
+First stable version. Pure Python.
+
+### 0.2.1
+Same API as 0.1.0. Ansi-C dynamic library.
+
+### 0.2.2
+Some demos added

{splinekit-0.2.1 → splinekit-0.2.3}/README.md

@@ -1,8 +1,10 @@
 <!-- splinekit/README.md -->
 
 # splinekit: Spline Operations
-`splinekit` is a Python-based open-source software library aimed at the
-manipulation of one-dimensional periodic splines.
+`splinekit` is a Python-based open-source software library aimed at the manipulation of one-dimensional periodic splines.
+
+| ***<div style="background-color:aliceblue">&#160;&#160;Full documentation at https://splinekit.github.io/ &#160;&#160;</div>*** |
+| - |
 
 ## Installation
 You need at least `Python 3.11` to install `splinekit`.
@@ -58,3 +60,14 @@ Install `splinekit` development environment in editable mode
 ```shell
 pip install -e .[dev]
 ```
+
+## Release Notes
+
+### 0.1.0
+First stable version. Pure Python.
+
+### 0.2.1
+Same API as 0.1.0. Ansi-C dynamic library.
+
+### 0.2.2
+Some demos added

splinekit-0.2.3/dev/ANSI-C/spline_padding_cmake/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.23)
+
+project(Padding)
+
+add_library(Padding SHARED)
+
+target_sources(Padding
+  PRIVATE
+    spline_padding.c
+  PUBLIC
+    FILE_SET spline_padding
+    TYPE HEADERS
+    FILES
+      spline_padding.h
+)

splinekit-0.2.3/dev/ANSI-C/spline_padding_cmake/spline_padding.c

@@ -0,0 +1,275 @@
+#include "spline_padding.h"
+
+extern void get_samples_to_coeff_p (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	if ((0 != poleCount) && (1 != dataCount)) {
+		for (int q = 0; q < poleCount; q++) {
+			const double z = pole[q];
+			double sigma = data[0];
+			double zeta = z;
+			int k = 1;
+			while ((k < dataCount) && (0.0 != zeta)) {
+				sigma += zeta * data[dataCount - k];
+				zeta *= z;
+				k++;
+			}
+			data[0] = sigma / (1.0 - zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[k] += z * data[k - 1];
+			}
+			sigma = data[dataCount - 1];
+			zeta = z;
+			k = 0;
+			while ((k < (dataCount - 1)) && (0.0 != zeta)) {
+				sigma += zeta * data[k];
+				zeta *= z;
+				k++;
+			}
+			const double z12 = (1.0 - z) * (1.0 - z);
+			data[dataCount - 1] = z12 * sigma / (1.0 - zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+			}
+		}
+	}
+} /* end get_samples_to_coeff_p */
+
+extern void get_samples_to_coeff_n (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	if ((0 != poleCount) && (1 != dataCount)) {
+		for (int q = 0; q < poleCount; q++) {
+			const double z = pole[q];
+			double sigma1 = data[0];
+			double sigma2 = data[dataCount - 1];
+			double zeta = z;
+			int k = 1;
+			while ((k < (dataCount - 1)) && (0.0 != zeta)) {
+				sigma1 += zeta * data[k];
+				sigma2 += zeta * data[dataCount - 1 - k];
+				zeta *= z;
+				k++;
+			}
+			data[0] = (sigma1 + zeta * sigma2) / (1.0 - zeta * zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[k] += z * data[k - 1];
+			}
+			const double z12 = (1.0 - z) * (1.0 - z);
+			data[dataCount - 1] = z12 * (z * data[dataCount - 2] + data[dataCount - 1]) / (1.0 - z * z);
+			for (int k = 1; k < dataCount; k++) {
+				data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+			}
+		}
+	}
+} /* end get_samples_to_coeff_n */
+
+extern void get_samples_to_coeff_w (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	if ((0 != poleCount) && (1 != dataCount)) {
+		for (int q = 0; q < poleCount; q++) {
+			const double z = pole[q];
+			double sigma1 = 0.0;
+			double sigma2 = 0.0;
+			double zeta = 1.0;
+			int k = 0;
+			while ((k < dataCount) && (0.0 != zeta)) {
+				sigma1 += zeta * data[k];
+				sigma2 += zeta * data[dataCount - 1 - k];
+				zeta *= z;
+				k++;
+			}
+			data[0] += z * (sigma1 + zeta * sigma2) / (1.0 - zeta * zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[k] += z * data[k - 1];
+			}
+			const double z12 = (1.0 - z) * (1.0 - z);
+			data[dataCount - 1] *= 1.0 - z;
+			for (int k = 1; k < dataCount; k++) {
+				data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+			}
+		}
+	}
+} /* end get_samples_to_coeff_w */
+
+extern void get_samples_to_coeff_a (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	if ((0 != poleCount) && (1 != dataCount)) {
+		for (int q = 0; q < poleCount; q++) {
+			const double z = pole[q];
+			double sigma1 = 0.0;
+			double sigma2 = 0.0;
+			double zeta = z;
+			int k = 1;
+			while ((k < (dataCount - 1)) && (0.0 != zeta)) {
+				sigma1 += zeta * data[k];
+				sigma2 += zeta * data[dataCount - 1 - k];
+				zeta *= z;
+				k++;
+			}
+			data[0] = ((data[0] - zeta * data[dataCount - 1]) * (1.0 + z) / (1.0 - z) - sigma1 + zeta * sigma2) / (1.0 - zeta * zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[k] += z * data[k - 1];
+			}
+			const double z12 = (1.0 - z) * (1.0 - z);
+			data[dataCount - 1] -= z * data[dataCount - 2];
+			for (int k = 1; k < dataCount; k++) {
+				data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+			}
+		}
+	}
+} /* end get_samples_to_coeff_a */
+
+extern void get_samples_to_coeff_np (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	for (int q = 0; q < poleCount; q++) {
+		const double z = pole[q];
+		double sigma1 = data[0];
+		double sigma2 = data[dataCount - 1];
+		double zeta = z;
+		int k = 1;
+		while ((k < dataCount) && (0.0 != zeta)) {
+			sigma1 += zeta * data[k];
+			sigma2 += zeta * data[dataCount - 1 - k];
+			zeta *= z;
+			k++;
+		}
+		const double Z0 = z / (1.0 + zeta);
+		sigma1 *= Z0;
+		sigma2 *= Z0;
+		data[0] -= sigma2;
+		for (int k = 1; k < dataCount; k++) {
+			data[k] += z * data[k - 1];
+		}
+		zeta *= zeta;
+		const double z12 = (1.0 - z) * (1.0 - z);
+		const double Z1 = (1.0 - z) / (1.0 + z);
+		data[dataCount - 1] *= (1.0 + zeta) * Z1;
+		data[dataCount - 1] -= (sigma2 * zeta / z + sigma1) * Z1;
+		for (int k = 1; k < dataCount; k++) {
+			data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+		}
+	}
+} /* end get_samples_to_coeff_np */
+
+extern void get_samples_to_coeff_nn (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	for (int q = 0; q < poleCount; q++) {
+		const double z = pole[q];
+		double sigma1 = 0.0;
+		double sigma2 = 0.0;
+		double zeta = 1.0;
+		int k = 0;
+		while ((k < dataCount) && (0.0 != zeta)) {
+			sigma1 += zeta * data[k];
+			sigma2 += zeta * data[dataCount - 1 - k];
+			zeta *= z;
+			k++;
+		}
+		zeta *= z;
+		data[0] -= (sigma1 - zeta * sigma2) * z * z / (1.0 - zeta * zeta);
+		for (int k = 1; k < dataCount; k++) {
+			data[k] += z * data[k - 1];
+		}
+		const double z12 = (1.0 - z) * (1.0 - z);
+		data[dataCount - 1] *= z12;
+		for (int k = 1; k < dataCount; k++) {
+			data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+		}
+	}
+} /* end get_samples_to_coeff_nn */
+
+extern void get_samples_to_coeff_nw (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	for (int q = 0; q < poleCount; q++) {
+		const double z = pole[q];
+		double sigma1 = 0.0;
+		double sigma2 = 0.0;
+		double zeta = 1.0;
+		int k = 0;
+		while ((k < dataCount) && (0.0 != zeta)) {
+			sigma1 += zeta * data[k];
+			sigma2 += zeta * data[dataCount - 1 - k];
+			zeta *= z;
+			k++;
+		}
+		data[0] -= (sigma1 - zeta * sigma2) * z / (1.0 - zeta * zeta);
+		for (int k = 1; k < dataCount; k++) {
+			data[k] += z * data[k - 1];
+		}
+		const double z12 = (1.0 - z) * (1.0 - z);
+		data[dataCount - 1] *= z12 / (1.0 + z);
+		for (int k = 1; k < dataCount; k++) {
+			data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+		}
+	}
+} /* end get_samples_to_coeff_nw */
+

splinekit-0.2.3/dev/ANSI-C/spline_padding_cmake/spline_padding.h

@@ -0,0 +1,56 @@
+#ifndef spline_padding_h
+#define spline_padding_h
+
+#include <stdio.h>
+#include <stdlib.h>
+
+extern void get_samples_to_coeff_p (
+	double *data,
+	int32_t dataCount,
+	double *pole,
+	int32_t poleCount
+);
+
+extern void get_samples_to_coeff_n (
+	double *data,
+	int32_t dataCount,
+	double *pole,
+	int32_t poleCount
+);
+
+extern void get_samples_to_coeff_w (
+	double *data,
+	int32_t dataCount,
+	double *pole,
+	int32_t poleCount
+);
+
+extern void get_samples_to_coeff_a (
+	double *data,
+	int32_t dataCount,
+	double *pole,
+	int32_t poleCount
+);
+
+extern void get_samples_to_coeff_np (
+	double *data,
+	int32_t dataCount,
+	double *pole,
+	int32_t poleCount
+);
+
+extern void get_samples_to_coeff_nn (
+	double *data,
+	int32_t dataCount,
+	double *pole,
+	int32_t poleCount
+);
+
+extern void get_samples_to_coeff_nw (
+	double *data,
+	int32_t dataCount,
+	double *pole,
+	int32_t poleCount
+);
+
+#endif /* spline_padding_h */

splinekit-0.2.3/dev/ANSI-C/spline_padding_xcode/spline_padding.c

@@ -0,0 +1,275 @@
+#include "spline_padding.h"
+
+extern void get_samples_to_coeff_p (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	if ((0 != poleCount) && (1 != dataCount)) {
+		for (int q = 0; q < poleCount; q++) {
+			const double z = pole[q];
+			double sigma = data[0];
+			double zeta = z;
+			int k = 1;
+			while ((k < dataCount) && (0.0 != zeta)) {
+				sigma += zeta * data[dataCount - k];
+				zeta *= z;
+				k++;
+			}
+			data[0] = sigma / (1.0 - zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[k] += z * data[k - 1];
+			}
+			sigma = data[dataCount - 1];
+			zeta = z;
+			k = 0;
+			while ((k < (dataCount - 1)) && (0.0 != zeta)) {
+				sigma += zeta * data[k];
+				zeta *= z;
+				k++;
+			}
+			const double z12 = (1.0 - z) * (1.0 - z);
+			data[dataCount - 1] = z12 * sigma / (1.0 - zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+			}
+		}
+	}
+} /* end get_samples_to_coeff_p */
+
+extern void get_samples_to_coeff_n (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	if ((0 != poleCount) && (1 != dataCount)) {
+		for (int q = 0; q < poleCount; q++) {
+			const double z = pole[q];
+			double sigma1 = data[0];
+			double sigma2 = data[dataCount - 1];
+			double zeta = z;
+			int k = 1;
+			while ((k < (dataCount - 1)) && (0.0 != zeta)) {
+				sigma1 += zeta * data[k];
+				sigma2 += zeta * data[dataCount - 1 - k];
+				zeta *= z;
+				k++;
+			}
+			data[0] = (sigma1 + zeta * sigma2) / (1.0 - zeta * zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[k] += z * data[k - 1];
+			}
+			const double z12 = (1.0 - z) * (1.0 - z);
+			data[dataCount - 1] = z12 * (z * data[dataCount - 2] + data[dataCount - 1]) / (1.0 - z * z);
+			for (int k = 1; k < dataCount; k++) {
+				data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+			}
+		}
+	}
+} /* end get_samples_to_coeff_n */
+
+extern void get_samples_to_coeff_w (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	if ((0 != poleCount) && (1 != dataCount)) {
+		for (int q = 0; q < poleCount; q++) {
+			const double z = pole[q];
+			double sigma1 = 0.0;
+			double sigma2 = 0.0;
+			double zeta = 1.0;
+			int k = 0;
+			while ((k < dataCount) && (0.0 != zeta)) {
+				sigma1 += zeta * data[k];
+				sigma2 += zeta * data[dataCount - 1 - k];
+				zeta *= z;
+				k++;
+			}
+			data[0] += z * (sigma1 + zeta * sigma2) / (1.0 - zeta * zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[k] += z * data[k - 1];
+			}
+			const double z12 = (1.0 - z) * (1.0 - z);
+			data[dataCount - 1] *= 1.0 - z;
+			for (int k = 1; k < dataCount; k++) {
+				data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+			}
+		}
+	}
+} /* end get_samples_to_coeff_w */
+
+extern void get_samples_to_coeff_a (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	if ((0 != poleCount) && (1 != dataCount)) {
+		for (int q = 0; q < poleCount; q++) {
+			const double z = pole[q];
+			double sigma1 = 0.0;
+			double sigma2 = 0.0;
+			double zeta = z;
+			int k = 1;
+			while ((k < (dataCount - 1)) && (0.0 != zeta)) {
+				sigma1 += zeta * data[k];
+				sigma2 += zeta * data[dataCount - 1 - k];
+				zeta *= z;
+				k++;
+			}
+			data[0] = ((data[0] - zeta * data[dataCount - 1]) * (1.0 + z) / (1.0 - z) - sigma1 + zeta * sigma2) / (1.0 - zeta * zeta);
+			for (int k = 1; k < dataCount; k++) {
+				data[k] += z * data[k - 1];
+			}
+			const double z12 = (1.0 - z) * (1.0 - z);
+			data[dataCount - 1] -= z * data[dataCount - 2];
+			for (int k = 1; k < dataCount; k++) {
+				data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+			}
+		}
+	}
+} /* end get_samples_to_coeff_a */
+
+extern void get_samples_to_coeff_np (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	for (int q = 0; q < poleCount; q++) {
+		const double z = pole[q];
+		double sigma1 = data[0];
+		double sigma2 = data[dataCount - 1];
+		double zeta = z;
+		int k = 1;
+		while ((k < dataCount) && (0.0 != zeta)) {
+			sigma1 += zeta * data[k];
+			sigma2 += zeta * data[dataCount - 1 - k];
+			zeta *= z;
+			k++;
+		}
+		const double Z0 = z / (1.0 + zeta);
+		sigma1 *= Z0;
+		sigma2 *= Z0;
+		data[0] -= sigma2;
+		for (int k = 1; k < dataCount; k++) {
+			data[k] += z * data[k - 1];
+		}
+		zeta *= zeta;
+		const double z12 = (1.0 - z) * (1.0 - z);
+		const double Z1 = (1.0 - z) / (1.0 + z);
+		data[dataCount - 1] *= (1.0 + zeta) * Z1;
+		data[dataCount - 1] -= (sigma2 * zeta / z + sigma1) * Z1;
+		for (int k = 1; k < dataCount; k++) {
+			data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+		}
+	}
+} /* end get_samples_to_coeff_np */
+
+extern void get_samples_to_coeff_nn (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	for (int q = 0; q < poleCount; q++) {
+		const double z = pole[q];
+		double sigma1 = 0.0;
+		double sigma2 = 0.0;
+		double zeta = 1.0;
+		int k = 0;
+		while ((k < dataCount) && (0.0 != zeta)) {
+			sigma1 += zeta * data[k];
+			sigma2 += zeta * data[dataCount - 1 - k];
+			zeta *= z;
+			k++;
+		}
+		zeta *= z;
+		data[0] -= (sigma1 - zeta * sigma2) * z * z / (1.0 - zeta * zeta);
+		for (int k = 1; k < dataCount; k++) {
+			data[k] += z * data[k - 1];
+		}
+		const double z12 = (1.0 - z) * (1.0 - z);
+		data[dataCount - 1] *= z12;
+		for (int k = 1; k < dataCount; k++) {
+			data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+		}
+	}
+} /* end get_samples_to_coeff_nn */
+
+extern void get_samples_to_coeff_nw (
+	double data[],
+	int32_t dataCount,
+	double pole[],
+	int32_t poleCount
+) {
+	if ((NULL == data) || (0 >= dataCount)) {
+		return;
+	}
+	if ((NULL == pole) || (0 >= poleCount)) {
+		return;
+	}
+	for (int q = 0; q < poleCount; q++) {
+		const double z = pole[q];
+		double sigma1 = 0.0;
+		double sigma2 = 0.0;
+		double zeta = 1.0;
+		int k = 0;
+		while ((k < dataCount) && (0.0 != zeta)) {
+			sigma1 += zeta * data[k];
+			sigma2 += zeta * data[dataCount - 1 - k];
+			zeta *= z;
+			k++;
+		}
+		data[0] -= (sigma1 - zeta * sigma2) * z / (1.0 - zeta * zeta);
+		for (int k = 1; k < dataCount; k++) {
+			data[k] += z * data[k - 1];
+		}
+		const double z12 = (1.0 - z) * (1.0 - z);
+		data[dataCount - 1] *= z12 / (1.0 + z);
+		for (int k = 1; k < dataCount; k++) {
+			data[dataCount - 1 - k] = z * data[dataCount - k] + z12 * data[dataCount - 1 - k];
+		}
+	}
+} /* end get_samples_to_coeff_nw */
+