Data commit

2023-07-01 11:58:00 -04:00 · 2023-07-01 11:58:00 -04:00 · cb5bb5e222
commit cb5bb5e222
parent 7387c8f97b
199093 changed files with 3378972 additions and 0 deletions
--- a/Task/Deconvolution-1D/00-META.yaml
+++ b/Task/Deconvolution-1D/00-META.yaml
@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Deconvolution/1D
+note: Mathematical operations
--- a/Task/Deconvolution-1D/00-TASK.txt
+++ b/Task/Deconvolution-1D/00-TASK.txt
@ -0,0 +1,80 @@
+The convolution of two functions <math>\mathit{F}</math> and <math>\mathit{H}</math> of
+an integer variable is defined as the function <math>\mathit{G}</math>
+satisfying
+
+:<math> G(n) = \sum_{m=-\infty}^{\infty} F(m) H(n-m) </math>
+
+for all integers <math>\mathit{n}</math>. Assume <math>F(n)</math> can be non-zero only for <math>0</math> &le; <math>\mathit{n}</math> &le; <math>|\mathit{F}|</math>, where <math>|\mathit{F}|</math> is the "length" of <math>\mathit{F}</math>, and similarly for <math>\mathit{G}</math> and <math>\mathit{H}</math>, so that the functions can be modeled as finite sequences by identifying <math>f_0, f_1, f_2, \dots</math> with <math>F(0), F(1), F(2), \dots</math>, etc. 
+Then for example, values of <math>|\mathit{F}| = 6</math> and <math>|\mathit{H}| = 5</math> would determine the following value of <math>\mathit{g}</math> by definition.
+
+:<math>
+\begin{array}{lllllllllll}
+g_0 &= &f_0h_0\\
+g_1 &= &f_1h_0 &+ &f_0h_1\\
+g_2 &= &f_2h_0 &+ &f_1h_1 &+ &f_0h_2\\
+g_3 &= &f_3h_0 &+ &f_2h_1 &+ &f_1h_2 &+ &f_0h_3\\
+g_4 &= &f_4h_0 &+ &f_3h_1 &+ &f_2h_2 &+ &f_1h_3 &+ &f_0h_4\\
+g_5 &= &f_5h_0 &+ &f_4h_1 &+ &f_3h_2 &+ &f_2h_3 &+ &f_1h_4\\
+g_6 &= &       &  &f_5h_1 &+ &f_4h_2 &+ &f_3h_3 &+ &f_2h_4\\
+g_7 &= &       &  &       &  &f_5h_2 &+ &f_4h_3 &+ &f_3h_4\\
+g_8 &= &       &  &       &  &       &  &f_5h_3 &+ &f_4h_4\\
+g_9 &= &       &  &       &  &       &  &       &  &f_5h_4
+\end{array}
+</math>
+
+We can write this in matrix form as:
+
+:<math>
+\left( 
+\begin{array}{l}
+g_0 \\
+g_1 \\
+g_2 \\
+g_3 \\
+g_4 \\
+g_5 \\
+g_6 \\
+g_7 \\
+g_8 \\
+g_9 \\
+\end{array}
+\right) = \left(
+\begin{array}{lllll}
+f_0\\
+f_1 & f_0\\
+f_2 & f_1 & f_0\\
+f_3 & f_2 & f_1 & f_0\\
+f_4 & f_3 & f_2 & f_1 & f_0\\
+f_5 & f_4 & f_3 & f_2 & f_1\\
+    & f_5 & f_4 & f_3 & f_2\\
+    &     & f_5 & f_4 & f_3\\
+    &     &     & f_5 & f_4\\
+    &     &     &     & f_5
+\end{array}
+\right) \; \left(
+\begin{array}{l}
+h_0 \\
+h_1 \\
+h_2 \\
+h_3 \\
+h_4 \\
+\end{array} \right)
+</math>
+
+or
+
+:<math>
+g = A \; h
+</math>
+
+For this task, implement a function (or method, procedure, subroutine, etc.) <code>deconv</code> to perform ''deconvolution'' (i.e., the ''inverse'' of convolution) by constructing and solving such a system of equations represented by the above matrix <math>A</math> for <math>\mathit{h}</math> given <math>\mathit{f}</math> and <math>\mathit{g}</math>.
+
+* The function should work for <math>\mathit{G}</math> of arbitrary length (i.e., not hard coded or constant) and <math>\mathit{F}</math> of any length up to that of <math>\mathit{G}</math>. Note that <math>|\mathit{H}|</math> will be given by <math>|\mathit{G}| - |\mathit{F}| + 1</math>.
+* There may be more equations than unknowns. If convenient, use a function from a [http://www.netlib.org/lapack/lug/node27.html library] that finds the best fitting solution to an overdetermined system of linear equations (as in the [[Multiple regression]] task).  Otherwise, prune the set of equations as needed and solve as in the [[Reduced row echelon form]] task.
+* Test your solution on the following data. Be sure to verify both that <code>deconv</code><math>(g,f) = h</math> and <code>deconv</code><math>(g,h) = f</math> and display the results in a human readable form.
+<code>
+h = [-8,-9,-3,-1,-6,7]<br>
+f = [-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1]<br>
+g = [24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7]
+</code>
+
--- a/Task/Deconvolution-1D/11l/deconvolution-1d.11l
+++ b/Task/Deconvolution-1D/11l/deconvolution-1d.11l
@ -0,0 +1,16 @@
+F deconv(g, f)
+   V result = [0]*(g.len - f.len + 1)
+   L(&e) result
+      V n = L.index
+      e = g[n]
+      V lower_bound = I n >= f.len {n - f.len + 1} E 0
+      L(i) lower_bound .< n
+         e -= result[i] * f[n - i]
+      e /= f[0]
+   R result
+
+V h = [-8,-9,-3,-1,-6,7]
+V f = [-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1]
+V g = [24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7]
+print(deconv(g, f))
+print(deconv(g, h))
--- a/Task/Deconvolution-1D/Ada/deconvolution-1d.ada
+++ b/Task/Deconvolution-1D/Ada/deconvolution-1d.ada
@ -0,0 +1,53 @@
+with Ada.Text_IO; use Ada.Text_IO;
+
+procedure Main is
+   package real_io is new Float_IO (Long_Float);
+   use real_io;
+
+   type Vector is array (Natural range <>) of Long_Float;
+
+   function deconv (g, f : Vector) return Vector is
+      len : Positive :=
+        Integer'Max ((g'Length - f'length), (f'length - g'length));
+      h     : Vector (0 .. len);
+      Lower : Natural := 0;
+   begin
+      for n in h'range loop
+         h (n) := g (n);
+         if n >= f'length then
+            Lower := n - f'length + 1;
+         end if;
+         for i in Lower .. n - 1 loop
+            h (n) := h (n) - (h (i) * f (n - i));
+         end loop;
+         h (n) := h (n) / f (0);
+      end loop;
+      return h;
+   end deconv;
+
+   procedure print (v : Vector) is
+   begin
+      Put ("(");
+      for I in v'range loop
+         Put (Item => v (I), Fore => 1, Aft => 1, Exp => 0);
+         if I < v'Last then
+            Put (" ");
+         else
+            Put_Line (")");
+         end if;
+      end loop;
+   end print;
+
+   h : Vector := (-8.0, -9.0, -3.0, -1.0, -6.0, 7.0);
+   f : Vector :=
+     (-3.0, -6.0, -1.0, 8.0, -6.0, 3.0, -1.0, -9.0, -9.0, 3.0, -2.0, 5.0, 2.0,
+      -2.0, -7.0, -1.0);
+   g : Vector :=
+     (24.0, 75.0, 71.0, -34.0, 3.0, 22.0, -45.0, 23.0, 245.0, 25.0, 52.0, 25.0,
+      -67.0, -96.0, 96.0, 31.0, 55.0, 36.0, 29.0, -43.0, -7.0);
+begin
+   print (h);
+   print (deconv (g, f));
+   print (f);
+   print (deconv (g, h));
+end Main;
--- a/Task/Deconvolution-1D/BBC-BASIC/deconvolution-1d.basic
+++ b/Task/Deconvolution-1D/BBC-BASIC/deconvolution-1d.basic
@ -0,0 +1,38 @@
+      *FLOAT 64
+      DIM h(5), f(15), g(20)
+      h() = -8,-9,-3,-1,-6,7
+      f() = -3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1
+      g() = 24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7
+
+      PROCdeconv(g(), f(), x())
+      PRINT "deconv(g,f) = " FNprintarray(x())
+      x() -= h() : IF SUM(x()) <> 0 PRINT "Error!"
+
+      PROCdeconv(g(), h(), y())
+      PRINT "deconv(g,h) = " FNprintarray(y())
+      y() -= f() : IF SUM(y()) <> 0 PRINT "Error!"
+      END
+
+      DEF PROCdeconv(g(), f(), RETURN h())
+      LOCAL f%, g%, i%, l%, n%
+      f% = DIM(f(),1) + 1
+      g% = DIM(g(),1) + 1
+      DIM h(g% - f%)
+      FOR n% = 0 TO g% - f%
+        h(n%) = g(n%)
+        IF n% < f% THEN l% = 0 ELSE l% = n% - f% + 1
+        IF n% THEN
+          FOR i% = l% TO n% - 1
+            h(n%) -= h(i%) * f(n% - i%)
+          NEXT
+        ENDIF
+        h(n%) /= f(0)
+      NEXT n%
+      ENDPROC
+
+      DEF FNprintarray(a())
+      LOCAL i%, a$
+      FOR i% = 0 TO DIM(a(),1)
+        a$ += STR$(a(i%)) + ", "
+      NEXT
+      = LEFT$(LEFT$(a$))
--- a/Task/Deconvolution-1D/C/deconvolution-1d.c
+++ b/Task/Deconvolution-1D/C/deconvolution-1d.c
@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <complex.h>
+
+double PI;
+typedef double complex cplx;
+
+void _fft(cplx buf[], cplx out[], int n, int step)
+{
+	if (step < n) {
+		_fft(out, buf, n, step * 2);
+		_fft(out + step, buf + step, n, step * 2);
+
+		for (int i = 0; i < n; i += 2 * step) {
+			cplx t = cexp(-I * PI * i / n) * out[i + step];
+			buf[i / 2]     = out[i] + t;
+			buf[(i + n)/2] = out[i] - t;
+		}
+	}
+}
+
+void fft(cplx buf[], int n)
+{
+	cplx out[n];
+	for (int i = 0; i < n; i++) out[i] = buf[i];
+	_fft(buf, out, n, 1);
+}
+
+/* pad array length to power of two */
+cplx *pad_two(double g[], int len, int *ns)
+{
+	int n = 1;
+	if (*ns) n = *ns;
+	else while (n < len) n *= 2;
+
+	cplx *buf = calloc(sizeof(cplx), n);
+	for (int i = 0; i < len; i++) buf[i] = g[i];
+	*ns = n;
+	return buf;
+}
+
+void deconv(double g[], int lg, double f[], int lf, double out[]) {
+	int ns = 0;
+	cplx *g2 = pad_two(g, lg, &ns);
+	cplx *f2 = pad_two(f, lf, &ns);
+
+	fft(g2, ns);
+	fft(f2, ns);
+
+	cplx h[ns];
+	for (int i = 0; i < ns; i++) h[i] = g2[i] / f2[i];
+	fft(h, ns);
+
+	for (int i = 0; i >= lf - lg; i--)
+		out[-i] = h[(i + ns) % ns]/32;
+	free(g2);
+	free(f2);
+}
+
+int main()
+{
+	PI = atan2(1,1) * 4;
+	double g[] = {24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7};
+	double f[] = { -3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1 };
+	double h[] = { -8,-9,-3,-1,-6,7 };
+
+	int lg = sizeof(g)/sizeof(double);
+	int lf = sizeof(f)/sizeof(double);
+	int lh = sizeof(h)/sizeof(double);
+
+	double h2[lh];
+	double f2[lf];
+
+	printf("f[] data is : ");
+	for (int i = 0; i < lf; i++) printf(" %g", f[i]);
+	printf("\n");
+
+	printf("deconv(g, h): ");
+	deconv(g, lg, h, lh, f2);
+	for (int i = 0; i < lf; i++) printf(" %g", f2[i]);
+	printf("\n");
+
+	printf("h[] data is : ");
+	for (int i = 0; i < lh; i++) printf(" %g", h[i]);
+	printf("\n");
+
+	printf("deconv(g, f): ");
+	deconv(g, lg, f, lf, h2);
+	for (int i = 0; i < lh; i++) printf(" %g", h2[i]);
+	printf("\n");
+}
--- a/Task/Deconvolution-1D/Common-Lisp/deconvolution-1d-1.lisp
+++ b/Task/Deconvolution-1D/Common-Lisp/deconvolution-1d-1.lisp
@ -0,0 +1,22 @@
+;; Assemble the mxn matrix A from the 2D row vector x.
+(defun make-conv-matrix (x m n)
+  (let ((lx (cadr (array-dimensions x)))
+        (A  (make-array `(,m ,n) :initial-element 0)))
+
+    (loop for j from 0 to (- n 1) do
+         (loop for i from 0 to (- m 1) do
+              (setf (aref A i j)
+                    (cond ((or (< i j) (>= i (+ j lx)))
+                           0)
+                          ((and (>= i j) (< i (+ j lx)))
+                           (aref x 0 (- i j)))))))
+    A))
+
+;; Solve the overdetermined system A(f)*h=g by linear least squares.
+(defun deconv (g f)
+  (let* ((lg (cadr (array-dimensions g)))
+         (lf (cadr (array-dimensions f)))
+         (lh (+ (- lg lf) 1))
+         (A  (make-conv-matrix f lg lh)))
+
+    (lsqr A (mtp g))))
--- a/Task/Deconvolution-1D/Common-Lisp/deconvolution-1d-2.lisp
+++ b/Task/Deconvolution-1D/Common-Lisp/deconvolution-1d-2.lisp
@ -0,0 +1,29 @@
+(setf f #2A((-3 -6 -1 8 -6 3 -1 -9 -9 3 -2 5 2 -2 -7 -1)))
+(setf h #2A((-8 -9 -3 -1 -6 7)))
+(setf g #2A((24 75 71 -34 3 22 -45 23 245 25 52 25 -67 -96 96 31 55 36 29 -43 -7)))
+
+(deconv g f)
+#2A((-8.0)
+    (-9.000000000000002)
+    (-2.999999999999999)
+    (-0.9999999999999997)
+    (-6.0)
+    (7.000000000000002))
+
+(deconv g h)
+#2A((-2.999999999999999)
+    (-6.000000000000001)
+    (-1.0000000000000002)
+    (8.0)
+    (-5.999999999999999)
+    (3.0000000000000004)
+    (-1.0000000000000004)
+    (-9.000000000000002)
+    (-9.0)
+    (2.9999999999999996)
+    (-1.9999999999999991)
+    (5.0)
+    (1.9999999999999996)
+    (-2.0000000000000004)
+    (-7.000000000000001)
+    (-0.9999999999999994))
--- a/Task/Deconvolution-1D/D/deconvolution-1d.d
+++ b/Task/Deconvolution-1D/D/deconvolution-1d.d
@ -0,0 +1,23 @@
+T[] deconv(T)(in T[] g, in T[] f) pure nothrow {
+    int flen = f.length;
+    int glen = g.length;
+    auto result = new T[glen - flen + 1];
+    foreach (int n, ref e; result) {
+        e = g[n];
+        immutable lowerBound = (n >= flen) ? n - flen + 1 : 0;
+        foreach (i; lowerBound .. n)
+                e -= result[i] * f[n - i];
+        e /= f[0];
+    }
+    return result;
+}
+
+void main() {
+    import std.stdio;
+    immutable h = [-8,-9,-3,-1,-6,7];
+    immutable f = [-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1];
+    immutable g = [24,75,71,-34,3,22,-45,23,245,25,52,25,-67,
+                   -96,96,31,55,36,29,-43,-7];
+    writeln(deconv(g, f) == h, " ", deconv(g, f));
+    writeln(deconv(g, h) == f, " ", deconv(g, h));
+}
--- a/Task/Deconvolution-1D/Fortran/deconvolution-1d-1.f
+++ b/Task/Deconvolution-1D/Fortran/deconvolution-1d-1.f
@ -0,0 +1,73 @@
+! Build
+! Windows: ifort /I "%IFORT_COMPILER11%\mkl\include\ia32" deconv1d.f90 "%IFORT_COMPILER11%\mkl\ia32\lib\*.lib"
+! Linux:
+
+program deconv
+  ! Use gelsd from LAPACK95.
+  use mkl95_lapack, only : gelsd
+
+  implicit none
+  real(8), allocatable :: g(:), href(:), A(:,:), f(:)
+  real(8), pointer     :: h(:), r(:)
+  integer              :: N
+  character(len=16)    :: cbuff
+  integer              :: i
+  intrinsic            :: nint
+
+  ! Allocate data arrays
+  allocate(g(21),f(16))
+  g = [24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7]
+  f = [-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1]
+
+  ! Calculate deconvolution
+  h => deco(f, g)
+
+  ! Check result against reference
+  N = size(h)
+  allocate(href(N))
+  href = [-8,-9,-3,-1,-6,7]
+  cbuff = ' '
+  write(cbuff,'(a,i0,a)') '(a,',N,'(i0,a),i0)'
+  if (any(abs(h-href) > 1.0d-4)) then
+     write(*,'(a)') 'deconv(f, g) - FAILED'
+  else
+     write(*,cbuff) 'deconv(f, g) = ',(nint(h(i)),', ',i=1,N-1),nint(h(N))
+  end if
+
+  ! Calculate deconvolution
+  r => deco(h, g)
+
+  cbuff = ' '
+  N = size(r)
+  write(cbuff,'(a,i0,a)') '(a,',N,'(i0,a),i0)'
+  if (any(abs(r-f) > 1.0d-4)) then
+     write(*,'(a)') 'deconv(h, g) - FAILED'
+  else
+     write(*,cbuff) 'deconv(h, g) = ',(nint(r(i)),', ',i=1,N-1),nint(r(N))
+  end if
+
+contains
+  function deco(p, q)
+    real(8), pointer    :: deco(:)
+    real(8), intent(in) :: p(:), q(:)
+
+    real(8), allocatable, target :: r(:)
+    real(8), allocatable         :: A(:,:)
+    integer :: N
+
+    ! Construct derived arrays
+    N = size(q) - size(p) + 1
+    allocate(A(size(q),N),r(size(q)))
+    A = 0.0d0
+    do i=1,N
+       A(i:i+size(p)-1,i) = p
+    end do
+
+    ! Invoke the LAPACK routine to do the work
+    r = q
+    call gelsd(A, r)
+
+    deco => r(1:N)
+  end function deco
+
+end program deconv
--- a/Task/Deconvolution-1D/Fortran/deconvolution-1d-2.f
+++ b/Task/Deconvolution-1D/Fortran/deconvolution-1d-2.f
@ -0,0 +1,2 @@
+deconv(f, g) = -8, -9, -3, -1, -6, 7
+deconv(h, g) = -3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1
--- a/Task/Deconvolution-1D/Go/deconvolution-1d-1.go
+++ b/Task/Deconvolution-1D/Go/deconvolution-1d-1.go
@ -0,0 +1,30 @@
+package main
+
+import "fmt"
+
+func main() {
+    h := []float64{-8, -9, -3, -1, -6, 7}
+    f := []float64{-3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1}
+    g := []float64{24, 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96,
+        96, 31, 55, 36, 29, -43, -7}
+    fmt.Println(h)
+    fmt.Println(deconv(g, f))
+    fmt.Println(f)
+    fmt.Println(deconv(g, h))
+}
+
+func deconv(g, f []float64) []float64 {
+    h := make([]float64, len(g)-len(f)+1)
+    for n := range h {
+        h[n] = g[n]
+        var lower int
+        if n >= len(f) {
+            lower = n - len(f) + 1
+        }
+        for i := lower; i < n; i++ {
+            h[n] -= h[i] * f[n-i]
+        }
+        h[n] /= f[0]
+    }
+    return h
+}
--- a/Task/Deconvolution-1D/Go/deconvolution-1d-2.go
+++ b/Task/Deconvolution-1D/Go/deconvolution-1d-2.go
@ -0,0 +1,65 @@
+package main
+
+import (
+    "fmt"
+    "math"
+    "math/cmplx"
+)
+
+func main() {
+    h := []float64{-8, -9, -3, -1, -6, 7}
+    f := []float64{-3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1}
+    g := []float64{24, 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96,
+        96, 31, 55, 36, 29, -43, -7}
+    fmt.Printf("%.1f\n", h)
+    fmt.Printf("%.1f\n", deconv(g, f))
+    fmt.Printf("%.1f\n", f)
+    fmt.Printf("%.1f\n", deconv(g, h))
+}
+
+func deconv(g, f []float64) []float64 {
+    n := 1
+    for n < len(g) {
+        n *= 2
+    }
+    g2 := make([]complex128, n)
+    for i, x := range g {
+        g2[i] = complex(x, 0)
+    }
+    f2 := make([]complex128, n)
+    for i, x := range f {
+        f2[i] = complex(x, 0)
+    }
+    gt := fft(g2)
+    ft := fft(f2)
+    for i := range gt {
+        gt[i] /= ft[i]
+    }
+    ht := fft(gt)
+    it := 1 / float64(n)
+    out := make([]float64, len(g)-len(f)+1)
+    out[0] = real(ht[0]) * it
+    for i := 1; i < len(out); i++ {
+        out[i] = real(ht[n-i]) * it
+    }
+    return out
+}
+
+func fft(in []complex128) []complex128 {
+    out := make([]complex128, len(in))
+    ditfft2(in, out, len(in), 1)
+    return out
+}
+
+func ditfft2(x, y []complex128, n, s int) {
+    if n == 1 {
+        y[0] = x[0]
+        return
+    }
+    ditfft2(x, y, n/2, 2*s)
+    ditfft2(x[s:], y[n/2:], n/2, 2*s)
+    for k := 0; k < n/2; k++ {
+        tf := cmplx.Rect(1, -2*math.Pi*float64(k)/float64(n)) * y[k+n/2]
+        y[k], y[k+n/2] = y[k]+tf, y[k]-tf
+    }
+}
--- a/Task/Deconvolution-1D/Go/deconvolution-1d-3.go
+++ b/Task/Deconvolution-1D/Go/deconvolution-1d-3.go
@ -0,0 +1,36 @@
+package main
+
+import (
+    "fmt"
+
+    "gonum.org/v1/gonum/mat"
+)
+
+var (
+    h = []float64{-8, -9, -3, -1, -6, 7}
+    f = []float64{-3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1}
+    g = []float64{24, 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96,
+        96, 31, 55, 36, 29, -43, -7}
+)
+
+func band(g, f []float64) *mat.Dense {
+    nh := len(g) - len(f) + 1
+    b := mat.NewDense(len(g), nh, nil)
+    for j := 0; j < nh; j++ {
+        for i, fi := range f {
+            b.Set(i+j, j, fi)
+        }
+    }
+    return b
+}
+
+func deconv(g, f []float64) mat.Matrix {
+    z := mat.NewDense(len(g)-len(f)+1, 1, nil)
+    z.Solve(band(g, f), mat.NewVecDense(len(g), g))
+    return z
+}
+
+func main() {
+    fmt.Printf("deconv(g, f) =\n%.1f\n\n", mat.Formatted(deconv(g, f)))
+    fmt.Printf("deconv(g, h) =\n%.1f\n", mat.Formatted(deconv(g, h)))
+}
--- a/Task/Deconvolution-1D/Haskell/deconvolution-1d.hs
+++ b/Task/Deconvolution-1D/Haskell/deconvolution-1d.hs
@ -0,0 +1,43 @@
+deconv1d :: [Double] -> [Double] -> [Double]
+deconv1d xs ys = takeWhile (/= 0) $ deconv xs ys
+  where
+    [] `deconv` _ = []
+    (0:xs) `deconv` (0:ys) = xs `deconv` ys
+    (x:xs) `deconv` (y:ys) =
+      let q = x / y
+      in q : zipWith (-) xs (scale q ys ++ repeat 0) `deconv` (y : ys)
+
+scale :: Double -> [Double] -> [Double]
+scale = map . (*)
+
+h, f, g :: [Double]
+h = [-8, -9, -3, -1, -6, 7]
+
+f = [-3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1]
+
+g =
+  [ 24
+  , 75
+  , 71
+  , -34
+  , 3
+  , 22
+  , -45
+  , 23
+  , 245
+  , 25
+  , 52
+  , 25
+  , -67
+  , -96
+  , 96
+  , 31
+  , 55
+  , 36
+  , 29
+  , -43
+  , -7
+  ]
+
+main :: IO ()
+main = print $ (h == deconv1d g f) && (f == deconv1d g h)
--- a/Task/Deconvolution-1D/J/deconvolution-1d-1.j
+++ b/Task/Deconvolution-1D/J/deconvolution-1d-1.j
@ -0,0 +1,2 @@
+Ai=: (i.@]  =/ i.@[ -/ i.@>:@-)&#
+divide=: [ +/ .*~ [:%.&.x: ] +/ .* Ai
--- a/Task/Deconvolution-1D/J/deconvolution-1d-2.j
+++ b/Task/Deconvolution-1D/J/deconvolution-1d-2.j
@ -0,0 +1,3 @@
+h=: _8 _9 _3 _1 _6 7
+f=: _3 _6 _1 8 _6 3 _1 _9 _9 3 _2 5 2 _2 _7 _1
+g=: 24 75 71 _34 3 22 _45 23 245 25 52 25 _67 _96 96 31 55 36 29
--- a/Task/Deconvolution-1D/J/deconvolution-1d-3.j
+++ b/Task/Deconvolution-1D/J/deconvolution-1d-3.j
@ -0,0 +1,4 @@
+   g divide f
+_8 _9 _3 _1 _6 7
+   g divide h
+_3 _6 _1 8 _6 3 _1 _9 _9 3 _2 5 2 _2 _7 _1
--- a/Task/Deconvolution-1D/J/deconvolution-1d-4.j
+++ b/Task/Deconvolution-1D/J/deconvolution-1d-4.j
@ -0,0 +1 @@
+divide=: [ +/ .*~ [:%. ] +/ .* Ai
--- a/Task/Deconvolution-1D/Java/deconvolution-1d.java
+++ b/Task/Deconvolution-1D/Java/deconvolution-1d.java
@ -0,0 +1,29 @@
+import java.util.Arrays;
+
+public class Deconvolution1D {
+    public static int[] deconv(int[] g, int[] f) {
+        int[] h = new int[g.length - f.length + 1];
+        for (int n = 0; n < h.length; n++) {
+            h[n] = g[n];
+            int lower = Math.max(n - f.length + 1, 0);
+            for (int i = lower; i < n; i++)
+                h[n] -= h[i] * f[n - i];
+            h[n] /= f[0];
+        }
+        return h;
+    }
+
+    public static void main(String[] args) {
+        int[] h = { -8, -9, -3, -1, -6, 7 };
+        int[] f = { -3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1 };
+        int[] g = { 24, 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96,
+                96, 31, 55, 36, 29, -43, -7 };
+
+        StringBuilder sb = new StringBuilder();
+        sb.append("h = " + Arrays.toString(h) + "\n");
+        sb.append("deconv(g, f) = " + Arrays.toString(deconv(g, f)) + "\n");
+        sb.append("f = " + Arrays.toString(f) + "\n");
+        sb.append("deconv(g, h) = " + Arrays.toString(deconv(g, h)) + "\n");
+        System.out.println(sb.toString());
+    }
+}
--- a/Task/Deconvolution-1D/Julia/deconvolution-1d.julia
+++ b/Task/Deconvolution-1D/Julia/deconvolution-1d.julia
@ -0,0 +1,9 @@
+h = [-8, -9, -3, -1, -6, 7]
+g = [24, 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96, 96, 31, 55, 36, 29, -43, -7]
+f = [-3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1]
+
+hanswer = deconv(float.(g), float.(f))
+println("The deconvolution deconv(g, f) is $hanswer, which is the same as h = $h\n")
+
+fanswer = deconv(float.(g), float.(h))
+println("The deconvolution deconv(g, h) is $fanswer, which is the same as f = $f\n")
--- a/Task/Deconvolution-1D/Kotlin/deconvolution-1d.kotlin
+++ b/Task/Deconvolution-1D/Kotlin/deconvolution-1d.kotlin
@ -0,0 +1,27 @@
+// version 1.1.3
+
+fun deconv(g: DoubleArray, f: DoubleArray): DoubleArray {
+    val fs = f.size
+    val h = DoubleArray(g.size - fs + 1)
+    for (n in h.indices) {
+        h[n] = g[n]
+        val lower = if (n >= fs) n - fs + 1 else 0
+        for (i in lower until n) h[n] -= h[i] * f[n -i]
+        h[n] /= f[0]
+    }
+    return h
+}
+
+fun main(args: Array<String>) {
+    val h = doubleArrayOf(-8.0, -9.0, -3.0, -1.0, -6.0, 7.0)
+    val f = doubleArrayOf(-3.0, -6.0, -1.0,  8.0, -6.0,  3.0, -1.0, -9.0,
+                          -9.0,  3.0, -2.0,  5.0,  2.0, -2.0, -7.0, -1.0)
+    val g = doubleArrayOf(24.0,  75.0, 71.0, -34.0,  3.0,  22.0, -45.0,
+                          23.0, 245.0, 25.0,  52.0, 25.0, -67.0, -96.0,
+                          96.0,  31.0, 55.0,  36.0, 29.0, -43.0,  -7.0)
+    println("${h.map { it.toInt() }}")
+    println("${deconv(g, f).map { it.toInt() }}")
+    println()
+    println("${f.map { it.toInt() }}")
+    println("${deconv(g, h).map { it.toInt() }}")
+}
--- a/Task/Deconvolution-1D/Lua/deconvolution-1d-1.lua
+++ b/Task/Deconvolution-1D/Lua/deconvolution-1d-1.lua
@ -0,0 +1,15 @@
+function deconvolve(f, g)
+   local h = setmetatable({}, {__index = function(self, n)
+      if n == 1 then self[1] = g[1] / f[1]
+      else
+         self[n] = g[n]
+         for i = 1, n - 1 do
+            self[n] = self[n] - self[i] * (f[n - i + 1] or 0)
+         end
+         self[n] = self[n] / f[1]
+      end
+      return self[n]
+   end})
+   local _ = h[#g - #f + 1]
+   return setmetatable(h, nil)
+end
--- a/Task/Deconvolution-1D/Lua/deconvolution-1d-2.lua
+++ b/Task/Deconvolution-1D/Lua/deconvolution-1d-2.lua
@ -0,0 +1,5 @@
+local f = {-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1}
+local g = {24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7}
+local h = {-8,-9,-3,-1,-6,7}
+print(unpack(deconvolve(f, g))) --> -8  -9  -3  -1  -6   7
+print(unpack(deconvolve(h, g))) --> -3  -6  -1   8  -6   3  -1  -9  -9   3  -2   5   2  -2  -7  -1
--- a/Task/Deconvolution-1D/MATLAB/deconvolution-1d.m
+++ b/Task/Deconvolution-1D/MATLAB/deconvolution-1d.m
@ -0,0 +1,14 @@
+>> h = [-8,-9,-3,-1,-6,7];
+>> g = [24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7];
+>> f = [-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1];
+>> deconv(g,f)
+
+ans =
+
+   -8.0000   -9.0000   -3.0000   -1.0000   -6.0000    7.0000
+
+>> deconv(g,h)
+
+ans =
+
+    -3    -6    -1     8    -6     3    -1    -9    -9     3    -2     5     2    -2    -7    -1
--- a/Task/Deconvolution-1D/Mathematica/deconvolution-1d.math
+++ b/Task/Deconvolution-1D/Mathematica/deconvolution-1d.math
@ -0,0 +1,5 @@
+deconv[f_List, g_List] :=
+ Module[{A =
+    SparseArray[
+     Table[Band[{n, 1}] -> f[[n]], {n, 1, Length[f]}], {Length[g], Length[f] - 1}]},
+  Take[LinearSolve[A, g], Length[g] - Length[f] + 1]]
--- a/Task/Deconvolution-1D/Nim/deconvolution-1d.nim
+++ b/Task/Deconvolution-1D/Nim/deconvolution-1d.nim
@ -0,0 +1,20 @@
+proc deconv(g, f: openArray[float]): seq[float] =
+  var h: seq[float] = newSeq[float](len(g) - len(f) + 1)
+  for n in 0..<len(h):
+    h[n] = g[n]
+    var lower: int
+    if n >= len(f):
+      lower = n - len(f) + 1
+    for i in lower..<n:
+      h[n] -= h[i] * f[n - i]
+    h[n] /= f[0]
+  h
+
+let h = [-8'f64, -9, -3, -1, -6, 7]
+let f = [-3'f64, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1]
+let g = [24'f64, 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96,
+         96, 31, 55, 36, 29, -43, -7]
+echo h
+echo deconv(g, f)
+echo f
+echo deconv(g, h)
--- a/Task/Deconvolution-1D/Perl/deconvolution-1d.pl
+++ b/Task/Deconvolution-1D/Perl/deconvolution-1d.pl
@ -0,0 +1,69 @@
+use v5.36;
+use Math::Cartesian::Product;
+
+sub deconvolve($g,$f) {
+    my @g = @{$g};
+    my @f = @{$f};
+    my(@m,@d);
+
+    my $h = 1 + @g - @f;
+    push @m, [(0) x $h, $g[$_]] for 0..$#g;
+    for my $j (0..$h-1) {
+        for my $k (0..$#f) {
+            $m[$j + $k][$j] = $f[$k]
+        }
+    }
+    rref(\@m);
+    push @d, @{ $m[$_] }[$h] for 0..$h-1;
+    @d;
+}
+
+sub convolve($f,$h) {
+    my @f = @{$f};
+    my @h = @{$h};
+    my @i;
+    for my $x (cartesian {@_} [0..$#f], [0..$#h]) {
+        push @i, @$x[0]+@$x[1];
+    }
+    my $cnt = 0;
+    my @g = (0) x (@f + @h - 1);
+    for my $x (cartesian {@_} [@f], [@h]) {
+        $g[$i[$cnt++]] += @$x[0]*@$x[1];
+    }
+    @g;
+}
+
+sub rref($m) {
+  my @m = @{$m};
+  @m or return;
+  my ($lead, $rows, $cols) = (0, scalar(@m), scalar(@{$m[0]}));
+
+  for my $r (0 .. $rows - 1) {
+      $lead < $cols or return;
+      my $i = $r;
+
+      until ($m[$i][$lead]) {
+          ++$i == $rows or next;
+          $i = $r;
+          ++$lead == $cols and return;
+      }
+
+      @m[$i, $r] = @m[$r, $i];
+      my $lv = $m[$r][$lead];
+      $_ /= $lv foreach @{ $m[$r] };
+
+      my @mr = @{ $m[$r] };
+      for my $i (0 .. $rows - 1) {
+          $i == $r and next;
+          ($lv, my $n) = ($m[$i][$lead], -1);
+          $_ -= $lv * $mr[++$n] foreach @{ $m[$i] };
+      }
+      ++$lead;
+   }
+}
+
+my @h = qw<-8 -9 -3 -1 -6 7>;
+my @f = qw<-3 -6 -1 8 -6 3 -1 -9 -9 3 -2 5 2 -2 -7 -1>;
+print '  conv(f,h) = g = ' . join(' ', my @g = convolve(\@f, \@h)) . "\n";
+print 'deconv(g,f) = h = ' . join(' ', deconvolve(\@g, \@f)) . "\n";
+print 'deconv(g,h) = f = ' . join(' ', deconvolve(\@g, \@h)) . "\n";
--- a/Task/Deconvolution-1D/Phix/deconvolution-1d.phix
+++ b/Task/Deconvolution-1D/Phix/deconvolution-1d.phix
@ -0,0 +1,39 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">deconv</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">g</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">lf</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">lg</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">g</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">lh</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">lg</span><span style="color: #0000FF;">-</span><span style="color: #000000;">lf</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">h</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lh</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">lh</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">atom</span> <span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">g</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">]</span>
+         <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">max</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">lf</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">to</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
+             <span style="color: #000000;">e</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">h</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">*</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+         <span style="color: #000000;">h</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">e</span><span style="color: #0000FF;">/</span><span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">h</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">conv</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">h</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">lf</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">lh</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">h</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">lg</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">lf</span><span style="color: #0000FF;">+</span><span style="color: #000000;">lh</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">g</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lg</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">lh</span> <span style="color: #008080;">do</span>
+         <span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">lf</span> <span style="color: #008080;">do</span>
+             <span style="color: #004080;">integer</span> <span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">j</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
+             <span style="color: #000000;">g</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">*</span> <span style="color: #000000;">h</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">g</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">constant</span> <span style="color: #000000;">h</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{-</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">},</span>
+     <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{-</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},</span>
+ <span style="color: #000000;">g</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">24</span><span style="color: #0000FF;">,</span><span style="color: #000000;">75</span><span style="color: #0000FF;">,</span><span style="color: #000000;">71</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">34</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">22</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">45</span><span style="color: #0000FF;">,</span><span style="color: #000000;">23</span><span style="color: #0000FF;">,</span><span style="color: #000000;">245</span><span style="color: #0000FF;">,</span><span style="color: #000000;">25</span><span style="color: #0000FF;">,</span><span style="color: #000000;">52</span><span style="color: #0000FF;">,</span><span style="color: #000000;">25</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">67</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">96</span><span style="color: #0000FF;">,</span><span style="color: #000000;">96</span><span style="color: #0000FF;">,</span><span style="color: #000000;">31</span><span style="color: #0000FF;">,</span><span style="color: #000000;">55</span><span style="color: #0000FF;">,</span><span style="color: #000000;">36</span><span style="color: #0000FF;">,</span><span style="color: #000000;">29</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">43</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">7</span><span style="color: #0000FF;">}</span>
+
+ <span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">desc</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">eq</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">e</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s (%ssame as %s): %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">desc</span><span style="color: #0000FF;">,</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">==</span><span style="color: #000000;">e</span><span style="color: #0000FF;">?</span><span style="color: #008000;">""</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"**NOT** "</span><span style="color: #0000FF;">),</span><span style="color: #000000;">eq</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
+
+ <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"  conv(h,f)"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"g"</span><span style="color: #0000FF;">,</span>  <span style="color: #000000;">conv</span><span style="color: #0000FF;">(</span><span style="color: #000000;">h</span><span style="color: #0000FF;">,</span><span style="color: #000000;">f</span><span style="color: #0000FF;">),</span><span style="color: #000000;">g</span><span style="color: #0000FF;">)</span>
+ <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"deconv(g,f)"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"h"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">deconv</span><span style="color: #0000FF;">(</span><span style="color: #000000;">g</span><span style="color: #0000FF;">,</span><span style="color: #000000;">f</span><span style="color: #0000FF;">),</span><span style="color: #000000;">h</span><span style="color: #0000FF;">)</span>
+ <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"deconv(g,h)"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"f"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">deconv</span><span style="color: #0000FF;">(</span><span style="color: #000000;">g</span><span style="color: #0000FF;">,</span><span style="color: #000000;">h</span><span style="color: #0000FF;">),</span><span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>
+<!--
--- a/Task/Deconvolution-1D/PicoLisp/deconvolution-1d-1.l
+++ b/Task/Deconvolution-1D/PicoLisp/deconvolution-1d-1.l
@ -0,0 +1,10 @@
+(load "@lib/math.l")
+
+(de deconv (G F)
+   (let A (pop 'F)
+      (make
+         (for (N . H) (head (- (length F)) G)
+            (for (I . M) (made)
+               (dec 'H
+                  (*/ M (get F (- N I)) 1.0) ) )
+            (link (*/ H 1.0 A)) ) ) ) )
--- a/Task/Deconvolution-1D/PicoLisp/deconvolution-1d-2.l
+++ b/Task/Deconvolution-1D/PicoLisp/deconvolution-1d-2.l
@ -0,0 +1,7 @@
+(setq
+   F (-3. -6. -1. 8. -6. 3. -1. -9. -9. 3. -2. 5. 2. -2. -7. -1.)
+   G (24. 75. 71. -34. 3. 22. -45. 23. 245. 25. 52. 25. -67. -96. 96. 31. 55. 36. 29. -43. -7.)
+   H (-8. -9. -3. -1. -6. 7.) )
+
+(test H (deconv G F))
+(test F (deconv G H))
--- a/Task/Deconvolution-1D/Python/deconvolution-1d-1.py
+++ b/Task/Deconvolution-1D/Python/deconvolution-1d-1.py
@ -0,0 +1,54 @@
+def ToReducedRowEchelonForm( M ):
+    if not M: return
+    lead = 0
+    rowCount = len(M)
+    columnCount = len(M[0])
+    for r in range(rowCount):
+        if lead >= columnCount:
+            return
+        i = r
+        while M[i][lead] == 0:
+            i += 1
+            if i == rowCount:
+                i = r
+                lead += 1
+                if columnCount == lead:
+                    return
+        M[i],M[r] = M[r],M[i]
+        lv = M[r][lead]
+        M[r] = [ mrx / lv for mrx in M[r]]
+        for i in range(rowCount):
+            if i != r:
+                lv = M[i][lead]
+                M[i] = [ iv - lv*rv for rv,iv in zip(M[r],M[i])]
+        lead += 1
+    return M
+
+def pmtx(mtx):
+    print ('\n'.join(''.join(' %4s' % col for col in row) for row in mtx))
+
+def convolve(f, h):
+    g = [0] * (len(f) + len(h) - 1)
+    for hindex, hval in enumerate(h):
+        for findex, fval in enumerate(f):
+            g[hindex + findex] += fval * hval
+    return g
+
+def deconvolve(g, f):
+    lenh = len(g) - len(f) + 1
+    mtx = [[0 for x in range(lenh+1)] for y in g]
+    for hindex in range(lenh):
+        for findex, fval in enumerate(f):
+            gindex = hindex + findex
+            mtx[gindex][hindex] = fval
+    for gindex, gval in enumerate(g):
+        mtx[gindex][lenh] = gval
+    ToReducedRowEchelonForm( mtx )
+    return [mtx[i][lenh] for i in range(lenh)]  # h
+
+if __name__ == '__main__':
+    h = [-8,-9,-3,-1,-6,7]
+    f = [-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1]
+    g = [24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7]
+    assert convolve(f,h) == g
+    assert deconvolve(g, f) == h
--- a/Task/Deconvolution-1D/Python/deconvolution-1d-2.py
+++ b/Task/Deconvolution-1D/Python/deconvolution-1d-2.py
@ -0,0 +1,38 @@
+import numpy
+
+h = [-8,-9,-3,-1,-6,7]
+f = [-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1]
+g = [24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7]
+
+# https://stackoverflow.com/questions/14267555/find-the-smallest-power-of-2-greater-than-n-in-python
+
+def shift_bit_length(x):
+    return 1<<(x-1).bit_length()
+
+def conv(a, b):
+    p = len(a)
+    q = len(b)
+    n = p + q - 1
+    r = shift_bit_length(n)
+    y = numpy.fft.ifft(numpy.fft.fft(a,r) * numpy.fft.fft(b,r),r)
+    return numpy.trim_zeros(numpy.around(numpy.real(y),decimals=6))
+
+def deconv(a, b):
+    p = len(a)
+    q = len(b)
+    n = p - q + 1
+    r = shift_bit_length(max(p, q))
+    y = numpy.fft.ifft(numpy.fft.fft(a,r) / numpy.fft.fft(b,r), r)
+    return numpy.trim_zeros(numpy.around(numpy.real(y),decimals=6))
+
+# should return g
+
+print(conv(h,f))
+
+# should return h
+
+print(deconv(g,f))
+
+# should return f
+
+print(deconv(g,h))
--- a/Task/Deconvolution-1D/R/deconvolution-1d-1.r
+++ b/Task/Deconvolution-1D/R/deconvolution-1d-1.r
@ -0,0 +1,17 @@
+conv <- function(a, b) {
+	p <- length(a)
+	q <- length(b)
+	n <- p + q - 1
+	r <- nextn(n, f=2)
+	y <- fft(fft(c(a, rep(0, r-p))) * fft(c(b, rep(0, r-q))), inverse=TRUE)/r
+	y[1:n]
+}
+
+deconv <- function(a, b) {
+	p <- length(a)
+	q <- length(b)
+	n <- p - q + 1
+	r <- nextn(max(p, q), f=2)
+	y <- fft(fft(c(a, rep(0, r-p))) / fft(c(b, rep(0, r-q))), inverse=TRUE)/r
+	return(y[1:n])
+}
--- a/Task/Deconvolution-1D/R/deconvolution-1d-2.r
+++ b/Task/Deconvolution-1D/R/deconvolution-1d-2.r
@ -0,0 +1,7 @@
+h <- c(-8,-9,-3,-1,-6,7)
+f <- c(-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1)
+g <- c(24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7)
+
+max(abs(conv(f,h) - g))
+max(abs(deconv(g,f) - h))
+max(abs(deconv(g,h) - f))
--- a/Task/Deconvolution-1D/R/deconvolution-1d-3.r
+++ b/Task/Deconvolution-1D/R/deconvolution-1d-3.r
@ -0,0 +1 @@
+conv(a, b) == convolve(a, rev(b), type="open")
--- a/Task/Deconvolution-1D/REXX/deconvolution-1d.rexx
+++ b/Task/Deconvolution-1D/REXX/deconvolution-1d.rexx
@ -0,0 +1,37 @@
+/*REXX pgm performs deconvolution of two arrays:    deconv(g,f)=h   and   deconv(g,h)=f */
+call make 'H',  "-8 -9 -3 -1 -6 7"
+call make 'F',  "-3 -6 -1 8 -6 3 -1 -9 -9 3 -2 5 2 -2 -7 -1"
+call make 'G',  "24 75 71 -34 3 22 -45 23 245 25 52 25 -67 -96 96 31 55 36 29 -43 -7"
+call show 'H'                                    /*display the elements of array  H.    */
+call show 'F'                                    /*   "     "     "      "   "    F.    */
+call show 'G'                                    /*   "     "     "      "   "    G.    */
+call deco 'G',  "F", 'X'                         /*deconvolution of  G  and  F  ───►  X */
+call test 'X',  "H"                              /*test: is array  H  equal to array  X?*/
+call deco 'G',  "H", 'Y'                         /*deconvolution of  G  and  H  ───►  Y */
+call test 'F',  "Y"                              /*test: is array  F  equal to array  Y?*/
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+deco: parse arg $1,$2,$r;   b= @.$2.# + 1;   a= @.$1.# + 1      /*get sizes of array 1&2*/
+      @.$r.#= a - b                                             /*size of return array. */
+            do n=0  to a-b                                      /*define  return array. */
+            @.$r.n= @.$1.n                                      /*define RETURN element.*/
+            if n<b  then L= 0                                   /*define the variable L.*/
+                    else L= n - b + 1                           /*   "    "     "     " */
+            if n>0  then do j=L  to n-1;                _= n-j  /*define elements > 0.  */
+                         @.$r.n= @.$r.n - @.$r.j * @.$2._       /*compute   "     " "   */
+                         end   /*j*/                            /* [↑] subtract product.*/
+            @.$r.n= @.$r.n / @.$2.0                             /*divide array element. */
+            end   /*n*/;                     return
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+make: parse arg $,z;                     @.$.#= words(z) - 1    /*obtain args; set size.*/
+            do k=0  to @.$.#;            @.$.k= word(z, k + 1)  /*define array element. */
+            end   /*k*/;                     return             /*array starts at unity.*/
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+show: parse arg $,z,_;    do s=0  to @.$.#;  _= strip(_ @.$.s)  /*obtain the arguments. */
+                          end   /*s*/                           /* [↑]  build the list. */
+      say 'array' $": " _;                   return             /*show the list;  return*/
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+test: parse arg $1,$2;    do t=0  to max(@.$1.#, @.$2.#)        /*obtain the arguments. */
+                          if @.$1.t= @.$2.t  then iterate       /*create array list.    */
+                          say "***error*** arrays"   $1    ' and '    $2   "aren't equal."
+                          end   /*t*/;       return             /* [↑]  build the list. */
--- a/Task/Deconvolution-1D/Racket/deconvolution-1d-1.rkt
+++ b/Task/Deconvolution-1D/Racket/deconvolution-1d-1.rkt
@ -0,0 +1,18 @@
+#lang racket
+(require math/matrix)
+(define T matrix-transpose)
+
+(define (convolution-matrix f m n)
+  (define l (matrix-num-rows f))
+  (for*/matrix m n ([i (in-range 0 m)] [j (in-range 0 n)])
+      (cond [(or  (< i j) (>= i (+ j l)))  0]
+            [(matrix-ref f (- i j) 0)])))
+
+(define (least-square X y)
+  (matrix-solve (matrix* (T X) X) (matrix* (T X) y)))
+
+(define (deconvolve g f)
+  (define lg (matrix-num-rows g))
+  (define lf (matrix-num-rows f))
+  (define lh (+ (- lg lf) 1))
+  (least-square (convolution-matrix f lg lh) g))
--- a/Task/Deconvolution-1D/Racket/deconvolution-1d-2.rkt
+++ b/Task/Deconvolution-1D/Racket/deconvolution-1d-2.rkt
@ -0,0 +1,6 @@
+(define f (col-matrix [-3 -6 -1 8 -6 3 -1 -9 -9 3 -2 5 2 -2 -7 -1]))
+(define h (col-matrix [-8 -9 -3 -1 -6 7]))
+(define g (col-matrix [24 75 71 -34 3 22 -45 23 245 25 52 25 -67 -96 96 31 55 36 29 -43 -7]))
+
+(deconvolve g f)
+(deconvolve g h)
--- a/Task/Deconvolution-1D/Racket/deconvolution-1d-3.rkt
+++ b/Task/Deconvolution-1D/Racket/deconvolution-1d-3.rkt
@ -0,0 +1,2 @@
+#<array '#(6 1) #[-8 -9 -3 -1 -6 7]>
+#<array '#(16 1) #[-3 -6 -1 8 -6 3 -1 -9 -9 3 -2 5 2 -2 -7 -1]>
--- a/Task/Deconvolution-1D/Raku/deconvolution-1d.raku
+++ b/Task/Deconvolution-1D/Raku/deconvolution-1d.raku
@ -0,0 +1,59 @@
+sub deconvolve (@g, @f) {
+    my \h = 1 + @g - @f;
+    my @m;
+    @m[^@g;^h] »+=» 0;
+    @m[^@g; h] »=«  @g;
+    for ^h -> \j { for @f.kv -> \k, \v { @m[j+k;j] = v } }
+    (rref @m)[^h;h]
+}
+
+sub convolve (@f, @h) {
+    my @g = 0 xx + @f + @h - 1;
+    @g[^@f X+ ^@h] »+=« (@f X× @h);
+    @g
+}
+
+# Reduced Row Echelon Form simultaneous equation solver
+# Can handle over-specified systems of equations (N unknowns in N + M equations)
+sub rref (@m) {
+    @m = trim-system @m;
+    my ($lead, $rows, $cols) = 0, @m, @m[0];
+    for ^$rows -> $r {
+        return @m unless $lead < $cols;
+        my $i = $r;
+        until @m[$i;$lead] {
+            next unless ++$i == $rows;
+            $i = $r;
+            return @m if ++$lead == $cols;
+        }
+        @m[$i, $r] = @m[$r, $i] if $r != $i;
+        @m[$r] »/=» $ = @m[$r;$lead];
+        for ^$rows -> $n {
+            next if $n == $r;
+            @m[$n] »-=» @m[$r] »×» (@m[$n;$lead] // 0);
+        }
+        ++$lead;
+    }
+    @m
+ }
+
+# Reduce to N equations in N unknowns; a no-op unless rows > cols
+sub trim-system (@m) {
+    return @m unless @m ≥ @m[0];
+    my (\vars, @t) = @m[0] - 1;
+    for ^vars -> \lead {
+        for ^@m -> \row {
+            @t.append: @m.splice(row, 1) and last if @m[row;lead];
+        }
+    }
+    while @t < vars and @m { @t.push: shift @m }
+    @t
+}
+
+my @h = (-8,-9,-3,-1,-6,7);
+my @f = (-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1);
+my @g = (24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7);
+
+.say for ~@g,   ~convolve(@f, @h),'';
+.say for ~@h, ~deconvolve(@g, @f),'';
+.say for ~@f, ~deconvolve(@g, @h),'';
--- a/Task/Deconvolution-1D/Scala/deconvolution-1d.scala
+++ b/Task/Deconvolution-1D/Scala/deconvolution-1d.scala
@ -0,0 +1,23 @@
+object Deconvolution1D extends App {
+  val (h, f) = (Array(-8, -9, -3, -1, -6, 7), Array(-3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1))
+  val g = Array(24, 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96, 96, 31, 55, 36, 29, -43, -7)
+  val sb = new StringBuilder
+
+  private def deconv(g: Array[Int], f: Array[Int]) = {
+    val h = Array.ofDim[Int](g.length - f.length + 1)
+
+    for (n <- h.indices) {
+      h(n) = g(n)
+      for (i <- math.max(n - f.length + 1, 0) until n) h(n) -= h(i) * f(n - i)
+      h(n) /= f(0)
+    }
+    h
+  }
+
+  sb.append(s"h = ${h.mkString("[", ", ", "]")}\n")
+    .append(s"deconv(g, f) = ${deconv(g, f).mkString("[", ", ", "]")}\n")
+    .append(s"f = ${f.mkString("[", ", ", "]")}\n")
+    .append(s"deconv(g, h) = ${deconv(g, h).mkString("[", ", ", "]")}")
+  println(sb.result())
+
+}
--- a/Task/Deconvolution-1D/Swift/deconvolution-1d.swift
+++ b/Task/Deconvolution-1D/Swift/deconvolution-1d.swift
@ -0,0 +1,31 @@
+func deconv(g: [Double], f: [Double]) -> [Double] {
+  let fs = f.count
+  var ret = [Double](repeating: 0, count: g.count - fs + 1)
+
+  for n in 0..<ret.count {
+    ret[n] = g[n]
+    let lower = n >= fs ? n - fs + 1 : 0
+
+    for i in lower..<n {
+      ret[n] -= ret[i] * f[n - i]
+    }
+
+    ret[n] /= f[0]
+  }
+
+  return ret
+}
+
+let h = [-8.0, -9.0, -3.0, -1.0, -6.0, 7.0]
+let f = [-3.0, -6.0, -1.0,  8.0, -6.0,  3.0, -1.0, -9.0,
+         -9.0,  3.0, -2.0,  5.0,  2.0, -2.0, -7.0, -1.0]
+let g = [24.0,  75.0, 71.0, -34.0,  3.0,  22.0, -45.0,
+         23.0, 245.0, 25.0,  52.0, 25.0, -67.0, -96.0,
+         96.0,  31.0, 55.0,  36.0, 29.0, -43.0,  -7.0]
+
+print("\(h.map({ Int($0) }))")
+print("\(deconv(g: g, f: f).map({ Int($0) }))\n")
+
+
+print("\(f.map({ Int($0) }))")
+print("\(deconv(g: g, f: h).map({ Int($0) }))")
--- a/Task/Deconvolution-1D/Tcl/deconvolution-1d-1.tcl
+++ b/Task/Deconvolution-1D/Tcl/deconvolution-1d-1.tcl
@ -0,0 +1,100 @@
+package require Tcl 8.5
+namespace eval 1D {
+    namespace ensemble create;   # Will be same name as namespace
+    namespace export convolve deconvolve
+    # Access core language math utility commands
+    namespace path {::tcl::mathfunc ::tcl::mathop}
+
+    # Utility for converting a matrix to Reduced Row Echelon Form
+    # From http://rosettacode.org/wiki/Reduced_row_echelon_form#Tcl
+    proc toRREF {m} {
+	set lead 0
+	set rows [llength $m]
+	set cols [llength [lindex $m 0]]
+	for {set r 0} {$r < $rows} {incr r} {
+	    if {$cols <= $lead} {
+		break
+	    }
+	    set i $r
+	    while {[lindex $m $i $lead] == 0} {
+		incr i
+		if {$rows == $i} {
+		    set i $r
+		    incr lead
+		    if {$cols == $lead} {
+			# Tcl can't break out of nested loops
+			return $m
+		    }
+		}
+	    }
+	    # swap rows i and r
+	    foreach j [list $i $r] row [list [lindex $m $r] [lindex $m $i]] {
+		lset m $j $row
+	    }
+	    # divide row r by m(r,lead)
+	    set val [lindex $m $r $lead]
+	    for {set j 0} {$j < $cols} {incr j} {
+		lset m $r $j [/ [double [lindex $m $r $j]] $val]
+	    }
+
+	    for {set i 0} {$i < $rows} {incr i} {
+		if {$i != $r} {
+		    # subtract m(i,lead) multiplied by row r from row i
+		    set val [lindex $m $i $lead]
+		    for {set j 0} {$j < $cols} {incr j} {
+			lset m $i $j \
+			    [- [lindex $m $i $j] [* $val [lindex $m $r $j]]]
+		    }
+		}
+	    }
+	    incr lead
+	}
+	return $m
+    }
+
+    # How to apply a 1D convolution of two "functions"
+    proc convolve {f h} {
+	set g [lrepeat [+ [llength $f] [llength $h] -1] 0]
+	set fi -1
+	foreach fv $f {
+	    incr fi
+	    set hi -1
+	    foreach hv $h {
+		set gi [+ $fi [incr hi]]
+		lset g $gi [+ [lindex $g $gi] [* $fv $hv]]
+	    }
+	}
+	return $g
+    }
+
+    # How to apply a 1D deconvolution of two "functions"
+    proc deconvolve {g f} {
+	# Compute the length of the result vector
+	set hlen [- [llength $g] [llength $f] -1]
+
+	# Build a matrix of equations to solve
+	set matrix {}
+	set i -1
+	foreach gv $g {
+	    lappend matrix [list {*}[lrepeat $hlen 0] $gv]
+	    set j [incr i]
+	    foreach fv $f {
+		if {$j < 0} {
+		    break
+		} elseif {$j < $hlen} {
+		    lset matrix $i $j $fv
+		}
+		incr j -1
+	    }
+	}
+
+	# Convert to RREF, solving the system of simultaneous equations
+	set reduced [toRREF $matrix]
+
+	# Extract the deconvolution from the last column of the reduced matrix
+	for {set i 0} {$i<$hlen} {incr i} {
+	    lappend result [lindex $reduced $i end]
+	}
+	return $result
+    }
+}
--- a/Task/Deconvolution-1D/Tcl/deconvolution-1d-2.tcl
+++ b/Task/Deconvolution-1D/Tcl/deconvolution-1d-2.tcl
@ -0,0 +1,18 @@
+# Simple pretty-printer
+proc pp {name nlist} {
+    set sep ""
+    puts -nonewline "$name = \["
+    foreach n $nlist {
+	puts -nonewline [format %s%g $sep $n]
+	set sep ,
+    }
+    puts "\]"
+}
+
+set h {-8 -9 -3 -1 -6 7}
+set f {-3 -6 -1 8 -6 3 -1 -9 -9 3 -2 5 2 -2 -7 -1}
+set g {24 75 71 -34 3 22 -45 23 245 25 52 25 -67 -96 96 31 55 36 29 -43 -7}
+
+pp "deconv(g,f) = h" [1D deconvolve $g $f]
+pp "deconv(g,h) = f" [1D deconvolve $g $h]
+pp "  conv(f,h) = g" [1D convolve $f $h]
--- a/Task/Deconvolution-1D/Ursala/deconvolution-1d-1.ursala
+++ b/Task/Deconvolution-1D/Ursala/deconvolution-1d-1.ursala
@ -0,0 +1,6 @@
+#import std
+#import nat
+
+band = pad0+ ~&rSS+ zipt^*D(~&r,^lrrSPT/~&ltK33tx zipt^/~&r ~&lSNyCK33+ zipp0)^/~&rx ~&B->NlNSPC ~&bt
+
+deconv = lapack..dgelsd^\~&l ~&||0.!**+ band
--- a/Task/Deconvolution-1D/Ursala/deconvolution-1d-2.ursala
+++ b/Task/Deconvolution-1D/Ursala/deconvolution-1d-2.ursala
@ -0,0 +1,11 @@
+h = <-8.,-9.,-3.,-1.,-6.,7.>
+f = <-3.,-6.,-1.,8.,-6.,3.,-1.,-9.,-9.,3.,-2.,5.,2.,-2.,-7.,-1.>
+g = <24.,75.,71.,-34.,3.,22.,-45.,23.,245.,25.,52.,25.,-67.,-96.,96.,31.,55.,36.,29.,-43.,-7.>
+
+#cast %eLm
+
+test =
+
+<
+   'h': deconv(g,f),
+   'f': deconv(g,h)>
--- a/Task/Deconvolution-1D/V-(Vlang)/deconvolution-1d.v
+++ b/Task/Deconvolution-1D/V-(Vlang)/deconvolution-1d.v
@ -0,0 +1,26 @@
+fn main() {
+    h := [f64(-8), -9, -3, -1, -6, 7]
+    f := [f64(-3), -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1]
+    g := [f64(24), 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96,
+        96, 31, 55, 36, 29, -43, -7]
+    println(h)
+    println(deconv(g, f))
+    println(f)
+    println(deconv(g, h))
+}
+
+fn deconv(g []f64, f []f64) []f64 {
+    mut h := []f64{len: g.len-f.len+1}
+    for n in 0..h.len {
+        h[n] = g[n]
+        mut lower := 0
+        if n >= f.len {
+            lower = n - f.len + 1
+        }
+        for i in lower..n {
+            h[n] -= h[i] * f[n-i]
+        }
+        h[n] /= f[0]
+    }
+    return h
+}
--- a/Task/Deconvolution-1D/Wren/deconvolution-1d.wren
+++ b/Task/Deconvolution-1D/Wren/deconvolution-1d.wren
@ -0,0 +1,22 @@
+var deconv = Fn.new { |g, f|
+    var h = List.filled(g.count - f.count + 1, 0)
+    for (n in 0...h.count) {
+        h[n] = g[n]
+        var lower = (n >= f.count) ? n - f.count + 1 : 0
+        var i = lower
+        while (i < n) {
+            h[n] = h[n] - h[i]*f[n-i]
+            i = i + 1
+        }
+        h[n] = h[n] / f[0]
+    }
+    return h
+}
+
+var h = [-8, -9, -3, -1, -6, 7]
+var f = [-3, -6, -1, 8, -6, 3, -1, -9, -9, 3, -2, 5, 2, -2, -7, -1]
+var g = [24, 75, 71, -34, 3, 22, -45, 23, 245, 25, 52, 25, -67, -96, 96, 31, 55, 36, 29, -43, -7]
+System.print(h)
+System.print(deconv.call(g, f))
+System.print(f)
+System.print(deconv.call(g, h))
--- a/Task/Deconvolution-1D/Zkl/deconvolution-1d-1.zkl
+++ b/Task/Deconvolution-1D/Zkl/deconvolution-1d-1.zkl
@ -0,0 +1,8 @@
+var [const] GSL=Import("zklGSL");	// libGSL (GNU Scientific Library)
+fcn dconv1D(f,g){
+   fsz,hsz:=f.len(), g.len() - fsz +1;
+   A:=GSL.Matrix(g.len(),hsz);
+   foreach n,fn in ([0..].zip(f)){ foreach rc in (hsz){ A[rc+n,rc]=fn } }
+   h:=A.AxEQb(g);
+   h
+}
--- a/Task/Deconvolution-1D/Zkl/deconvolution-1d-2.zkl
+++ b/Task/Deconvolution-1D/Zkl/deconvolution-1d-2.zkl
@ -0,0 +1,7 @@
+f:=GSL.VectorFromData(-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1);
+g:=GSL.VectorFromData(24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7);
+h:=dconv1D(f,g);
+h.format().println();
+
+f:=dconv1D(h,g);
+f.format().println();
--- a/Task/Deconvolution-1D/Zkl/deconvolution-1d-3.zkl
+++ b/Task/Deconvolution-1D/Zkl/deconvolution-1d-3.zkl
@ -0,0 +1,11 @@
+fcn deconv(g,f){
+   flen, glen, delta:=f.len(), g.len(), glen - flen + 1;
+   result:=List.createLong(delta); // allocate list with space for items
+   foreach n in (delta){
+      e:=g[n];
+      lowerBound:=(if (n>=flen) n - flen + 1 else 0);
+      foreach i in ([lowerBound .. n-1]){ e-=result[i]*f[n - i]; }
+      result.append(e/f[0]);
+    }
+    result;
+}
--- a/Task/Deconvolution-1D/Zkl/deconvolution-1d-4.zkl
+++ b/Task/Deconvolution-1D/Zkl/deconvolution-1d-4.zkl
@ -0,0 +1,6 @@
+h:=T(-8,-9,-3,-1,-6,7);
+f:=T(-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1);
+g:=T(24,75,71,-34,3,22,-45,23,245,25,52,25,-67,
+                   -96,96,31,55,36,29,-43,-7);
+println(deconv(g, f) == h, " ", deconv(g, f));
+println(deconv(g, h) == f, " ", deconv(g, h));
				`@ -0,0 +1 @@`
				`conv(a, b) == convolve(a, rev(b), type="open")`