Fnft kdvv inverse

.gitignore

@@ -35,6 +35,7 @@
 !/test/fnft__poly/
 !/test/fnft_version_test/
 !/test/fnft_version_test.c/
+!/test/fnft_kdvv_inverse/
 
 # Ignore MacOS hidden files in subdirectories
 /**/*.DS_Store

examples/fnft_kdvv_inverse_example_1.c

@@ -0,0 +1,75 @@
+/*
+* This file is part of FNFT.  
+*                                                                  
+* FNFT is free software; you can redistribute it and/or
+* modify it under the terms of the version 2 of the GNU General
+* Public License as published by the Free Software Foundation.
+*
+* FNFT is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*                                                                      
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contributors:
+* Fabian Fischer (Hiwi KIT) 2026
+*/
+
+// This is a simple example for the usage of the inverse kdvv transform in C
+
+#define FNFT_ENABLE_SHORT_NAMES
+
+#include <stdio.h>
+
+#include "fnft_kdvv_inverse.h"
+#include "fnft__errwarn.h"
+#include "fnft__misc.h"
+
+#define K 5     // number of bound states to add
+
+INT main()
+{
+    INT ret_code = SUCCESS;
+
+    COMPLEX * q = NULL;
+    COMPLEX * contspec = NULL;
+
+    // five desired bound states and norming constants
+    // - bound states have to be positive, purely imaginary numbers
+    // - bound states have to be in descending order
+    // - every norming constants belong to the bound state at the same index
+    // - the signs of the norming constants have to alternate regarding the order
+    //   of bound states. The norming constant of the biggest bound state has to be positive.
+    COMPLEX bound_states[K] = { I*5.0, I*4.0, I*3.0, I*2.0, I*1.0 };
+    COMPLEX norming_constants[K] = { 1e5, -1e-2, 1e0, -1e3, 1e1 };
+
+    // General parameters
+    UINT D = 256;                   // Number of samples of the computed output
+    REAL T[2] = {-10.0, 10.0};      // area for which the output should be computed
+
+    // allocation of memory for the computed output
+    q = malloc(D * sizeof(COMPLEX));
+    CHECK_NOMEM(q, ret_code, leave_fun);
+
+    // Define continuous spectrum
+    // continuous spectrum is out of function, but needs to be defined/allocated for using 
+    // the inverse kdvv (state 04/2026)
+    UINT M = 10;
+    REAL XI[2] = {-2.0, 2.0};
+
+    contspec = malloc(M * sizeof(COMPLEX));
+    CHECK_NOMEM(contspec, ret_code, leave_fun);
+
+    // call of the inverse kdvv
+    ret_code = fnft_kdvv_inverse(M, contspec, XI, K, bound_states, norming_constants, D, q, T, NULL);
+    CHECK_RETCODE(ret_code, leave_fun);
+
+    // prints the results in the console
+    misc_print_buf(D, q, "output");
+
+leave_fun:
+    free(q);
+    free(contspec);
+}

examples/fnft_kdvv_inverse_example_2.c

@@ -0,0 +1,88 @@
+/*
+* This file is part of FNFT.  
+*                                                                  
+* FNFT is free software; you can redistribute it and/or
+* modify it under the terms of the version 2 of the GNU General
+* Public License as published by the Free Software Foundation.
+*
+* FNFT is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*                                                                      
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contributors:
+* Fabian Fischer (Hiwi KIT) 2026
+*/
+
+// This is an example for the usage of the inverse kdvv transform with many 
+// bound states
+
+#define FNFT_ENABLE_SHORT_NAMES
+
+#include <stdio.h>
+
+#include "fnft_kdvv_inverse.h"
+#include "fnft__errwarn.h"
+#include "fnft__misc.h"
+
+#define K 19    // Number of bound states to add
+
+INT main()
+{
+    INT ret_code = SUCCESS;
+
+    COMPLEX * bound_states = NULL;
+    COMPLEX * q = NULL;
+    COMPLEX * contspec = NULL;
+
+    COMPLEX desired_solitions_height[K] = { 40.0, 39.0, 38.0, 37.0, 36.0,
+                                            30.0, 29.0, 28.0, 27.0, 26.0,
+                                            20.0, 19.0, 18.0, 17.0, 16.0,
+                                            10.0, 9.0, 8.0, 7.0};
+
+    COMPLEX normconsts[K] = {   1e20, -1e-7, 1e5, -1e3, 1e1,
+                                -1e0, 1e2, -1e4, 1e-6, -1e8,
+                                1e2, -1e4, 1e6, -1e8, 1e-10,
+                                -1e7, 1e-6, -1e5, 1e-9};
+
+    // resulting bound states out of desired solitions height                                
+    bound_states = malloc(K * sizeof(COMPLEX));
+    CHECK_NOMEM(bound_states, ret_code, leave_fun);
+
+    for (UINT i = 0; i<K; i++){
+        bound_states[i] = I*SQRT(desired_solitions_height[i]/2.0);
+    }
+
+    // General parameters
+    UINT D = 256;
+    REAL T[2] = {-18.0, 12.0};
+
+    // allocating memory for the output of the inverse kdvv
+    q = malloc(D * sizeof(COMPLEX));
+    CHECK_NOMEM(q, ret_code, leave_fun);
+
+    // Define Parameters and allocate memory for continuous spectrum
+    // inverse kdvv cannot deal with a nonzero continuous spectrum (state 04/2026), 
+    // hence it is implicitly assumed to zero.
+    // Nevertheless the variables needs to be delivered
+    UINT M = 10;
+    REAL XI[2] = {-2.0, 2.0};
+
+    contspec = malloc(M * sizeof(COMPLEX));
+    CHECK_NOMEM(contspec, ret_code, leave_fun);
+
+    // call inverse kdvv transform
+    ret_code = fnft_kdvv_inverse(M, contspec, XI, K, bound_states, normconsts, D, q, T, NULL);
+    CHECK_RETCODE(ret_code, leave_fun);
+
+    // print output of inverse kdvv into console
+    misc_print_buf(D, q, "output");
+
+leave_fun:
+    free(bound_states);
+    free(q);
+    free(contspec);
+}

