passagemath-modules 10.6.31rc3__cp314-cp314-musllinux_1_2_aarch64.whl

sage/calculus/transforms/dwt.pxd

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-modules
+from sage.libs.gsl.wavelet cimport *
+from sage.libs.gsl.array cimport GSLDoubleArray
+
+cdef class DiscreteWaveletTransform(GSLDoubleArray):
+    cdef gsl_wavelet* wavelet
+    cdef gsl_wavelet_workspace* workspace

sage/calculus/transforms/dwt.pyx

@@ -0,0 +1,160 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Discrete Wavelet Transform
+
+Wraps ``GSL's gsl_wavelet_transform_forward()``,
+and ``gsl_wavelet_transform_inverse()`` and creates plot methods.
+
+AUTHOR:
+
+- Josh Kantor (2006-10-07)  - initial version
+- David Joyner (2006-10-09) - minor changes to docstrings and examples.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2006 Joshua Kantor <jkantor@math.washington.edu>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+
+def WaveletTransform(n, wavelet_type, wavelet_k):
+    r"""
+    This function initializes an GSLDoubleArray of length n which
+    can perform a discrete wavelet transform.
+
+    INPUT:
+
+    - ``n`` -- a power of 2
+    - ``T`` -- the data in the GSLDoubleArray must be real
+    - ``wavelet_type`` -- the name of the type of wavelet, valid choices are:
+
+      * ``'daubechies'``
+      * ``'daubechies_centered'``
+      * ``'haar'``
+      * ``'haar_centered'``
+      * ``'bspline'``
+      * ``'bspline_centered'``
+
+    For daubechies wavelets, ``wavelet_k`` specifies a daubechie wavelet
+    with `k/2` vanishing moments. `k = 4,6,...,20` for `k` even are the
+    only ones implemented.
+
+    For Haar wavelets, ``wavelet_k`` must be 2.
+
+    For bspline wavelets, ``wavelet_k`` of `103,105,202,204,206,208,301,
+    305,307,309` will give biorthogonal B-spline wavelets of order `(i,j)`
+    where ``wavelet_k`` is `100*i+j`.
+    The wavelet transform uses `J = \log_2(n)` levels.
+
+    OUTPUT:
+
+    An array of the form
+    `(s_{-1,0}, d_{0,0}, d_{1,0}, d_{1,1}, d_{2,0}, \ldots, d_{J-1,2^{J-1}-1})`
+    for `d_{j,k}` the detail coefficients of level `j`.
+    The centered forms align the coefficients of the sub-bands on edges.
+
+    EXAMPLES::
+
+        sage: a = WaveletTransform(128,'daubechies',4)
+        sage: for i in range(1, 11):
+        ....:     a[i] = 1
+        ....:     a[128-i] = 1
+        sage: a.plot().show(ymin=0)                                                     # needs sage.plot
+        sage: a.forward_transform()
+        sage: a.plot().show()                                                           # needs sage.plot
+        sage: a = WaveletTransform(128,'haar',2)
+        sage: for i in range(1, 11): a[i] = 1; a[128-i] = 1
+        sage: a.forward_transform()
+        sage: a.plot().show(ymin=0)                                                     # needs sage.plot
+        sage: a = WaveletTransform(128,'bspline_centered',103)
+        sage: for i in range(1, 11): a[i] = 1; a[100+i] = 1
+        sage: a.forward_transform()
+        sage: a.plot().show(ymin=0)                                                     # needs sage.plot
+
+    This example gives a simple example of wavelet compression::
+
+        sage: # needs sage.symbolic
+        sage: a = DWT(2048,'daubechies',6)
+        sage: for i in range(2048): a[i]=float(sin((i*5/2048)**2))
+        sage: a.plot().show()                   # long time (7s on sage.math, 2011), needs sage.plot
+        sage: a.forward_transform()
+        sage: for i in range(1800): a[2048-i-1] = 0
+        sage: a.backward_transform()
+        sage: a.plot().show()                   # long time (7s on sage.math, 2011), needs sage.plot
+    """
+    cdef size_t _n, _k
+    _n = int(n)
+    if _n < 0:
+        raise ValueError("n must be nonnegative.")
+    _k = int(wavelet_k)
+    if not is2pow(_n):
+        raise NotImplementedError("discrete wavelet transform only implemented when n is a 2-power")
+    return DiscreteWaveletTransform(_n,1,wavelet_type,_k)
+
+
+DWT = WaveletTransform
+
+
+cdef class DiscreteWaveletTransform(GSLDoubleArray):
+    """
+    Discrete wavelet transform class.
+    """
+    def __cinit__(self, size_t n, size_t stride, wavelet_type, size_t wavelet_k):
+        self.wavelet = NULL
+        self.workspace = NULL
+
+    def __init__(self, size_t n, size_t stride, wavelet_type, size_t wavelet_k):
+        if not is2pow(n):
+            raise NotImplementedError("discrete wavelet transform only implemented when n is a 2-power")
+        GSLDoubleArray.__init__(self,n,stride)
+        if wavelet_type=="daubechies":
+            self.wavelet = <gsl_wavelet*> gsl_wavelet_alloc(gsl_wavelet_daubechies, wavelet_k)
+        elif wavelet_type == "daubechies_centered":
+            self.wavelet = <gsl_wavelet*> gsl_wavelet_alloc(gsl_wavelet_daubechies_centered,wavelet_k)
+        elif wavelet_type == "haar":
+            self.wavelet = <gsl_wavelet *> gsl_wavelet_alloc(gsl_wavelet_haar,wavelet_k)
+        elif wavelet_type == "haar_centered":
+            self.wavelet = <gsl_wavelet*> gsl_wavelet_alloc(gsl_wavelet_haar_centered,wavelet_k)
+        elif wavelet_type == "bspline":
+            self.wavelet = <gsl_wavelet*> gsl_wavelet_alloc(gsl_wavelet_bspline,wavelet_k)
+        elif wavelet_type == "bspline_centered":
+            self.wavelet = <gsl_wavelet*> gsl_wavelet_alloc(gsl_wavelet_bspline_centered,wavelet_k)
+        self.workspace = <gsl_wavelet_workspace*> gsl_wavelet_workspace_alloc(n)
+
+    def __dealloc__(self):
+        if self.wavelet != NULL:
+            gsl_wavelet_free(self.wavelet)
+            gsl_wavelet_workspace_free(self.workspace)
+
+    def forward_transform(self):
+        gsl_wavelet_transform_forward(self.wavelet,self.data,self.stride,self.n,self.workspace)
+
+    def backward_transform(self):
+        gsl_wavelet_transform_inverse(self.wavelet,self.data,self.stride,self.n,self.workspace)
+
+    def plot(self, xmin=None, xmax=None, **args):
+        from sage.plot.point import point
+
+        cdef int i
+        cdef double x
+        v = []
+        if xmin is None:
+            x_min = 0
+        if xmax is None:
+            x_max = self.n
+        for i in range(x_min, x_max):
+            x = self.data[i]
+            if i > 0:
+                v.append(point([(i, x)], hue=(1, 1, 1), **args))
+        return sum(v)
+
+
+def is2pow(unsigned int n):
+    while n and not n % 2:
+        n = n >> 1
+    return n == 1

