objc2_metal_performance_shaders/generated/MPSMatrix/

MPSMatrixSolve.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 objc2_metal::*;

use crate::*;

extern_class!(
    /// Dependencies: This depends on Metal.framework.
    ///
    ///
    /// A kernel for computing the solution of a linear system of
    /// equations using a triangular coefficient matrix.
    ///
    ///
    /// A MPSMatrixSolveTriangular finds the solution matrix to the
    /// triangular system:
    ///
    /// op(A) * X = alpha * B    or    X * op(A) = alpha * B
    ///
    /// Where A is either upper or lower triangular and op(A) is A**T
    /// or A.  B is the array of right hand sides for which the
    /// equations are to be solved.  X is the resulting matrix of
    /// solutions.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsmatrixsolvetriangular?language=objc)
    #[unsafe(super(MPSMatrixBinaryKernel, MPSKernel, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
    pub struct MPSMatrixSolveTriangular;
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSCoding for MPSMatrixSolveTriangular {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSCopying for MPSMatrixSolveTriangular {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
unsafe impl CopyingHelper for MPSMatrixSolveTriangular {
    type Result = Self;
}

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSObjectProtocol for MPSMatrixSolveTriangular {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSSecureCoding for MPSMatrixSolveTriangular {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveTriangular {
    extern_methods!(
        /// Initialize an MPSMatrixSolveTriangular object on a device
        ///
        ///
        /// Parameter `device`: The device on which the kernel will execute.
        ///
        ///
        /// Parameter `right`: A boolean value which indicates if the
        /// coefficient matrix is multiplied on the left
        /// or right side of the solution.  NO indicates
        /// the multiplication is on the left.
        ///
        ///
        /// Parameter `upper`: A boolean value which indicates if the source
        /// is lower or upper triangular.  NO indicates
        /// that the coefficient matrix is lower triangular.
        ///
        ///
        /// Parameter `transpose`: A boolean value which indicates if the source
        /// matrix should be used in transposed form.  NO
        /// indicates that the coefficient matrix is to be
        /// used normally.
        ///
        ///
        /// Parameter `unit`: A boolean value which indicates if the source
        /// matrix is unit triangular.
        ///
        ///
        /// Parameter `order`: The order of the source matrix and, if
        /// right == NO, the number of rows in the solution
        /// and right hand side matrices.  If right == YES
        /// the number of columns in the solution and right
        /// hand side matrices.
        ///
        ///
        /// Parameter `numberOfRightHandSides`: If right == NO, the number of columns in the
        /// solution and right hand side matrices.  The
        /// number of rows otherwise.
        ///
        ///
        /// Parameter `alpha`: A double precision value used to scale the right
        /// hand sides.
        ///
        ///
        /// This function initializes a MPSMatrixSolveTriangular object.  It
        /// may allocate device side memory.
        ///
        ///
        /// Returns: A valid MPSMatrixSolveTriangular object or nil, if failure.
        #[unsafe(method(initWithDevice:right:upper:transpose:unit:order:numberOfRightHandSides:alpha:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice_right_upper_transpose_unit_order_numberOfRightHandSides_alpha(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
            right: bool,
            upper: bool,
            transpose: bool,
            unit: bool,
            order: NSUInteger,
            number_of_right_hand_sides: NSUInteger,
            alpha: c_double,
        ) -> Retained<Self>;

        /// Encode a MPSMatrixSolveTriangular kernel into a command Buffer.
        ///
        ///
        /// Parameter `commandBuffer`: A valid MTLCommandBuffer to receive the
        /// encoded filter
        ///
        ///
        /// Parameter `sourceMatrix`: A valid MPSMatrix containing the source
        /// matrix.
        ///
        ///
        /// Parameter `rightHandSideMatrix`: A valid MPSMatrix containing the right hand
        /// side values.
        ///
        ///
        /// Parameter `solutionMatrix`: A valid MPSMatrix to contain the result.
        ///
        ///
        /// This function encodes the MPSMatrixSolveTriangular object to a
        /// valid command buffer.
        ///
        /// rightHandSideMatrix and solutionMatrix must be large enough to
        /// hold at least order * numberOfRightHandSides values starting at
        /// secondarySourceMatrixOrigin and resultMatrixOrigin respectively.
        ///
        /// sourceMatrix must be at least size order x order starting at
        /// primarySourceMatrixOrigin.
        #[unsafe(method(encodeToCommandBuffer:sourceMatrix:rightHandSideMatrix:solutionMatrix:))]
        #[unsafe(method_family = none)]
        pub unsafe fn encodeToCommandBuffer_sourceMatrix_rightHandSideMatrix_solutionMatrix(
            &self,
            command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,
            source_matrix: &MPSMatrix,
            right_hand_side_matrix: &MPSMatrix,
            solution_matrix: &MPSMatrix,
        );
    );
}

/// Methods declared on superclass `MPSKernel`.
#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveTriangular {
    extern_methods!(
        /// Standard init with default properties per filter type
        ///
        /// Parameter `device`: The device that the filter will be used on. May not be NULL.
        ///
        /// Returns: a pointer to the newly initialized object. This will fail, returning
        /// nil if the device is not supported. Devices must be
        /// MTLFeatureSet_iOS_GPUFamily2_v1 or later.
        #[unsafe(method(initWithDevice:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
        ) -> Retained<Self>;

        /// Called by NSCoder to decode MPSKernels
        ///
        /// This isn't the right interface to decode a MPSKernel, but
        /// it is the one that NSCoder uses. To enable your NSCoder
        /// (e.g. NSKeyedUnarchiver) to set which device to use
        /// extend the object to adopt the MPSDeviceProvider
        /// protocol. Otherwise, the Metal system default device
        /// will be used.
        ///
        /// # Safety
        ///
        /// `a_decoder` possibly has further requirements.
        #[unsafe(method(initWithCoder:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoder(
            this: Allocated<Self>,
            a_decoder: &NSCoder,
        ) -> Option<Retained<Self>>;

        /// NSSecureCoding compatability
        ///
        /// While the standard NSSecureCoding/NSCoding method
        /// -initWithCoder: should work, since the file can't
        /// know which device your data is allocated on, we
        /// have to guess and may guess incorrectly.  To avoid
        /// that problem, use initWithCoder:device instead.
        ///
        /// Parameter `aDecoder`: The NSCoder subclass with your serialized MPSKernel
        ///
        /// Parameter `device`: The MTLDevice on which to make the MPSKernel
        ///
        /// Returns: A new MPSKernel object, or nil if failure.
        ///
        /// # Safety
        ///
        /// `a_decoder` possibly has further requirements.
        #[unsafe(method(initWithCoder:device:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoder_device(
            this: Allocated<Self>,
            a_decoder: &NSCoder,
            device: &ProtocolObject<dyn MTLDevice>,
        ) -> Option<Retained<Self>>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveTriangular {
    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>;
    );
}

extern_class!(
    /// Dependencies: This depends on Metal.framework.
    ///
    ///
    /// A kernel for computing the solution of a linear system of equations
    /// using the LU factorization resulting from a MPSMatrixDecompositionLU
    /// kernel.
    ///
    ///
    /// A MPSMatrixSolveLU finds the solution matrix to the system:
    ///
    /// op(A) * X = B
    ///
    /// Where op(A) is A**T or A.  B is the array of right hand sides for which
    /// the equations are to be solved.  X is the resulting matrix of solutions.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsmatrixsolvelu?language=objc)
    #[unsafe(super(MPSMatrixBinaryKernel, MPSKernel, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
    pub struct MPSMatrixSolveLU;
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSCoding for MPSMatrixSolveLU {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSCopying for MPSMatrixSolveLU {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
unsafe impl CopyingHelper for MPSMatrixSolveLU {
    type Result = Self;
}

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSObjectProtocol for MPSMatrixSolveLU {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSSecureCoding for MPSMatrixSolveLU {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveLU {
    extern_methods!(
        /// Initialize an MPSMatrixSolveLU object on a device
        ///
        ///
        /// Parameter `device`: The device on which the kernel will execute.
        ///
        ///
        /// Parameter `transpose`: A boolean value which indicates if the source
        /// matrix should be used in transposed form.
        ///
        ///
        /// Parameter `order`: The order of the source matrix and the number of
        /// rows in the solution and right hand side matrices.
        ///
        ///
        /// Parameter `numberOfRightHandSides`: The number of columns in the solution and right hand side
        /// matrices.
        ///
        ///
        /// Returns: A valid MPSMatrixSolveLU object or nil, if failure.
        #[unsafe(method(initWithDevice:transpose:order:numberOfRightHandSides:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice_transpose_order_numberOfRightHandSides(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
            transpose: bool,
            order: NSUInteger,
            number_of_right_hand_sides: NSUInteger,
        ) -> Retained<Self>;

        /// Encode a MPSMatrixSolveLU kernel into a command Buffer.
        ///
        ///
        /// Parameter `commandBuffer`: A valid MTLCommandBuffer to receive the encoded filter
        ///
        ///
        /// Parameter `sourceMatrix`: A valid MPSMatrix containing the source matrix in factored
        /// form as returned by a previous successful execution of a
        /// MPSMatrixDecompositionLU kernel.
        ///
        ///
        /// Parameter `rightHandSideMatrix`: A valid MPSMatrix containing the right hand side values.
        ///
        ///
        /// Parameter `pivotIndices`: A valid MPSMatrix which contains the pivot indices as returned by
        /// a previous successful execution of a MPSMatrixDecompositionLU
        /// kernel.
        ///
        ///
        /// Parameter `solutionMatrix`: A valid MPSMatrix to contain the result.
        ///
        ///
        /// This function encodes the MPSMatrixSolveLU object to a valid command buffer.
        /// sourceMatrix should contain the lower and upper triangular factors of A as
        /// results from a previous execution of MPSMatrixDecompositionLU.
        ///
        /// pivotIndices is an array of pivots resulting from a previous execution of
        /// MPSMatrixDecompositionLU.
        ///
        /// rightHandSideMatrix and solutionMatrix must be large enough to hold a matrix
        /// of size order x numberOfRightHandSides starting at secondarySourceMatrixOrigin and
        /// resultMatrixOrigin respectively.
        ///
        /// sourceMatrix must be at least size order x order starting at primarySourceMatrixOrigin.
        #[unsafe(method(encodeToCommandBuffer:sourceMatrix:rightHandSideMatrix:pivotIndices:solutionMatrix:))]
        #[unsafe(method_family = none)]
        pub unsafe fn encodeToCommandBuffer_sourceMatrix_rightHandSideMatrix_pivotIndices_solutionMatrix(
            &self,
            command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,
            source_matrix: &MPSMatrix,
            right_hand_side_matrix: &MPSMatrix,
            pivot_indices: &MPSMatrix,
            solution_matrix: &MPSMatrix,
        );
    );
}

/// Methods declared on superclass `MPSKernel`.
#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveLU {
    extern_methods!(
        /// Standard init with default properties per filter type
        ///
        /// Parameter `device`: The device that the filter will be used on. May not be NULL.
        ///
        /// Returns: a pointer to the newly initialized object. This will fail, returning
        /// nil if the device is not supported. Devices must be
        /// MTLFeatureSet_iOS_GPUFamily2_v1 or later.
        #[unsafe(method(initWithDevice:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
        ) -> Retained<Self>;

        /// Called by NSCoder to decode MPSKernels
        ///
        /// This isn't the right interface to decode a MPSKernel, but
        /// it is the one that NSCoder uses. To enable your NSCoder
        /// (e.g. NSKeyedUnarchiver) to set which device to use
        /// extend the object to adopt the MPSDeviceProvider
        /// protocol. Otherwise, the Metal system default device
        /// will be used.
        ///
        /// # Safety
        ///
        /// `a_decoder` possibly has further requirements.
        #[unsafe(method(initWithCoder:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoder(
            this: Allocated<Self>,
            a_decoder: &NSCoder,
        ) -> Option<Retained<Self>>;

        /// NSSecureCoding compatability
        ///
        /// While the standard NSSecureCoding/NSCoding method
        /// -initWithCoder: should work, since the file can't
        /// know which device your data is allocated on, we
        /// have to guess and may guess incorrectly.  To avoid
        /// that problem, use initWithCoder:device instead.
        ///
        /// Parameter `aDecoder`: The NSCoder subclass with your serialized MPSKernel
        ///
        /// Parameter `device`: The MTLDevice on which to make the MPSKernel
        ///
        /// Returns: A new MPSKernel object, or nil if failure.
        ///
        /// # Safety
        ///
        /// `a_decoder` possibly has further requirements.
        #[unsafe(method(initWithCoder:device:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoder_device(
            this: Allocated<Self>,
            a_decoder: &NSCoder,
            device: &ProtocolObject<dyn MTLDevice>,
        ) -> Option<Retained<Self>>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveLU {
    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>;
    );
}

extern_class!(
    /// Dependencies: This depends on Metal.framework.
    ///
    ///
    /// A kernel for computing the solution of a linear system of equations
    /// using the Cholesky factorization resulting from a
    /// MPSMatrixDecompositionCholesky kernel.
    ///
    ///
    /// A MPSMatrixSolveCholesky finds the solution matrix to the system:
    ///
    /// A * X = B
    ///
    /// Where A is symmetric positive definite.  B is the array of
    /// right hand sides for which the equations are to be solved.
    /// X is the resulting matrix of solutions.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsmatrixsolvecholesky?language=objc)
    #[unsafe(super(MPSMatrixBinaryKernel, MPSKernel, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
    pub struct MPSMatrixSolveCholesky;
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSCoding for MPSMatrixSolveCholesky {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSCopying for MPSMatrixSolveCholesky {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
unsafe impl CopyingHelper for MPSMatrixSolveCholesky {
    type Result = Self;
}

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSObjectProtocol for MPSMatrixSolveCholesky {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
extern_conformance!(
    unsafe impl NSSecureCoding for MPSMatrixSolveCholesky {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveCholesky {
    extern_methods!(
        /// Initialize an MPSMatrixSolveCholesky object on a device
        ///
        ///
        /// Parameter `device`: The device on which the kernel will execute.
        ///
        ///
        /// Parameter `upper`: A boolean value which indicates if the source
        /// matrix stores the lower or upper triangular
        /// factors.
        ///
        ///
        /// Parameter `order`: The order of the source matrix and the number of
        /// rows in the solution and right hand side matrices.
        ///
        ///
        /// Parameter `numberOfRightHandSides`: The number of columns in the solution and right hand side
        /// matrices.
        ///
        ///
        /// Returns: A valid MPSMatrixSolveCholesky object or nil, if failure.
        #[unsafe(method(initWithDevice:upper:order:numberOfRightHandSides:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice_upper_order_numberOfRightHandSides(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
            upper: bool,
            order: NSUInteger,
            number_of_right_hand_sides: NSUInteger,
        ) -> Retained<Self>;

        /// Encode a MPSMatrixSolveCholesky kernel into a command Buffer.
        ///
        ///
        /// Parameter `commandBuffer`: A valid MTLCommandBuffer to receive the encoded filter
        ///
        ///
        /// Parameter `sourceMatrix`: A valid MPSMatrix containing the source matrix in factored
        /// form as returned by a previous successful execution of a
        /// MPSMatrixDecompositionCholesky kernel.
        ///
        ///
        /// Parameter `rightHandSideMatrix`: A valid MPSMatrix containing the right hand side values.
        ///
        ///
        /// Parameter `solutionMatrix`: A valid MPSMatrix to contain the result.
        ///
        ///
        /// This function encodes the MPSMatrixSolveCholesky object to a valid
        /// command buffer. sourceMatrix should contain either the lower or upper triangular
        /// factors corresponding to the factorization returned by a previous execution
        /// of MPSMatrixDecompositionCholesky.
        ///
        /// rightHandSideMatrix and solutionMatrix must be large enough to hold a matrix
        /// of size order x numberOfRightHandSides starting at secondarySourceMatrixOrigin and
        /// resultMatrixOrigin respectively.
        ///
        /// sourceMatrix must be at least size order x order starting at primarySourceMatrixOrigin.
        #[unsafe(method(encodeToCommandBuffer:sourceMatrix:rightHandSideMatrix:solutionMatrix:))]
        #[unsafe(method_family = none)]
        pub unsafe fn encodeToCommandBuffer_sourceMatrix_rightHandSideMatrix_solutionMatrix(
            &self,
            command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,
            source_matrix: &MPSMatrix,
            right_hand_side_matrix: &MPSMatrix,
            solution_matrix: &MPSMatrix,
        );
    );
}

/// Methods declared on superclass `MPSKernel`.
#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveCholesky {
    extern_methods!(
        /// Standard init with default properties per filter type
        ///
        /// Parameter `device`: The device that the filter will be used on. May not be NULL.
        ///
        /// Returns: a pointer to the newly initialized object. This will fail, returning
        /// nil if the device is not supported. Devices must be
        /// MTLFeatureSet_iOS_GPUFamily2_v1 or later.
        #[unsafe(method(initWithDevice:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
        ) -> Retained<Self>;

        /// Called by NSCoder to decode MPSKernels
        ///
        /// This isn't the right interface to decode a MPSKernel, but
        /// it is the one that NSCoder uses. To enable your NSCoder
        /// (e.g. NSKeyedUnarchiver) to set which device to use
        /// extend the object to adopt the MPSDeviceProvider
        /// protocol. Otherwise, the Metal system default device
        /// will be used.
        ///
        /// # Safety
        ///
        /// `a_decoder` possibly has further requirements.
        #[unsafe(method(initWithCoder:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoder(
            this: Allocated<Self>,
            a_decoder: &NSCoder,
        ) -> Option<Retained<Self>>;

        /// NSSecureCoding compatability
        ///
        /// While the standard NSSecureCoding/NSCoding method
        /// -initWithCoder: should work, since the file can't
        /// know which device your data is allocated on, we
        /// have to guess and may guess incorrectly.  To avoid
        /// that problem, use initWithCoder:device instead.
        ///
        /// Parameter `aDecoder`: The NSCoder subclass with your serialized MPSKernel
        ///
        /// Parameter `device`: The MTLDevice on which to make the MPSKernel
        ///
        /// Returns: A new MPSKernel object, or nil if failure.
        ///
        /// # Safety
        ///
        /// `a_decoder` possibly has further requirements.
        #[unsafe(method(initWithCoder:device:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoder_device(
            this: Allocated<Self>,
            a_decoder: &NSCoder,
            device: &ProtocolObject<dyn MTLDevice>,
        ) -> Option<Retained<Self>>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(all(feature = "MPSCore", feature = "MPSKernel", feature = "MPSMatrixTypes"))]
impl MPSMatrixSolveCholesky {
    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>;
    );
}