pyNFFT3 1.1.0__py3-none-win_arm64.whl

pyNFFT3/FSFT.py

@@ -0,0 +1,347 @@
+import ctypes
+
+import numpy as np
+
+from . import _nfsftlib, fsft_plan
+from .flags import *
+
+# Set arugment and return types for functions
+_nfsftlib.jnfsft_init.argtypes = [
+    ctypes.POINTER(fsft_plan),
+    ctypes.c_int32,
+    ctypes.c_int32,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+    ctypes.c_int32,
+]
+
+_nfsftlib.jnfsft_alloc.restype = ctypes.POINTER(fsft_plan)
+_nfsftlib.jnfsft_finalize.argtypes = (ctypes.POINTER(fsft_plan),)
+
+_nfsftlib.jnfsft_set_x.argtypes = [
+    ctypes.POINTER(fsft_plan),
+    np.ctypeslib.ndpointer(np.float64, flags="C"),
+]
+_nfsftlib.jnfsft_set_x.restype = ctypes.POINTER(ctypes.c_double)
+_nfsftlib.jnfsft_set_f.argtypes = [
+    ctypes.POINTER(fsft_plan),
+    np.ctypeslib.ndpointer(np.complex128, flags="C"),
+]
+_nfsftlib.jnfsft_set_f.restype = ctypes.POINTER(ctypes.c_double)
+_nfsftlib.jnfsft_set_fhat.argtypes = [
+    ctypes.POINTER(fsft_plan),
+    np.ctypeslib.ndpointer(np.complex128, flags="C"),
+]
+_nfsftlib.jnfsft_set_fhat.restype = ctypes.POINTER(ctypes.c_double)
+
+_nfsftlib.jnfsft_trafo.argtypes = [ctypes.POINTER(fsft_plan)]
+_nfsftlib.jnfsft_trafo.restype = ctypes.POINTER(ctypes.c_double)
+_nfsftlib.jnfsft_adjoint.argtypes = [ctypes.POINTER(fsft_plan)]
+_nfsftlib.jnfsft_adjoint.restype = ctypes.POINTER(ctypes.c_double)
+_nfsftlib.jnfsft_trafo_direct.argtypes = [ctypes.POINTER(fsft_plan)]
+_nfsftlib.jnfsft_trafo_direct.restype = ctypes.POINTER(ctypes.c_double)
+_nfsftlib.jnfsft_adjoint_direct.argtypes = [ctypes.POINTER(fsft_plan)]
+_nfsftlib.jnfsft_adjoint_direct.restype = ctypes.POINTER(ctypes.c_double)
+
+
+class FSFT:
+    """
+    Class to perform fast spherical Fourier transforms (FSFT).
+    Just **N** and **M** are required for initializing a plan.
+    """
+
+    def __init__(
+        self,
+        N: int,
+        M: int,
+        flags: ctypes.c_uint32 = nfsft_default | NFSFT_EQUISPACED,
+        nfft_flags: ctypes.c_uint32 = nfsft_nfft_default,
+        nfft_cutoff: int = nfsft_default_nfft_cut_off,
+    ):
+        self.plan = None
+        self.N = N  # bandwidth
+        self.flags = flags
+        self.nfft_flags = nfft_flags
+        self.nfft_cutoff = nfft_cutoff
+        self.init_done = False  # bool for plan init
+        self.finalized = False  # bool for finalizer
+        # self.x = None  # nodes, will be set later
+        self._f = None  # function coefficients
+        self._fhat = None  # spherical Fourier coefficients
+        self._fhat_corrupted_by_fast_trafo = False
+
+        if N <= 0:
+            raise ValueError(f"Invalid N: {N}. Argument must be a positive integer")
+
+        if M <= 0:
+            raise ValueError(f"Invalid M: {M}. Argument must be a positive integer")
+
+        if (self.flags & NFSFT_EQUISPACED) == 0:
+            raise ValueError("Must use NFSFT_EQUISPACED flag. Use NFSFT instead")
+
+        # The underlying C library ignores the M passed to its init function
+        # for equispaced plans and always allocates/uses the fixed grid size
+        # (2*N+2)*(N+2) instead (see nfsft_init_guru() in
+        # kernel/nfsft/nfsft.c). Mirror that here so the Python-side f/fhat
+        # buffer bookkeeping (which used to trust the caller-supplied M)
+        # matches the C library's real buffer size - using a smaller M here
+        # used to silently read/write past the actual buffer, leaving most of
+        # it uninitialized and producing NaN from fsft_adjoint().
+        self.M = (2 * N + 2) * (N + 2)  # number of equispaced grid nodes
+
+    def __del__(self):
+        self.finalize_plan()
+
+    def fsft_finalize_plan(self):
+        """
+        Finalizes an FSFT plan.
+        This function does not have to be called by the user.
+        """
+
+        if not self.init_done:
+            raise ValueError("FSFT not initialized.")
+
+        if not self.finalized:
+            self.finalized = True
+            _nfsftlib.jnfsft_finalize(self.plan)
+
+    def finalize_plan(self):
+        """
+        Alternate call for **fsft_finalize_plan()**
+        """
+        return self.fsft_finalize_plan()
+
+    def fsft_init(self):
+        """
+        Initializes the FSFT plan in C.
+        This function does not have to be called by the user.
+        """
+        # Call init for memory allocation
+        ptr = _nfsftlib.jnfsft_alloc()
+
+        # Set the pointer
+        self.plan = ctypes.cast(ptr, ctypes.POINTER(fsft_plan))
+
+        # Initialize values
+        _nfsftlib.jnfsft_init(
+            self.plan,
+            ctypes.c_int(self.N),
+            ctypes.c_int(self.M),
+            self.flags,
+            self.nfft_flags,
+            ctypes.c_int(self.nfft_cutoff),
+        )
+        self.init_done = True
+
+        # nfsft_trafo_direct()/nfsft_adjoint_direct() (shared with NFSFT)
+        # unconditionally read plan->x for node positions, including when
+        # called internally by trafo()/adjoint() for N < NFSFT_BREAK_EVEN -
+        # but FSFT has no x setter of its own (the whole point of
+        # NFSFT_EQUISPACED is that the grid is implicit in N), and
+        # empirically plan->x is left uninitialized rather than auto-filled
+        # with the equispaced grid as kernel/nfsft/nfsft.c's
+        # nfsft_init_guru() comments suggest it should be - this produced
+        # NaN/garbage results that varied by process/heap state (see the
+        # FSFT_test.py fix this was found in). Set the equispaced grid
+        # ourselves via jnfsft_set_x, mirroring that same C code:
+        #   x[2*(i*(N+2)+j)]   = (i-N-1)/(2N+2)   for i in 0..2N+1
+        #   x[2*(i*(N+2)+j)+1] =      j/(2N+2)    for j in 0..N+1
+        # jnfsft_set_x additionally expects its input in "raw angle" units
+        # (it divides by 2*pi itself, with a wraparound for the first
+        # component) rather than plan->x's own normalized units directly, so
+        # the values below are first scaled back up by 2*pi to compensate.
+        i = np.arange(2 * self.N + 2, dtype=np.float64)
+        j = np.arange(self.N + 2, dtype=np.float64)
+        I, J = np.meshgrid(i, j, indexing="ij")  # I, J both shape (2N+2, N+2)
+        phi = (I - self.N - 1) / (2.0 * self.N + 2)
+        theta = J / (2.0 * self.N + 2)
+        grid = np.empty(self.M * 2, dtype=np.float64)
+        grid[0::2] = (phi * 2.0 * np.pi).ravel()
+        grid[1::2] = (theta * 2.0 * np.pi).ravel()
+        _nfsftlib.jnfsft_set_x(self.plan, grid)
+
+    def init(self):
+        """
+        Alternate call for **fsft_init()**
+        """
+        return self.fsft_init()
+
+    # @property
+    # def x(self) -> np.ndarray:
+    #     return self._X
+
+    @property
+    def f(self) -> np.ndarray:
+        return self._f
+
+    @f.setter
+    def f(self, value: np.ndarray):
+        if value is not None:
+            if not self.init_done:
+                self.fsft_init()
+            if self.finalized:
+                raise RuntimeError("Plan already finalized")
+            if not (
+                isinstance(value, np.ndarray)
+                and value.dtype == np.complex128
+                and value.flags["C"]
+                and value.size == self.M
+            ):
+                raise RuntimeError(
+                    f"f has to be C-continuous, numpy complex128 array of size M ({self.M})"
+                )
+            self._f = np.ctypeslib.as_array(
+                _nfsftlib.jnfsft_set_f(self.plan, value), shape=(self.M * 2,)
+            ).view(np.complex128)
+
+    @property
+    def fhat(self) -> np.ndarray:
+        return self._fhat
+
+    @fhat.setter
+    def fhat(self, value: np.ndarray):
+        if value is not None:
+            N_total = (2 * self.N + 2) ** 2
+            if not self.init_done:
+                self.fsft_init()
+            if self.finalized:
+                raise RuntimeError("Plan already finalized")
+            if not (
+                isinstance(value, np.ndarray)
+                and value.dtype == np.complex128
+                and value.flags["C"]
+            ):
+                raise RuntimeError(
+                    "fhat has to be C-continuous, numpy complex128 array"
+                )
+            if value.shape != (N_total,):
+                raise RuntimeError(f"fhat must be of size N_total ({N_total})")
+            self._fhat = np.ctypeslib.as_array(
+                _nfsftlib.jnfsft_set_fhat(self.plan, value), shape=(N_total * 2,)
+            ).view(np.complex128)
+            self._fhat_corrupted_by_fast_trafo = False
+
+    @property
+    def num_threads(self) -> int:
+        return _nfsftlib.nfft_get_num_threads()
+
+    def fsft_index(self, k: int, n: int) -> int:
+        """
+        Calculates the index for f_hat calculations.
+        This function does not have to be called by the user.
+        """
+        return (2 * self.N + 2) * (self.N - n + 1) + (self.N + k + 1)
+
+    def fsft_trafo(self):
+        """
+        Computes the FSFT using the fast approximate transform for the provided nodes in **x** and coefficients in **fhat**.
+        """
+        # Prevent bad stuff from happening
+        if self.finalized:
+            raise RuntimeError("FSFT already finalized")
+
+        if not hasattr(self, "_fhat"):
+            raise ValueError("fhat has not been set.")
+        self._f = (
+            np.ctypeslib.as_array(
+                _nfsftlib.jnfsft_trafo(self.plan), shape=(self.M * 2,)
+            )
+            .view(np.complex128)
+            .copy()
+        )
+        # Same underlying nfsft_trafo() as NFSFT: without NFSFT_PRESERVE_F_HAT
+        # it overwrites fhat in place with internal FPT/FFT scratch data.
+        if not (self.flags & NFSFT_PRESERVE_F_HAT):
+            self._fhat_corrupted_by_fast_trafo = True
+
+    def trafo(self):
+        """
+        Alternative call for **fsft_trafo()**
+        """
+        return self.fsft_trafo()
+
+    def fsft_trafo_direct(self):
+        """
+        Computes the NDSFT using direct transformation for the provided nodes in **x** and coefficients in **fhat**.
+        """
+        # Prevent bad stuff from happening
+        if self.finalized:
+            raise RuntimeError("FSFT already finalized")
+
+        if getattr(self, "_fhat_corrupted_by_fast_trafo", False):
+            raise RuntimeError(
+                "fsft_trafo_direct() cannot be trusted on this plan: "
+                "fsft_trafo() already overwrote fhat in place with internal "
+                "scratch data (expected behaviour of the underlying library "
+                "without the NFSFT_PRESERVE_F_HAT flag - see simpleTest/"
+                "example_nfsft.py). Set fhat again, pass NFSFT_PRESERVE_F_HAT "
+                "explicitly, or create a new FSFT plan."
+            )
+
+        if self._fhat is None:
+            raise ValueError("fhat has not been set.")
+        self._f = (
+            np.ctypeslib.as_array(
+                _nfsftlib.jnfsft_trafo_direct(self.plan), shape=(self.M * 2,)
+            )
+            .view(np.complex128)
+            .copy()
+        )
+
+    def trafo_direct(self):
+        """
+        Alternative call for **fsft_trafo_direct()**
+        """
+        return self.fsft_trafo_direct()
+
+    def fsft_adjoint(self):
+        """
+        Computes the adjoint FSFT using the fast approximate transform for the provided nodes in **x** and coefficients in **f**.
+        """
+        N_total = (2 * self.N + 2) ** 2
+        # Prevent bad stuff from happening
+        if self.finalized:
+            raise RuntimeError("FSFT already finalized")
+
+        if not hasattr(self, "_f"):
+            raise ValueError("f has not been set.")
+        self._fhat = (
+            np.ctypeslib.as_array(
+                _nfsftlib.jnfsft_adjoint(self.plan), shape=(N_total * 2,)
+            )
+            .view(np.complex128)
+            .copy()
+        )
+        self._fhat_corrupted_by_fast_trafo = False
+
+    def adjoint(self):
+        """
+        Alternative call for **fsft_adjoint()**
+        """
+        return self.fsft_adjoint()
+
+    def fsft_adjoint_direct(self):
+        """
+        Computes the adjoint NDFST using direct transformation for the provided nodes in **x** and coefficients in **f**.
+        """
+        N_total = (2 * self.N + 2) ** 2
+        # Prevent bad stuff from happening
+        if self.finalized:
+            raise RuntimeError("FSFT already finalized")
+
+        if not hasattr(self, "_f"):
+            raise ValueError("f has not been set.")
+        self._fhat = (
+            np.ctypeslib.as_array(
+                _nfsftlib.jnfsft_adjoint_direct(self.plan), shape=(N_total * 2,)
+            )
+            .view(np.complex128)
+            .copy()
+        )
+        self._fhat_corrupted_by_fast_trafo = False
+
+    def adjoint_direct(self):
+        """
+        Alternative call for **fsft_adjoint_direct()**
+        """
+        return self.fsft_adjoint_direct()