sage/calculus/transforms/fft.pxd

@@ -0,0 +1,12 @@
+# sage_setup: distribution = sagemath-modules
+from sage.libs.gsl.fft cimport *
+
+cdef class FastFourierTransform_base:
+    pass
+
+cdef class FastFourierTransform_complex(FastFourierTransform_base):
+    cdef double * data
+    cdef size_t n
+    cdef size_t stride
+    cdef gsl_fft_complex_wavetable * wt
+    cdef gsl_fft_complex_workspace * mem

sage/calculus/transforms/fft.pyx

@@ -0,0 +1,487 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Fast Fourier Transforms Using GSL
+
+AUTHORS:
+
+- William Stein (2006-9): initial file (radix2)
+- D. Joyner (2006-10): Minor modifications (from radix2 to general case\
+                        and some documentation).
+- M. Hansen (2013-3): Fix radix2 backwards transformation
+- L.F. Tabera Alonso (2013-3): Documentation
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from cysignals.memory cimport sig_malloc, sig_free
+
+from sage.rings.integer import Integer
+from sage.rings.complex_mpfr import ComplexNumber
+
+
+def FastFourierTransform(size, base_ring=None):
+    """
+    Create an array for fast Fourier transform conversion using gsl.
+
+    INPUT:
+
+    - ``size`` -- the size of the array
+    - ``base_ring`` -- unused (2013-03)
+
+    EXAMPLES:
+
+    We create an array of the desired size::
+
+        sage: a = FastFourierTransform(8)
+        sage: a
+        [(0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)]
+
+    Now, set the values of the array::
+
+        sage: for i in range(8): a[i] = i + 1
+        sage: a
+        [(1.0, 0.0), (2.0, 0.0), (3.0, 0.0), (4.0, 0.0), (5.0, 0.0), (6.0, 0.0), (7.0, 0.0), (8.0, 0.0)]
+
+    We can perform the forward Fourier transform on the array::
+
+        sage: a.forward_transform()
+        sage: a                       #abs tol 1e-2
+        [(36.0, 0.0), (-4.00, 9.65), (-4.0, 4.0), (-4.0, 1.65), (-4.0, 0.0), (-4.0, -1.65), (-4.0, -4.0), (-4.0, -9.65)]
+
+    And backwards::
+
+        sage: a.backward_transform()
+        sage: a                       #abs tol 1e-2
+        [(8.0, 0.0), (16.0, 0.0), (24.0, 0.0), (32.0, 0.0), (40.0, 0.0), (48.0, 0.0), (56.0, 0.0), (64.0, 0.0)]
+
+    Other example::
+
+        sage: a = FastFourierTransform(128)
+        sage: for i in range(1, 11):
+        ....:    a[i] = 1
+        ....:    a[128-i] = 1
+        sage: a[:6:2]
+        [(0.0, 0.0), (1.0, 0.0), (1.0, 0.0)]
+        sage: a.plot().show(ymin=0)                                                     # needs sage.plot
+        sage: a.forward_transform()
+        sage: a.plot().show()                                                           # needs sage.plot
+    """
+    return FastFourierTransform_complex(int(size))
+
+
+FFT = FastFourierTransform
+
+
+cdef class FastFourierTransform_base:
+    pass
+
+cdef class FastFourierTransform_complex(FastFourierTransform_base):
+    """
+    Wrapper class for GSL's fast Fourier transform.
+    """
+
+    def __init__(self, size_t n, size_t stride=1):
+        """
+        Create an array-like object of fixed size that will contain the vector to
+        apply the Fast Fourier Transform.
+
+        INPUT:
+
+        - ``n`` -- integer, the size of the array
+        - ``stride`` -- the stride to be applied when manipulating the array
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(1) # indirect doctest
+            sage: a
+            [(0.0, 0.0)]
+        """
+        self.n = n
+        self.stride = stride
+        self.data = <double*>sig_malloc(sizeof(double)*(2*n))
+        cdef int i
+        for i in range(2 * n):
+            self.data[i] = 0
+
+    def __dealloc__(self):
+        """
+        Frees allocated memory.
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(128)
+            sage: del a
+        """
+        sig_free(self.data)
+
+    def __len__(self):
+        """
+        Return the size of the array.
+
+        OUTPUT: the size of the array
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(48)
+            sage: len(a)
+            48
+        """
+        return self.n
+
+    def __setitem__(self, size_t i, xy):
+        """
+        Assign a value to an index of the array.
+
+        Currently the input has to be en element that can be coerced
+        to ``float`` or a ``ComplexNumber`` element.
+
+        INPUT:
+
+        - ``i`` -- integer; the index
+        - ``xy`` -- an object to store as `i`-th element of the array ``self[i]``
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.mpfr sage.symbolic
+            sage: I = CC(I)
+            sage: a = FastFourierTransform(4)
+            sage: a[0] = 1
+            sage: a[1] = I
+            sage: a[2] = 1+I
+            sage: a[3] = (2,2)
+            sage: a
+            [(1.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, 2.0)]
+            sage: I = CDF(I)
+            sage: a[1] = I
+            Traceback (most recent call last):
+            ...
+            TypeError: unable to convert 1.0*I to float; use abs() or real_part() as desired
+
+        TESTS:
+
+        Verify that :issue:`10758` is fixed. ::
+
+            sage: F = FFT(1)
+            sage: F[0] = (1,1)
+            sage: F[0] = 1
+            sage: F[0]
+            (1.0, 0.0)
+        """
+        # just set real for now
+        if i < 0 or i >= self.n:
+            raise IndexError
+        if isinstance(xy, (tuple, ComplexNumber)):
+            self.data[2*i] = xy[0]
+            self.data[2*i+1] = xy[1]
+        else:
+            self.data[2*i] = xy
+            self.data[2*i+1] = 0
+
+    def __getitem__(self, i):
+        """
+        Get the `i`-th element of the array.
+
+        INPUT:
+
+        - ``i`` -- integer
+
+        OUTPUT: the `i`-th element of the array ``self[i]``
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(4)
+            sage: a[0]
+            (0.0, 0.0)
+            sage: a[0] = 1
+            sage: a[0] == (1,0)
+            True
+        """
+        if isinstance(i, slice):
+            start, stop, step = i.indices(self.n)
+            return list(self)[start:stop:step]
+        else:
+            if i < 0 or i >= self.n:
+                raise IndexError
+            return self.data[2*i], self.data[2*i+1]
+
+    def __repr__(self):
+        """
+        String representation of the array.
+
+        OUTPUT:
+
+        - A string representing this array. The complex numbers are
+            presented as a tuple of two float elements.
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(4)
+            sage: for i in range(4): a[i] = i
+            sage: a
+            [(0.0, 0.0), (1.0, 0.0), (2.0, 0.0), (3.0, 0.0)]
+        """
+        return str(list(self))
+
+    def _plot_polar(self, xmin, xmax, **args):
+        """
+        Plot a slice of the array using polar coordinates.
+
+        INPUT:
+
+        - ``xmin`` -- the lower bound of the slice to plot
+        - ``xmax`` -- the upper bound of the slice to plot
+        - ``**args`` -- passed on to the line plotting function
+
+        OUTPUT: a plot of the array interpreting each element as polar coordinates
+
+        This method should not be called directly. See :meth:`plot` for the details.
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(4)
+            sage: a._plot_polar(0,2)                                                    # needs sage.plot sage.symbolic
+            Graphics object consisting of 2 graphics primitives
+        """
+        from sage.plot.point import point
+        from sage.symbolic.constants import pi, I
+
+        cdef int i
+        v = []
+
+        pi = pi.n()
+        I = I.n()
+        s = 1/(3*pi)   # so arg gets scaled between -1/3 and 1/3.
+
+        for i in range(xmin, xmax):
+            z = self.data[2*i] + I*self.data[2*i+1]
+            mag = z.abs()
+            arg = z.arg()*s
+            v.append(point((i, mag), hue=arg, **args))
+        return sum(v)
+
+    def _plot_rect(self, xmin, xmax, **args):
+        """
+        Plot a slice of the array.
+
+        INPUT:
+
+        - ``xmin`` -- the lower bound of the slice to plot
+        - ``xmax`` -- the upper bound of the slice to plot
+        - ``**args`` -- passed on to the line plotting function
+
+        OUTPUT: a plot of the array
+
+        This method should not be called directly. See :meth:`plot` for the details.
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(4)
+            sage: a._plot_rect(0,3)                                                     # needs sage.plot
+            Graphics object consisting of 3 graphics primitives
+        """
+        from sage.plot.point import point
+
+        cdef int i
+        cdef double x, h
+        v = []
+
+        for i in range(xmin, xmax):
+            x = self.data[2*i]
+            h = self.data[2*i+1]
+            v.append(point((i, x), hue=h, **args))
+        return sum(v)
+
+    def plot(self, style='rect', xmin=None, xmax=None, **args):
+        """
+        Plot a slice of the array.
+
+        - ``style`` -- style of the plot, options are ``'rect'`` or ``'polar'``
+
+          - ``'rect'`` -- height represents real part, color represents
+            imaginary part
+          - ``'polar'`` -- height represents absolute value, color
+            represents argument
+
+        - ``xmin`` -- the lower bound of the slice to plot; 0 by default
+        - ``xmax`` -- the upper bound of the slice to plot; ``len(self)`` by default
+        - ``**args`` -- passed on to the line plotting function
+
+        OUTPUT: a plot of the array
+
+        EXAMPLES::
+
+            sage: # needs sage.plot
+            sage: a = FastFourierTransform(16)
+            sage: for i in range(16): a[i] = (random(),random())
+            sage: A = plot(a)
+            sage: B = plot(a, style='polar')                                            # needs sage.symbolic
+            sage: type(A)
+            <class 'sage.plot.graphics.Graphics'>
+            sage: type(B)                                                               # needs sage.symbolic
+            <class 'sage.plot.graphics.Graphics'>
+            sage: a = FastFourierTransform(125)
+            sage: b = FastFourierTransform(125)
+            sage: for i in range(1, 60): a[i]=1
+            sage: for i in range(1, 60): b[i]=1
+            sage: a.forward_transform()
+            sage: a.inverse_transform()
+            sage: a.plot() + b.plot()
+            Graphics object consisting of 250 graphics primitives
+        """
+        if xmin is None:
+            xmin = 0
+        else:
+            xmin = int(xmin)
+        if xmax is None:
+            xmax = self.n
+        else:
+            xmax = int(xmax)
+        if style == 'rect':
+            return self._plot_rect(xmin, xmax, **args)
+        elif style == 'polar':
+            return self._plot_polar(xmin, xmax, **args)
+        else:
+            raise ValueError("unknown style '%s'" % style)
+
+    def forward_transform(self):
+        """
+        Compute the in-place forward Fourier transform of this data
+        using the Cooley-Tukey algorithm.
+
+        OUTPUT: none, the transformation is done in-place
+
+        If the number of sample points in the input is a power of 2 then the
+        gsl function ``gsl_fft_complex_radix2_forward`` is automatically called.
+        Otherwise, ``gsl_fft_complex_forward`` is called.
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(4)
+            sage: for i in range(4): a[i] = i
+            sage: a.forward_transform()
+            sage: a #abs tol 1e-2
+            [(6.0, 0.0), (-2.0, 2.0), (-2.0, 0.0), (-2.0, -2.0)]
+        """
+        cdef gsl_fft_complex_wavetable * wt
+        cdef gsl_fft_complex_workspace * mem
+        N = Integer(self.n)
+        e = N.exact_log(2)
+        if N==2**e:
+            gsl_fft_complex_radix2_forward(self.data, self.stride, self.n)
+        else:
+            mem = gsl_fft_complex_workspace_alloc(self.n)
+            wt = gsl_fft_complex_wavetable_alloc(self.n)
+            gsl_fft_complex_forward(self.data, self.stride, self.n, wt, mem)
+            gsl_fft_complex_workspace_free(mem)
+            gsl_fft_complex_wavetable_free(wt)
+
+    def inverse_transform(self):
+        """
+        Compute the in-place inverse Fourier transform of this data
+        using the Cooley-Tukey algorithm.
+
+        OUTPUT: none, the transformation is done in-place
+
+        If the number of sample points in the input is a power of 2 then the
+        function ``gsl_fft_complex_radix2_inverse`` is automatically called.
+        Otherwise, ``gsl_fft_complex_inverse`` is called.
+
+        This transform is normalized so ``f.forward_transform().inverse_transform() == f``
+        modulo round-off errors. See also :meth:`backward_transform`.
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(125)
+            sage: b = FastFourierTransform(125)
+            sage: for i in range(1, 60): a[i]=1
+            sage: for i in range(1, 60): b[i]=1
+            sage: a.forward_transform()
+            sage: a.inverse_transform()
+            sage: a.plot() + b.plot()                                                   # needs sage.plot
+            Graphics object consisting of 250 graphics primitives
+            sage: abs(sum([CDF(a[i])-CDF(b[i]) for i in range(125)])) < 2**-16
+            True
+
+        Here we check it with a power of two::
+
+            sage: a = FastFourierTransform(128)
+            sage: b = FastFourierTransform(128)
+            sage: for i in range(1, 60): a[i]=1
+            sage: for i in range(1, 60): b[i]=1
+            sage: a.forward_transform()
+            sage: a.inverse_transform()
+            sage: a.plot() + b.plot()                                                   # needs sage.plot
+            Graphics object consisting of 256 graphics primitives
+        """
+        cdef gsl_fft_complex_wavetable * wt
+        cdef gsl_fft_complex_workspace * mem
+        N = Integer(self.n)
+        e = N.exact_log(2)
+        if N==2**e:
+            gsl_fft_complex_radix2_inverse(self.data, self.stride, self.n)
+        else:
+            mem = gsl_fft_complex_workspace_alloc(self.n)
+            wt = gsl_fft_complex_wavetable_alloc(self.n)
+            gsl_fft_complex_inverse(self.data, self.stride, self.n, wt, mem)
+            gsl_fft_complex_workspace_free(mem)
+            gsl_fft_complex_wavetable_free(wt)
+
+    def backward_transform(self):
+        """
+        Compute the in-place backwards Fourier transform of this data
+        using the Cooley-Tukey algorithm.
+
+        OUTPUT: none, the transformation is done in-place
+
+        This is the same as :meth:`inverse_transform` but lacks normalization
+        so that ``f.forward_transform().backward_transform() == n*f``. Where
+        ``n`` is the size of the array.
+
+        EXAMPLES::
+
+            sage: a = FastFourierTransform(125)
+            sage: b = FastFourierTransform(125)
+            sage: for i in range(1, 60): a[i]=1
+            sage: for i in range(1, 60): b[i]=1
+            sage: a.forward_transform()
+            sage: a.backward_transform()
+            sage: (a.plot() + b.plot()).show(ymin=0)    # long time (2s on sage.math, 2011), needs sage.plot
+            sage: abs(sum([CDF(a[i])/125-CDF(b[i]) for i in range(125)])) < 2**-16
+            True
+
+        Here we check it with a power of two::
+
+            sage: a = FastFourierTransform(128)
+            sage: b = FastFourierTransform(128)
+            sage: for i in range(1, 60): a[i]=1
+            sage: for i in range(1, 60): b[i]=1
+            sage: a.forward_transform()
+            sage: a.backward_transform()
+            sage: (a.plot() + b.plot()).show(ymin=0)                                    # needs sage.plot
+        """
+        cdef gsl_fft_complex_wavetable * wt
+        cdef gsl_fft_complex_workspace * mem
+        N = Integer(self.n)
+        e = N.exact_log(2)
+        if N==2**e:
+            gsl_fft_complex_radix2_backward(self.data, self.stride, self.n)
+        else:
+            mem = gsl_fft_complex_workspace_alloc(self.n)
+            wt = gsl_fft_complex_wavetable_alloc(self.n)
+            gsl_fft_complex_backward(self.data, self.stride, self.n, wt, mem)
+            gsl_fft_complex_workspace_free(mem)
+            gsl_fft_complex_wavetable_free(wt)
+
+cdef class FourierTransform_complex:
+    pass
+
+cdef class FourierTransform_real:
+    pass