objc2_metal_performance_shaders_graph/generated/

MPSGraphFourierTransformOps.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use objc2_foundation::*;

use crate::*;

/// The scaling modes for Fourier transform operations.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphfftscalingmode?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct MPSGraphFFTScalingMode(pub NSUInteger);
impl MPSGraphFFTScalingMode {
    /// Computes the FFT result with no scaling.
    #[doc(alias = "MPSGraphFFTScalingModeNone")]
    pub const None: Self = Self(0);
    /// Scales the FFT result with reciprocal of the total FFT size over all transformed dimensions.
    #[doc(alias = "MPSGraphFFTScalingModeSize")]
    pub const Size: Self = Self(1);
    /// Scales the FFT result with reciprocal square root of the total FFT size over all transformed dimensions, resulting in signal strength conserving transformation.
    #[doc(alias = "MPSGraphFFTScalingModeUnitary")]
    pub const Unitary: Self = Self(2);
}

unsafe impl Encode for MPSGraphFFTScalingMode {
    const ENCODING: Encoding = NSUInteger::ENCODING;
}

unsafe impl RefEncode for MPSGraphFFTScalingMode {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

extern_class!(
    /// The class that defines the parameters for a fast Fourier transform (FFT) operation.
    ///
    /// Use this descriptor with ``MPSGraph/fastFourierTransformWithTensor:axes:descriptor:name:``,
    /// ``MPSGraph/realToHermiteanFFTWithTensor:axesTensor:descriptor:name:``, and
    /// ``MPSGraph/HermiteanToRealFFTWithTensor:axesTensor:descriptor:name:`` methods.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphfftdescriptor?language=objc)
    #[unsafe(super(MPSGraphObject, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "MPSGraphCore")]
    pub struct MPSGraphFFTDescriptor;
);

#[cfg(feature = "MPSGraphCore")]
extern_conformance!(
    unsafe impl NSCopying for MPSGraphFFTDescriptor {}
);

#[cfg(feature = "MPSGraphCore")]
unsafe impl CopyingHelper for MPSGraphFFTDescriptor {
    type Result = Self;
}

#[cfg(feature = "MPSGraphCore")]
extern_conformance!(
    unsafe impl NSObjectProtocol for MPSGraphFFTDescriptor {}
);

#[cfg(feature = "MPSGraphCore")]
impl MPSGraphFFTDescriptor {
    extern_methods!(
        /// A Boolean-valued parameter that defines the phase factor sign for Fourier transforms.
        ///
        /// When set to `YES` graph uses the positive phase factor: `exp(+i 2Pi mu nu / n)`, when computing the (inverse) Fourier transform.
        /// Otherwise MPSGraph uses the negative phase factor: `exp(-i 2Pi mu nu / n)`, when computing the Fourier transform.
        /// Default value: `NO`.
        #[unsafe(method(inverse))]
        #[unsafe(method_family = none)]
        pub unsafe fn inverse(&self) -> bool;

        /// Setter for [`inverse`][Self::inverse].
        #[unsafe(method(setInverse:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setInverse(&self, inverse: bool);

        /// The scaling mode of the fast fourier transform (FFT) operation.
        ///
        /// Note that the scaling mode is independent from the phase factor. Default value: `MPSGraphFFTScalingModeNone`.
        #[unsafe(method(scalingMode))]
        #[unsafe(method_family = none)]
        pub unsafe fn scalingMode(&self) -> MPSGraphFFTScalingMode;

        /// Setter for [`scalingMode`][Self::scalingMode].
        #[unsafe(method(setScalingMode:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setScalingMode(&self, scaling_mode: MPSGraphFFTScalingMode);

        /// A parameter which controls how graph rounds the output tensor size for a Hermitean-to-real Fourier transform.
        ///
        /// If set to `YES` then MPSGraph rounds the last output dimension of the result tensor in
        /// ``MPSGraph/HermiteanToRealFFTWithTensor:axesTensor:descriptor:name:`` to an odd value.
        /// Has no effect in the other Fourier transform operations.
        /// Default value: `NO`.
        #[unsafe(method(roundToOddHermitean))]
        #[unsafe(method_family = none)]
        pub unsafe fn roundToOddHermitean(&self) -> bool;

        /// Setter for [`roundToOddHermitean`][Self::roundToOddHermitean].
        #[unsafe(method(setRoundToOddHermitean:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setRoundToOddHermitean(&self, round_to_odd_hermitean: bool);

        /// Creates a fast Fourier transform descriptor with default parameter values.
        #[unsafe(method(descriptor))]
        #[unsafe(method_family = none)]
        pub unsafe fn descriptor() -> Option<Retained<Self>>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(feature = "MPSGraphCore")]
impl MPSGraphFFTDescriptor {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

/// MPSGraphFourierTransformOps.
#[cfg(all(feature = "MPSGraph", feature = "MPSGraphCore"))]
impl MPSGraph {
    extern_methods!(
        #[cfg(feature = "MPSGraphTensor")]
        /// Creates a fast Fourier transform operation and returns the result tensor.
        ///
        /// This operation computes the fast Fourier transform of the input tensor according to the following formulae.
        /// ```md
        /// output[mu] = scale * sum_nu exp( +/- i * 2Pi * mu * nu / n ) input[nu], where
        /// ```
        /// `scale = 1` for `scaling_mode = none`,
        /// `scale = 1/V_f` for `scaling_mode = size`,
        /// `scale = 1/sqrt(V_f)` for `scaling_mode = unitary`, where
        /// `V_f` is the volume of the transformation defined by the dimensions included in `axes`
        /// (`V_f = prod_{i
        /// \in axes} shape(input)[i]`) (see ``MPSGraphFFTDescriptor/scalingMode``),
        /// `+` is selected in `+/-` when `inverse` is specified, otherwise `-` is used
        /// and the sum is done separately over each dimension in `axes` and `n` is the
        /// dimension length of that axis.
        ///
        /// > Tip: Currently MPSGraph supports the transformation only within the last four dimensions of the input tensor. In case
        /// you need to transform higher dimensions than the last four, you can tranpose the higher dimensions of the input
        /// with ``MPSGraph/transposeTensor:permutation:name:``  to be within that last four and then transpose
        /// the result tensor back with the inverse of the input transpose.
        ///
        /// - Parameters:
        /// - tensor: A complex or real-valued input tensor.
        /// - axes: An array of numbers that specifies over which axes MPSGraph performs the Fourier transform - all axes must be contained within last four dimensions of the input tensor.
        /// - descriptor: A descriptor that defines the parameters of the Fourier transform operation - see ``MPSGraphFFTDescriptor``.
        /// - name: The name for the operation.
        /// - Returns: A valid complex-valued MPSGraphTensor of the same shape as `tensor`.
        #[unsafe(method(fastFourierTransformWithTensor:axes:descriptor:name:))]
        #[unsafe(method_family = none)]
        pub unsafe fn fastFourierTransformWithTensor_axes_descriptor_name(
            &self,
            tensor: &MPSGraphTensor,
            axes: &NSArray<NSNumber>,
            descriptor: &MPSGraphFFTDescriptor,
            name: Option<&NSString>,
        ) -> Retained<MPSGraphTensor>;

        #[cfg(feature = "MPSGraphTensor")]
        /// Creates a fast Fourier transform operation and returns the result tensor.
        ///
        /// This operation computes the fast Fourier transform of the input tensor according to the following formulae.
        /// ```md
        /// output[mu] = scale * sum_nu exp( +/- i * 2Pi * mu * nu / n ) input[nu], where
        /// ```
        /// `scale = 1` for `scaling_mode = none`,
        /// `scale = 1/V_f` for `scaling_mode = size`,
        /// `scale = 1/sqrt(V_f)` for `scaling_mode = unitary`, where
        /// `V_f` is the volume of the transformation defined by the dimensions included in `axes`
        /// (`V_f = prod_{i
        /// \in axes} shape(input)[i]`) (see ``MPSGraphFFTDescriptor/scalingMode``),
        /// `+` is selected in `+/-` when `inverse` is specified, otherwise `-` is used
        /// and the sum is done separately over each dimension in `axes` and `n` is the
        /// dimension length of that axis.
        ///
        /// > Tip: Currently MPSGraph supports the transformation only within the last four dimensions of the input tensor. In case
        /// you need to transform higher dimensions than the last four, you can tranpose the higher dimensions of the input
        /// with ``MPSGraph/transposeTensor:permutation:name:``  to be within that last four and then transpose
        /// the result tensor back with the inverse of the input transpose.
        ///
        /// - Parameters:
        /// - tensor: A complex or real-valued input tensor.
        /// - axesTensor: A tensor of rank one containing the axes over which MPSGraph performs the transformation. See ``MPSGraph/fastFourierTransformWithTensor:axes:descriptor:name:``.
        /// - descriptor: A descriptor that defines the parameters of the Fourier transform operation - see ``MPSGraphFFTDescriptor``.
        /// - name: The name for the operation.
        /// - Returns: A valid complex-valued MPSGraphTensor of the same shape as `tensor`.
        #[unsafe(method(fastFourierTransformWithTensor:axesTensor:descriptor:name:))]
        #[unsafe(method_family = none)]
        pub unsafe fn fastFourierTransformWithTensor_axesTensor_descriptor_name(
            &self,
            tensor: &MPSGraphTensor,
            axes_tensor: &MPSGraphTensor,
            descriptor: &MPSGraphFFTDescriptor,
            name: Option<&NSString>,
        ) -> Retained<MPSGraphTensor>;

        #[cfg(feature = "MPSGraphTensor")]
        /// Creates a Real-to-Hermitean fast Fourier transform operation and returns the result tensor.
        ///
        /// This operation computes the fast Fourier transform of a real-valued input tensor according to the following formulae.
        /// ```md
        /// output[mu] = scale * sum_nu exp( +/- i * 2Pi * mu * nu / n ) input[nu], where
        /// ```
        /// `scale = 1` for `scaling_mode = none`,
        /// `scale = 1/V_f` for `scaling_mode = size`,
        /// `scale = 1/sqrt(V_f)` for `scaling_mode = unitary`, where
        /// `V_f` is the volume of the transformation defined by the dimensions included in `axes`
        /// (`V_f = prod_{i
        /// \in axes} shape(input)[i]`) (see ``MPSGraphFFTDescriptor/scalingMode``),
        /// `+` is selected in `+/-` when `inverse` is specified, otherwise `-` is used
        /// and the sum is done separately over each dimension in `axes` and `n` is the
        /// dimension length of that axis. With this API MPSGraph writes out only the results for the unique
        /// frequencies, resulting in a tensor which has size `(n/2)+1` in the last dimension defined by `axes`.
        ///
        /// > Tip: Currently MPSGraph supports the transformation only within the last four dimensions of the input tensor. In case
        /// you need to transform higher dimensions than the last four, you can tranpose the higher dimensions of the input
        /// with ``MPSGraph/transposeTensor:permutation:name:``  to be within that last four and then transpose
        /// the result tensor back with the inverse of the input transpose.
        ///
        /// - Parameters:
        /// - tensor: A Real-valued input tensor. Must have datatype `MPSDataTypeFloat32` or `MPSDatatypeFloat16`.
        /// - axes: An array of numbers that specifies over which axes MPSGraph performs the Fourier transform - all axes must be contained within last four dimensions of the input tensor.
        /// - descriptor: A descriptor that defines the parameters of the Fourier transform operation - see ``MPSGraphFFTDescriptor``.
        /// - name: The name for the operation.
        /// - Returns: A valid MPSGraphTensor of type `MPSDataTypeComplexFloat32` or `MPSDataTypeComplexFloat16` with reduced size (see Discussion).
        #[unsafe(method(realToHermiteanFFTWithTensor:axes:descriptor:name:))]
        #[unsafe(method_family = none)]
        pub unsafe fn realToHermiteanFFTWithTensor_axes_descriptor_name(
            &self,
            tensor: &MPSGraphTensor,
            axes: &NSArray<NSNumber>,
            descriptor: &MPSGraphFFTDescriptor,
            name: Option<&NSString>,
        ) -> Retained<MPSGraphTensor>;

        #[cfg(feature = "MPSGraphTensor")]
        /// Creates a Real-to-Hermitean fast Fourier transform operation and returns the result tensor.
        ///
        /// This operation computes the fast Fourier transform of a real-valued input tensor according to the following formulae.
        /// ```md
        /// output[mu] = scale * sum_nu exp( +/- i * 2Pi * mu * nu / n ) input[nu], where
        /// ```
        /// `scale = 1` for `scaling_mode = none`,
        /// `scale = 1/V_f` for `scaling_mode = size`,
        /// `scale = 1/sqrt(V_f)` for `scaling_mode = unitary`, where
        /// `V_f` is the volume of the transformation defined by the dimensions included in `axes`
        /// (`V_f = prod_{i
        /// \in axes} shape(input)[i]`) (see ``MPSGraphFFTDescriptor/scalingMode``),
        /// `+` is selected in `+/-` when `inverse` is specified, otherwise `-` is used
        /// and the sum is done separately over each dimension in `axes` and `n` is the
        /// dimension length of that axis. With this API MPSGraph writes out only the results for the unique
        /// frequencies, resulting in a tensor which has size `(n/2)+1` in the last dimension defined by `axes`.
        ///
        /// > Tip: Currently MPSGraph supports the transformation only within the last four dimensions of the input tensor. In case
        /// you need to transform higher dimensions than the last four, you can tranpose the higher dimensions of the input
        /// with ``MPSGraph/transposeTensor:permutation:name:``  to be within that last four and then transpose
        /// the result tensor back with the inverse of the input transpose.
        ///
        /// - Parameters:
        /// - tensor: A real-valued input tensor. Must have datatype `MPSDataTypeFloat32` or `MPSDatatypeFloat16`.
        /// - axesTensor: A tensor of rank one containing the axes over which MPSGraph performs the transformation. See ``MPSGraph/fastFourierTransformWithTensor:axes:descriptor:name:``.
        /// - descriptor: A descriptor that defines the parameters of the Fourier transform operation - see ``MPSGraphFFTDescriptor``.
        /// - name: The name for the operation.
        /// - Returns: A valid MPSGraphTensor of type `MPSDataTypeComplexFloat32` or `MPSDataTypeComplexFloat16`  with reduced size (see Discussion).
        #[unsafe(method(realToHermiteanFFTWithTensor:axesTensor:descriptor:name:))]
        #[unsafe(method_family = none)]
        pub unsafe fn realToHermiteanFFTWithTensor_axesTensor_descriptor_name(
            &self,
            tensor: &MPSGraphTensor,
            axes_tensor: &MPSGraphTensor,
            descriptor: &MPSGraphFFTDescriptor,
            name: Option<&NSString>,
        ) -> Retained<MPSGraphTensor>;

        #[cfg(feature = "MPSGraphTensor")]
        /// Creates a Hermitean-to-real fast Fourier transform operation and returns the result tensor.
        ///
        /// This operation computes the fast Fourier transform of a complex-valued input tensor according to the following formulae.
        /// ```md
        /// output[mu] = scale * sum_nu exp( +/- i * 2Pi * mu * nu / n ) in'[nu], where
        /// ```
        /// `in'[nu] = conjugate(in[n - nu])`, for the last dimension defined by `axes` when `nu` is out of range of the input dimension.
        /// `scale = 1` for `scaling_mode = none`,
        /// `scale = 1/V_f` for `scaling_mode = size`,
        /// `scale = 1/sqrt(V_f)` for `scaling_mode = unitary`, where
        /// `V_f` is the volume of the transformation defined by the dimensions included in `axes`
        /// (`V_f = prod_{i
        /// \in axes} shape(input)[i]`) (see ``MPSGraphFFTDescriptor/scalingMode``),
        /// `+` is selected in `+/-` when `inverse` is specified, otherwise `-` is used
        /// and the sum is done separately over each dimension in `axes` and `n` is the
        /// dimension length of that axis. With this API MPSGraph treats the input tensor to have only the unique
        /// frequencies, which means that the resulting tensor has size `(inSize-1)*2 + x` in the last dimension defined by `axes`,
        /// where `inSize = shape(input)[axis] ( = (n/2)+1 )` is the size of the input `tensor` in the last transformed dimension and
        /// `x = 1` when ``MPSGraphFFTDescriptor/roundToOddHermitean`` = `YES` and `x = 0` otherwise.
        ///
        /// > Tip: Currently transformation is supported only within the last four dimensions of the input tensor. In case
        /// you need to transform higher dimensions than the last four, you can tranpose the higher dimensions of the input
        /// with ``MPSGraph/transposeTensor:permutation:name:``  to be within that last four and then transpose
        /// the result tensor back with the inverse of the input transpose.
        ///
        /// - Parameters:
        /// - tensor: A complex-valued input tensor with reduced size (see Discussion). Must have datatype `MPSDataTypeComplexFloat32` or `MPSDataTypeComplexFloat16`.
        /// - axes: An array of numbers that specifies over which axes MPSGraph performs the Fourier transform - all axes must be contained within last four dimensions of the input tensor.
        /// - descriptor: A descriptor that defines the parameters of the Fourier transform operation - see ``MPSGraphFFTDescriptor``.
        /// - name: The name for the operation.
        /// - Returns: A valid MPSGraphTensor of type `MPSDataTypeFloat32` or `MPSDataTypeFloat16` (full size).
        #[unsafe(method(HermiteanToRealFFTWithTensor:axes:descriptor:name:))]
        #[unsafe(method_family = none)]
        pub unsafe fn HermiteanToRealFFTWithTensor_axes_descriptor_name(
            &self,
            tensor: &MPSGraphTensor,
            axes: &NSArray<NSNumber>,
            descriptor: &MPSGraphFFTDescriptor,
            name: Option<&NSString>,
        ) -> Retained<MPSGraphTensor>;

        #[cfg(feature = "MPSGraphTensor")]
        /// Creates a Hermitean-to-real fast Fourier transform operation and returns the result tensor.
        ///
        /// This operation computes the fast Fourier transform of a complex-valued input tensor according to the following formulae.
        /// ```md
        /// output[mu] = scale * sum_nu exp( +/- i * 2Pi * mu * nu / n ) in'[nu], where
        /// ```
        /// `in'[nu] = conjugate(in[n - nu])`, for the last dimension defined by `axes` when `nu` is out of range of the input dimension.
        /// `scale = 1` for `scaling_mode = none`,
        /// `scale = 1/V_f` for `scaling_mode = size`,
        /// `scale = 1/sqrt(V_f)` for `scaling_mode = unitary`, where
        /// `V_f` is the volume of the transformation defined by the dimensions included in `axes`
        /// (`V_f = prod_{i
        /// \in axes} shape(input)[i]`) (see ``MPSGraphFFTDescriptor/scalingMode``),
        /// `+` is selected in `+/-` when `inverse` is specified, otherwise `-` is used
        /// and the sum is done separately over each dimension in `axes` and `n` is the
        /// dimension length of that axis. With this API MPSGraph treats the input tensor to have only the unique
        /// frequencies, which means that the resulting tensor has size `(inSize-1)*2 + x` in the last dimension defined by `axes`,
        /// where `inSize = shape(input)[axis] ( = (n/2)+1 )` is the size of the input `tensor` in the last transformed dimension and
        /// `x = 1` when ``MPSGraphFFTDescriptor/roundToOddHermitean`` = `YES` and `x = 0` otherwise.
        ///
        /// > Tip: Currently MPSGraph supports the transformation only within the last four dimensions of the input tensor. In case
        /// you need to transform higher dimensions than the last four, you can tranpose the higher dimensions of the input
        /// with ``MPSGraph/transposeTensor:permutation:name:``  to be within that last four and then transpose
        /// the result tensor back with the inverse of the input transpose.
        ///
        /// - Parameters:
        /// - tensor: A complex-valued input tensor with reduced size (see Discussion). Must have datatype `MPSDataTypeComplexFloat32` or `MPSDataTypeComplexFloat16`.
        /// - axesTensor: A tensor of rank one containing the axes over which MPSGraph performs the transformation. See ``MPSGraph/fastFourierTransformWithTensor:axes:descriptor:name:``.
        /// - descriptor: A descriptor that defines the parameters of the Fourier transform operation - see ``MPSGraphFFTDescriptor``.
        /// - name: The name for the operation.
        /// - Returns: A valid MPSGraphTensor of type `MPSDataTypeFloat32` or `MPSDataTypeFloat16` (full size).
        #[unsafe(method(HermiteanToRealFFTWithTensor:axesTensor:descriptor:name:))]
        #[unsafe(method_family = none)]
        pub unsafe fn HermiteanToRealFFTWithTensor_axesTensor_descriptor_name(
            &self,
            tensor: &MPSGraphTensor,
            axes_tensor: &MPSGraphTensor,
            descriptor: &MPSGraphFFTDescriptor,
            name: Option<&NSString>,
        ) -> Retained<MPSGraphTensor>;
    );
}