pyNFFT3/NFCT.py

@@ -0,0 +1,343 @@
+import ctypes
+
+import numpy as np
+
+from . import _nfctlib, nfct_plan
+from .flags import *
+
+# Set arugment and return types for functions
+_nfctlib.jnfct_init.argtypes = [
+    ctypes.POINTER(nfct_plan),
+    ctypes.c_int32,
+    ctypes.POINTER(ctypes.c_int32),
+    ctypes.c_int32,
+    ctypes.POINTER(ctypes.c_int32),
+    ctypes.c_int32,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+]
+
+_nfctlib.jnfct_alloc.restype = ctypes.POINTER(nfct_plan)
+_nfctlib.jnfct_finalize.argtypes = (ctypes.POINTER(nfct_plan),)
+
+_nfctlib.jnfct_set_x.argtypes = [
+    ctypes.POINTER(nfct_plan),
+    np.ctypeslib.ndpointer(np.float64, flags="C"),
+]
+_nfctlib.jnfct_set_x.restype = ctypes.POINTER(ctypes.c_double)
+_nfctlib.jnfct_set_f.argtypes = [
+    ctypes.POINTER(nfct_plan),
+    np.ctypeslib.ndpointer(np.float64, ndim=1, flags="C"),
+]
+_nfctlib.jnfct_set_f.restype = ctypes.POINTER(ctypes.c_double)
+_nfctlib.jnfct_set_fhat.argtypes = [
+    ctypes.POINTER(nfct_plan),
+    np.ctypeslib.ndpointer(np.float64, ndim=1, flags="C"),
+]
+_nfctlib.jnfct_set_fhat.restype = ctypes.POINTER(ctypes.c_double)
+
+_nfctlib.jnfct_trafo.argtypes = [ctypes.POINTER(nfct_plan)]
+_nfctlib.jnfct_trafo.restype = ctypes.POINTER(ctypes.c_double)
+_nfctlib.jnfct_adjoint.argtypes = [ctypes.POINTER(nfct_plan)]
+_nfctlib.jnfct_adjoint.restype = ctypes.POINTER(ctypes.c_double)
+_nfctlib.jnfct_trafo_direct.argtypes = [ctypes.POINTER(nfct_plan)]
+_nfctlib.jnfct_trafo_direct.restype = ctypes.POINTER(ctypes.c_double)
+_nfctlib.jnfct_adjoint_direct.argtypes = [ctypes.POINTER(nfct_plan)]
+_nfctlib.jnfct_adjoint_direct.restype = ctypes.POINTER(ctypes.c_double)
+
+
+class NFCT:
+    """
+    Class to perform non-equispaced fast cosine transforms (NFCT)
+    with a dimension of **D**.
+    Just **N** and **M** are required for initializing a plan.
+    """
+
+    def __init__(
+        self,
+        N: np.ndarray,
+        M: int,
+        n: np.ndarray = None,
+        m: int = default_window_cut_off,
+        f1: ctypes.c_uint32 = None,
+        f2: ctypes.c_uint32 = f2_default,
+    ):
+        self.plan = None
+        self.N = N  # bandwidth tuple
+        self.M = M  # number of nodes
+        self.n = n  # oversampling per dimension
+        self.m = m  # window size
+        self.D = len(N)  # dimensions
+
+        if any(x <= 0 for x in N):
+            raise ValueError(f"Invalid N: {N}. Argument must be a positive integer")
+
+        if sum(x % 2 for x in N) != 0:
+            raise ValueError(f"Invalid N: {N}. Argument must be an even integer")
+
+        if M <= 0:
+            raise ValueError(f"Invalid M: {M}. Argument must be a positive integer")
+
+        if n is None:
+            self.n = (2 ** (np.ceil(np.log(self.N) / np.log(2)) + 1)).astype("int32")
+
+        if any(x <= 0 for x in self.n):
+            raise ValueError(
+                f"Invalid n: {self.n}. Argument must be a positive integer"
+            )
+
+        if any(x <= y for x, y in zip(self.n, N)):
+            raise ValueError(f"Invalid n: {self.n}. Argument must fulfil n_i > N_i")
+
+        if sum(x % 2 for x in self.n) != 0:
+            raise ValueError(f"Invalid n: {self.n}. Argument must be an even integer")
+
+        if m <= 0:
+            raise ValueError(f"Invalid m: {m}. Argument must be a positive integer")
+
+        if f1 is None:
+            self.f1 = f1_default if self.D > 1 else f1_default_1d
+        else:
+            self.f1 = f1
+
+        self.f2 = f2  # FFTW flags
+        self.init_done = False  # bool for plan init
+        self.finalized = False  # bool for finalizer
+        self._X = None  # nodes, will be set later
+        self._f = None  # function values
+        self._fhat = None  # Fourier coefficients
+
+    def __del__(self):
+        self.finalize_plan()
+
+    def nfct_finalize_plan(self):
+        """
+        Finalizes an NFCT plan.
+        This function does not have to be called by the user.
+        """
+
+        if not self.init_done:
+            raise ValueError("NFST not initialized.")
+
+        if not self.finalized:
+            _nfctlib.jnfct_finalize(self.plan)
+            self.finalized = True
+
+    def finalize_plan(self):
+        """
+        Alternative call for **nfct_finalize_plan()**
+        """
+        return self.nfct_finalize_plan()
+
+    def nfct_init(self):
+        """
+        Initializes the NFCT plan in C.
+        This function does not have to be called by the user.
+        """
+        # Convert N and n to numpy arrays for passing them to C
+        Nv = np.array(self.N, dtype=np.int32)
+        n = np.array(self.n, dtype=np.int32)
+
+        # Call init for memory allocation
+        ptr = _nfctlib.jnfct_alloc()
+
+        # Set the pointer
+        self.plan = ctypes.cast(ptr, ctypes.POINTER(nfct_plan))
+
+        # Initialize values
+        _nfctlib.jnfct_init(
+            self.plan,
+            ctypes.c_int(self.D),
+            ctypes.cast(Nv.ctypes.data, ctypes.POINTER(ctypes.c_int)),
+            ctypes.c_int(self.M),
+            ctypes.cast(n.ctypes.data, ctypes.POINTER(ctypes.c_int)),
+            ctypes.c_int(self.m),
+            self.f1,
+            self.f2,
+        )
+        self.init_done = True
+
+    def init(self):
+        """
+        Alternative call for **nfct_init()**
+        """
+        return self.nfct_init()
+
+    @property
+    def x(self) -> np.ndarray:
+        return self._X
+
+    @x.setter
+    def x(self, value: np.ndarray):
+        if value is not None:
+            if not self.init_done:
+                self.nfct_init()
+            if self.finalized:
+                raise RuntimeError("Plan already finalized")
+            if not (
+                isinstance(value, np.ndarray)
+                and value.dtype == np.float64
+                and value.flags["C"]
+            ):
+                raise RuntimeError("x has to be C-continuous, numpy float64 array")
+            if self.D == 1:
+                shape = self.M
+            else:
+                shape = (self.M, self.D)
+            self._X = np.ctypeslib.as_array(
+                _nfctlib.jnfct_set_x(self.plan, value), shape=(self.M * self.D,)
+            ).reshape(shape)
+
+    @property
+    def f(self) -> np.ndarray:
+        return self._f
+
+    @f.setter
+    def f(self, value: np.ndarray):
+        if value is not None:
+            if not self.init_done:
+                self.nfct_init()
+            if self.finalized:
+                raise RuntimeError("Plan already finalized")
+            if not (
+                isinstance(value, np.ndarray)
+                and value.dtype == np.float64
+                and value.flags["C"]
+            ):
+                raise RuntimeError("f has to be C-continuous, numpy float64 array")
+            self._f = np.ctypeslib.as_array(
+                _nfctlib.jnfct_set_f(self.plan, value), shape=(self.M,)
+            )
+
+    @property
+    def fhat(self) -> np.ndarray:
+        return self._fhat
+
+    @fhat.setter
+    def fhat(self, value: np.ndarray):
+        if value is not None:
+            Ns = np.prod(self.N)
+            if not self.init_done:
+                self.nfct_init()
+            if self.finalized:
+                raise RuntimeError("Plan already finalized")
+            if not (isinstance(value, np.ndarray) and value.dtype == np.float64):
+                raise RuntimeError("fhat has to be a numpy float64 array")
+            if not value.flags["C"]:
+                raise RuntimeError("fhat has to be C-continuous")
+            if value.size != Ns:
+                raise ValueError(f"fhat has to be an array of size {Ns}")
+            self._fhat = np.ctypeslib.as_array(
+                _nfctlib.jnfct_set_fhat(self.plan, value), shape=(Ns,)
+            )
+
+    @property
+    def num_threads(self) -> int:
+        return _nfctlib.nfft_get_num_threads()
+
+    def nfct_trafo(self):
+        """
+        Computes the NDCT via the fast NFCT algorithm for the provided nodes in **x** and coefficients in **fhat**.
+        """
+        # Prevent bad stuff from happening
+        if self.finalized:
+            raise RuntimeError("NFCT already finalized")
+
+        if not hasattr(self, "_fhat"):
+            raise ValueError("fhat has not been set.")
+
+        if not hasattr(self, "_X"):
+            raise ValueError("x has not been set.")
+        self._f = np.ctypeslib.as_array(
+            _nfctlib.jnfct_trafo(self.plan), shape=(self.M,)
+        ).copy()
+
+    def trafo(self):
+        """
+        Alternative call for **nfct_trafo()**
+        """
+        return self.nfct_trafo()
+
+    def nfct_trafo_direct(self):
+        """
+        Computes the NDCT via naive matrix-vector multiplication for the provided nodes in **x** and coefficients in **fhat**.
+        """
+        # Prevent bad stuff from happening
+        if self.finalized:
+            raise RuntimeError("NFCT already finalized")
+
+        if self._fhat is None:
+            raise ValueError("fhat has not been set.")
+
+        if self._X is None:
+            raise ValueError("x has not been set.")
+        self._f = np.ctypeslib.as_array(
+            _nfctlib.jnfct_trafo_direct(self.plan), shape=(self.M,)
+        ).copy()
+
+    def trafo_direct(self):
+        """
+        Alternative call for **nfct_trafo_direct()**
+        """
+        return self.nfct_trafo_direct()
+
+    def nfct_transposed(self):
+        """
+        Computes the transposed NDCT via the fast transposed NFCT algorithm for the provided nodes in **x** and coefficients in **f**.
+        """
+        Ns = np.prod(self.N)
+
+        # Prevent bad stuff from happening
+        if self.finalized:
+            raise RuntimeError("NFCT already finalized")
+
+        if self._f is None:
+            raise ValueError("f has not been set.")
+
+        if self._X is None:
+            raise ValueError("x has not been set.")
+        self._fhat = np.ctypeslib.as_array(
+            _nfctlib.jnfct_adjoint(self.plan), shape=(Ns,)
+        ).copy()
+
+    def nfct_transposed_direct(self):
+        """
+        Computes the transposed NDCT via naive matrix-vector multiplication for provided nodes for the provided nodes in **x** and coefficients in **f**.
+        """
+        Ns = np.prod(self.N)
+        # Prevent bad stuff from happening
+        if self.finalized:
+            raise RuntimeError("NFCT already finalized")
+
+        if self._f is None:
+            raise ValueError("f has not been set.")
+
+        if self._X is None:
+            raise ValueError("x has not been set.")
+        self._fhat = np.ctypeslib.as_array(
+            _nfctlib.jnfct_adjoint_direct(self.plan), shape=(Ns,)
+        ).copy()
+
+    def nfct_adjoint(self):
+        """
+        Alternative call for **nfct_transposed()**
+        """
+        return self.nfct_transposed()
+
+    def nfct_adjoint_direct(self):
+        """
+        Alternative call for **nfct_transposed_direct()**
+        """
+        return self.nfct_transposed_direct()
+
+    def adjoint(self):
+        """
+        Alternative call for **nfct_adjoint()**
+        """
+        return self.nfct_adjoint()
+
+    def adjoint_direct(self):
+        """
+        Alternative call for **nfct_adjoint_direct()**
+        """
+        return self.nfct_adjoint_direct()