examples/mex_fnft_kdvv_inverse_example_1.m

@@ -0,0 +1,73 @@
+% This file is part of FNFT.
+%
+% FNFT is free software; you can redistribute it and/or
+% modify it under the terms of the version 2 of the GNU General
+% Public License as published by the Free Software Foundation.
+%
+% FNFT is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this program. If not, see <http://www.gnu.org/licenses/>.
+%
+% Contributors:
+% Sander Wahls (KIT) 2026.
+% Fabian Fischer (Hiwi KIT) 2026.
+
+% This example should illustrate how to use the inverse kdvv transform
+
+clear all;
+close all;
+
+% desired height of solitions:
+desired_solitions = [4, 3, 2, 1];
+
+% resulting bound states out of desired heights of solitions:
+% - bound states have to be positive, purely imaginary numbers
+% - the bound states have to be in descendent order
+bound_states = 1i*sqrt(desired_solitions ./2);
+
+% desired norming constants
+% defines how much the solitions are shifted towards each other
+% - signs have to alternate regards to the order of the bound states
+% - sign of the normconst for the biggest eigenvalue has to be positive
+norming_constants = complex([1, -1, 1, -1].*[0.00001, 0.1, 1, 10]);
+
+% Number of samples of the output of the inverse kdvv
+D = 1001;
+
+% Area, for which the output has to be computed
+% Can be asymmetric
+T = [-10 10];
+
+% defining the continuous spectrum:
+% out of function, just for seek of completeness (state 04/2026)
+contspec = [];
+XI = [1e-6 1];
+
+% calls function of c-library FNFT
+q = mex_fnft_kdvv_inverse(contspec, XI, bound_states, norming_constants, D, T);
+% the result consists of solitions with desired height (if the solitions are far
+% away enough to each other)
+
+% --- Plot the results ---
+t = linspace(T(1), T(2), D);
+
+% the output of the inverse kdvv is defined as a complex number (state 04/2026),
+% however only the imaginary part should be zero and can be neglected
+q = double(real(q(:)'));
+
+figure;
+plot(t, q);
+title('output of inverse kdvv: time-domain');
+xlabel('t');
+ylabel('q(t)');
+legend('q(t)');
+
+figure;
+stem(imag(bound_states),real(norming_constants), 'x');
+title('Bound states and norming constants');
+xlabel('bound states');
+ylabel('norming constants');

examples/mex_fnft_kdvv_inverse_example_2.m

@@ -0,0 +1,85 @@
+% This file is part of FNFT.
+%
+% FNFT is free software; you can redistribute it and/or
+% modify it under the terms of the version 2 of the GNU General
+% Public License as published by the Free Software Foundation.
+%
+% FNFT is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this program. If not, see <http://www.gnu.org/licenses/>.
+%
+% Contributors:
+% Sander Wahls (KIT) 2026.
+% Fabian Fischer (Hiwi KIT) 2026.
+
+% This example should illustrate, how to use the inverse kdvv in combination 
+% with the forward kdvv transform. For basic usage of the inverse kdvv, please
+% please have a look at mex_fnft_kdvv_inverse_example_1.m (state 04/2026).
+
+clear all;
+close all;
+
+contspec_initial = [];
+XI = [1e-6 10];
+
+bound_states_initial = 1i*sqrt([4, 3, 2, 1] ./2);
+norming_constants_initial = complex([1, -1, 1, -1].*[10000, 0.1, 1, 0.001]);
+
+D = 1001;
+T = [-15 10];
+
+% inverse kdvv transform
+q = mex_fnft_kdvv_inverse(contspec_initial, XI, bound_states_initial, norming_constants_initial, D, T);
+
+q = double(real(q(:)'));
+
+% compute the nonlinear Fourier transform of the output of the inverse kdvv
+[contspec_computed, bound_states_computed, norming_constants_computed] = mex_fnft_kdvv(q, T, XI);
+
+
+% --- Plot the results ---
+t = linspace(T(1), T(2), D);
+
+figure;
+plot(t, q);
+title('output of inverse kdvv: time-domain');
+xlabel('t');
+ylabel('q(t)');
+legend('q(t)');
+
+% plotting the initial and the computed discrete spectrum
+% the difference between the initial and the computed spectrum should be very small
+
+figure;
+stem(imag(bound_states_initial),real(norming_constants_initial), 'x', 'color', 'r');
+hold on;
+stem(imag(bound_states_computed),real(norming_constants_computed), 'x', 'color', 'g');
+hold off;
+title('initial and computed bound states and norming constants');
+xlabel('bound states');
+ylabel('norming constants');
+legend('initial', 'computed');
+
+% plotting of continuous spectrum
+% values are small because initial continuous spectrum was assumed as zero
+% and the computed continuous spectrum is only the result of numerical errors
+
+ep_xi = (XI(2) - XI(1)) / (D - 1);
+xi = XI(1):ep_xi:XI(2);
+
+figure;
+hmag=subplot(2,1,1);
+semilogy(xi, abs(contspec_computed));
+title('computed continuous spectrum');
+xlabel('\xi');
+ylabel('|r(\xi)|');
+hang=subplot(2,1,2);
+plot(xi, angle(contspec_computed));
+xlabel('\xi');
+ylabel('\angle r(\xi)');
+linkaxes([hmag,hang],'x');
+