1#[repr(C)]
4#[derive(Debug, Copy, Clone)]
5pub struct CUevent_st {
6 _unused: [u8; 0],
7}
8#[repr(C)]
9#[repr(align(8))]
10#[derive(Debug, Copy, Clone)]
11pub struct float2 {
12 pub x: f32,
13 pub y: f32,
14}
15#[allow(clippy::unnecessary_operation, clippy::identity_op)]
16const _: () = {
17 ["Size of float2"][::std::mem::size_of::<float2>() - 8usize];
18 ["Alignment of float2"][::std::mem::align_of::<float2>() - 8usize];
19 ["Offset of field: float2::x"][::std::mem::offset_of!(float2, x) - 0usize];
20 ["Offset of field: float2::y"][::std::mem::offset_of!(float2, y) - 4usize];
21};
22#[doc = " The API call returned with no errors. In the case of query calls, this\n also means that the operation being queried is complete (see\n ::cudaEventQuery() and ::cudaStreamQuery())."]
23pub const cudaError_cudaSuccess: cudaError = 0;
24#[doc = " This indicates that one or more of the parameters passed to the API call\n is not within an acceptable range of values."]
25pub const cudaError_cudaErrorInvalidValue: cudaError = 1;
26#[doc = " The API call failed because it was unable to allocate enough memory to\n perform the requested operation."]
27pub const cudaError_cudaErrorMemoryAllocation: cudaError = 2;
28#[doc = " The API call failed because the CUDA driver and runtime could not be\n initialized."]
29pub const cudaError_cudaErrorInitializationError: cudaError = 3;
30#[doc = " This indicates that a CUDA Runtime API call cannot be executed because\n it is being called during process shut down, at a point in time after\n CUDA driver has been unloaded."]
31pub const cudaError_cudaErrorCudartUnloading: cudaError = 4;
32#[doc = " This indicates profiler is not initialized for this run. This can\n happen when the application is running with external profiling tools\n like visual profiler."]
33pub const cudaError_cudaErrorProfilerDisabled: cudaError = 5;
34#[doc = " \\deprecated\n This error return is deprecated as of CUDA 5.0. It is no longer an error\n to attempt to enable/disable the profiling via ::cudaProfilerStart or\n ::cudaProfilerStop without initialization."]
35pub const cudaError_cudaErrorProfilerNotInitialized: cudaError = 6;
36#[doc = " \\deprecated\n This error return is deprecated as of CUDA 5.0. It is no longer an error\n to call cudaProfilerStart() when profiling is already enabled."]
37pub const cudaError_cudaErrorProfilerAlreadyStarted: cudaError = 7;
38#[doc = " \\deprecated\n This error return is deprecated as of CUDA 5.0. It is no longer an error\n to call cudaProfilerStop() when profiling is already disabled."]
39pub const cudaError_cudaErrorProfilerAlreadyStopped: cudaError = 8;
40#[doc = " This indicates that a kernel launch is requesting resources that can\n never be satisfied by the current device. Requesting more shared memory\n per block than the device supports will trigger this error, as will\n requesting too many threads or blocks. See ::cudaDeviceProp for more\n device limitations."]
41pub const cudaError_cudaErrorInvalidConfiguration: cudaError = 9;
42#[doc = " This indicates that one or more of the pitch-related parameters passed\n to the API call is not within the acceptable range for pitch."]
43pub const cudaError_cudaErrorInvalidPitchValue: cudaError = 12;
44#[doc = " This indicates that the symbol name/identifier passed to the API call\n is not a valid name or identifier."]
45pub const cudaError_cudaErrorInvalidSymbol: cudaError = 13;
46#[doc = " This indicates that at least one host pointer passed to the API call is\n not a valid host pointer.\n \\deprecated\n This error return is deprecated as of CUDA 10.1."]
47pub const cudaError_cudaErrorInvalidHostPointer: cudaError = 16;
48#[doc = " This indicates that at least one device pointer passed to the API call is\n not a valid device pointer.\n \\deprecated\n This error return is deprecated as of CUDA 10.1."]
49pub const cudaError_cudaErrorInvalidDevicePointer: cudaError = 17;
50#[doc = " This indicates that the texture passed to the API call is not a valid\n texture."]
51pub const cudaError_cudaErrorInvalidTexture: cudaError = 18;
52#[doc = " This indicates that the texture binding is not valid. This occurs if you\n call ::cudaGetTextureAlignmentOffset() with an unbound texture."]
53pub const cudaError_cudaErrorInvalidTextureBinding: cudaError = 19;
54#[doc = " This indicates that the channel descriptor passed to the API call is not\n valid. This occurs if the format is not one of the formats specified by\n ::cudaChannelFormatKind, or if one of the dimensions is invalid."]
55pub const cudaError_cudaErrorInvalidChannelDescriptor: cudaError = 20;
56#[doc = " This indicates that the direction of the memcpy passed to the API call is\n not one of the types specified by ::cudaMemcpyKind."]
57pub const cudaError_cudaErrorInvalidMemcpyDirection: cudaError = 21;
58#[doc = " This indicated that the user has taken the address of a constant variable,\n which was forbidden up until the CUDA 3.1 release.\n \\deprecated\n This error return is deprecated as of CUDA 3.1. Variables in constant\n memory may now have their address taken by the runtime via\n ::cudaGetSymbolAddress()."]
59pub const cudaError_cudaErrorAddressOfConstant: cudaError = 22;
60#[doc = " This indicated that a texture fetch was not able to be performed.\n This was previously used for device emulation of texture operations.\n \\deprecated\n This error return is deprecated as of CUDA 3.1. Device emulation mode was\n removed with the CUDA 3.1 release."]
61pub const cudaError_cudaErrorTextureFetchFailed: cudaError = 23;
62#[doc = " This indicated that a texture was not bound for access.\n This was previously used for device emulation of texture operations.\n \\deprecated\n This error return is deprecated as of CUDA 3.1. Device emulation mode was\n removed with the CUDA 3.1 release."]
63pub const cudaError_cudaErrorTextureNotBound: cudaError = 24;
64#[doc = " This indicated that a synchronization operation had failed.\n This was previously used for some device emulation functions.\n \\deprecated\n This error return is deprecated as of CUDA 3.1. Device emulation mode was\n removed with the CUDA 3.1 release."]
65pub const cudaError_cudaErrorSynchronizationError: cudaError = 25;
66#[doc = " This indicates that a non-float texture was being accessed with linear\n filtering. This is not supported by CUDA."]
67pub const cudaError_cudaErrorInvalidFilterSetting: cudaError = 26;
68#[doc = " This indicates that an attempt was made to read a non-float texture as a\n normalized float. This is not supported by CUDA."]
69pub const cudaError_cudaErrorInvalidNormSetting: cudaError = 27;
70#[doc = " Mixing of device and device emulation code was not allowed.\n \\deprecated\n This error return is deprecated as of CUDA 3.1. Device emulation mode was\n removed with the CUDA 3.1 release."]
71pub const cudaError_cudaErrorMixedDeviceExecution: cudaError = 28;
72#[doc = " This indicates that the API call is not yet implemented. Production\n releases of CUDA will never return this error.\n \\deprecated\n This error return is deprecated as of CUDA 4.1."]
73pub const cudaError_cudaErrorNotYetImplemented: cudaError = 31;
74#[doc = " This indicated that an emulated device pointer exceeded the 32-bit address\n range.\n \\deprecated\n This error return is deprecated as of CUDA 3.1. Device emulation mode was\n removed with the CUDA 3.1 release."]
75pub const cudaError_cudaErrorMemoryValueTooLarge: cudaError = 32;
76#[doc = " This indicates that the CUDA driver that the application has loaded is a\n stub library. Applications that run with the stub rather than a real\n driver loaded will result in CUDA API returning this error."]
77pub const cudaError_cudaErrorStubLibrary: cudaError = 34;
78#[doc = " This indicates that the installed NVIDIA CUDA driver is older than the\n CUDA runtime library. This is not a supported configuration. Users should\n install an updated NVIDIA display driver to allow the application to run."]
79pub const cudaError_cudaErrorInsufficientDriver: cudaError = 35;
80#[doc = " This indicates that the API call requires a newer CUDA driver than the one\n currently installed. Users should install an updated NVIDIA CUDA driver\n to allow the API call to succeed."]
81pub const cudaError_cudaErrorCallRequiresNewerDriver: cudaError = 36;
82#[doc = " This indicates that the surface passed to the API call is not a valid\n surface."]
83pub const cudaError_cudaErrorInvalidSurface: cudaError = 37;
84#[doc = " This indicates that multiple global or constant variables (across separate\n CUDA source files in the application) share the same string name."]
85pub const cudaError_cudaErrorDuplicateVariableName: cudaError = 43;
86#[doc = " This indicates that multiple textures (across separate CUDA source\n files in the application) share the same string name."]
87pub const cudaError_cudaErrorDuplicateTextureName: cudaError = 44;
88#[doc = " This indicates that multiple surfaces (across separate CUDA source\n files in the application) share the same string name."]
89pub const cudaError_cudaErrorDuplicateSurfaceName: cudaError = 45;
90#[doc = " This indicates that all CUDA devices are busy or unavailable at the current\n time. Devices are often busy/unavailable due to use of\n ::cudaComputeModeProhibited, ::cudaComputeModeExclusiveProcess, or when long\n running CUDA kernels have filled up the GPU and are blocking new work\n from starting. They can also be unavailable due to memory constraints\n on a device that already has active CUDA work being performed."]
91pub const cudaError_cudaErrorDevicesUnavailable: cudaError = 46;
92#[doc = " This indicates that the current context is not compatible with this\n the CUDA Runtime. This can only occur if you are using CUDA\n Runtime/Driver interoperability and have created an existing Driver\n context using the driver API. The Driver context may be incompatible\n either because the Driver context was created using an older version\n of the API, because the Runtime API call expects a primary driver\n context and the Driver context is not primary, or because the Driver\n context has been destroyed. Please see \\ref CUDART_DRIVER \"Interactions\n with the CUDA Driver API\" for more information."]
93pub const cudaError_cudaErrorIncompatibleDriverContext: cudaError = 49;
94#[doc = " The device function being invoked (usually via ::cudaLaunchKernel()) was not\n previously configured via the ::cudaConfigureCall() function."]
95pub const cudaError_cudaErrorMissingConfiguration: cudaError = 52;
96#[doc = " This indicated that a previous kernel launch failed. This was previously\n used for device emulation of kernel launches.\n \\deprecated\n This error return is deprecated as of CUDA 3.1. Device emulation mode was\n removed with the CUDA 3.1 release."]
97pub const cudaError_cudaErrorPriorLaunchFailure: cudaError = 53;
98#[doc = " This error indicates that a device runtime grid launch did not occur\n because the depth of the child grid would exceed the maximum supported\n number of nested grid launches."]
99pub const cudaError_cudaErrorLaunchMaxDepthExceeded: cudaError = 65;
100#[doc = " This error indicates that a grid launch did not occur because the kernel\n uses file-scoped textures which are unsupported by the device runtime.\n Kernels launched via the device runtime only support textures created with\n the Texture Object API's."]
101pub const cudaError_cudaErrorLaunchFileScopedTex: cudaError = 66;
102#[doc = " This error indicates that a grid launch did not occur because the kernel\n uses file-scoped surfaces which are unsupported by the device runtime.\n Kernels launched via the device runtime only support surfaces created with\n the Surface Object API's."]
103pub const cudaError_cudaErrorLaunchFileScopedSurf: cudaError = 67;
104#[doc = " This error indicates that a call to ::cudaDeviceSynchronize made from\n the device runtime failed because the call was made at grid depth greater\n than than either the default (2 levels of grids) or user specified device\n limit ::cudaLimitDevRuntimeSyncDepth. To be able to synchronize on\n launched grids at a greater depth successfully, the maximum nested\n depth at which ::cudaDeviceSynchronize will be called must be specified\n with the ::cudaLimitDevRuntimeSyncDepth limit to the ::cudaDeviceSetLimit\n api before the host-side launch of a kernel using the device runtime.\n Keep in mind that additional levels of sync depth require the runtime\n to reserve large amounts of device memory that cannot be used for\n user allocations. Note that ::cudaDeviceSynchronize made from device\n runtime is only supported on devices of compute capability < 9.0."]
105pub const cudaError_cudaErrorSyncDepthExceeded: cudaError = 68;
106#[doc = " This error indicates that a device runtime grid launch failed because\n the launch would exceed the limit ::cudaLimitDevRuntimePendingLaunchCount.\n For this launch to proceed successfully, ::cudaDeviceSetLimit must be\n called to set the ::cudaLimitDevRuntimePendingLaunchCount to be higher\n than the upper bound of outstanding launches that can be issued to the\n device runtime. Keep in mind that raising the limit of pending device\n runtime launches will require the runtime to reserve device memory that\n cannot be used for user allocations."]
107pub const cudaError_cudaErrorLaunchPendingCountExceeded: cudaError = 69;
108#[doc = " The requested device function does not exist or is not compiled for the\n proper device architecture."]
109pub const cudaError_cudaErrorInvalidDeviceFunction: cudaError = 98;
110#[doc = " This indicates that no CUDA-capable devices were detected by the installed\n CUDA driver."]
111pub const cudaError_cudaErrorNoDevice: cudaError = 100;
112#[doc = " This indicates that the device ordinal supplied by the user does not\n correspond to a valid CUDA device or that the action requested is\n invalid for the specified device."]
113pub const cudaError_cudaErrorInvalidDevice: cudaError = 101;
114#[doc = " This indicates that the device doesn't have a valid Grid License."]
115pub const cudaError_cudaErrorDeviceNotLicensed: cudaError = 102;
116#[doc = " By default, the CUDA runtime may perform a minimal set of self-tests,\n as well as CUDA driver tests, to establish the validity of both.\n Introduced in CUDA 11.2, this error return indicates that at least one\n of these tests has failed and the validity of either the runtime\n or the driver could not be established."]
117pub const cudaError_cudaErrorSoftwareValidityNotEstablished: cudaError = 103;
118#[doc = " This indicates an internal startup failure in the CUDA runtime."]
119pub const cudaError_cudaErrorStartupFailure: cudaError = 127;
120#[doc = " This indicates that the device kernel image is invalid."]
121pub const cudaError_cudaErrorInvalidKernelImage: cudaError = 200;
122#[doc = " This most frequently indicates that there is no context bound to the\n current thread. This can also be returned if the context passed to an\n API call is not a valid handle (such as a context that has had\n ::cuCtxDestroy() invoked on it). This can also be returned if a user\n mixes different API versions (i.e. 3010 context with 3020 API calls).\n See ::cuCtxGetApiVersion() for more details."]
123pub const cudaError_cudaErrorDeviceUninitialized: cudaError = 201;
124#[doc = " This indicates that the buffer object could not be mapped."]
125pub const cudaError_cudaErrorMapBufferObjectFailed: cudaError = 205;
126#[doc = " This indicates that the buffer object could not be unmapped."]
127pub const cudaError_cudaErrorUnmapBufferObjectFailed: cudaError = 206;
128#[doc = " This indicates that the specified array is currently mapped and thus\n cannot be destroyed."]
129pub const cudaError_cudaErrorArrayIsMapped: cudaError = 207;
130#[doc = " This indicates that the resource is already mapped."]
131pub const cudaError_cudaErrorAlreadyMapped: cudaError = 208;
132#[doc = " This indicates that there is no kernel image available that is suitable\n for the device. This can occur when a user specifies code generation\n options for a particular CUDA source file that do not include the\n corresponding device configuration."]
133pub const cudaError_cudaErrorNoKernelImageForDevice: cudaError = 209;
134#[doc = " This indicates that a resource has already been acquired."]
135pub const cudaError_cudaErrorAlreadyAcquired: cudaError = 210;
136#[doc = " This indicates that a resource is not mapped."]
137pub const cudaError_cudaErrorNotMapped: cudaError = 211;
138#[doc = " This indicates that a mapped resource is not available for access as an\n array."]
139pub const cudaError_cudaErrorNotMappedAsArray: cudaError = 212;
140#[doc = " This indicates that a mapped resource is not available for access as a\n pointer."]
141pub const cudaError_cudaErrorNotMappedAsPointer: cudaError = 213;
142#[doc = " This indicates that an uncorrectable ECC error was detected during\n execution."]
143pub const cudaError_cudaErrorECCUncorrectable: cudaError = 214;
144#[doc = " This indicates that the ::cudaLimit passed to the API call is not\n supported by the active device."]
145pub const cudaError_cudaErrorUnsupportedLimit: cudaError = 215;
146#[doc = " This indicates that a call tried to access an exclusive-thread device that\n is already in use by a different thread."]
147pub const cudaError_cudaErrorDeviceAlreadyInUse: cudaError = 216;
148#[doc = " This error indicates that P2P access is not supported across the given\n devices."]
149pub const cudaError_cudaErrorPeerAccessUnsupported: cudaError = 217;
150#[doc = " A PTX compilation failed. The runtime may fall back to compiling PTX if\n an application does not contain a suitable binary for the current device."]
151pub const cudaError_cudaErrorInvalidPtx: cudaError = 218;
152#[doc = " This indicates an error with the OpenGL or DirectX context."]
153pub const cudaError_cudaErrorInvalidGraphicsContext: cudaError = 219;
154#[doc = " This indicates that an uncorrectable NVLink error was detected during the\n execution."]
155pub const cudaError_cudaErrorNvlinkUncorrectable: cudaError = 220;
156#[doc = " This indicates that the PTX JIT compiler library was not found. The JIT Compiler\n library is used for PTX compilation. The runtime may fall back to compiling PTX\n if an application does not contain a suitable binary for the current device."]
157pub const cudaError_cudaErrorJitCompilerNotFound: cudaError = 221;
158#[doc = " This indicates that the provided PTX was compiled with an unsupported toolchain.\n The most common reason for this, is the PTX was generated by a compiler newer\n than what is supported by the CUDA driver and PTX JIT compiler."]
159pub const cudaError_cudaErrorUnsupportedPtxVersion: cudaError = 222;
160#[doc = " This indicates that the JIT compilation was disabled. The JIT compilation compiles\n PTX. The runtime may fall back to compiling PTX if an application does not contain\n a suitable binary for the current device."]
161pub const cudaError_cudaErrorJitCompilationDisabled: cudaError = 223;
162#[doc = " This indicates that the provided execution affinity is not supported by the device."]
163pub const cudaError_cudaErrorUnsupportedExecAffinity: cudaError = 224;
164#[doc = " This indicates that the code to be compiled by the PTX JIT contains\n unsupported call to cudaDeviceSynchronize."]
165pub const cudaError_cudaErrorUnsupportedDevSideSync: cudaError = 225;
166#[doc = " This indicates that the device kernel source is invalid."]
167pub const cudaError_cudaErrorInvalidSource: cudaError = 300;
168#[doc = " This indicates that the file specified was not found."]
169pub const cudaError_cudaErrorFileNotFound: cudaError = 301;
170#[doc = " This indicates that a link to a shared object failed to resolve."]
171pub const cudaError_cudaErrorSharedObjectSymbolNotFound: cudaError = 302;
172#[doc = " This indicates that initialization of a shared object failed."]
173pub const cudaError_cudaErrorSharedObjectInitFailed: cudaError = 303;
174#[doc = " This error indicates that an OS call failed."]
175pub const cudaError_cudaErrorOperatingSystem: cudaError = 304;
176#[doc = " This indicates that a resource handle passed to the API call was not\n valid. Resource handles are opaque types like ::cudaStream_t and\n ::cudaEvent_t."]
177pub const cudaError_cudaErrorInvalidResourceHandle: cudaError = 400;
178#[doc = " This indicates that a resource required by the API call is not in a\n valid state to perform the requested operation."]
179pub const cudaError_cudaErrorIllegalState: cudaError = 401;
180#[doc = " This indicates that a named symbol was not found. Examples of symbols\n are global/constant variable names, driver function names, texture names,\n and surface names."]
181pub const cudaError_cudaErrorSymbolNotFound: cudaError = 500;
182#[doc = " This indicates that asynchronous operations issued previously have not\n completed yet. This result is not actually an error, but must be indicated\n differently than ::cudaSuccess (which indicates completion). Calls that\n may return this value include ::cudaEventQuery() and ::cudaStreamQuery()."]
183pub const cudaError_cudaErrorNotReady: cudaError = 600;
184#[doc = " The device encountered a load or store instruction on an invalid memory address.\n This leaves the process in an inconsistent state and any further CUDA work\n will return the same error. To continue using CUDA, the process must be terminated\n and relaunched."]
185pub const cudaError_cudaErrorIllegalAddress: cudaError = 700;
186#[doc = " This indicates that a launch did not occur because it did not have\n appropriate resources. Although this error is similar to\n ::cudaErrorInvalidConfiguration, this error usually indicates that the\n user has attempted to pass too many arguments to the device kernel, or the\n kernel launch specifies too many threads for the kernel's register count."]
187pub const cudaError_cudaErrorLaunchOutOfResources: cudaError = 701;
188#[doc = " This indicates that the device kernel took too long to execute. This can\n only occur if timeouts are enabled - see the device property\n \\ref ::cudaDeviceProp::kernelExecTimeoutEnabled \"kernelExecTimeoutEnabled\"\n for more information.\n This leaves the process in an inconsistent state and any further CUDA work\n will return the same error. To continue using CUDA, the process must be terminated\n and relaunched."]
189pub const cudaError_cudaErrorLaunchTimeout: cudaError = 702;
190#[doc = " This error indicates a kernel launch that uses an incompatible texturing\n mode."]
191pub const cudaError_cudaErrorLaunchIncompatibleTexturing: cudaError = 703;
192#[doc = " This error indicates that a call to ::cudaDeviceEnablePeerAccess() is\n trying to re-enable peer addressing on from a context which has already\n had peer addressing enabled."]
193pub const cudaError_cudaErrorPeerAccessAlreadyEnabled: cudaError = 704;
194#[doc = " This error indicates that ::cudaDeviceDisablePeerAccess() is trying to\n disable peer addressing which has not been enabled yet via\n ::cudaDeviceEnablePeerAccess()."]
195pub const cudaError_cudaErrorPeerAccessNotEnabled: cudaError = 705;
196#[doc = " This indicates that the user has called ::cudaSetValidDevices(),\n ::cudaSetDeviceFlags(), ::cudaD3D9SetDirect3DDevice(),\n ::cudaD3D10SetDirect3DDevice, ::cudaD3D11SetDirect3DDevice(), or\n ::cudaVDPAUSetVDPAUDevice() after initializing the CUDA runtime by\n calling non-device management operations (allocating memory and\n launching kernels are examples of non-device management operations).\n This error can also be returned if using runtime/driver\n interoperability and there is an existing ::CUcontext active on the\n host thread."]
197pub const cudaError_cudaErrorSetOnActiveProcess: cudaError = 708;
198#[doc = " This error indicates that the context current to the calling thread\n has been destroyed using ::cuCtxDestroy, or is a primary context which\n has not yet been initialized."]
199pub const cudaError_cudaErrorContextIsDestroyed: cudaError = 709;
200#[doc = " An assert triggered in device code during kernel execution. The device\n cannot be used again. All existing allocations are invalid. To continue\n using CUDA, the process must be terminated and relaunched."]
201pub const cudaError_cudaErrorAssert: cudaError = 710;
202#[doc = " This error indicates that the hardware resources required to enable\n peer access have been exhausted for one or more of the devices\n passed to ::cudaEnablePeerAccess()."]
203pub const cudaError_cudaErrorTooManyPeers: cudaError = 711;
204#[doc = " This error indicates that the memory range passed to ::cudaHostRegister()\n has already been registered."]
205pub const cudaError_cudaErrorHostMemoryAlreadyRegistered: cudaError = 712;
206#[doc = " This error indicates that the pointer passed to ::cudaHostUnregister()\n does not correspond to any currently registered memory region."]
207pub const cudaError_cudaErrorHostMemoryNotRegistered: cudaError = 713;
208#[doc = " Device encountered an error in the call stack during kernel execution,\n possibly due to stack corruption or exceeding the stack size limit.\n This leaves the process in an inconsistent state and any further CUDA work\n will return the same error. To continue using CUDA, the process must be terminated\n and relaunched."]
209pub const cudaError_cudaErrorHardwareStackError: cudaError = 714;
210#[doc = " The device encountered an illegal instruction during kernel execution\n This leaves the process in an inconsistent state and any further CUDA work\n will return the same error. To continue using CUDA, the process must be terminated\n and relaunched."]
211pub const cudaError_cudaErrorIllegalInstruction: cudaError = 715;
212#[doc = " The device encountered a load or store instruction\n on a memory address which is not aligned.\n This leaves the process in an inconsistent state and any further CUDA work\n will return the same error. To continue using CUDA, the process must be terminated\n and relaunched."]
213pub const cudaError_cudaErrorMisalignedAddress: cudaError = 716;
214#[doc = " While executing a kernel, the device encountered an instruction\n which can only operate on memory locations in certain address spaces\n (global, shared, or local), but was supplied a memory address not\n belonging to an allowed address space.\n This leaves the process in an inconsistent state and any further CUDA work\n will return the same error. To continue using CUDA, the process must be terminated\n and relaunched."]
215pub const cudaError_cudaErrorInvalidAddressSpace: cudaError = 717;
216#[doc = " The device encountered an invalid program counter.\n This leaves the process in an inconsistent state and any further CUDA work\n will return the same error. To continue using CUDA, the process must be terminated\n and relaunched."]
217pub const cudaError_cudaErrorInvalidPc: cudaError = 718;
218#[doc = " An exception occurred on the device while executing a kernel. Common\n causes include dereferencing an invalid device pointer and accessing\n out of bounds shared memory. Less common cases can be system specific - more\n information about these cases can be found in the system specific user guide.\n This leaves the process in an inconsistent state and any further CUDA work\n will return the same error. To continue using CUDA, the process must be terminated\n and relaunched."]
219pub const cudaError_cudaErrorLaunchFailure: cudaError = 719;
220#[doc = " This error indicates that the number of blocks launched per grid for a kernel that was\n launched via either ::cudaLaunchCooperativeKernel or ::cudaLaunchCooperativeKernelMultiDevice\n exceeds the maximum number of blocks as allowed by ::cudaOccupancyMaxActiveBlocksPerMultiprocessor\n or ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags times the number of multiprocessors\n as specified by the device attribute ::cudaDevAttrMultiProcessorCount."]
221pub const cudaError_cudaErrorCooperativeLaunchTooLarge: cudaError = 720;
222#[doc = " This error indicates the attempted operation is not permitted."]
223pub const cudaError_cudaErrorNotPermitted: cudaError = 800;
224#[doc = " This error indicates the attempted operation is not supported\n on the current system or device."]
225pub const cudaError_cudaErrorNotSupported: cudaError = 801;
226#[doc = " This error indicates that the system is not yet ready to start any CUDA\n work. To continue using CUDA, verify the system configuration is in a\n valid state and all required driver daemons are actively running.\n More information about this error can be found in the system specific\n user guide."]
227pub const cudaError_cudaErrorSystemNotReady: cudaError = 802;
228#[doc = " This error indicates that there is a mismatch between the versions of\n the display driver and the CUDA driver. Refer to the compatibility documentation\n for supported versions."]
229pub const cudaError_cudaErrorSystemDriverMismatch: cudaError = 803;
230#[doc = " This error indicates that the system was upgraded to run with forward compatibility\n but the visible hardware detected by CUDA does not support this configuration.\n Refer to the compatibility documentation for the supported hardware matrix or ensure\n that only supported hardware is visible during initialization via the CUDA_VISIBLE_DEVICES\n environment variable."]
231pub const cudaError_cudaErrorCompatNotSupportedOnDevice: cudaError = 804;
232#[doc = " This error indicates that the MPS client failed to connect to the MPS control daemon or the MPS server."]
233pub const cudaError_cudaErrorMpsConnectionFailed: cudaError = 805;
234#[doc = " This error indicates that the remote procedural call between the MPS server and the MPS client failed."]
235pub const cudaError_cudaErrorMpsRpcFailure: cudaError = 806;
236#[doc = " This error indicates that the MPS server is not ready to accept new MPS client requests.\n This error can be returned when the MPS server is in the process of recovering from a fatal failure."]
237pub const cudaError_cudaErrorMpsServerNotReady: cudaError = 807;
238#[doc = " This error indicates that the hardware resources required to create MPS client have been exhausted."]
239pub const cudaError_cudaErrorMpsMaxClientsReached: cudaError = 808;
240#[doc = " This error indicates the the hardware resources required to device connections have been exhausted."]
241pub const cudaError_cudaErrorMpsMaxConnectionsReached: cudaError = 809;
242#[doc = " This error indicates that the MPS client has been terminated by the server. To continue using CUDA, the process must be terminated and relaunched."]
243pub const cudaError_cudaErrorMpsClientTerminated: cudaError = 810;
244#[doc = " This error indicates, that the program is using CUDA Dynamic Parallelism, but the current configuration, like MPS, does not support it."]
245pub const cudaError_cudaErrorCdpNotSupported: cudaError = 811;
246#[doc = " This error indicates, that the program contains an unsupported interaction between different versions of CUDA Dynamic Parallelism."]
247pub const cudaError_cudaErrorCdpVersionMismatch: cudaError = 812;
248#[doc = " The operation is not permitted when the stream is capturing."]
249pub const cudaError_cudaErrorStreamCaptureUnsupported: cudaError = 900;
250#[doc = " The current capture sequence on the stream has been invalidated due to\n a previous error."]
251pub const cudaError_cudaErrorStreamCaptureInvalidated: cudaError = 901;
252#[doc = " The operation would have resulted in a merge of two independent capture\n sequences."]
253pub const cudaError_cudaErrorStreamCaptureMerge: cudaError = 902;
254#[doc = " The capture was not initiated in this stream."]
255pub const cudaError_cudaErrorStreamCaptureUnmatched: cudaError = 903;
256#[doc = " The capture sequence contains a fork that was not joined to the primary\n stream."]
257pub const cudaError_cudaErrorStreamCaptureUnjoined: cudaError = 904;
258#[doc = " A dependency would have been created which crosses the capture sequence\n boundary. Only implicit in-stream ordering dependencies are allowed to\n cross the boundary."]
259pub const cudaError_cudaErrorStreamCaptureIsolation: cudaError = 905;
260#[doc = " The operation would have resulted in a disallowed implicit dependency on\n a current capture sequence from cudaStreamLegacy."]
261pub const cudaError_cudaErrorStreamCaptureImplicit: cudaError = 906;
262#[doc = " The operation is not permitted on an event which was last recorded in a\n capturing stream."]
263pub const cudaError_cudaErrorCapturedEvent: cudaError = 907;
264#[doc = " A stream capture sequence not initiated with the ::cudaStreamCaptureModeRelaxed\n argument to ::cudaStreamBeginCapture was passed to ::cudaStreamEndCapture in a\n different thread."]
265pub const cudaError_cudaErrorStreamCaptureWrongThread: cudaError = 908;
266#[doc = " This indicates that the wait operation has timed out."]
267pub const cudaError_cudaErrorTimeout: cudaError = 909;
268#[doc = " This error indicates that the graph update was not performed because it included\n changes which violated constraints specific to instantiated graph update."]
269pub const cudaError_cudaErrorGraphExecUpdateFailure: cudaError = 910;
270#[doc = " This indicates that an async error has occurred in a device outside of CUDA.\n If CUDA was waiting for an external device's signal before consuming shared data,\n the external device signaled an error indicating that the data is not valid for\n consumption. This leaves the process in an inconsistent state and any further CUDA\n work will return the same error. To continue using CUDA, the process must be\n terminated and relaunched."]
271pub const cudaError_cudaErrorExternalDevice: cudaError = 911;
272#[doc = " This indicates that a kernel launch error has occurred due to cluster\n misconfiguration."]
273pub const cudaError_cudaErrorInvalidClusterSize: cudaError = 912;
274#[doc = " This indicates that an unknown internal error has occurred."]
275pub const cudaError_cudaErrorUnknown: cudaError = 999;
276#[doc = " Any unhandled CUDA driver error is added to this value and returned via\n the runtime. Production releases of CUDA should not return such errors.\n \\deprecated\n This error return is deprecated as of CUDA 4.1."]
277pub const cudaError_cudaErrorApiFailureBase: cudaError = 10000;
278#[doc = " CUDA error types"]
279pub type cudaError = ::std::os::raw::c_uint;
280#[doc = " CUDA Error types"]
281pub use self::cudaError as cudaError_t;
282#[doc = " CUDA event types"]
283pub type cudaEvent_t = *mut CUevent_st;
284#[doc = " CURAND XORWOW state"]
285#[repr(C)]
286#[derive(Debug, Copy, Clone)]
287pub struct curandStateXORWOW {
288 pub d: ::std::os::raw::c_uint,
289 pub v: [::std::os::raw::c_uint; 5usize],
290 pub boxmuller_flag: ::std::os::raw::c_int,
291 pub boxmuller_flag_double: ::std::os::raw::c_int,
292 pub boxmuller_extra: f32,
293 pub boxmuller_extra_double: f64,
294}
295#[allow(clippy::unnecessary_operation, clippy::identity_op)]
296const _: () = {
297 ["Size of curandStateXORWOW"][::std::mem::size_of::<curandStateXORWOW>() - 48usize];
298 ["Alignment of curandStateXORWOW"][::std::mem::align_of::<curandStateXORWOW>() - 8usize];
299 ["Offset of field: curandStateXORWOW::d"]
300 [::std::mem::offset_of!(curandStateXORWOW, d) - 0usize];
301 ["Offset of field: curandStateXORWOW::v"]
302 [::std::mem::offset_of!(curandStateXORWOW, v) - 4usize];
303 ["Offset of field: curandStateXORWOW::boxmuller_flag"]
304 [::std::mem::offset_of!(curandStateXORWOW, boxmuller_flag) - 24usize];
305 ["Offset of field: curandStateXORWOW::boxmuller_flag_double"]
306 [::std::mem::offset_of!(curandStateXORWOW, boxmuller_flag_double) - 28usize];
307 ["Offset of field: curandStateXORWOW::boxmuller_extra"]
308 [::std::mem::offset_of!(curandStateXORWOW, boxmuller_extra) - 32usize];
309 ["Offset of field: curandStateXORWOW::boxmuller_extra_double"]
310 [::std::mem::offset_of!(curandStateXORWOW, boxmuller_extra_double) - 40usize];
311};
312#[doc = " CURAND XORWOW state"]
313pub type curandState = curandStateXORWOW;
314pub type cufftHandle = ::std::os::raw::c_int;
315pub const cublasStatus_t_CUBLAS_STATUS_SUCCESS: cublasStatus_t = 0;
316pub const cublasStatus_t_CUBLAS_STATUS_NOT_INITIALIZED: cublasStatus_t = 1;
317pub const cublasStatus_t_CUBLAS_STATUS_ALLOC_FAILED: cublasStatus_t = 3;
318pub const cublasStatus_t_CUBLAS_STATUS_INVALID_VALUE: cublasStatus_t = 7;
319pub const cublasStatus_t_CUBLAS_STATUS_ARCH_MISMATCH: cublasStatus_t = 8;
320pub const cublasStatus_t_CUBLAS_STATUS_MAPPING_ERROR: cublasStatus_t = 11;
321pub const cublasStatus_t_CUBLAS_STATUS_EXECUTION_FAILED: cublasStatus_t = 13;
322pub const cublasStatus_t_CUBLAS_STATUS_INTERNAL_ERROR: cublasStatus_t = 14;
323pub const cublasStatus_t_CUBLAS_STATUS_NOT_SUPPORTED: cublasStatus_t = 15;
324pub const cublasStatus_t_CUBLAS_STATUS_LICENSE_ERROR: cublasStatus_t = 16;
325pub type cublasStatus_t = ::std::os::raw::c_uint;
326#[repr(C)]
327#[derive(Debug, Copy, Clone)]
328pub struct cublasContext {
329 _unused: [u8; 0],
330}
331pub type cublasHandle_t = *mut cublasContext;
332#[repr(C)]
333#[derive(Debug, Copy, Clone)]
334pub struct cusparseContext {
335 _unused: [u8; 0],
336}
337pub type cusparseHandle_t = *mut cusparseContext;
338#[repr(C)]
339#[derive(Debug, Copy, Clone)]
340pub struct cusparseMatDescr {
341 _unused: [u8; 0],
342}
343pub type cusparseMatDescr_t = *mut cusparseMatDescr;
344pub const cusparseStatus_t_CUSPARSE_STATUS_SUCCESS: cusparseStatus_t = 0;
345pub const cusparseStatus_t_CUSPARSE_STATUS_NOT_INITIALIZED: cusparseStatus_t = 1;
346pub const cusparseStatus_t_CUSPARSE_STATUS_ALLOC_FAILED: cusparseStatus_t = 2;
347pub const cusparseStatus_t_CUSPARSE_STATUS_INVALID_VALUE: cusparseStatus_t = 3;
348pub const cusparseStatus_t_CUSPARSE_STATUS_ARCH_MISMATCH: cusparseStatus_t = 4;
349pub const cusparseStatus_t_CUSPARSE_STATUS_MAPPING_ERROR: cusparseStatus_t = 5;
350pub const cusparseStatus_t_CUSPARSE_STATUS_EXECUTION_FAILED: cusparseStatus_t = 6;
351pub const cusparseStatus_t_CUSPARSE_STATUS_INTERNAL_ERROR: cusparseStatus_t = 7;
352pub const cusparseStatus_t_CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED: cusparseStatus_t = 8;
353pub const cusparseStatus_t_CUSPARSE_STATUS_ZERO_PIVOT: cusparseStatus_t = 9;
354pub const cusparseStatus_t_CUSPARSE_STATUS_NOT_SUPPORTED: cusparseStatus_t = 10;
355pub const cusparseStatus_t_CUSPARSE_STATUS_INSUFFICIENT_RESOURCES: cusparseStatus_t = 11;
356pub type cusparseStatus_t = ::std::os::raw::c_uint;
357#[repr(C)]
358#[derive(Debug, Copy, Clone)]
359pub struct cusolverDnContext {
360 _unused: [u8; 0],
361}
362pub type cusolverDnHandle_t = *mut cusolverDnContext;
363extern "C" {
364 #[link_name = "\u{1}_Z10set_devicei"]
365 pub fn set_device(id: ::std::os::raw::c_int);
366}
367extern "C" {
368 #[link_name = "\u{1}_Z16get_device_countv"]
369 pub fn get_device_count() -> ::std::os::raw::c_int;
370}
371pub type rtd = f64;
372#[repr(C)]
373#[derive(Debug, Copy, Clone)]
374pub struct vector {
375 pub x: rtd,
376 pub y: rtd,
377 pub z: rtd,
378}
379#[allow(clippy::unnecessary_operation, clippy::identity_op)]
380const _: () = {
381 ["Size of vector"][::std::mem::size_of::<vector>() - 24usize];
382 ["Alignment of vector"][::std::mem::align_of::<vector>() - 8usize];
383 ["Offset of field: vector::x"][::std::mem::offset_of!(vector, x) - 0usize];
384 ["Offset of field: vector::y"][::std::mem::offset_of!(vector, y) - 8usize];
385 ["Offset of field: vector::z"][::std::mem::offset_of!(vector, z) - 16usize];
386};
387extern "C" {
388 #[link_name = "\u{1}_ZN6vector4rho2Ev"]
389 pub fn vector_rho2(this: *mut vector) -> rtd;
390}
391extern "C" {
392 #[link_name = "\u{1}_ZN6vector10rho2_shiftEdd"]
393 pub fn vector_rho2_shift(this: *mut vector, x0: rtd, y0: rtd) -> rtd;
394}
395extern "C" {
396 #[link_name = "\u{1}_ZN6vector3magEv"]
397 pub fn vector_mag(this: *mut vector) -> rtd;
398}
399extern "C" {
400 #[link_name = "\u{1}_ZN6vector3magEd"]
401 pub fn vector_mag1(this: *mut vector, R: rtd) -> rtd;
402}
403extern "C" {
404 #[link_name = "\u{1}_ZN6vector5angleEv"]
405 pub fn vector_angle(this: *mut vector) -> rtd;
406}
407extern "C" {
408 #[link_name = "\u{1}_ZN6vector4normEv"]
409 pub fn vector_norm(this: *mut vector) -> rtd;
410}
411extern "C" {
412 #[link_name = "\u{1}_ZN6vector3dotEPS_"]
413 pub fn vector_dot(this: *mut vector, u: *mut vector) -> rtd;
414}
415extern "C" {
416 #[link_name = "\u{1}_ZN6vector4unitEv"]
417 pub fn vector_unit(this: *mut vector);
418}
419extern "C" {
420 #[link_name = "\u{1}_ZN6vector10left_crossEPS_S0_"]
421 pub fn vector_left_cross(this: *mut vector, w: *mut vector, u: *mut vector);
422}
423extern "C" {
424 #[link_name = "\u{1}_ZN6vector11right_crossEPS_S0_"]
425 pub fn vector_right_cross(this: *mut vector, w: *mut vector, u: *mut vector);
426}
427impl vector {
428 #[inline]
429 pub unsafe fn rho2(&mut self) -> rtd {
430 vector_rho2(self)
431 }
432 #[inline]
433 pub unsafe fn rho2_shift(&mut self, x0: rtd, y0: rtd) -> rtd {
434 vector_rho2_shift(self, x0, y0)
435 }
436 #[inline]
437 pub unsafe fn mag(&mut self) -> rtd {
438 vector_mag(self)
439 }
440 #[inline]
441 pub unsafe fn mag1(&mut self, R: rtd) -> rtd {
442 vector_mag1(self, R)
443 }
444 #[inline]
445 pub unsafe fn angle(&mut self) -> rtd {
446 vector_angle(self)
447 }
448 #[inline]
449 pub unsafe fn norm(&mut self) -> rtd {
450 vector_norm(self)
451 }
452 #[inline]
453 pub unsafe fn dot(&mut self, u: *mut vector) -> rtd {
454 vector_dot(self, u)
455 }
456 #[inline]
457 pub unsafe fn unit(&mut self) {
458 vector_unit(self)
459 }
460 #[inline]
461 pub unsafe fn left_cross(&mut self, w: *mut vector, u: *mut vector) {
462 vector_left_cross(self, w, u)
463 }
464 #[inline]
465 pub unsafe fn right_cross(&mut self, w: *mut vector, u: *mut vector) {
466 vector_right_cross(self, w, u)
467 }
468}
469#[repr(C)]
470#[derive(Debug, Copy, Clone)]
471pub struct stopwatch {
472 pub elapsedTime: f32,
473 pub start: cudaEvent_t,
474 pub stop: cudaEvent_t,
475}
476#[allow(clippy::unnecessary_operation, clippy::identity_op)]
477const _: () = {
478 ["Size of stopwatch"][::std::mem::size_of::<stopwatch>() - 24usize];
479 ["Alignment of stopwatch"][::std::mem::align_of::<stopwatch>() - 8usize];
480 ["Offset of field: stopwatch::elapsedTime"]
481 [::std::mem::offset_of!(stopwatch, elapsedTime) - 0usize];
482 ["Offset of field: stopwatch::start"][::std::mem::offset_of!(stopwatch, start) - 8usize];
483 ["Offset of field: stopwatch::stop"][::std::mem::offset_of!(stopwatch, stop) - 16usize];
484};
485#[repr(C)]
486#[derive(Debug, Copy, Clone)]
487pub struct mask {
488 pub m: *mut ::std::os::raw::c_char,
489 pub f: *mut f32,
490 pub idx: *mut ::std::os::raw::c_int,
491 pub size_px: [::std::os::raw::c_int; 2usize],
492 pub nel: ::std::os::raw::c_int,
493 pub nnz: f32,
494 pub size_m: [f32; 2usize],
495 pub area: f32,
496 pub delta: [f32; 2usize],
497 pub handle: cublasHandle_t,
498 pub d__piston_mask: *mut ::std::os::raw::c_int,
499}
500#[allow(clippy::unnecessary_operation, clippy::identity_op)]
501const _: () = {
502 ["Size of mask"][::std::mem::size_of::<mask>() - 80usize];
503 ["Alignment of mask"][::std::mem::align_of::<mask>() - 8usize];
504 ["Offset of field: mask::m"][::std::mem::offset_of!(mask, m) - 0usize];
505 ["Offset of field: mask::f"][::std::mem::offset_of!(mask, f) - 8usize];
506 ["Offset of field: mask::idx"][::std::mem::offset_of!(mask, idx) - 16usize];
507 ["Offset of field: mask::size_px"][::std::mem::offset_of!(mask, size_px) - 24usize];
508 ["Offset of field: mask::nel"][::std::mem::offset_of!(mask, nel) - 32usize];
509 ["Offset of field: mask::nnz"][::std::mem::offset_of!(mask, nnz) - 36usize];
510 ["Offset of field: mask::size_m"][::std::mem::offset_of!(mask, size_m) - 40usize];
511 ["Offset of field: mask::area"][::std::mem::offset_of!(mask, area) - 48usize];
512 ["Offset of field: mask::delta"][::std::mem::offset_of!(mask, delta) - 52usize];
513 ["Offset of field: mask::handle"][::std::mem::offset_of!(mask, handle) - 64usize];
514 ["Offset of field: mask::d__piston_mask"]
515 [::std::mem::offset_of!(mask, d__piston_mask) - 72usize];
516};
517extern "C" {
518 #[link_name = "\u{1}_ZN4mask5setupEi"]
519 pub fn mask_setup(this: *mut mask, n: ::std::os::raw::c_int);
520}
521extern "C" {
522 #[link_name = "\u{1}_ZN4mask5setupEif"]
523 pub fn mask_setup1(this: *mut mask, n: ::std::os::raw::c_int, L: f32);
524}
525extern "C" {
526 #[link_name = "\u{1}_ZN4mask5setupEifiii"]
527 pub fn mask_setup2(
528 this: *mut mask,
529 n: ::std::os::raw::c_int,
530 L: f32,
531 i_s: ::std::os::raw::c_int,
532 j_s: ::std::os::raw::c_int,
533 n_out: ::std::os::raw::c_int,
534 );
535}
536extern "C" {
537 #[link_name = "\u{1}_ZN4mask5setupEfffffffi"]
538 pub fn mask_setup3(
539 this: *mut mask,
540 n: f32,
541 L: f32,
542 i_0: f32,
543 j_0: f32,
544 theta: f32,
545 i_s: f32,
546 j_s: f32,
547 n_out: ::std::os::raw::c_int,
548 );
549}
550extern "C" {
551 #[link_name = "\u{1}_ZN4mask14setup_circularEi"]
552 pub fn mask_setup_circular(this: *mut mask, n: ::std::os::raw::c_int);
553}
554extern "C" {
555 #[link_name = "\u{1}_ZN4mask14setup_circularEif"]
556 pub fn mask_setup_circular1(this: *mut mask, n: ::std::os::raw::c_int, D: f32);
557}
558extern "C" {
559 #[link_name = "\u{1}_ZN4mask14setup_circularEiff"]
560 pub fn mask_setup_circular2(this: *mut mask, n: ::std::os::raw::c_int, D: f32, scale: f32);
561}
562extern "C" {
563 #[link_name = "\u{1}_ZN4mask9setup_GMTEif"]
564 pub fn mask_setup_GMT(this: *mut mask, n: ::std::os::raw::c_int, S: f32);
565}
566extern "C" {
567 #[link_name = "\u{1}_ZN4mask10set_filterEv"]
568 pub fn mask_set_filter(this: *mut mask);
569}
570extern "C" {
571 #[link_name = "\u{1}_ZN4mask16set_filter_quietEv"]
572 pub fn mask_set_filter_quiet(this: *mut mask);
573}
574extern "C" {
575 #[link_name = "\u{1}_ZN4mask9set_indexEv"]
576 pub fn mask_set_index(this: *mut mask);
577}
578extern "C" {
579 #[link_name = "\u{1}_ZN4mask14set_gmt_pistonEPfS0_"]
580 pub fn mask_set_gmt_piston(this: *mut mask, phase: *mut f32, d__p: *mut f32);
581}
582extern "C" {
583 #[link_name = "\u{1}_ZN4mask5alterEPf"]
584 pub fn mask_alter(this: *mut mask, filter: *mut f32);
585}
586extern "C" {
587 #[link_name = "\u{1}_ZN4mask3addEPS_"]
588 pub fn mask_add(this: *mut mask, other: *mut mask);
589}
590extern "C" {
591 #[link_name = "\u{1}_ZN4mask3addEPci"]
592 pub fn mask_add1(
593 this: *mut mask,
594 other: *mut ::std::os::raw::c_char,
595 other_nel: ::std::os::raw::c_int,
596 );
597}
598extern "C" {
599 #[link_name = "\u{1}_ZN4mask3addEPS_i"]
600 pub fn mask_add2(this: *mut mask, other: *mut mask, offset: ::std::os::raw::c_int);
601}
602extern "C" {
603 #[link_name = "\u{1}_ZN4mask3addEPcii"]
604 pub fn mask_add3(
605 this: *mut mask,
606 other: *mut ::std::os::raw::c_char,
607 other_nel: ::std::os::raw::c_int,
608 offset: ::std::os::raw::c_int,
609 );
610}
611extern "C" {
612 #[link_name = "\u{1}_ZN4mask5resetEv"]
613 pub fn mask_reset(this: *mut mask);
614}
615extern "C" {
616 #[link_name = "\u{1}_ZN4mask7cleanupEv"]
617 pub fn mask_cleanup(this: *mut mask);
618}
619impl mask {
620 #[inline]
621 pub unsafe fn setup(&mut self, n: ::std::os::raw::c_int) {
622 mask_setup(self, n)
623 }
624 #[inline]
625 pub unsafe fn setup1(&mut self, n: ::std::os::raw::c_int, L: f32) {
626 mask_setup1(self, n, L)
627 }
628 #[inline]
629 pub unsafe fn setup2(
630 &mut self,
631 n: ::std::os::raw::c_int,
632 L: f32,
633 i_s: ::std::os::raw::c_int,
634 j_s: ::std::os::raw::c_int,
635 n_out: ::std::os::raw::c_int,
636 ) {
637 mask_setup2(self, n, L, i_s, j_s, n_out)
638 }
639 #[inline]
640 pub unsafe fn setup3(
641 &mut self,
642 n: f32,
643 L: f32,
644 i_0: f32,
645 j_0: f32,
646 theta: f32,
647 i_s: f32,
648 j_s: f32,
649 n_out: ::std::os::raw::c_int,
650 ) {
651 mask_setup3(self, n, L, i_0, j_0, theta, i_s, j_s, n_out)
652 }
653 #[inline]
654 pub unsafe fn setup_circular(&mut self, n: ::std::os::raw::c_int) {
655 mask_setup_circular(self, n)
656 }
657 #[inline]
658 pub unsafe fn setup_circular1(&mut self, n: ::std::os::raw::c_int, D: f32) {
659 mask_setup_circular1(self, n, D)
660 }
661 #[inline]
662 pub unsafe fn setup_circular2(&mut self, n: ::std::os::raw::c_int, D: f32, scale: f32) {
663 mask_setup_circular2(self, n, D, scale)
664 }
665 #[inline]
666 pub unsafe fn setup_GMT(&mut self, n: ::std::os::raw::c_int, S: f32) {
667 mask_setup_GMT(self, n, S)
668 }
669 #[inline]
670 pub unsafe fn set_filter(&mut self) {
671 mask_set_filter(self)
672 }
673 #[inline]
674 pub unsafe fn set_filter_quiet(&mut self) {
675 mask_set_filter_quiet(self)
676 }
677 #[inline]
678 pub unsafe fn set_index(&mut self) {
679 mask_set_index(self)
680 }
681 #[inline]
682 pub unsafe fn set_gmt_piston(&mut self, phase: *mut f32, d__p: *mut f32) {
683 mask_set_gmt_piston(self, phase, d__p)
684 }
685 #[inline]
686 pub unsafe fn alter(&mut self, filter: *mut f32) {
687 mask_alter(self, filter)
688 }
689 #[inline]
690 pub unsafe fn add(&mut self, other: *mut mask) {
691 mask_add(self, other)
692 }
693 #[inline]
694 pub unsafe fn add1(
695 &mut self,
696 other: *mut ::std::os::raw::c_char,
697 other_nel: ::std::os::raw::c_int,
698 ) {
699 mask_add1(self, other, other_nel)
700 }
701 #[inline]
702 pub unsafe fn add2(&mut self, other: *mut mask, offset: ::std::os::raw::c_int) {
703 mask_add2(self, other, offset)
704 }
705 #[inline]
706 pub unsafe fn add3(
707 &mut self,
708 other: *mut ::std::os::raw::c_char,
709 other_nel: ::std::os::raw::c_int,
710 offset: ::std::os::raw::c_int,
711 ) {
712 mask_add3(self, other, other_nel, offset)
713 }
714 #[inline]
715 pub unsafe fn reset(&mut self) {
716 mask_reset(self)
717 }
718 #[inline]
719 pub unsafe fn cleanup(&mut self) {
720 mask_cleanup(self)
721 }
722}
723#[repr(C)]
724#[derive(Debug, Copy, Clone)]
725pub struct stats {
726 pub handle: cublasHandle_t,
727 pub status: cublasStatus_t,
728}
729#[allow(clippy::unnecessary_operation, clippy::identity_op)]
730const _: () = {
731 ["Size of stats"][::std::mem::size_of::<stats>() - 16usize];
732 ["Alignment of stats"][::std::mem::align_of::<stats>() - 8usize];
733 ["Offset of field: stats::handle"][::std::mem::offset_of!(stats, handle) - 0usize];
734 ["Offset of field: stats::status"][::std::mem::offset_of!(stats, status) - 8usize];
735};
736extern "C" {
737 #[link_name = "\u{1}_ZN5stats5setupEv"]
738 pub fn stats_setup(this: *mut stats);
739}
740extern "C" {
741 #[link_name = "\u{1}_ZN5stats7cleanupEv"]
742 pub fn stats_cleanup(this: *mut stats);
743}
744extern "C" {
745 #[link_name = "\u{1}_ZN5stats4meanEPKfi"]
746 pub fn stats_mean(this: *mut stats, data: *const f32, n_data: ::std::os::raw::c_int) -> f32;
747}
748extern "C" {
749 #[link_name = "\u{1}_ZN5stats4meanEPKfP4maski"]
750 pub fn stats_mean1(
751 this: *mut stats,
752 data: *const f32,
753 M: *mut mask,
754 n_data: ::std::os::raw::c_int,
755 ) -> f32;
756}
757extern "C" {
758 #[link_name = "\u{1}_ZN5stats3varEPKfi"]
759 pub fn stats_var(this: *mut stats, data: *const f32, n_data: ::std::os::raw::c_int) -> f32;
760}
761extern "C" {
762 #[link_name = "\u{1}_ZN5stats3stdEPKfi"]
763 pub fn stats_std(this: *mut stats, data: *const f32, n_data: ::std::os::raw::c_int) -> f32;
764}
765extern "C" {
766 #[link_name = "\u{1}_ZN5stats8diff_varEPKfS1_i"]
767 pub fn stats_diff_var(
768 this: *mut stats,
769 data_1: *const f32,
770 data_2: *const f32,
771 n_data: ::std::os::raw::c_int,
772 ) -> f32;
773}
774extern "C" {
775 #[link_name = "\u{1}_ZN5stats8diff_stdEPKfS1_i"]
776 pub fn stats_diff_std(
777 this: *mut stats,
778 data_1: *const f32,
779 data_2: *const f32,
780 n_data: ::std::os::raw::c_int,
781 ) -> f32;
782}
783extern "C" {
784 #[link_name = "\u{1}_ZN5stats3varEPKfP4maski"]
785 pub fn stats_var1(
786 this: *mut stats,
787 data1: *const f32,
788 M: *mut mask,
789 n_data: ::std::os::raw::c_int,
790 ) -> f32;
791}
792extern "C" {
793 #[link_name = "\u{1}_ZN5stats3stdEPKfP4maski"]
794 pub fn stats_std1(
795 this: *mut stats,
796 data1: *const f32,
797 M: *mut mask,
798 n_data: ::std::os::raw::c_int,
799 ) -> f32;
800}
801extern "C" {
802 #[link_name = "\u{1}_ZN5stats8diff_varEPKfS1_P4maski"]
803 pub fn stats_diff_var1(
804 this: *mut stats,
805 data1: *const f32,
806 data2: *const f32,
807 M: *mut mask,
808 n_data: ::std::os::raw::c_int,
809 ) -> f32;
810}
811extern "C" {
812 #[link_name = "\u{1}_ZN5stats8diff_stdEPKfS1_P4maski"]
813 pub fn stats_diff_std1(
814 this: *mut stats,
815 data1: *const f32,
816 data2: *const f32,
817 M: *mut mask,
818 n_data: ::std::os::raw::c_int,
819 ) -> f32;
820}
821impl stats {
822 #[inline]
823 pub unsafe fn setup(&mut self) {
824 stats_setup(self)
825 }
826 #[inline]
827 pub unsafe fn cleanup(&mut self) {
828 stats_cleanup(self)
829 }
830 #[inline]
831 pub unsafe fn mean(&mut self, data: *const f32, n_data: ::std::os::raw::c_int) -> f32 {
832 stats_mean(self, data, n_data)
833 }
834 #[inline]
835 pub unsafe fn mean1(
836 &mut self,
837 data: *const f32,
838 M: *mut mask,
839 n_data: ::std::os::raw::c_int,
840 ) -> f32 {
841 stats_mean1(self, data, M, n_data)
842 }
843 #[inline]
844 pub unsafe fn var(&mut self, data: *const f32, n_data: ::std::os::raw::c_int) -> f32 {
845 stats_var(self, data, n_data)
846 }
847 #[inline]
848 pub unsafe fn std(&mut self, data: *const f32, n_data: ::std::os::raw::c_int) -> f32 {
849 stats_std(self, data, n_data)
850 }
851 #[inline]
852 pub unsafe fn diff_var(
853 &mut self,
854 data_1: *const f32,
855 data_2: *const f32,
856 n_data: ::std::os::raw::c_int,
857 ) -> f32 {
858 stats_diff_var(self, data_1, data_2, n_data)
859 }
860 #[inline]
861 pub unsafe fn diff_std(
862 &mut self,
863 data_1: *const f32,
864 data_2: *const f32,
865 n_data: ::std::os::raw::c_int,
866 ) -> f32 {
867 stats_diff_std(self, data_1, data_2, n_data)
868 }
869 #[inline]
870 pub unsafe fn var1(
871 &mut self,
872 data1: *const f32,
873 M: *mut mask,
874 n_data: ::std::os::raw::c_int,
875 ) -> f32 {
876 stats_var1(self, data1, M, n_data)
877 }
878 #[inline]
879 pub unsafe fn std1(
880 &mut self,
881 data1: *const f32,
882 M: *mut mask,
883 n_data: ::std::os::raw::c_int,
884 ) -> f32 {
885 stats_std1(self, data1, M, n_data)
886 }
887 #[inline]
888 pub unsafe fn diff_var1(
889 &mut self,
890 data1: *const f32,
891 data2: *const f32,
892 M: *mut mask,
893 n_data: ::std::os::raw::c_int,
894 ) -> f32 {
895 stats_diff_var1(self, data1, data2, M, n_data)
896 }
897 #[inline]
898 pub unsafe fn diff_std1(
899 &mut self,
900 data1: *const f32,
901 data2: *const f32,
902 M: *mut mask,
903 n_data: ::std::os::raw::c_int,
904 ) -> f32 {
905 stats_diff_std1(self, data1, data2, M, n_data)
906 }
907}
908extern "C" {
909 #[link_name = "\u{1}_Z8dev2hostPfS_i"]
910 pub fn dev2host(host_data: *mut f32, dev_data: *mut f32, N: ::std::os::raw::c_int);
911}
912extern "C" {
913 #[link_name = "\u{1}_Z12dev2host_intPiS_i"]
914 pub fn dev2host_int(
915 host_data: *mut ::std::os::raw::c_int,
916 dev_data: *mut ::std::os::raw::c_int,
917 N: ::std::os::raw::c_int,
918 );
919}
920extern "C" {
921 #[link_name = "\u{1}_Z8host2devPfS_i"]
922 pub fn host2dev(dev_data: *mut f32, host_data: *mut f32, N: ::std::os::raw::c_int);
923}
924extern "C" {
925 #[link_name = "\u{1}_Z13host2dev_charPcS_i"]
926 pub fn host2dev_char(
927 dev_data: *mut ::std::os::raw::c_char,
928 host_data: *mut ::std::os::raw::c_char,
929 N: ::std::os::raw::c_int,
930 );
931}
932#[repr(C)]
933#[derive(Debug, Copy, Clone)]
934pub struct gpu_float {
935 pub dev_data: *mut f32,
936 pub host_data: *mut f32,
937 pub d_tau: *mut f32,
938 pub N: ::std::os::raw::c_int,
939 pub nb: ::std::os::raw::c_int,
940 pub S: stats,
941 pub stat: cublasStatus_t,
942 pub handle: cublasHandle_t,
943 pub cusolverH: cusolverDnHandle_t,
944}
945#[allow(clippy::unnecessary_operation, clippy::identity_op)]
946const _: () = {
947 ["Size of gpu_float"][::std::mem::size_of::<gpu_float>() - 72usize];
948 ["Alignment of gpu_float"][::std::mem::align_of::<gpu_float>() - 8usize];
949 ["Offset of field: gpu_float::dev_data"][::std::mem::offset_of!(gpu_float, dev_data) - 0usize];
950 ["Offset of field: gpu_float::host_data"]
951 [::std::mem::offset_of!(gpu_float, host_data) - 8usize];
952 ["Offset of field: gpu_float::d_tau"][::std::mem::offset_of!(gpu_float, d_tau) - 16usize];
953 ["Offset of field: gpu_float::N"][::std::mem::offset_of!(gpu_float, N) - 24usize];
954 ["Offset of field: gpu_float::nb"][::std::mem::offset_of!(gpu_float, nb) - 28usize];
955 ["Offset of field: gpu_float::S"][::std::mem::offset_of!(gpu_float, S) - 32usize];
956 ["Offset of field: gpu_float::stat"][::std::mem::offset_of!(gpu_float, stat) - 48usize];
957 ["Offset of field: gpu_float::handle"][::std::mem::offset_of!(gpu_float, handle) - 56usize];
958 ["Offset of field: gpu_float::cusolverH"]
959 [::std::mem::offset_of!(gpu_float, cusolverH) - 64usize];
960};
961extern "C" {
962 #[link_name = "\u{1}_ZN9gpu_float5setupEv"]
963 pub fn gpu_float_setup(this: *mut gpu_float);
964}
965extern "C" {
966 #[link_name = "\u{1}_ZN9gpu_float5setupEi"]
967 pub fn gpu_float_setup1(this: *mut gpu_float, N_T: ::std::os::raw::c_int);
968}
969extern "C" {
970 #[link_name = "\u{1}_ZN9gpu_float10dev_mallocEv"]
971 pub fn gpu_float_dev_malloc(this: *mut gpu_float);
972}
973extern "C" {
974 #[link_name = "\u{1}_ZN9gpu_float8free_devEv"]
975 pub fn gpu_float_free_dev(this: *mut gpu_float);
976}
977extern "C" {
978 #[link_name = "\u{1}_ZN9gpu_float8dev2hostEv"]
979 pub fn gpu_float_dev2host(this: *mut gpu_float);
980}
981extern "C" {
982 #[link_name = "\u{1}_ZN9gpu_float8host2devEv"]
983 pub fn gpu_float_host2dev(this: *mut gpu_float);
984}
985extern "C" {
986 #[link_name = "\u{1}_ZN9gpu_float5resetEv"]
987 pub fn gpu_float_reset(this: *mut gpu_float);
988}
989extern "C" {
990 #[link_name = "\u{1}_ZN9gpu_float2qrEi"]
991 pub fn gpu_float_qr(this: *mut gpu_float, m: ::std::os::raw::c_int);
992}
993extern "C" {
994 #[link_name = "\u{1}_ZN9gpu_float7dev2devEPS_"]
995 pub fn gpu_float_dev2dev(this: *mut gpu_float, other: *mut gpu_float);
996}
997extern "C" {
998 #[link_name = "\u{1}_ZN9gpu_float4axpyEPKS_f"]
999 pub fn gpu_float_axpy(this: *mut gpu_float, x: *const gpu_float, alpha: f32);
1000}
1001extern "C" {
1002 #[link_name = "\u{1}_ZN9gpu_float5scaleEf"]
1003 pub fn gpu_float_scale(this: *mut gpu_float, alpha: f32);
1004}
1005extern "C" {
1006 #[link_name = "\u{1}_ZN9gpu_float2mvEPS_PKS_"]
1007 pub fn gpu_float_mv(this: *mut gpu_float, y: *mut gpu_float, x: *const gpu_float);
1008}
1009extern "C" {
1010 #[link_name = "\u{1}_ZN9gpu_float8qr_solveEPS_S0_"]
1011 pub fn gpu_float_qr_solve(this: *mut gpu_float, x: *mut gpu_float, b: *mut gpu_float);
1012}
1013impl gpu_float {
1014 #[inline]
1015 pub unsafe fn setup(&mut self) {
1016 gpu_float_setup(self)
1017 }
1018 #[inline]
1019 pub unsafe fn setup1(&mut self, N_T: ::std::os::raw::c_int) {
1020 gpu_float_setup1(self, N_T)
1021 }
1022 #[inline]
1023 pub unsafe fn dev_malloc(&mut self) {
1024 gpu_float_dev_malloc(self)
1025 }
1026 #[inline]
1027 pub unsafe fn free_dev(&mut self) {
1028 gpu_float_free_dev(self)
1029 }
1030 #[inline]
1031 pub unsafe fn dev2host(&mut self) {
1032 gpu_float_dev2host(self)
1033 }
1034 #[inline]
1035 pub unsafe fn host2dev(&mut self) {
1036 gpu_float_host2dev(self)
1037 }
1038 #[inline]
1039 pub unsafe fn reset(&mut self) {
1040 gpu_float_reset(self)
1041 }
1042 #[inline]
1043 pub unsafe fn qr(&mut self, m: ::std::os::raw::c_int) {
1044 gpu_float_qr(self, m)
1045 }
1046 #[inline]
1047 pub unsafe fn dev2dev(&mut self, other: *mut gpu_float) {
1048 gpu_float_dev2dev(self, other)
1049 }
1050 #[inline]
1051 pub unsafe fn axpy(&mut self, x: *const gpu_float, alpha: f32) {
1052 gpu_float_axpy(self, x, alpha)
1053 }
1054 #[inline]
1055 pub unsafe fn scale(&mut self, alpha: f32) {
1056 gpu_float_scale(self, alpha)
1057 }
1058 #[inline]
1059 pub unsafe fn mv(&mut self, y: *mut gpu_float, x: *const gpu_float) {
1060 gpu_float_mv(self, y, x)
1061 }
1062 #[inline]
1063 pub unsafe fn qr_solve(&mut self, x: *mut gpu_float, b: *mut gpu_float) {
1064 gpu_float_qr_solve(self, x, b)
1065 }
1066}
1067#[repr(C)]
1068#[derive(Debug, Copy, Clone)]
1069pub struct gpu_double {
1070 pub dev_data: *mut f64,
1071 pub host_data: *mut f64,
1072 pub N: ::std::os::raw::c_int,
1073 pub nb: ::std::os::raw::c_int,
1074 pub S: stats,
1075 pub stat: cublasStatus_t,
1076 pub handle: cublasHandle_t,
1077 pub cusolverH: cusolverDnHandle_t,
1078}
1079#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1080const _: () = {
1081 ["Size of gpu_double"][::std::mem::size_of::<gpu_double>() - 64usize];
1082 ["Alignment of gpu_double"][::std::mem::align_of::<gpu_double>() - 8usize];
1083 ["Offset of field: gpu_double::dev_data"]
1084 [::std::mem::offset_of!(gpu_double, dev_data) - 0usize];
1085 ["Offset of field: gpu_double::host_data"]
1086 [::std::mem::offset_of!(gpu_double, host_data) - 8usize];
1087 ["Offset of field: gpu_double::N"][::std::mem::offset_of!(gpu_double, N) - 16usize];
1088 ["Offset of field: gpu_double::nb"][::std::mem::offset_of!(gpu_double, nb) - 20usize];
1089 ["Offset of field: gpu_double::S"][::std::mem::offset_of!(gpu_double, S) - 24usize];
1090 ["Offset of field: gpu_double::stat"][::std::mem::offset_of!(gpu_double, stat) - 40usize];
1091 ["Offset of field: gpu_double::handle"][::std::mem::offset_of!(gpu_double, handle) - 48usize];
1092 ["Offset of field: gpu_double::cusolverH"]
1093 [::std::mem::offset_of!(gpu_double, cusolverH) - 56usize];
1094};
1095extern "C" {
1096 #[link_name = "\u{1}_ZN10gpu_double5setupEv"]
1097 pub fn gpu_double_setup(this: *mut gpu_double);
1098}
1099extern "C" {
1100 #[link_name = "\u{1}_ZN10gpu_double5setupEi"]
1101 pub fn gpu_double_setup1(this: *mut gpu_double, N_T: ::std::os::raw::c_int);
1102}
1103extern "C" {
1104 #[link_name = "\u{1}_ZN10gpu_double10dev_mallocEv"]
1105 pub fn gpu_double_dev_malloc(this: *mut gpu_double);
1106}
1107extern "C" {
1108 #[link_name = "\u{1}_ZN10gpu_double8free_devEv"]
1109 pub fn gpu_double_free_dev(this: *mut gpu_double);
1110}
1111extern "C" {
1112 #[link_name = "\u{1}_ZN10gpu_double8dev2hostEv"]
1113 pub fn gpu_double_dev2host(this: *mut gpu_double);
1114}
1115extern "C" {
1116 #[link_name = "\u{1}_ZN10gpu_double8host2devEv"]
1117 pub fn gpu_double_host2dev(this: *mut gpu_double);
1118}
1119extern "C" {
1120 #[link_name = "\u{1}_ZN10gpu_double5resetEv"]
1121 pub fn gpu_double_reset(this: *mut gpu_double);
1122}
1123extern "C" {
1124 #[link_name = "\u{1}_ZN10gpu_double2qrEi"]
1125 pub fn gpu_double_qr(this: *mut gpu_double, m: ::std::os::raw::c_int);
1126}
1127extern "C" {
1128 #[link_name = "\u{1}_ZN10gpu_double2mvEP9gpu_floatPKS0_"]
1129 pub fn gpu_double_mv(this: *mut gpu_double, y: *mut gpu_float, x: *const gpu_float);
1130}
1131impl gpu_double {
1132 #[inline]
1133 pub unsafe fn setup(&mut self) {
1134 gpu_double_setup(self)
1135 }
1136 #[inline]
1137 pub unsafe fn setup1(&mut self, N_T: ::std::os::raw::c_int) {
1138 gpu_double_setup1(self, N_T)
1139 }
1140 #[inline]
1141 pub unsafe fn dev_malloc(&mut self) {
1142 gpu_double_dev_malloc(self)
1143 }
1144 #[inline]
1145 pub unsafe fn free_dev(&mut self) {
1146 gpu_double_free_dev(self)
1147 }
1148 #[inline]
1149 pub unsafe fn dev2host(&mut self) {
1150 gpu_double_dev2host(self)
1151 }
1152 #[inline]
1153 pub unsafe fn host2dev(&mut self) {
1154 gpu_double_host2dev(self)
1155 }
1156 #[inline]
1157 pub unsafe fn reset(&mut self) {
1158 gpu_double_reset(self)
1159 }
1160 #[inline]
1161 pub unsafe fn qr(&mut self, m: ::std::os::raw::c_int) {
1162 gpu_double_qr(self, m)
1163 }
1164 #[inline]
1165 pub unsafe fn mv(&mut self, y: *mut gpu_float, x: *const gpu_float) {
1166 gpu_double_mv(self, y, x)
1167 }
1168}
1169#[repr(C)]
1170#[derive(Debug, Copy, Clone)]
1171pub struct gpu_int {
1172 pub dev_data: *mut ::std::os::raw::c_int,
1173 pub host_data: *mut ::std::os::raw::c_int,
1174 pub N: ::std::os::raw::c_int,
1175 pub nb: ::std::os::raw::c_int,
1176 pub S: stats,
1177 pub stat: cublasStatus_t,
1178 pub handle: cublasHandle_t,
1179 pub cusolverH: cusolverDnHandle_t,
1180}
1181#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1182const _: () = {
1183 ["Size of gpu_int"][::std::mem::size_of::<gpu_int>() - 64usize];
1184 ["Alignment of gpu_int"][::std::mem::align_of::<gpu_int>() - 8usize];
1185 ["Offset of field: gpu_int::dev_data"][::std::mem::offset_of!(gpu_int, dev_data) - 0usize];
1186 ["Offset of field: gpu_int::host_data"][::std::mem::offset_of!(gpu_int, host_data) - 8usize];
1187 ["Offset of field: gpu_int::N"][::std::mem::offset_of!(gpu_int, N) - 16usize];
1188 ["Offset of field: gpu_int::nb"][::std::mem::offset_of!(gpu_int, nb) - 20usize];
1189 ["Offset of field: gpu_int::S"][::std::mem::offset_of!(gpu_int, S) - 24usize];
1190 ["Offset of field: gpu_int::stat"][::std::mem::offset_of!(gpu_int, stat) - 40usize];
1191 ["Offset of field: gpu_int::handle"][::std::mem::offset_of!(gpu_int, handle) - 48usize];
1192 ["Offset of field: gpu_int::cusolverH"][::std::mem::offset_of!(gpu_int, cusolverH) - 56usize];
1193};
1194extern "C" {
1195 #[link_name = "\u{1}_ZN7gpu_int5setupEv"]
1196 pub fn gpu_int_setup(this: *mut gpu_int);
1197}
1198extern "C" {
1199 #[link_name = "\u{1}_ZN7gpu_int5setupEi"]
1200 pub fn gpu_int_setup1(this: *mut gpu_int, N_T: ::std::os::raw::c_int);
1201}
1202extern "C" {
1203 #[link_name = "\u{1}_ZN7gpu_int10dev_mallocEv"]
1204 pub fn gpu_int_dev_malloc(this: *mut gpu_int);
1205}
1206extern "C" {
1207 #[link_name = "\u{1}_ZN7gpu_int8free_devEv"]
1208 pub fn gpu_int_free_dev(this: *mut gpu_int);
1209}
1210extern "C" {
1211 #[link_name = "\u{1}_ZN7gpu_int8dev2hostEv"]
1212 pub fn gpu_int_dev2host(this: *mut gpu_int);
1213}
1214extern "C" {
1215 #[link_name = "\u{1}_ZN7gpu_int8host2devEv"]
1216 pub fn gpu_int_host2dev(this: *mut gpu_int);
1217}
1218extern "C" {
1219 #[link_name = "\u{1}_ZN7gpu_int5resetEv"]
1220 pub fn gpu_int_reset(this: *mut gpu_int);
1221}
1222extern "C" {
1223 #[link_name = "\u{1}_ZN7gpu_int2qrEi"]
1224 pub fn gpu_int_qr(this: *mut gpu_int, m: ::std::os::raw::c_int);
1225}
1226impl gpu_int {
1227 #[inline]
1228 pub unsafe fn setup(&mut self) {
1229 gpu_int_setup(self)
1230 }
1231 #[inline]
1232 pub unsafe fn setup1(&mut self, N_T: ::std::os::raw::c_int) {
1233 gpu_int_setup1(self, N_T)
1234 }
1235 #[inline]
1236 pub unsafe fn dev_malloc(&mut self) {
1237 gpu_int_dev_malloc(self)
1238 }
1239 #[inline]
1240 pub unsafe fn free_dev(&mut self) {
1241 gpu_int_free_dev(self)
1242 }
1243 #[inline]
1244 pub unsafe fn dev2host(&mut self) {
1245 gpu_int_dev2host(self)
1246 }
1247 #[inline]
1248 pub unsafe fn host2dev(&mut self) {
1249 gpu_int_host2dev(self)
1250 }
1251 #[inline]
1252 pub unsafe fn reset(&mut self) {
1253 gpu_int_reset(self)
1254 }
1255 #[inline]
1256 pub unsafe fn qr(&mut self, m: ::std::os::raw::c_int) {
1257 gpu_int_qr(self, m)
1258 }
1259}
1260extern "C" {
1261 #[link_name = "\u{1}_Z5geqrfPfS_ii"]
1262 pub fn geqrf(d_tau: *mut f32, a: *mut f32, m: ::std::os::raw::c_int, n: ::std::os::raw::c_int);
1263}
1264extern "C" {
1265 #[link_name = "\u{1}_Z5ormqrPfiS_S_i"]
1266 pub fn ormqr(
1267 b: *mut f32,
1268 m: ::std::os::raw::c_int,
1269 q: *mut f32,
1270 tau: *mut f32,
1271 n: ::std::os::raw::c_int,
1272 );
1273}
1274#[repr(C)]
1275#[derive(Debug, Copy, Clone)]
1276pub struct ray {
1277 pub coordinates: vector,
1278 pub directions: vector,
1279 pub surface_normal: vector,
1280 pub optical_path_length: rtd,
1281 pub optical_path_difference: rtd,
1282 pub v: ::std::os::raw::c_char,
1283 pub n_iteration: ::std::os::raw::c_int,
1284 pub throughput: rtd,
1285}
1286#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1287const _: () = {
1288 ["Size of ray"][::std::mem::size_of::<ray>() - 104usize];
1289 ["Alignment of ray"][::std::mem::align_of::<ray>() - 8usize];
1290 ["Offset of field: ray::coordinates"][::std::mem::offset_of!(ray, coordinates) - 0usize];
1291 ["Offset of field: ray::directions"][::std::mem::offset_of!(ray, directions) - 24usize];
1292 ["Offset of field: ray::surface_normal"][::std::mem::offset_of!(ray, surface_normal) - 48usize];
1293 ["Offset of field: ray::optical_path_length"]
1294 [::std::mem::offset_of!(ray, optical_path_length) - 72usize];
1295 ["Offset of field: ray::optical_path_difference"]
1296 [::std::mem::offset_of!(ray, optical_path_difference) - 80usize];
1297 ["Offset of field: ray::v"][::std::mem::offset_of!(ray, v) - 88usize];
1298 ["Offset of field: ray::n_iteration"][::std::mem::offset_of!(ray, n_iteration) - 92usize];
1299 ["Offset of field: ray::throughput"][::std::mem::offset_of!(ray, throughput) - 96usize];
1300};
1301#[repr(C)]
1302#[derive(Debug, Copy, Clone)]
1303pub struct bundle {
1304 pub N_RAY: ::std::os::raw::c_int,
1305 pub d__ray: *mut ray,
1306 pub N_BUNDLE: ::std::os::raw::c_int,
1307 pub N_RAY_TOTAL: ::std::os::raw::c_int,
1308 pub d__origin: *mut vector,
1309 pub rot_angle: f64,
1310 pub d__chief_ray: *mut ray,
1311 pub d__chief_origin: *mut vector,
1312 pub V: mask,
1313 pub geom: [::std::os::raw::c_char; 8usize],
1314 pub N_RADIUS: ::std::os::raw::c_int,
1315 pub N_THETA: ::std::os::raw::c_int,
1316 pub N_L: ::std::os::raw::c_int,
1317 pub L: rtd,
1318 pub d__sphere_distance: *mut rtd,
1319 pub d__sphere_radius: *mut rtd,
1320 pub d__sphere_origin: *mut vector,
1321 pub d__piston_mask: *mut ::std::os::raw::c_int,
1322 pub refractive_index: rtd,
1323 pub d__Vx: *mut f64,
1324 pub d__Vy: *mut f64,
1325}
1326#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1327const _: () = {
1328 ["Size of bundle"][::std::mem::size_of::<bundle>() - 224usize];
1329 ["Alignment of bundle"][::std::mem::align_of::<bundle>() - 8usize];
1330 ["Offset of field: bundle::N_RAY"][::std::mem::offset_of!(bundle, N_RAY) - 0usize];
1331 ["Offset of field: bundle::d__ray"][::std::mem::offset_of!(bundle, d__ray) - 8usize];
1332 ["Offset of field: bundle::N_BUNDLE"][::std::mem::offset_of!(bundle, N_BUNDLE) - 16usize];
1333 ["Offset of field: bundle::N_RAY_TOTAL"][::std::mem::offset_of!(bundle, N_RAY_TOTAL) - 20usize];
1334 ["Offset of field: bundle::d__origin"][::std::mem::offset_of!(bundle, d__origin) - 24usize];
1335 ["Offset of field: bundle::rot_angle"][::std::mem::offset_of!(bundle, rot_angle) - 32usize];
1336 ["Offset of field: bundle::d__chief_ray"]
1337 [::std::mem::offset_of!(bundle, d__chief_ray) - 40usize];
1338 ["Offset of field: bundle::d__chief_origin"]
1339 [::std::mem::offset_of!(bundle, d__chief_origin) - 48usize];
1340 ["Offset of field: bundle::V"][::std::mem::offset_of!(bundle, V) - 56usize];
1341 ["Offset of field: bundle::geom"][::std::mem::offset_of!(bundle, geom) - 136usize];
1342 ["Offset of field: bundle::N_RADIUS"][::std::mem::offset_of!(bundle, N_RADIUS) - 144usize];
1343 ["Offset of field: bundle::N_THETA"][::std::mem::offset_of!(bundle, N_THETA) - 148usize];
1344 ["Offset of field: bundle::N_L"][::std::mem::offset_of!(bundle, N_L) - 152usize];
1345 ["Offset of field: bundle::L"][::std::mem::offset_of!(bundle, L) - 160usize];
1346 ["Offset of field: bundle::d__sphere_distance"]
1347 [::std::mem::offset_of!(bundle, d__sphere_distance) - 168usize];
1348 ["Offset of field: bundle::d__sphere_radius"]
1349 [::std::mem::offset_of!(bundle, d__sphere_radius) - 176usize];
1350 ["Offset of field: bundle::d__sphere_origin"]
1351 [::std::mem::offset_of!(bundle, d__sphere_origin) - 184usize];
1352 ["Offset of field: bundle::d__piston_mask"]
1353 [::std::mem::offset_of!(bundle, d__piston_mask) - 192usize];
1354 ["Offset of field: bundle::refractive_index"]
1355 [::std::mem::offset_of!(bundle, refractive_index) - 200usize];
1356 ["Offset of field: bundle::d__Vx"][::std::mem::offset_of!(bundle, d__Vx) - 208usize];
1357 ["Offset of field: bundle::d__Vy"][::std::mem::offset_of!(bundle, d__Vy) - 216usize];
1358};
1359extern "C" {
1360 #[link_name = "\u{1}_ZN6bundle5setupEdii6vectori"]
1361 pub fn bundle_setup(
1362 this: *mut bundle,
1363 RADIUS: rtd,
1364 N_RADIUS: ::std::os::raw::c_int,
1365 N_THETA: ::std::os::raw::c_int,
1366 origin: vector,
1367 N_SRC: ::std::os::raw::c_int,
1368 );
1369}
1370extern "C" {
1371 #[link_name = "\u{1}_ZN6bundle5setupEdi6vectori"]
1372 pub fn bundle_setup1(
1373 this: *mut bundle,
1374 L: rtd,
1375 N_L: ::std::os::raw::c_int,
1376 origin: vector,
1377 N_SRC: ::std::os::raw::c_int,
1378 );
1379}
1380extern "C" {
1381 #[link_name = "\u{1}_ZN6bundle5setupEdi6vectorS0_i"]
1382 pub fn bundle_setup2(
1383 this: *mut bundle,
1384 L: rtd,
1385 N_L: ::std::os::raw::c_int,
1386 origin: vector,
1387 chief_origin: vector,
1388 N_SRC: ::std::os::raw::c_int,
1389 );
1390}
1391extern "C" {
1392 #[link_name = "\u{1}_ZN6bundle10setup_freeEiPdS0_6vector"]
1393 pub fn bundle_setup_free(
1394 this: *mut bundle,
1395 _N_RAY_: ::std::os::raw::c_int,
1396 x: *mut f64,
1397 y: *mut f64,
1398 origin: vector,
1399 );
1400}
1401extern "C" {
1402 #[link_name = "\u{1}_ZN6bundle10setup_freeEddiPdS0_6vector"]
1403 pub fn bundle_setup_free1(
1404 this: *mut bundle,
1405 zenith: f64,
1406 azimuth: f64,
1407 _N_RAY_: ::std::os::raw::c_int,
1408 x: *mut f64,
1409 y: *mut f64,
1410 origin: vector,
1411 );
1412}
1413extern "C" {
1414 #[link_name = "\u{1}_ZN6bundle7cleanupEv"]
1415 pub fn bundle_cleanup(this: *mut bundle);
1416}
1417extern "C" {
1418 #[link_name = "\u{1}_ZN6bundle10to_z_planeEd"]
1419 pub fn bundle_to_z_plane(this: *mut bundle, z_in: rtd);
1420}
1421extern "C" {
1422 #[link_name = "\u{1}_ZN6bundle14to_focal_planeEdd"]
1423 pub fn bundle_to_focal_plane(this: *mut bundle, z_chief_on_axis: rtd, rho_focal_plane: rtd);
1424}
1425extern "C" {
1426 #[link_name = "\u{1}_ZN6bundle9to_sphereE6vector"]
1427 pub fn bundle_to_sphere(this: *mut bundle, sphere_origin: vector);
1428}
1429extern "C" {
1430 #[link_name = "\u{1}_ZN6bundle9to_sphereEdd"]
1431 pub fn bundle_to_sphere1(this: *mut bundle, z_chief_on_axis: rtd, rho_focal_plane: rtd);
1432}
1433extern "C" {
1434 #[link_name = "\u{1}_ZN6bundle15get_coordinatesEPd"]
1435 pub fn bundle_get_coordinates(this: *mut bundle, d__coord: *mut f64);
1436}
1437extern "C" {
1438 #[link_name = "\u{1}_ZN6bundle21get_chief_coordinatesEPd"]
1439 pub fn bundle_get_chief_coordinates(this: *mut bundle, d__coord: *mut f64);
1440}
1441extern "C" {
1442 #[link_name = "\u{1}_ZN6bundle18get_sphere_originsEPd"]
1443 pub fn bundle_get_sphere_origins(this: *mut bundle, d__coord: *mut f64);
1444}
1445extern "C" {
1446 #[link_name = "\u{1}_ZN6bundle14get_directionsEPd"]
1447 pub fn bundle_get_directions(this: *mut bundle, d__dir: *mut f64);
1448}
1449extern "C" {
1450 #[link_name = "\u{1}_ZN6bundle20get_chief_directionsEPd"]
1451 pub fn bundle_get_chief_directions(this: *mut bundle, d__dir: *mut f64);
1452}
1453extern "C" {
1454 #[link_name = "\u{1}_ZN6bundle29get_chief_optical_path_lengthEPd"]
1455 pub fn bundle_get_chief_optical_path_length(this: *mut bundle, d__opl: *mut f64);
1456}
1457extern "C" {
1458 #[link_name = "\u{1}_ZN6bundle23get_optical_path_lengthEPd"]
1459 pub fn bundle_get_optical_path_length(this: *mut bundle, d__opl: *mut f64);
1460}
1461extern "C" {
1462 #[link_name = "\u{1}_ZN6bundle27get_optical_path_differenceEPd"]
1463 pub fn bundle_get_optical_path_difference(this: *mut bundle, d__opd: *mut f64);
1464}
1465extern "C" {
1466 #[link_name = "\u{1}_ZN6bundle27get_optical_path_differenceEPdfifi"]
1467 pub fn bundle_get_optical_path_difference1(
1468 this: *mut bundle,
1469 d__opd: *mut f64,
1470 delta_x: f32,
1471 N_x: ::std::os::raw::c_int,
1472 delta_y: f32,
1473 N_y: ::std::os::raw::c_int,
1474 );
1475}
1476extern "C" {
1477 #[link_name = "\u{1}_ZN6bundle14get_vignettingEPd"]
1478 pub fn bundle_get_vignetting(this: *mut bundle, d__v: *mut f64);
1479}
1480extern "C" {
1481 #[link_name = "\u{1}_ZN6bundle15get_n_iterationEPi"]
1482 pub fn bundle_get_n_iteration(this: *mut bundle, n_iteration: *mut ::std::os::raw::c_int);
1483}
1484extern "C" {
1485 #[link_name = "\u{1}_ZN6bundle16gmt_truss_onaxisEv"]
1486 pub fn bundle_gmt_truss_onaxis(this: *mut bundle);
1487}
1488extern "C" {
1489 #[link_name = "\u{1}_ZN6bundle18gmt_truss_onaxis_1Ed"]
1490 pub fn bundle_gmt_truss_onaxis_1(this: *mut bundle, scale: f64);
1491}
1492extern "C" {
1493 #[link_name = "\u{1}_ZN6bundle18gmt_truss_onaxis_2Ed"]
1494 pub fn bundle_gmt_truss_onaxis_2(this: *mut bundle, scale: f64);
1495}
1496extern "C" {
1497 #[link_name = "\u{1}_ZN6bundle18gmt_truss_onaxis_3Ed"]
1498 pub fn bundle_gmt_truss_onaxis_3(this: *mut bundle, scale: f64);
1499}
1500extern "C" {
1501 #[link_name = "\u{1}_ZN6bundle14gmt_pma_onaxisEv"]
1502 pub fn bundle_gmt_pma_onaxis(this: *mut bundle);
1503}
1504extern "C" {
1505 #[link_name = "\u{1}_ZN6bundle20gmt_pma_plate_onaxisEv"]
1506 pub fn bundle_gmt_pma_plate_onaxis(this: *mut bundle);
1507}
1508extern "C" {
1509 #[link_name = "\u{1}_ZN6bundle13gmt_m2_baffleEv"]
1510 pub fn bundle_gmt_m2_baffle(this: *mut bundle);
1511}
1512impl bundle {
1513 #[inline]
1514 pub unsafe fn setup(
1515 &mut self,
1516 RADIUS: rtd,
1517 N_RADIUS: ::std::os::raw::c_int,
1518 N_THETA: ::std::os::raw::c_int,
1519 origin: vector,
1520 N_SRC: ::std::os::raw::c_int,
1521 ) {
1522 bundle_setup(self, RADIUS, N_RADIUS, N_THETA, origin, N_SRC)
1523 }
1524 #[inline]
1525 pub unsafe fn setup1(
1526 &mut self,
1527 L: rtd,
1528 N_L: ::std::os::raw::c_int,
1529 origin: vector,
1530 N_SRC: ::std::os::raw::c_int,
1531 ) {
1532 bundle_setup1(self, L, N_L, origin, N_SRC)
1533 }
1534 #[inline]
1535 pub unsafe fn setup2(
1536 &mut self,
1537 L: rtd,
1538 N_L: ::std::os::raw::c_int,
1539 origin: vector,
1540 chief_origin: vector,
1541 N_SRC: ::std::os::raw::c_int,
1542 ) {
1543 bundle_setup2(self, L, N_L, origin, chief_origin, N_SRC)
1544 }
1545 #[inline]
1546 pub unsafe fn setup_free(
1547 &mut self,
1548 _N_RAY_: ::std::os::raw::c_int,
1549 x: *mut f64,
1550 y: *mut f64,
1551 origin: vector,
1552 ) {
1553 bundle_setup_free(self, _N_RAY_, x, y, origin)
1554 }
1555 #[inline]
1556 pub unsafe fn setup_free1(
1557 &mut self,
1558 zenith: f64,
1559 azimuth: f64,
1560 _N_RAY_: ::std::os::raw::c_int,
1561 x: *mut f64,
1562 y: *mut f64,
1563 origin: vector,
1564 ) {
1565 bundle_setup_free1(self, zenith, azimuth, _N_RAY_, x, y, origin)
1566 }
1567 #[inline]
1568 pub unsafe fn cleanup(&mut self) {
1569 bundle_cleanup(self)
1570 }
1571 #[inline]
1572 pub unsafe fn to_z_plane(&mut self, z_in: rtd) {
1573 bundle_to_z_plane(self, z_in)
1574 }
1575 #[inline]
1576 pub unsafe fn to_focal_plane(&mut self, z_chief_on_axis: rtd, rho_focal_plane: rtd) {
1577 bundle_to_focal_plane(self, z_chief_on_axis, rho_focal_plane)
1578 }
1579 #[inline]
1580 pub unsafe fn to_sphere(&mut self, sphere_origin: vector) {
1581 bundle_to_sphere(self, sphere_origin)
1582 }
1583 #[inline]
1584 pub unsafe fn to_sphere1(&mut self, z_chief_on_axis: rtd, rho_focal_plane: rtd) {
1585 bundle_to_sphere1(self, z_chief_on_axis, rho_focal_plane)
1586 }
1587 #[inline]
1588 pub unsafe fn get_coordinates(&mut self, d__coord: *mut f64) {
1589 bundle_get_coordinates(self, d__coord)
1590 }
1591 #[inline]
1592 pub unsafe fn get_chief_coordinates(&mut self, d__coord: *mut f64) {
1593 bundle_get_chief_coordinates(self, d__coord)
1594 }
1595 #[inline]
1596 pub unsafe fn get_sphere_origins(&mut self, d__coord: *mut f64) {
1597 bundle_get_sphere_origins(self, d__coord)
1598 }
1599 #[inline]
1600 pub unsafe fn get_directions(&mut self, d__dir: *mut f64) {
1601 bundle_get_directions(self, d__dir)
1602 }
1603 #[inline]
1604 pub unsafe fn get_chief_directions(&mut self, d__dir: *mut f64) {
1605 bundle_get_chief_directions(self, d__dir)
1606 }
1607 #[inline]
1608 pub unsafe fn get_chief_optical_path_length(&mut self, d__opl: *mut f64) {
1609 bundle_get_chief_optical_path_length(self, d__opl)
1610 }
1611 #[inline]
1612 pub unsafe fn get_optical_path_length(&mut self, d__opl: *mut f64) {
1613 bundle_get_optical_path_length(self, d__opl)
1614 }
1615 #[inline]
1616 pub unsafe fn get_optical_path_difference(&mut self, d__opd: *mut f64) {
1617 bundle_get_optical_path_difference(self, d__opd)
1618 }
1619 #[inline]
1620 pub unsafe fn get_optical_path_difference1(
1621 &mut self,
1622 d__opd: *mut f64,
1623 delta_x: f32,
1624 N_x: ::std::os::raw::c_int,
1625 delta_y: f32,
1626 N_y: ::std::os::raw::c_int,
1627 ) {
1628 bundle_get_optical_path_difference1(self, d__opd, delta_x, N_x, delta_y, N_y)
1629 }
1630 #[inline]
1631 pub unsafe fn get_vignetting(&mut self, d__v: *mut f64) {
1632 bundle_get_vignetting(self, d__v)
1633 }
1634 #[inline]
1635 pub unsafe fn get_n_iteration(&mut self, n_iteration: *mut ::std::os::raw::c_int) {
1636 bundle_get_n_iteration(self, n_iteration)
1637 }
1638 #[inline]
1639 pub unsafe fn gmt_truss_onaxis(&mut self) {
1640 bundle_gmt_truss_onaxis(self)
1641 }
1642 #[inline]
1643 pub unsafe fn gmt_truss_onaxis_1(&mut self, scale: f64) {
1644 bundle_gmt_truss_onaxis_1(self, scale)
1645 }
1646 #[inline]
1647 pub unsafe fn gmt_truss_onaxis_2(&mut self, scale: f64) {
1648 bundle_gmt_truss_onaxis_2(self, scale)
1649 }
1650 #[inline]
1651 pub unsafe fn gmt_truss_onaxis_3(&mut self, scale: f64) {
1652 bundle_gmt_truss_onaxis_3(self, scale)
1653 }
1654 #[inline]
1655 pub unsafe fn gmt_pma_onaxis(&mut self) {
1656 bundle_gmt_pma_onaxis(self)
1657 }
1658 #[inline]
1659 pub unsafe fn gmt_pma_plate_onaxis(&mut self) {
1660 bundle_gmt_pma_plate_onaxis(self)
1661 }
1662 #[inline]
1663 pub unsafe fn gmt_m2_baffle(&mut self) {
1664 bundle_gmt_m2_baffle(self)
1665 }
1666}
1667#[repr(C)]
1668#[derive(Debug, Copy, Clone)]
1669pub struct complex_amplitude {
1670 pub N_PX: ::std::os::raw::c_int,
1671 pub N: ::std::os::raw::c_int,
1672 pub amplitude: *mut f32,
1673 pub phase: *mut f32,
1674 pub M: *mut mask,
1675 pub handle: cublasHandle_t,
1676 pub buffer: *mut f32,
1677}
1678#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1679const _: () = {
1680 ["Size of complex_amplitude"][::std::mem::size_of::<complex_amplitude>() - 48usize];
1681 ["Alignment of complex_amplitude"][::std::mem::align_of::<complex_amplitude>() - 8usize];
1682 ["Offset of field: complex_amplitude::N_PX"]
1683 [::std::mem::offset_of!(complex_amplitude, N_PX) - 0usize];
1684 ["Offset of field: complex_amplitude::N"]
1685 [::std::mem::offset_of!(complex_amplitude, N) - 4usize];
1686 ["Offset of field: complex_amplitude::amplitude"]
1687 [::std::mem::offset_of!(complex_amplitude, amplitude) - 8usize];
1688 ["Offset of field: complex_amplitude::phase"]
1689 [::std::mem::offset_of!(complex_amplitude, phase) - 16usize];
1690 ["Offset of field: complex_amplitude::M"]
1691 [::std::mem::offset_of!(complex_amplitude, M) - 24usize];
1692 ["Offset of field: complex_amplitude::handle"]
1693 [::std::mem::offset_of!(complex_amplitude, handle) - 32usize];
1694 ["Offset of field: complex_amplitude::buffer"]
1695 [::std::mem::offset_of!(complex_amplitude, buffer) - 40usize];
1696};
1697extern "C" {
1698 #[link_name = "\u{1}_ZN17complex_amplitude5setupEi"]
1699 pub fn complex_amplitude_setup(this: *mut complex_amplitude, n_pixel: ::std::os::raw::c_int);
1700}
1701extern "C" {
1702 #[link_name = "\u{1}_ZN17complex_amplitude5setupEii"]
1703 pub fn complex_amplitude_setup1(
1704 this: *mut complex_amplitude,
1705 n_pixel: ::std::os::raw::c_int,
1706 n_src: ::std::os::raw::c_int,
1707 );
1708}
1709extern "C" {
1710 #[link_name = "\u{1}_ZN17complex_amplitude7cleanupEv"]
1711 pub fn complex_amplitude_cleanup(this: *mut complex_amplitude);
1712}
1713extern "C" {
1714 #[link_name = "\u{1}_ZN17complex_amplitude5resetEv"]
1715 pub fn complex_amplitude_reset(this: *mut complex_amplitude);
1716}
1717extern "C" {
1718 #[link_name = "\u{1}_ZN17complex_amplitude5resetEPS_"]
1719 pub fn complex_amplitude_reset1(
1720 this: *mut complex_amplitude,
1721 wavefront: *mut complex_amplitude,
1722 );
1723}
1724extern "C" {
1725 #[link_name = "\u{1}_ZN17complex_amplitude15reset_amplitudeEv"]
1726 pub fn complex_amplitude_reset_amplitude(this: *mut complex_amplitude);
1727}
1728extern "C" {
1729 #[link_name = "\u{1}_ZN17complex_amplitude11reset_phaseEv"]
1730 pub fn complex_amplitude_reset_phase(this: *mut complex_amplitude);
1731}
1732extern "C" {
1733 #[link_name = "\u{1}_ZN17complex_amplitude11reset_phaseEPS_"]
1734 pub fn complex_amplitude_reset_phase1(
1735 this: *mut complex_amplitude,
1736 wavefront_prime: *mut complex_amplitude,
1737 );
1738}
1739extern "C" {
1740 #[link_name = "\u{1}_ZN17complex_amplitude9add_phaseEfPf"]
1741 pub fn complex_amplitude_add_phase(
1742 this: *mut complex_amplitude,
1743 alpha: f32,
1744 phase_prime: *mut f32,
1745 );
1746}
1747extern "C" {
1748 #[link_name = "\u{1}_ZN17complex_amplitude14add_same_phaseEfPf"]
1749 pub fn complex_amplitude_add_same_phase(
1750 this: *mut complex_amplitude,
1751 alpha: f32,
1752 phase_prime: *mut f32,
1753 );
1754}
1755extern "C" {
1756 #[link_name = "\u{1}_ZN17complex_amplitude6maskedEv"]
1757 pub fn complex_amplitude_masked(this: *mut complex_amplitude);
1758}
1759extern "C" {
1760 #[link_name = "\u{1}_ZN17complex_amplitude6maskedEP4mask"]
1761 pub fn complex_amplitude_masked1(this: *mut complex_amplitude, M_in: *mut mask);
1762}
1763extern "C" {
1764 #[link_name = "\u{1}_ZN17complex_amplitude3rmsEPf"]
1765 pub fn complex_amplitude_rms(this: *mut complex_amplitude, rms: *mut f32);
1766}
1767extern "C" {
1768 #[link_name = "\u{1}_ZN17complex_amplitude17finite_differenceEPfS0_if"]
1769 pub fn complex_amplitude_finite_difference(
1770 this: *mut complex_amplitude,
1771 sx: *mut f32,
1772 sy: *mut f32,
1773 NL: ::std::os::raw::c_int,
1774 d: f32,
1775 );
1776}
1777extern "C" {
1778 #[link_name = "\u{1}_ZN17complex_amplitude17finite_differenceEPfS0_ifP4mask"]
1779 pub fn complex_amplitude_finite_difference1(
1780 this: *mut complex_amplitude,
1781 sx: *mut f32,
1782 sy: *mut f32,
1783 NL: ::std::os::raw::c_int,
1784 d: f32,
1785 valid_lenslet: *mut mask,
1786 );
1787}
1788extern "C" {
1789 #[link_name = "\u{1}_ZN17complex_amplitude16gradient_averageEPfS0_if"]
1790 pub fn complex_amplitude_gradient_average(
1791 this: *mut complex_amplitude,
1792 sx: *mut f32,
1793 sy: *mut f32,
1794 NL: ::std::os::raw::c_int,
1795 d: f32,
1796 );
1797}
1798extern "C" {
1799 #[link_name = "\u{1}_ZN17complex_amplitude16gradient_averageEPfS0_f"]
1800 pub fn complex_amplitude_gradient_average1(
1801 this: *mut complex_amplitude,
1802 sx: *mut f32,
1803 sy: *mut f32,
1804 d: f32,
1805 );
1806}
1807extern "C" {
1808 #[link_name = "\u{1}_ZN17complex_amplitude25segments_gradient_averageEPfS0_fPi"]
1809 pub fn complex_amplitude_segments_gradient_average(
1810 this: *mut complex_amplitude,
1811 sx: *mut f32,
1812 sy: *mut f32,
1813 D: f32,
1814 segment_markers: *mut ::std::os::raw::c_int,
1815 );
1816}
1817extern "C" {
1818 #[link_name = "\u{1}_ZN17complex_amplitude29segments_gradient_averageFastEPfS0_fPi"]
1819 pub fn complex_amplitude_segments_gradient_averageFast(
1820 this: *mut complex_amplitude,
1821 sx: *mut f32,
1822 sy: *mut f32,
1823 D: f32,
1824 segment_markers: *mut ::std::os::raw::c_int,
1825 );
1826}
1827extern "C" {
1828 #[link_name = "\u{1}_ZN17complex_amplitude10show_phaseEPc"]
1829 pub fn complex_amplitude_show_phase(
1830 this: *mut complex_amplitude,
1831 filename: *mut ::std::os::raw::c_char,
1832 );
1833}
1834extern "C" {
1835 #[link_name = "\u{1}_ZN17complex_amplitude10show_phaseEPci"]
1836 pub fn complex_amplitude_show_phase1(
1837 this: *mut complex_amplitude,
1838 filename: *mut ::std::os::raw::c_char,
1839 N_SRC: ::std::os::raw::c_int,
1840 );
1841}
1842extern "C" {
1843 #[link_name = "\u{1}_ZN17complex_amplitude14show_amplitudeEPc"]
1844 pub fn complex_amplitude_show_amplitude(
1845 this: *mut complex_amplitude,
1846 filename: *mut ::std::os::raw::c_char,
1847 );
1848}
1849extern "C" {
1850 #[link_name = "\u{1}_ZN17complex_amplitude14show_amplitudeEPcii"]
1851 pub fn complex_amplitude_show_amplitude1(
1852 this: *mut complex_amplitude,
1853 filename: *mut ::std::os::raw::c_char,
1854 N: ::std::os::raw::c_int,
1855 M: ::std::os::raw::c_int,
1856 );
1857}
1858impl complex_amplitude {
1859 #[inline]
1860 pub unsafe fn setup(&mut self, n_pixel: ::std::os::raw::c_int) {
1861 complex_amplitude_setup(self, n_pixel)
1862 }
1863 #[inline]
1864 pub unsafe fn setup1(&mut self, n_pixel: ::std::os::raw::c_int, n_src: ::std::os::raw::c_int) {
1865 complex_amplitude_setup1(self, n_pixel, n_src)
1866 }
1867 #[inline]
1868 pub unsafe fn cleanup(&mut self) {
1869 complex_amplitude_cleanup(self)
1870 }
1871 #[inline]
1872 pub unsafe fn reset(&mut self) {
1873 complex_amplitude_reset(self)
1874 }
1875 #[inline]
1876 pub unsafe fn reset1(&mut self, wavefront: *mut complex_amplitude) {
1877 complex_amplitude_reset1(self, wavefront)
1878 }
1879 #[inline]
1880 pub unsafe fn reset_amplitude(&mut self) {
1881 complex_amplitude_reset_amplitude(self)
1882 }
1883 #[inline]
1884 pub unsafe fn reset_phase(&mut self) {
1885 complex_amplitude_reset_phase(self)
1886 }
1887 #[inline]
1888 pub unsafe fn reset_phase1(&mut self, wavefront_prime: *mut complex_amplitude) {
1889 complex_amplitude_reset_phase1(self, wavefront_prime)
1890 }
1891 #[inline]
1892 pub unsafe fn add_phase(&mut self, alpha: f32, phase_prime: *mut f32) {
1893 complex_amplitude_add_phase(self, alpha, phase_prime)
1894 }
1895 #[inline]
1896 pub unsafe fn add_same_phase(&mut self, alpha: f32, phase_prime: *mut f32) {
1897 complex_amplitude_add_same_phase(self, alpha, phase_prime)
1898 }
1899 #[inline]
1900 pub unsafe fn masked(&mut self) {
1901 complex_amplitude_masked(self)
1902 }
1903 #[inline]
1904 pub unsafe fn masked1(&mut self, M_in: *mut mask) {
1905 complex_amplitude_masked1(self, M_in)
1906 }
1907 #[inline]
1908 pub unsafe fn rms(&mut self, rms: *mut f32) {
1909 complex_amplitude_rms(self, rms)
1910 }
1911 #[inline]
1912 pub unsafe fn finite_difference(
1913 &mut self,
1914 sx: *mut f32,
1915 sy: *mut f32,
1916 NL: ::std::os::raw::c_int,
1917 d: f32,
1918 ) {
1919 complex_amplitude_finite_difference(self, sx, sy, NL, d)
1920 }
1921 #[inline]
1922 pub unsafe fn finite_difference1(
1923 &mut self,
1924 sx: *mut f32,
1925 sy: *mut f32,
1926 NL: ::std::os::raw::c_int,
1927 d: f32,
1928 valid_lenslet: *mut mask,
1929 ) {
1930 complex_amplitude_finite_difference1(self, sx, sy, NL, d, valid_lenslet)
1931 }
1932 #[inline]
1933 pub unsafe fn gradient_average(
1934 &mut self,
1935 sx: *mut f32,
1936 sy: *mut f32,
1937 NL: ::std::os::raw::c_int,
1938 d: f32,
1939 ) {
1940 complex_amplitude_gradient_average(self, sx, sy, NL, d)
1941 }
1942 #[inline]
1943 pub unsafe fn gradient_average1(&mut self, sx: *mut f32, sy: *mut f32, d: f32) {
1944 complex_amplitude_gradient_average1(self, sx, sy, d)
1945 }
1946 #[inline]
1947 pub unsafe fn segments_gradient_average(
1948 &mut self,
1949 sx: *mut f32,
1950 sy: *mut f32,
1951 D: f32,
1952 segment_markers: *mut ::std::os::raw::c_int,
1953 ) {
1954 complex_amplitude_segments_gradient_average(self, sx, sy, D, segment_markers)
1955 }
1956 #[inline]
1957 pub unsafe fn segments_gradient_averageFast(
1958 &mut self,
1959 sx: *mut f32,
1960 sy: *mut f32,
1961 D: f32,
1962 segment_markers: *mut ::std::os::raw::c_int,
1963 ) {
1964 complex_amplitude_segments_gradient_averageFast(self, sx, sy, D, segment_markers)
1965 }
1966 #[inline]
1967 pub unsafe fn show_phase(&mut self, filename: *mut ::std::os::raw::c_char) {
1968 complex_amplitude_show_phase(self, filename)
1969 }
1970 #[inline]
1971 pub unsafe fn show_phase1(
1972 &mut self,
1973 filename: *mut ::std::os::raw::c_char,
1974 N_SRC: ::std::os::raw::c_int,
1975 ) {
1976 complex_amplitude_show_phase1(self, filename, N_SRC)
1977 }
1978 #[inline]
1979 pub unsafe fn show_amplitude(&mut self, filename: *mut ::std::os::raw::c_char) {
1980 complex_amplitude_show_amplitude(self, filename)
1981 }
1982 #[inline]
1983 pub unsafe fn show_amplitude1(
1984 &mut self,
1985 filename: *mut ::std::os::raw::c_char,
1986 N: ::std::os::raw::c_int,
1987 M: ::std::os::raw::c_int,
1988 ) {
1989 complex_amplitude_show_amplitude1(self, filename, N, M)
1990 }
1991}
1992#[repr(C)]
1993#[derive(Debug, Copy, Clone)]
1994pub struct source {
1995 pub N_SRC: ::std::os::raw::c_int,
1996 pub zenith: f32,
1997 pub azimuth: f32,
1998 pub height: f32,
1999 pub theta_x: f32,
2000 pub theta_y: f32,
2001 pub _zenith_64_: rtd,
2002 pub _azimuth_64_: rtd,
2003 pub _height_64_: rtd,
2004 pub _theta_x_64_: rtd,
2005 pub _theta_y_64_: rtd,
2006 pub photometric_band: *const ::std::os::raw::c_char,
2007 pub magnitude: f32,
2008 pub N_PHOTON: f32,
2009 pub fwhm: f32,
2010 pub wavefront: complex_amplitude,
2011 pub dev_ptr: *mut source,
2012 pub tag: [::std::os::raw::c_char; 8usize],
2013 pub rays_exist: ::std::os::raw::c_char,
2014 pub rays: bundle,
2015}
2016#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2017const _: () = {
2018 ["Size of source"][::std::mem::size_of::<source>() - 384usize];
2019 ["Alignment of source"][::std::mem::align_of::<source>() - 8usize];
2020 ["Offset of field: source::N_SRC"][::std::mem::offset_of!(source, N_SRC) - 0usize];
2021 ["Offset of field: source::zenith"][::std::mem::offset_of!(source, zenith) - 4usize];
2022 ["Offset of field: source::azimuth"][::std::mem::offset_of!(source, azimuth) - 8usize];
2023 ["Offset of field: source::height"][::std::mem::offset_of!(source, height) - 12usize];
2024 ["Offset of field: source::theta_x"][::std::mem::offset_of!(source, theta_x) - 16usize];
2025 ["Offset of field: source::theta_y"][::std::mem::offset_of!(source, theta_y) - 20usize];
2026 ["Offset of field: source::_zenith_64_"][::std::mem::offset_of!(source, _zenith_64_) - 24usize];
2027 ["Offset of field: source::_azimuth_64_"]
2028 [::std::mem::offset_of!(source, _azimuth_64_) - 32usize];
2029 ["Offset of field: source::_height_64_"][::std::mem::offset_of!(source, _height_64_) - 40usize];
2030 ["Offset of field: source::_theta_x_64_"]
2031 [::std::mem::offset_of!(source, _theta_x_64_) - 48usize];
2032 ["Offset of field: source::_theta_y_64_"]
2033 [::std::mem::offset_of!(source, _theta_y_64_) - 56usize];
2034 ["Offset of field: source::photometric_band"]
2035 [::std::mem::offset_of!(source, photometric_band) - 64usize];
2036 ["Offset of field: source::magnitude"][::std::mem::offset_of!(source, magnitude) - 72usize];
2037 ["Offset of field: source::N_PHOTON"][::std::mem::offset_of!(source, N_PHOTON) - 76usize];
2038 ["Offset of field: source::fwhm"][::std::mem::offset_of!(source, fwhm) - 80usize];
2039 ["Offset of field: source::wavefront"][::std::mem::offset_of!(source, wavefront) - 88usize];
2040 ["Offset of field: source::dev_ptr"][::std::mem::offset_of!(source, dev_ptr) - 136usize];
2041 ["Offset of field: source::tag"][::std::mem::offset_of!(source, tag) - 144usize];
2042 ["Offset of field: source::rays_exist"][::std::mem::offset_of!(source, rays_exist) - 152usize];
2043 ["Offset of field: source::rays"][::std::mem::offset_of!(source, rays) - 160usize];
2044};
2045extern "C" {
2046 #[link_name = "\u{1}_ZN6source5setupEPKcfff"]
2047 pub fn source_setup(
2048 this: *mut source,
2049 _photometric_band: *const ::std::os::raw::c_char,
2050 zenith: f32,
2051 azimuth: f32,
2052 height: f32,
2053 );
2054}
2055extern "C" {
2056 #[link_name = "\u{1}_ZN6source5setupEPKcfffi"]
2057 pub fn source_setup1(
2058 this: *mut source,
2059 _photometric_band: *const ::std::os::raw::c_char,
2060 zenith: f32,
2061 azimuth: f32,
2062 height: f32,
2063 resolution: ::std::os::raw::c_int,
2064 );
2065}
2066extern "C" {
2067 #[link_name = "\u{1}_ZN6source5setupEPKcfffS1_"]
2068 pub fn source_setup2(
2069 this: *mut source,
2070 _photometric_band: *const ::std::os::raw::c_char,
2071 zenith: f32,
2072 azimuth: f32,
2073 height: f32,
2074 tag_in: *const ::std::os::raw::c_char,
2075 );
2076}
2077extern "C" {
2078 #[link_name = "\u{1}_ZN6source5setupEPKcfffiS1_"]
2079 pub fn source_setup3(
2080 this: *mut source,
2081 _photometric_band: *const ::std::os::raw::c_char,
2082 zenith: f32,
2083 azimuth: f32,
2084 height: f32,
2085 resolution: ::std::os::raw::c_int,
2086 tag_in: *const ::std::os::raw::c_char,
2087 );
2088}
2089extern "C" {
2090 #[link_name = "\u{1}_ZN6source5setupEPKcPfS2_fi"]
2091 pub fn source_setup4(
2092 this: *mut source,
2093 _photometric_band: *const ::std::os::raw::c_char,
2094 _zenith: *mut f32,
2095 _azimuth: *mut f32,
2096 _height: f32,
2097 _N_SRC: ::std::os::raw::c_int,
2098 );
2099}
2100extern "C" {
2101 #[link_name = "\u{1}_ZN6source5setupEPKcPfS2_fii"]
2102 pub fn source_setup5(
2103 this: *mut source,
2104 _photometric_band: *const ::std::os::raw::c_char,
2105 _zenith: *mut f32,
2106 _azimuth: *mut f32,
2107 _height: f32,
2108 _N_SRC: ::std::os::raw::c_int,
2109 resolution: ::std::os::raw::c_int,
2110 );
2111}
2112extern "C" {
2113 #[link_name = "\u{1}_ZN6source5setupEPKcPfS2_fidi6vector"]
2114 pub fn source_setup6(
2115 this: *mut source,
2116 _photometric_band: *const ::std::os::raw::c_char,
2117 _zenith: *mut f32,
2118 _azimuth: *mut f32,
2119 _height: f32,
2120 _N_SRC: ::std::os::raw::c_int,
2121 _L_: rtd,
2122 _N_L_: ::std::os::raw::c_int,
2123 origin: vector,
2124 );
2125}
2126extern "C" {
2127 #[link_name = "\u{1}_ZN6source5setupEPKcPfS2_S2_fidi6vector"]
2128 pub fn source_setup7(
2129 this: *mut source,
2130 _photometric_band: *const ::std::os::raw::c_char,
2131 magnitude: *mut f32,
2132 _zenith: *mut f32,
2133 _azimuth: *mut f32,
2134 _height: f32,
2135 _N_SRC: ::std::os::raw::c_int,
2136 _L_: rtd,
2137 _N_L_: ::std::os::raw::c_int,
2138 origin: vector,
2139 );
2140}
2141extern "C" {
2142 #[link_name = "\u{1}_ZN6source5setupEPKcPfPdS3_fidi6vector"]
2143 pub fn source_setup8(
2144 this: *mut source,
2145 _photometric_band: *const ::std::os::raw::c_char,
2146 magnitude: *mut f32,
2147 _zenith: *mut rtd,
2148 _azimuth: *mut rtd,
2149 _height: f32,
2150 _N_SRC: ::std::os::raw::c_int,
2151 _L_: rtd,
2152 _N_L_: ::std::os::raw::c_int,
2153 origin: vector,
2154 );
2155}
2156extern "C" {
2157 #[link_name = "\u{1}_ZN6source11setup_chiefEPKcPfPdS3_fidi6vectorS4_"]
2158 pub fn source_setup_chief(
2159 this: *mut source,
2160 _photometric_band: *const ::std::os::raw::c_char,
2161 magnitude: *mut f32,
2162 _zenith: *mut rtd,
2163 _azimuth: *mut rtd,
2164 _height: f32,
2165 _N_SRC: ::std::os::raw::c_int,
2166 _L_: rtd,
2167 _N_L_: ::std::os::raw::c_int,
2168 origin: vector,
2169 chief_origin: vector,
2170 );
2171}
2172extern "C" {
2173 #[link_name = "\u{1}_ZN6source5setupEPKcPfPdS3_fiiS3_S3_6vector"]
2174 pub fn source_setup9(
2175 this: *mut source,
2176 _photometric_band: *const ::std::os::raw::c_char,
2177 _magnitude: *mut f32,
2178 _zenith: *mut rtd,
2179 _azimuth: *mut rtd,
2180 _height: f32,
2181 _N_SRC: ::std::os::raw::c_int,
2182 _N_RAY_: ::std::os::raw::c_int,
2183 x: *mut f64,
2184 y: *mut f64,
2185 origin: vector,
2186 );
2187}
2188extern "C" {
2189 #[link_name = "\u{1}_ZN6source7cleanupEv"]
2190 pub fn source_cleanup(this: *mut source);
2191}
2192extern "C" {
2193 #[link_name = "\u{1}_ZN6source10reset_raysEv"]
2194 pub fn source_reset_rays(this: *mut source);
2195}
2196extern "C" {
2197 #[link_name = "\u{1}_ZN6source10reset_raysEi"]
2198 pub fn source_reset_rays1(this: *mut source, RESET_RAYS_MASK: ::std::os::raw::c_int);
2199}
2200extern "C" {
2201 #[link_name = "\u{1}_ZN6source9opd2phaseEv"]
2202 pub fn source_opd2phase(this: *mut source);
2203}
2204extern "C" {
2205 #[link_name = "\u{1}_ZN6source9opd2phaseEi"]
2206 pub fn source_opd2phase1(this: *mut source, RESET_RAYS_MASK: ::std::os::raw::c_int);
2207}
2208extern "C" {
2209 #[link_name = "\u{1}_ZN6source4infoEv"]
2210 pub fn source_info(this: *mut source);
2211}
2212extern "C" {
2213 #[link_name = "\u{1}_ZN6source10phase2fileEPKc"]
2214 pub fn source_phase2file(this: *mut source, filename: *const ::std::os::raw::c_char);
2215}
2216extern "C" {
2217 #[link_name = "\u{1}_ZN6source10wavelengthEv"]
2218 pub fn source_wavelength(this: *mut source) -> f32;
2219}
2220extern "C" {
2221 #[link_name = "\u{1}_ZN6source17wavelength_micronEv"]
2222 pub fn source_wavelength_micron(this: *mut source) -> f32;
2223}
2224extern "C" {
2225 #[link_name = "\u{1}_ZN6source18spectral_bandwidthEv"]
2226 pub fn source_spectral_bandwidth(this: *mut source) -> f32;
2227}
2228extern "C" {
2229 #[link_name = "\u{1}_ZN6source8n_photonEv"]
2230 pub fn source_n_photon(this: *mut source) -> f32;
2231}
2232extern "C" {
2233 #[link_name = "\u{1}_ZN6source8n_photonEf"]
2234 pub fn source_n_photon1(this: *mut source, _magnitude_: f32) -> f32;
2235}
2236extern "C" {
2237 #[link_name = "\u{1}_ZN6source19n_background_photonEf"]
2238 pub fn source_n_background_photon(this: *mut source, backgroundMagnitude: f32) -> f32;
2239}
2240extern "C" {
2241 #[link_name = "\u{1}_ZN6source10wavenumberEv"]
2242 pub fn source_wavenumber(this: *mut source) -> f32;
2243}
2244extern "C" {
2245 #[link_name = "\u{1}_ZN6source17update_directionsEPdS0_i"]
2246 pub fn source_update_directions(
2247 this: *mut source,
2248 zenith: *mut f64,
2249 azimuth: *mut f64,
2250 N_DIR: ::std::os::raw::c_int,
2251 );
2252}
2253extern "C" {
2254 #[link_name = "\u{1}_ZN6source16update_magnitudeEPfi"]
2255 pub fn source_update_magnitude(
2256 this: *mut source,
2257 magnitude: *mut f32,
2258 N_MAG: ::std::os::raw::c_int,
2259 );
2260}
2261extern "C" {
2262 #[link_name = "\u{1}_ZN6source14copy_magnitudeEPS_"]
2263 pub fn source_copy_magnitude(this: *mut source, other_src: *mut source);
2264}
2265extern "C" {
2266 #[link_name = "\u{1}_ZN6source25optical_transfer_functionEP6float2"]
2267 pub fn source_optical_transfer_function(this: *mut source, d__otf: *mut float2);
2268}
2269impl source {
2270 #[inline]
2271 pub unsafe fn setup(
2272 &mut self,
2273 _photometric_band: *const ::std::os::raw::c_char,
2274 zenith: f32,
2275 azimuth: f32,
2276 height: f32,
2277 ) {
2278 source_setup(self, _photometric_band, zenith, azimuth, height)
2279 }
2280 #[inline]
2281 pub unsafe fn setup1(
2282 &mut self,
2283 _photometric_band: *const ::std::os::raw::c_char,
2284 zenith: f32,
2285 azimuth: f32,
2286 height: f32,
2287 resolution: ::std::os::raw::c_int,
2288 ) {
2289 source_setup1(self, _photometric_band, zenith, azimuth, height, resolution)
2290 }
2291 #[inline]
2292 pub unsafe fn setup2(
2293 &mut self,
2294 _photometric_band: *const ::std::os::raw::c_char,
2295 zenith: f32,
2296 azimuth: f32,
2297 height: f32,
2298 tag_in: *const ::std::os::raw::c_char,
2299 ) {
2300 source_setup2(self, _photometric_band, zenith, azimuth, height, tag_in)
2301 }
2302 #[inline]
2303 pub unsafe fn setup3(
2304 &mut self,
2305 _photometric_band: *const ::std::os::raw::c_char,
2306 zenith: f32,
2307 azimuth: f32,
2308 height: f32,
2309 resolution: ::std::os::raw::c_int,
2310 tag_in: *const ::std::os::raw::c_char,
2311 ) {
2312 source_setup3(
2313 self,
2314 _photometric_band,
2315 zenith,
2316 azimuth,
2317 height,
2318 resolution,
2319 tag_in,
2320 )
2321 }
2322 #[inline]
2323 pub unsafe fn setup4(
2324 &mut self,
2325 _photometric_band: *const ::std::os::raw::c_char,
2326 _zenith: *mut f32,
2327 _azimuth: *mut f32,
2328 _height: f32,
2329 _N_SRC: ::std::os::raw::c_int,
2330 ) {
2331 source_setup4(self, _photometric_band, _zenith, _azimuth, _height, _N_SRC)
2332 }
2333 #[inline]
2334 pub unsafe fn setup5(
2335 &mut self,
2336 _photometric_band: *const ::std::os::raw::c_char,
2337 _zenith: *mut f32,
2338 _azimuth: *mut f32,
2339 _height: f32,
2340 _N_SRC: ::std::os::raw::c_int,
2341 resolution: ::std::os::raw::c_int,
2342 ) {
2343 source_setup5(
2344 self,
2345 _photometric_band,
2346 _zenith,
2347 _azimuth,
2348 _height,
2349 _N_SRC,
2350 resolution,
2351 )
2352 }
2353 #[inline]
2354 pub unsafe fn setup6(
2355 &mut self,
2356 _photometric_band: *const ::std::os::raw::c_char,
2357 _zenith: *mut f32,
2358 _azimuth: *mut f32,
2359 _height: f32,
2360 _N_SRC: ::std::os::raw::c_int,
2361 _L_: rtd,
2362 _N_L_: ::std::os::raw::c_int,
2363 origin: vector,
2364 ) {
2365 source_setup6(
2366 self,
2367 _photometric_band,
2368 _zenith,
2369 _azimuth,
2370 _height,
2371 _N_SRC,
2372 _L_,
2373 _N_L_,
2374 origin,
2375 )
2376 }
2377 #[inline]
2378 pub unsafe fn setup7(
2379 &mut self,
2380 _photometric_band: *const ::std::os::raw::c_char,
2381 magnitude: *mut f32,
2382 _zenith: *mut f32,
2383 _azimuth: *mut f32,
2384 _height: f32,
2385 _N_SRC: ::std::os::raw::c_int,
2386 _L_: rtd,
2387 _N_L_: ::std::os::raw::c_int,
2388 origin: vector,
2389 ) {
2390 source_setup7(
2391 self,
2392 _photometric_band,
2393 magnitude,
2394 _zenith,
2395 _azimuth,
2396 _height,
2397 _N_SRC,
2398 _L_,
2399 _N_L_,
2400 origin,
2401 )
2402 }
2403 #[inline]
2404 pub unsafe fn setup8(
2405 &mut self,
2406 _photometric_band: *const ::std::os::raw::c_char,
2407 magnitude: *mut f32,
2408 _zenith: *mut rtd,
2409 _azimuth: *mut rtd,
2410 _height: f32,
2411 _N_SRC: ::std::os::raw::c_int,
2412 _L_: rtd,
2413 _N_L_: ::std::os::raw::c_int,
2414 origin: vector,
2415 ) {
2416 source_setup8(
2417 self,
2418 _photometric_band,
2419 magnitude,
2420 _zenith,
2421 _azimuth,
2422 _height,
2423 _N_SRC,
2424 _L_,
2425 _N_L_,
2426 origin,
2427 )
2428 }
2429 #[inline]
2430 pub unsafe fn setup_chief(
2431 &mut self,
2432 _photometric_band: *const ::std::os::raw::c_char,
2433 magnitude: *mut f32,
2434 _zenith: *mut rtd,
2435 _azimuth: *mut rtd,
2436 _height: f32,
2437 _N_SRC: ::std::os::raw::c_int,
2438 _L_: rtd,
2439 _N_L_: ::std::os::raw::c_int,
2440 origin: vector,
2441 chief_origin: vector,
2442 ) {
2443 source_setup_chief(
2444 self,
2445 _photometric_band,
2446 magnitude,
2447 _zenith,
2448 _azimuth,
2449 _height,
2450 _N_SRC,
2451 _L_,
2452 _N_L_,
2453 origin,
2454 chief_origin,
2455 )
2456 }
2457 #[inline]
2458 pub unsafe fn setup9(
2459 &mut self,
2460 _photometric_band: *const ::std::os::raw::c_char,
2461 _magnitude: *mut f32,
2462 _zenith: *mut rtd,
2463 _azimuth: *mut rtd,
2464 _height: f32,
2465 _N_SRC: ::std::os::raw::c_int,
2466 _N_RAY_: ::std::os::raw::c_int,
2467 x: *mut f64,
2468 y: *mut f64,
2469 origin: vector,
2470 ) {
2471 source_setup9(
2472 self,
2473 _photometric_band,
2474 _magnitude,
2475 _zenith,
2476 _azimuth,
2477 _height,
2478 _N_SRC,
2479 _N_RAY_,
2480 x,
2481 y,
2482 origin,
2483 )
2484 }
2485 #[inline]
2486 pub unsafe fn cleanup(&mut self) {
2487 source_cleanup(self)
2488 }
2489 #[inline]
2490 pub unsafe fn reset_rays(&mut self) {
2491 source_reset_rays(self)
2492 }
2493 #[inline]
2494 pub unsafe fn reset_rays1(&mut self, RESET_RAYS_MASK: ::std::os::raw::c_int) {
2495 source_reset_rays1(self, RESET_RAYS_MASK)
2496 }
2497 #[inline]
2498 pub unsafe fn opd2phase(&mut self) {
2499 source_opd2phase(self)
2500 }
2501 #[inline]
2502 pub unsafe fn opd2phase1(&mut self, RESET_RAYS_MASK: ::std::os::raw::c_int) {
2503 source_opd2phase1(self, RESET_RAYS_MASK)
2504 }
2505 #[inline]
2506 pub unsafe fn info(&mut self) {
2507 source_info(self)
2508 }
2509 #[inline]
2510 pub unsafe fn phase2file(&mut self, filename: *const ::std::os::raw::c_char) {
2511 source_phase2file(self, filename)
2512 }
2513 #[inline]
2514 pub unsafe fn wavelength(&mut self) -> f32 {
2515 source_wavelength(self)
2516 }
2517 #[inline]
2518 pub unsafe fn wavelength_micron(&mut self) -> f32 {
2519 source_wavelength_micron(self)
2520 }
2521 #[inline]
2522 pub unsafe fn spectral_bandwidth(&mut self) -> f32 {
2523 source_spectral_bandwidth(self)
2524 }
2525 #[inline]
2526 pub unsafe fn n_photon(&mut self) -> f32 {
2527 source_n_photon(self)
2528 }
2529 #[inline]
2530 pub unsafe fn n_photon1(&mut self, _magnitude_: f32) -> f32 {
2531 source_n_photon1(self, _magnitude_)
2532 }
2533 #[inline]
2534 pub unsafe fn n_background_photon(&mut self, backgroundMagnitude: f32) -> f32 {
2535 source_n_background_photon(self, backgroundMagnitude)
2536 }
2537 #[inline]
2538 pub unsafe fn wavenumber(&mut self) -> f32 {
2539 source_wavenumber(self)
2540 }
2541 #[inline]
2542 pub unsafe fn update_directions(
2543 &mut self,
2544 zenith: *mut f64,
2545 azimuth: *mut f64,
2546 N_DIR: ::std::os::raw::c_int,
2547 ) {
2548 source_update_directions(self, zenith, azimuth, N_DIR)
2549 }
2550 #[inline]
2551 pub unsafe fn update_magnitude(&mut self, magnitude: *mut f32, N_MAG: ::std::os::raw::c_int) {
2552 source_update_magnitude(self, magnitude, N_MAG)
2553 }
2554 #[inline]
2555 pub unsafe fn copy_magnitude(&mut self, other_src: *mut source) {
2556 source_copy_magnitude(self, other_src)
2557 }
2558 #[inline]
2559 pub unsafe fn optical_transfer_function(&mut self, d__otf: *mut float2) {
2560 source_optical_transfer_function(self, d__otf)
2561 }
2562}
2563#[repr(C)]
2564#[derive(Debug, Copy, Clone)]
2565pub struct pssn {
2566 pub N_O: ::std::os::raw::c_int,
2567 pub N_O0: ::std::os::raw::c_int,
2568 pub n_byte: ::std::os::raw::c_int,
2569 pub d__O: *mut float2,
2570 pub d__O0: *mut float2,
2571 pub buffer: *mut float2,
2572 pub d__C: *mut float2,
2573 pub N_PX: ::std::os::raw::c_int,
2574 pub N: ::std::os::raw::c_int,
2575 pub d__W: *mut float2,
2576 pub N_OTF: ::std::os::raw::c_int,
2577 pub N_OTF2: ::std::os::raw::c_int,
2578 pub NN: ::std::os::raw::c_int,
2579 pub plan: cufftHandle,
2580 pub handle: cublasHandle_t,
2581 pub num: f32,
2582 pub denom: *mut f32,
2583}
2584#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2585const _: () = {
2586 ["Size of pssn"][::std::mem::size_of::<pssn>() - 104usize];
2587 ["Alignment of pssn"][::std::mem::align_of::<pssn>() - 8usize];
2588 ["Offset of field: pssn::N_O"][::std::mem::offset_of!(pssn, N_O) - 0usize];
2589 ["Offset of field: pssn::N_O0"][::std::mem::offset_of!(pssn, N_O0) - 4usize];
2590 ["Offset of field: pssn::n_byte"][::std::mem::offset_of!(pssn, n_byte) - 8usize];
2591 ["Offset of field: pssn::d__O"][::std::mem::offset_of!(pssn, d__O) - 16usize];
2592 ["Offset of field: pssn::d__O0"][::std::mem::offset_of!(pssn, d__O0) - 24usize];
2593 ["Offset of field: pssn::buffer"][::std::mem::offset_of!(pssn, buffer) - 32usize];
2594 ["Offset of field: pssn::d__C"][::std::mem::offset_of!(pssn, d__C) - 40usize];
2595 ["Offset of field: pssn::N_PX"][::std::mem::offset_of!(pssn, N_PX) - 48usize];
2596 ["Offset of field: pssn::N"][::std::mem::offset_of!(pssn, N) - 52usize];
2597 ["Offset of field: pssn::d__W"][::std::mem::offset_of!(pssn, d__W) - 56usize];
2598 ["Offset of field: pssn::N_OTF"][::std::mem::offset_of!(pssn, N_OTF) - 64usize];
2599 ["Offset of field: pssn::N_OTF2"][::std::mem::offset_of!(pssn, N_OTF2) - 68usize];
2600 ["Offset of field: pssn::NN"][::std::mem::offset_of!(pssn, NN) - 72usize];
2601 ["Offset of field: pssn::plan"][::std::mem::offset_of!(pssn, plan) - 76usize];
2602 ["Offset of field: pssn::handle"][::std::mem::offset_of!(pssn, handle) - 80usize];
2603 ["Offset of field: pssn::num"][::std::mem::offset_of!(pssn, num) - 88usize];
2604 ["Offset of field: pssn::denom"][::std::mem::offset_of!(pssn, denom) - 96usize];
2605};
2606extern "C" {
2607 #[link_name = "\u{1}_ZN4pssn5setupEP6sourceff"]
2608 pub fn pssn_setup(this: *mut pssn, src: *mut source, r0: f32, L0: f32);
2609}
2610extern "C" {
2611 #[link_name = "\u{1}_ZN4pssn7cleanupEv"]
2612 pub fn pssn_cleanup(this: *mut pssn);
2613}
2614extern "C" {
2615 #[link_name = "\u{1}_ZN4pssn7__otf__EP6sourceP6float2"]
2616 pub fn pssn___otf__(this: *mut pssn, src: *mut source, _d__O_: *mut float2);
2617}
2618extern "C" {
2619 #[link_name = "\u{1}_ZN4pssn3otfEP6source"]
2620 pub fn pssn_otf(this: *mut pssn, src: *mut source);
2621}
2622extern "C" {
2623 #[link_name = "\u{1}_ZN4pssn7atm_otfEfff"]
2624 pub fn pssn_atm_otf(this: *mut pssn, d: f32, r0: f32, L0: f32);
2625}
2626extern "C" {
2627 #[link_name = "\u{1}_ZN4pssn4evalEv"]
2628 pub fn pssn_eval(this: *mut pssn) -> f32;
2629}
2630extern "C" {
2631 #[link_name = "\u{1}_ZN4pssn5oevalEv"]
2632 pub fn pssn_oeval(this: *mut pssn) -> f32;
2633}
2634extern "C" {
2635 #[link_name = "\u{1}_ZN4pssn4evalEPf"]
2636 pub fn pssn_eval1(this: *mut pssn, results: *mut f32);
2637}
2638extern "C" {
2639 #[link_name = "\u{1}_ZN4pssn5oevalEPf"]
2640 pub fn pssn_oeval1(this: *mut pssn, results: *mut f32);
2641}
2642extern "C" {
2643 #[link_name = "\u{1}_ZN4pssn4xotfEPf"]
2644 pub fn pssn_xotf(this: *mut pssn, buffer: *mut f32);
2645}
2646extern "C" {
2647 #[link_name = "\u{1}_ZN4pssn1OEPf"]
2648 pub fn pssn_O(this: *mut pssn, buffer: *mut f32);
2649}
2650extern "C" {
2651 #[link_name = "\u{1}_ZN4pssn2O0EPf"]
2652 pub fn pssn_O0(this: *mut pssn, buffer: *mut f32);
2653}
2654extern "C" {
2655 #[link_name = "\u{1}_ZN4pssn1CEPf"]
2656 pub fn pssn_C(this: *mut pssn, buffer: *mut f32);
2657}
2658extern "C" {
2659 #[link_name = "\u{1}_ZN4pssn1BEPf"]
2660 pub fn pssn_B(this: *mut pssn, buffer: *mut f32);
2661}
2662impl pssn {
2663 #[inline]
2664 pub unsafe fn setup(&mut self, src: *mut source, r0: f32, L0: f32) {
2665 pssn_setup(self, src, r0, L0)
2666 }
2667 #[inline]
2668 pub unsafe fn cleanup(&mut self) {
2669 pssn_cleanup(self)
2670 }
2671 #[inline]
2672 pub unsafe fn __otf__(&mut self, src: *mut source, _d__O_: *mut float2) {
2673 pssn___otf__(self, src, _d__O_)
2674 }
2675 #[inline]
2676 pub unsafe fn otf(&mut self, src: *mut source) {
2677 pssn_otf(self, src)
2678 }
2679 #[inline]
2680 pub unsafe fn atm_otf(&mut self, d: f32, r0: f32, L0: f32) {
2681 pssn_atm_otf(self, d, r0, L0)
2682 }
2683 #[inline]
2684 pub unsafe fn eval(&mut self) -> f32 {
2685 pssn_eval(self)
2686 }
2687 #[inline]
2688 pub unsafe fn oeval(&mut self) -> f32 {
2689 pssn_oeval(self)
2690 }
2691 #[inline]
2692 pub unsafe fn eval1(&mut self, results: *mut f32) {
2693 pssn_eval1(self, results)
2694 }
2695 #[inline]
2696 pub unsafe fn oeval1(&mut self, results: *mut f32) {
2697 pssn_oeval1(self, results)
2698 }
2699 #[inline]
2700 pub unsafe fn xotf(&mut self, buffer: *mut f32) {
2701 pssn_xotf(self, buffer)
2702 }
2703 #[inline]
2704 pub unsafe fn O(&mut self, buffer: *mut f32) {
2705 pssn_O(self, buffer)
2706 }
2707 #[inline]
2708 pub unsafe fn O0(&mut self, buffer: *mut f32) {
2709 pssn_O0(self, buffer)
2710 }
2711 #[inline]
2712 pub unsafe fn C(&mut self, buffer: *mut f32) {
2713 pssn_C(self, buffer)
2714 }
2715 #[inline]
2716 pub unsafe fn B(&mut self, buffer: *mut f32) {
2717 pssn_B(self, buffer)
2718 }
2719}
2720#[repr(C)]
2721#[derive(Debug, Copy, Clone)]
2722pub struct coordinate_system {
2723 pub origin: *mut vector,
2724 pub euler_angles: *mut vector,
2725 pub N: ::std::os::raw::c_int,
2726 pub R: *mut rtd,
2727 pub d__R: *mut rtd,
2728 pub float_R: *mut f32,
2729 pub d__origin: *mut vector,
2730 pub tag: [::std::os::raw::c_char; 32usize],
2731}
2732#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2733const _: () = {
2734 ["Size of coordinate_system"][::std::mem::size_of::<coordinate_system>() - 88usize];
2735 ["Alignment of coordinate_system"][::std::mem::align_of::<coordinate_system>() - 8usize];
2736 ["Offset of field: coordinate_system::origin"]
2737 [::std::mem::offset_of!(coordinate_system, origin) - 0usize];
2738 ["Offset of field: coordinate_system::euler_angles"]
2739 [::std::mem::offset_of!(coordinate_system, euler_angles) - 8usize];
2740 ["Offset of field: coordinate_system::N"]
2741 [::std::mem::offset_of!(coordinate_system, N) - 16usize];
2742 ["Offset of field: coordinate_system::R"]
2743 [::std::mem::offset_of!(coordinate_system, R) - 24usize];
2744 ["Offset of field: coordinate_system::d__R"]
2745 [::std::mem::offset_of!(coordinate_system, d__R) - 32usize];
2746 ["Offset of field: coordinate_system::float_R"]
2747 [::std::mem::offset_of!(coordinate_system, float_R) - 40usize];
2748 ["Offset of field: coordinate_system::d__origin"]
2749 [::std::mem::offset_of!(coordinate_system, d__origin) - 48usize];
2750 ["Offset of field: coordinate_system::tag"]
2751 [::std::mem::offset_of!(coordinate_system, tag) - 56usize];
2752};
2753extern "C" {
2754 #[link_name = "\u{1}_ZN17coordinate_system5setupEv"]
2755 pub fn coordinate_system_setup(this: *mut coordinate_system);
2756}
2757extern "C" {
2758 #[link_name = "\u{1}_ZN17coordinate_system5setupE6vectorS0_"]
2759 pub fn coordinate_system_setup1(
2760 this: *mut coordinate_system,
2761 _origin_: vector,
2762 _euler_angles_: vector,
2763 );
2764}
2765extern "C" {
2766 #[link_name = "\u{1}_ZN17coordinate_system5setupEP6vectorS1_i"]
2767 pub fn coordinate_system_setup2(
2768 this: *mut coordinate_system,
2769 _origin_: *mut vector,
2770 _euler_angles_: *mut vector,
2771 _N_: ::std::os::raw::c_int,
2772 );
2773}
2774extern "C" {
2775 #[link_name = "\u{1}_ZN17coordinate_system5setupEP6vectorS1_iPc"]
2776 pub fn coordinate_system_setup3(
2777 this: *mut coordinate_system,
2778 _origin_: *mut vector,
2779 _euler_angles_: *mut vector,
2780 _N_: ::std::os::raw::c_int,
2781 _tag_: *mut ::std::os::raw::c_char,
2782 );
2783}
2784extern "C" {
2785 #[link_name = "\u{1}_ZN17coordinate_system7cleanupEv"]
2786 pub fn coordinate_system_cleanup(this: *mut coordinate_system);
2787}
2788extern "C" {
2789 #[link_name = "\u{1}_ZN17coordinate_system4infoEv"]
2790 pub fn coordinate_system_info(this: *mut coordinate_system);
2791}
2792extern "C" {
2793 #[link_name = "\u{1}_ZN17coordinate_system12info_detailsEv"]
2794 pub fn coordinate_system_info_details(this: *mut coordinate_system);
2795}
2796extern "C" {
2797 #[link_name = "\u{1}_ZN17coordinate_system6updateEv"]
2798 pub fn coordinate_system_update(this: *mut coordinate_system);
2799}
2800extern "C" {
2801 #[link_name = "\u{1}_ZN17coordinate_system6updateE6vectorS0_i"]
2802 pub fn coordinate_system_update1(
2803 this: *mut coordinate_system,
2804 _origin_: vector,
2805 _euler_angles_: vector,
2806 idx: ::std::os::raw::c_int,
2807 );
2808}
2809impl coordinate_system {
2810 #[inline]
2811 pub unsafe fn setup(&mut self) {
2812 coordinate_system_setup(self)
2813 }
2814 #[inline]
2815 pub unsafe fn setup1(&mut self, _origin_: vector, _euler_angles_: vector) {
2816 coordinate_system_setup1(self, _origin_, _euler_angles_)
2817 }
2818 #[inline]
2819 pub unsafe fn setup2(
2820 &mut self,
2821 _origin_: *mut vector,
2822 _euler_angles_: *mut vector,
2823 _N_: ::std::os::raw::c_int,
2824 ) {
2825 coordinate_system_setup2(self, _origin_, _euler_angles_, _N_)
2826 }
2827 #[inline]
2828 pub unsafe fn setup3(
2829 &mut self,
2830 _origin_: *mut vector,
2831 _euler_angles_: *mut vector,
2832 _N_: ::std::os::raw::c_int,
2833 _tag_: *mut ::std::os::raw::c_char,
2834 ) {
2835 coordinate_system_setup3(self, _origin_, _euler_angles_, _N_, _tag_)
2836 }
2837 #[inline]
2838 pub unsafe fn cleanup(&mut self) {
2839 coordinate_system_cleanup(self)
2840 }
2841 #[inline]
2842 pub unsafe fn info(&mut self) {
2843 coordinate_system_info(self)
2844 }
2845 #[inline]
2846 pub unsafe fn info_details(&mut self) {
2847 coordinate_system_info_details(self)
2848 }
2849 #[inline]
2850 pub unsafe fn update(&mut self) {
2851 coordinate_system_update(self)
2852 }
2853 #[inline]
2854 pub unsafe fn update1(
2855 &mut self,
2856 _origin_: vector,
2857 _euler_angles_: vector,
2858 idx: ::std::os::raw::c_int,
2859 ) {
2860 coordinate_system_update1(self, _origin_, _euler_angles_, idx)
2861 }
2862}
2863#[repr(C)]
2864#[derive(Debug, Copy, Clone)]
2865pub struct conic {
2866 pub ref_frame: coordinate_system,
2867 pub origin: vector,
2868 pub d__origin: *mut vector,
2869 pub c: rtd,
2870 pub k: rtd,
2871 pub refractive_index: rtd,
2872 pub even_asphere_N: ::std::os::raw::c_int,
2873 pub d__even_asphere_a: *mut rtd,
2874}
2875#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2876const _: () = {
2877 ["Size of conic"][::std::mem::size_of::<conic>() - 160usize];
2878 ["Alignment of conic"][::std::mem::align_of::<conic>() - 8usize];
2879 ["Offset of field: conic::ref_frame"][::std::mem::offset_of!(conic, ref_frame) - 0usize];
2880 ["Offset of field: conic::origin"][::std::mem::offset_of!(conic, origin) - 88usize];
2881 ["Offset of field: conic::d__origin"][::std::mem::offset_of!(conic, d__origin) - 112usize];
2882 ["Offset of field: conic::c"][::std::mem::offset_of!(conic, c) - 120usize];
2883 ["Offset of field: conic::k"][::std::mem::offset_of!(conic, k) - 128usize];
2884 ["Offset of field: conic::refractive_index"]
2885 [::std::mem::offset_of!(conic, refractive_index) - 136usize];
2886 ["Offset of field: conic::even_asphere_N"]
2887 [::std::mem::offset_of!(conic, even_asphere_N) - 144usize];
2888 ["Offset of field: conic::d__even_asphere_a"]
2889 [::std::mem::offset_of!(conic, d__even_asphere_a) - 152usize];
2890};
2891extern "C" {
2892 #[link_name = "\u{1}_ZN5conic5setupEdd"]
2893 pub fn conic_setup(this: *mut conic, _c_: rtd, _k_: rtd);
2894}
2895extern "C" {
2896 #[link_name = "\u{1}_ZN5conic5setupEdd6vectorS0_"]
2897 pub fn conic_setup1(
2898 this: *mut conic,
2899 _c_: rtd,
2900 _k_: rtd,
2901 _origin_: vector,
2902 _euler_angles_: vector,
2903 );
2904}
2905extern "C" {
2906 #[link_name = "\u{1}_ZN5conic5setupEdd6vectorS0_S0_"]
2907 pub fn conic_setup2(
2908 this: *mut conic,
2909 _c_: rtd,
2910 _k_: rtd,
2911 _origin_: vector,
2912 _euler_angles_: vector,
2913 conic_origin: vector,
2914 );
2915}
2916extern "C" {
2917 #[link_name = "\u{1}_ZN5conic5setupEdd6vectorS0_S0_d"]
2918 pub fn conic_setup3(
2919 this: *mut conic,
2920 _c_: rtd,
2921 _k_: rtd,
2922 _origin_: vector,
2923 _euler_angles_: vector,
2924 conic_origin: vector,
2925 _refractive_index_: rtd,
2926 );
2927}
2928extern "C" {
2929 #[link_name = "\u{1}_ZN5conic5setupEdd6vectorS0_S0_diPd"]
2930 pub fn conic_setup4(
2931 this: *mut conic,
2932 _c_: rtd,
2933 _k_: rtd,
2934 _origin_: vector,
2935 _euler_angles_: vector,
2936 conic_origin: vector,
2937 _refractive_index_: rtd,
2938 asphere_N: ::std::os::raw::c_int,
2939 asphere_a: *mut rtd,
2940 );
2941}
2942extern "C" {
2943 #[link_name = "\u{1}_ZN5conic7cleanupEv"]
2944 pub fn conic_cleanup(this: *mut conic);
2945}
2946extern "C" {
2947 #[link_name = "\u{1}_ZN5conic5traceEP6bundle"]
2948 pub fn conic_trace(this: *mut conic, src: *mut bundle);
2949}
2950extern "C" {
2951 #[link_name = "\u{1}_ZN5conic4infoEv"]
2952 pub fn conic_info(this: *mut conic);
2953}
2954impl conic {
2955 #[inline]
2956 pub unsafe fn setup(&mut self, _c_: rtd, _k_: rtd) {
2957 conic_setup(self, _c_, _k_)
2958 }
2959 #[inline]
2960 pub unsafe fn setup1(&mut self, _c_: rtd, _k_: rtd, _origin_: vector, _euler_angles_: vector) {
2961 conic_setup1(self, _c_, _k_, _origin_, _euler_angles_)
2962 }
2963 #[inline]
2964 pub unsafe fn setup2(
2965 &mut self,
2966 _c_: rtd,
2967 _k_: rtd,
2968 _origin_: vector,
2969 _euler_angles_: vector,
2970 conic_origin: vector,
2971 ) {
2972 conic_setup2(self, _c_, _k_, _origin_, _euler_angles_, conic_origin)
2973 }
2974 #[inline]
2975 pub unsafe fn setup3(
2976 &mut self,
2977 _c_: rtd,
2978 _k_: rtd,
2979 _origin_: vector,
2980 _euler_angles_: vector,
2981 conic_origin: vector,
2982 _refractive_index_: rtd,
2983 ) {
2984 conic_setup3(
2985 self,
2986 _c_,
2987 _k_,
2988 _origin_,
2989 _euler_angles_,
2990 conic_origin,
2991 _refractive_index_,
2992 )
2993 }
2994 #[inline]
2995 pub unsafe fn setup4(
2996 &mut self,
2997 _c_: rtd,
2998 _k_: rtd,
2999 _origin_: vector,
3000 _euler_angles_: vector,
3001 conic_origin: vector,
3002 _refractive_index_: rtd,
3003 asphere_N: ::std::os::raw::c_int,
3004 asphere_a: *mut rtd,
3005 ) {
3006 conic_setup4(
3007 self,
3008 _c_,
3009 _k_,
3010 _origin_,
3011 _euler_angles_,
3012 conic_origin,
3013 _refractive_index_,
3014 asphere_N,
3015 asphere_a,
3016 )
3017 }
3018 #[inline]
3019 pub unsafe fn cleanup(&mut self) {
3020 conic_cleanup(self)
3021 }
3022 #[inline]
3023 pub unsafe fn trace(&mut self, src: *mut bundle) {
3024 conic_trace(self, src)
3025 }
3026 #[inline]
3027 pub unsafe fn info(&mut self) {
3028 conic_info(self)
3029 }
3030}
3031#[repr(C)]
3032#[derive(Debug, Copy, Clone)]
3033pub struct zernikeS {
3034 pub max_n: ::std::os::raw::c_int,
3035 pub j: ::std::os::raw::c_uint,
3036 pub n: ::std::os::raw::c_uint,
3037 pub m: ::std::os::raw::c_uint,
3038 pub n_mode: ::std::os::raw::c_uint,
3039 pub a: *mut rtd,
3040 pub d__a: *mut rtd,
3041 pub bx: *mut rtd,
3042 pub by: *mut rtd,
3043 pub d__bx: *mut rtd,
3044 pub d__by: *mut rtd,
3045 pub bx_row_idx: *mut ::std::os::raw::c_uint,
3046 pub bx_col_ptr: *mut ::std::os::raw::c_uint,
3047 pub by_row_idx: *mut ::std::os::raw::c_uint,
3048 pub by_col_ptr: *mut ::std::os::raw::c_uint,
3049 pub bx_nnz: ::std::os::raw::c_uint,
3050 pub by_nnz: ::std::os::raw::c_uint,
3051 pub cx: *mut rtd,
3052 pub d__cx: *mut rtd,
3053 pub cy: *mut rtd,
3054 pub d__cy: *mut rtd,
3055 pub N: ::std::os::raw::c_int,
3056 pub ref_frame: coordinate_system,
3057}
3058#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3059const _: () = {
3060 ["Size of zernikeS"][::std::mem::size_of::<zernikeS>() - 240usize];
3061 ["Alignment of zernikeS"][::std::mem::align_of::<zernikeS>() - 8usize];
3062 ["Offset of field: zernikeS::max_n"][::std::mem::offset_of!(zernikeS, max_n) - 0usize];
3063 ["Offset of field: zernikeS::j"][::std::mem::offset_of!(zernikeS, j) - 4usize];
3064 ["Offset of field: zernikeS::n"][::std::mem::offset_of!(zernikeS, n) - 8usize];
3065 ["Offset of field: zernikeS::m"][::std::mem::offset_of!(zernikeS, m) - 12usize];
3066 ["Offset of field: zernikeS::n_mode"][::std::mem::offset_of!(zernikeS, n_mode) - 16usize];
3067 ["Offset of field: zernikeS::a"][::std::mem::offset_of!(zernikeS, a) - 24usize];
3068 ["Offset of field: zernikeS::d__a"][::std::mem::offset_of!(zernikeS, d__a) - 32usize];
3069 ["Offset of field: zernikeS::bx"][::std::mem::offset_of!(zernikeS, bx) - 40usize];
3070 ["Offset of field: zernikeS::by"][::std::mem::offset_of!(zernikeS, by) - 48usize];
3071 ["Offset of field: zernikeS::d__bx"][::std::mem::offset_of!(zernikeS, d__bx) - 56usize];
3072 ["Offset of field: zernikeS::d__by"][::std::mem::offset_of!(zernikeS, d__by) - 64usize];
3073 ["Offset of field: zernikeS::bx_row_idx"]
3074 [::std::mem::offset_of!(zernikeS, bx_row_idx) - 72usize];
3075 ["Offset of field: zernikeS::bx_col_ptr"]
3076 [::std::mem::offset_of!(zernikeS, bx_col_ptr) - 80usize];
3077 ["Offset of field: zernikeS::by_row_idx"]
3078 [::std::mem::offset_of!(zernikeS, by_row_idx) - 88usize];
3079 ["Offset of field: zernikeS::by_col_ptr"]
3080 [::std::mem::offset_of!(zernikeS, by_col_ptr) - 96usize];
3081 ["Offset of field: zernikeS::bx_nnz"][::std::mem::offset_of!(zernikeS, bx_nnz) - 104usize];
3082 ["Offset of field: zernikeS::by_nnz"][::std::mem::offset_of!(zernikeS, by_nnz) - 108usize];
3083 ["Offset of field: zernikeS::cx"][::std::mem::offset_of!(zernikeS, cx) - 112usize];
3084 ["Offset of field: zernikeS::d__cx"][::std::mem::offset_of!(zernikeS, d__cx) - 120usize];
3085 ["Offset of field: zernikeS::cy"][::std::mem::offset_of!(zernikeS, cy) - 128usize];
3086 ["Offset of field: zernikeS::d__cy"][::std::mem::offset_of!(zernikeS, d__cy) - 136usize];
3087 ["Offset of field: zernikeS::N"][::std::mem::offset_of!(zernikeS, N) - 144usize];
3088 ["Offset of field: zernikeS::ref_frame"]
3089 [::std::mem::offset_of!(zernikeS, ref_frame) - 152usize];
3090};
3091extern "C" {
3092 #[link_name = "\u{1}_ZN8zernikeS5setupEiPd"]
3093 pub fn zernikeS_setup(this: *mut zernikeS, max_n: ::std::os::raw::c_int, a: *mut rtd);
3094}
3095extern "C" {
3096 #[link_name = "\u{1}_ZN8zernikeS5setupEiPdi"]
3097 pub fn zernikeS_setup1(
3098 this: *mut zernikeS,
3099 _max_n_: ::std::os::raw::c_int,
3100 _a_: *mut rtd,
3101 _N_: ::std::os::raw::c_int,
3102 );
3103}
3104extern "C" {
3105 #[link_name = "\u{1}_ZN8zernikeS5setupEiPd6vectorS1_"]
3106 pub fn zernikeS_setup2(
3107 this: *mut zernikeS,
3108 max_n: ::std::os::raw::c_int,
3109 a: *mut rtd,
3110 _origin_: vector,
3111 _euler_angles_: vector,
3112 );
3113}
3114extern "C" {
3115 #[link_name = "\u{1}_ZN8zernikeS5setupEiPd6vectorS1_i"]
3116 pub fn zernikeS_setup3(
3117 this: *mut zernikeS,
3118 max_n: ::std::os::raw::c_int,
3119 a: *mut rtd,
3120 _origin_: vector,
3121 _euler_angles_: vector,
3122 _N_: ::std::os::raw::c_int,
3123 );
3124}
3125extern "C" {
3126 #[link_name = "\u{1}_ZN8zernikeS7cleanupEv"]
3127 pub fn zernikeS_cleanup(this: *mut zernikeS);
3128}
3129extern "C" {
3130 #[link_name = "\u{1}_ZN8zernikeS7surfaceEPdS0_S0_i"]
3131 pub fn zernikeS_surface(
3132 this: *mut zernikeS,
3133 S: *mut rtd,
3134 r: *mut rtd,
3135 o: *mut rtd,
3136 N: ::std::os::raw::c_int,
3137 );
3138}
3139extern "C" {
3140 #[link_name = "\u{1}_ZN8zernikeS7surfaceEPdS0_S0_ii"]
3141 pub fn zernikeS_surface1(
3142 this: *mut zernikeS,
3143 S: *mut rtd,
3144 r: *mut rtd,
3145 o: *mut rtd,
3146 N: ::std::os::raw::c_int,
3147 surf_id: ::std::os::raw::c_int,
3148 );
3149}
3150extern "C" {
3151 #[link_name = "\u{1}_ZN8zernikeS6updateEPd"]
3152 pub fn zernikeS_update(this: *mut zernikeS, a: *mut rtd);
3153}
3154extern "C" {
3155 #[link_name = "\u{1}_ZN8zernikeS24surface_derivative_coefsEv"]
3156 pub fn zernikeS_surface_derivative_coefs(this: *mut zernikeS);
3157}
3158extern "C" {
3159 #[link_name = "\u{1}_ZN8zernikeS19surface_derivativesEPdS0_S0_S0_i"]
3160 pub fn zernikeS_surface_derivatives(
3161 this: *mut zernikeS,
3162 d__dSdx: *mut rtd,
3163 d__dSdy: *mut rtd,
3164 d__r: *mut rtd,
3165 d__o: *mut rtd,
3166 N: ::std::os::raw::c_int,
3167 );
3168}
3169extern "C" {
3170 #[link_name = "\u{1}_ZN8zernikeS23surface_and_derivativesEPdS0_S0_S0_S0_i"]
3171 pub fn zernikeS_surface_and_derivatives(
3172 this: *mut zernikeS,
3173 d__S: *mut rtd,
3174 d__dSdx: *mut rtd,
3175 d__dSdy: *mut rtd,
3176 d__r: *mut rtd,
3177 d__o: *mut rtd,
3178 N: ::std::os::raw::c_int,
3179 );
3180}
3181extern "C" {
3182 #[link_name = "\u{1}_ZN8zernikeS23surface_and_derivativesEPdS0_S0_S0_S0_ii"]
3183 pub fn zernikeS_surface_and_derivatives1(
3184 this: *mut zernikeS,
3185 d__S: *mut rtd,
3186 d__dSdx: *mut rtd,
3187 d__dSdy: *mut rtd,
3188 d__r: *mut rtd,
3189 d__o: *mut rtd,
3190 N: ::std::os::raw::c_int,
3191 surf_id: ::std::os::raw::c_int,
3192 );
3193}
3194extern "C" {
3195 #[link_name = "\u{1}_ZN8zernikeS10projectionEPfPdS1_i"]
3196 pub fn zernikeS_projection(
3197 this: *mut zernikeS,
3198 d__phase: *mut f32,
3199 d__r: *mut rtd,
3200 d__o: *mut rtd,
3201 N: ::std::os::raw::c_int,
3202 );
3203}
3204impl zernikeS {
3205 #[inline]
3206 pub unsafe fn setup(&mut self, max_n: ::std::os::raw::c_int, a: *mut rtd) {
3207 zernikeS_setup(self, max_n, a)
3208 }
3209 #[inline]
3210 pub unsafe fn setup1(
3211 &mut self,
3212 _max_n_: ::std::os::raw::c_int,
3213 _a_: *mut rtd,
3214 _N_: ::std::os::raw::c_int,
3215 ) {
3216 zernikeS_setup1(self, _max_n_, _a_, _N_)
3217 }
3218 #[inline]
3219 pub unsafe fn setup2(
3220 &mut self,
3221 max_n: ::std::os::raw::c_int,
3222 a: *mut rtd,
3223 _origin_: vector,
3224 _euler_angles_: vector,
3225 ) {
3226 zernikeS_setup2(self, max_n, a, _origin_, _euler_angles_)
3227 }
3228 #[inline]
3229 pub unsafe fn setup3(
3230 &mut self,
3231 max_n: ::std::os::raw::c_int,
3232 a: *mut rtd,
3233 _origin_: vector,
3234 _euler_angles_: vector,
3235 _N_: ::std::os::raw::c_int,
3236 ) {
3237 zernikeS_setup3(self, max_n, a, _origin_, _euler_angles_, _N_)
3238 }
3239 #[inline]
3240 pub unsafe fn cleanup(&mut self) {
3241 zernikeS_cleanup(self)
3242 }
3243 #[inline]
3244 pub unsafe fn surface(
3245 &mut self,
3246 S: *mut rtd,
3247 r: *mut rtd,
3248 o: *mut rtd,
3249 N: ::std::os::raw::c_int,
3250 ) {
3251 zernikeS_surface(self, S, r, o, N)
3252 }
3253 #[inline]
3254 pub unsafe fn surface1(
3255 &mut self,
3256 S: *mut rtd,
3257 r: *mut rtd,
3258 o: *mut rtd,
3259 N: ::std::os::raw::c_int,
3260 surf_id: ::std::os::raw::c_int,
3261 ) {
3262 zernikeS_surface1(self, S, r, o, N, surf_id)
3263 }
3264 #[inline]
3265 pub unsafe fn update(&mut self, a: *mut rtd) {
3266 zernikeS_update(self, a)
3267 }
3268 #[inline]
3269 pub unsafe fn surface_derivative_coefs(&mut self) {
3270 zernikeS_surface_derivative_coefs(self)
3271 }
3272 #[inline]
3273 pub unsafe fn surface_derivatives(
3274 &mut self,
3275 d__dSdx: *mut rtd,
3276 d__dSdy: *mut rtd,
3277 d__r: *mut rtd,
3278 d__o: *mut rtd,
3279 N: ::std::os::raw::c_int,
3280 ) {
3281 zernikeS_surface_derivatives(self, d__dSdx, d__dSdy, d__r, d__o, N)
3282 }
3283 #[inline]
3284 pub unsafe fn surface_and_derivatives(
3285 &mut self,
3286 d__S: *mut rtd,
3287 d__dSdx: *mut rtd,
3288 d__dSdy: *mut rtd,
3289 d__r: *mut rtd,
3290 d__o: *mut rtd,
3291 N: ::std::os::raw::c_int,
3292 ) {
3293 zernikeS_surface_and_derivatives(self, d__S, d__dSdx, d__dSdy, d__r, d__o, N)
3294 }
3295 #[inline]
3296 pub unsafe fn surface_and_derivatives1(
3297 &mut self,
3298 d__S: *mut rtd,
3299 d__dSdx: *mut rtd,
3300 d__dSdy: *mut rtd,
3301 d__r: *mut rtd,
3302 d__o: *mut rtd,
3303 N: ::std::os::raw::c_int,
3304 surf_id: ::std::os::raw::c_int,
3305 ) {
3306 zernikeS_surface_and_derivatives1(self, d__S, d__dSdx, d__dSdy, d__r, d__o, N, surf_id)
3307 }
3308 #[inline]
3309 pub unsafe fn projection(
3310 &mut self,
3311 d__phase: *mut f32,
3312 d__r: *mut rtd,
3313 d__o: *mut rtd,
3314 N: ::std::os::raw::c_int,
3315 ) {
3316 zernikeS_projection(self, d__phase, d__r, d__o, N)
3317 }
3318}
3319#[repr(C)]
3320#[derive(Debug, Copy, Clone)]
3321pub struct aperture {
3322 pub D_px: ::std::os::raw::c_int,
3323 pub D: rtd,
3324 pub ri: rtd,
3325 pub D_seg: rtd,
3326 pub N: ::std::os::raw::c_int,
3327 pub V: mask,
3328 pub ref_frame: coordinate_system,
3329}
3330#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3331const _: () = {
3332 ["Size of aperture"][::std::mem::size_of::<aperture>() - 208usize];
3333 ["Alignment of aperture"][::std::mem::align_of::<aperture>() - 8usize];
3334 ["Offset of field: aperture::D_px"][::std::mem::offset_of!(aperture, D_px) - 0usize];
3335 ["Offset of field: aperture::D"][::std::mem::offset_of!(aperture, D) - 8usize];
3336 ["Offset of field: aperture::ri"][::std::mem::offset_of!(aperture, ri) - 16usize];
3337 ["Offset of field: aperture::D_seg"][::std::mem::offset_of!(aperture, D_seg) - 24usize];
3338 ["Offset of field: aperture::N"][::std::mem::offset_of!(aperture, N) - 32usize];
3339 ["Offset of field: aperture::V"][::std::mem::offset_of!(aperture, V) - 40usize];
3340 ["Offset of field: aperture::ref_frame"]
3341 [::std::mem::offset_of!(aperture, ref_frame) - 120usize];
3342};
3343extern "C" {
3344 #[link_name = "\u{1}_ZN8aperture5setupEdi6vectorS0_"]
3345 pub fn aperture_setup(
3346 this: *mut aperture,
3347 _D_: rtd,
3348 _D_px_: ::std::os::raw::c_int,
3349 _origin_: vector,
3350 _euler_angles_: vector,
3351 );
3352}
3353extern "C" {
3354 #[link_name = "\u{1}_ZN8aperture5setupEddi6vectorS0_"]
3355 pub fn aperture_setup1(
3356 this: *mut aperture,
3357 _D_: rtd,
3358 _ri_: rtd,
3359 _D_px_: ::std::os::raw::c_int,
3360 _origin_: vector,
3361 _euler_angles_: vector,
3362 );
3363}
3364extern "C" {
3365 #[link_name = "\u{1}_ZN8aperture5setupEdddiP6vectorS1_i"]
3366 pub fn aperture_setup2(
3367 this: *mut aperture,
3368 _D_: rtd,
3369 _ri_: rtd,
3370 _D_seg_: rtd,
3371 _D_px_: ::std::os::raw::c_int,
3372 _origin_: *mut vector,
3373 _euler_angles_: *mut vector,
3374 N_segment: ::std::os::raw::c_int,
3375 );
3376}
3377extern "C" {
3378 #[link_name = "\u{1}_ZN8aperture12setup_GMT_M1Edi"]
3379 pub fn aperture_setup_GMT_M1(this: *mut aperture, _D_: rtd, _D_px_: ::std::os::raw::c_int);
3380}
3381extern "C" {
3382 #[link_name = "\u{1}_ZN8aperture7cleanupEv"]
3383 pub fn aperture_cleanup(this: *mut aperture);
3384}
3385extern "C" {
3386 #[link_name = "\u{1}_ZN8aperture10vignettingEP6bundle"]
3387 pub fn aperture_vignetting(this: *mut aperture, rays: *mut bundle);
3388}
3389impl aperture {
3390 #[inline]
3391 pub unsafe fn setup(
3392 &mut self,
3393 _D_: rtd,
3394 _D_px_: ::std::os::raw::c_int,
3395 _origin_: vector,
3396 _euler_angles_: vector,
3397 ) {
3398 aperture_setup(self, _D_, _D_px_, _origin_, _euler_angles_)
3399 }
3400 #[inline]
3401 pub unsafe fn setup1(
3402 &mut self,
3403 _D_: rtd,
3404 _ri_: rtd,
3405 _D_px_: ::std::os::raw::c_int,
3406 _origin_: vector,
3407 _euler_angles_: vector,
3408 ) {
3409 aperture_setup1(self, _D_, _ri_, _D_px_, _origin_, _euler_angles_)
3410 }
3411 #[inline]
3412 pub unsafe fn setup2(
3413 &mut self,
3414 _D_: rtd,
3415 _ri_: rtd,
3416 _D_seg_: rtd,
3417 _D_px_: ::std::os::raw::c_int,
3418 _origin_: *mut vector,
3419 _euler_angles_: *mut vector,
3420 N_segment: ::std::os::raw::c_int,
3421 ) {
3422 aperture_setup2(
3423 self,
3424 _D_,
3425 _ri_,
3426 _D_seg_,
3427 _D_px_,
3428 _origin_,
3429 _euler_angles_,
3430 N_segment,
3431 )
3432 }
3433 #[inline]
3434 pub unsafe fn setup_GMT_M1(&mut self, _D_: rtd, _D_px_: ::std::os::raw::c_int) {
3435 aperture_setup_GMT_M1(self, _D_, _D_px_)
3436 }
3437 #[inline]
3438 pub unsafe fn cleanup(&mut self) {
3439 aperture_cleanup(self)
3440 }
3441 #[inline]
3442 pub unsafe fn vignetting(&mut self, rays: *mut bundle) {
3443 aperture_vignetting(self, rays)
3444 }
3445}
3446extern "C" {
3447 #[link_name = "\u{1}_Z14transform_to_SP6bundleP5conic"]
3448 pub fn transform_to_S(rays: *mut bundle, F: *mut conic);
3449}
3450extern "C" {
3451 #[link_name = "\u{1}_Z14transform_to_SP6bundleP8aperture"]
3452 pub fn transform_to_S1(rays: *mut bundle, A: *mut aperture);
3453}
3454extern "C" {
3455 #[link_name = "\u{1}_Z14transform_to_RP6bundleP5conic"]
3456 pub fn transform_to_R(rays: *mut bundle, F: *mut conic);
3457}
3458extern "C" {
3459 #[link_name = "\u{1}_Z14transform_to_RP6bundleP8aperture"]
3460 pub fn transform_to_R1(rays: *mut bundle, A: *mut aperture);
3461}
3462extern "C" {
3463 #[link_name = "\u{1}_Z9intersectP6bundleP5conic"]
3464 pub fn intersect(rays: *mut bundle, F: *mut conic);
3465}
3466extern "C" {
3467 #[link_name = "\u{1}_Z7reflectP6bundle"]
3468 pub fn reflect(rays: *mut bundle);
3469}
3470extern "C" {
3471 #[link_name = "\u{1}_Z7refractP6bundled"]
3472 pub fn refract(rays: *mut bundle, mu: rtd);
3473}
3474#[repr(C)]
3475#[derive(Debug, Copy, Clone)]
3476pub struct imaging {
3477 pub N_PX_PUPIL: ::std::os::raw::c_int,
3478 pub N_DFT: ::std::os::raw::c_int,
3479 pub N_SIDE_LENSLET: ::std::os::raw::c_int,
3480 pub N_LENSLET: ::std::os::raw::c_int,
3481 pub N_SOURCE: ::std::os::raw::c_int,
3482 pub N_PX_IMAGE: ::std::os::raw::c_int,
3483 pub N_PX_CAMERA: ::std::os::raw::c_int,
3484 pub N_FRAME: ::std::os::raw::c_int,
3485 pub BIN_IMAGE: ::std::os::raw::c_int,
3486 pub LOCAL_RAND_SEED: ::std::os::raw::c_int,
3487 pub plan: cufftHandle,
3488 pub N_PHOTON_PER_SECOND_PER_FRAME: f32,
3489 pub N_PHOTON_PER_FRAME: f32,
3490 pub d__wave_PUPIL: *mut float2,
3491 pub d__frame: *mut f32,
3492 pub zenith: f32,
3493 pub azimuth: f32,
3494 pub theta_x: f32,
3495 pub theta_y: f32,
3496 pub d__zenith: *mut f32,
3497 pub d__azimuth: *mut f32,
3498 pub d__theta_x: *mut f32,
3499 pub d__theta_y: *mut f32,
3500 pub pixel_scale: f32,
3501 pub photoelectron_gain: f32,
3502 pub absolute_pointing: ::std::os::raw::c_char,
3503 pub devStates: *mut curandState,
3504}
3505#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3506const _: () = {
3507 ["Size of imaging"][::std::mem::size_of::<imaging>() - 144usize];
3508 ["Alignment of imaging"][::std::mem::align_of::<imaging>() - 8usize];
3509 ["Offset of field: imaging::N_PX_PUPIL"][::std::mem::offset_of!(imaging, N_PX_PUPIL) - 0usize];
3510 ["Offset of field: imaging::N_DFT"][::std::mem::offset_of!(imaging, N_DFT) - 4usize];
3511 ["Offset of field: imaging::N_SIDE_LENSLET"]
3512 [::std::mem::offset_of!(imaging, N_SIDE_LENSLET) - 8usize];
3513 ["Offset of field: imaging::N_LENSLET"][::std::mem::offset_of!(imaging, N_LENSLET) - 12usize];
3514 ["Offset of field: imaging::N_SOURCE"][::std::mem::offset_of!(imaging, N_SOURCE) - 16usize];
3515 ["Offset of field: imaging::N_PX_IMAGE"][::std::mem::offset_of!(imaging, N_PX_IMAGE) - 20usize];
3516 ["Offset of field: imaging::N_PX_CAMERA"]
3517 [::std::mem::offset_of!(imaging, N_PX_CAMERA) - 24usize];
3518 ["Offset of field: imaging::N_FRAME"][::std::mem::offset_of!(imaging, N_FRAME) - 28usize];
3519 ["Offset of field: imaging::BIN_IMAGE"][::std::mem::offset_of!(imaging, BIN_IMAGE) - 32usize];
3520 ["Offset of field: imaging::LOCAL_RAND_SEED"]
3521 [::std::mem::offset_of!(imaging, LOCAL_RAND_SEED) - 36usize];
3522 ["Offset of field: imaging::plan"][::std::mem::offset_of!(imaging, plan) - 40usize];
3523 ["Offset of field: imaging::N_PHOTON_PER_SECOND_PER_FRAME"]
3524 [::std::mem::offset_of!(imaging, N_PHOTON_PER_SECOND_PER_FRAME) - 44usize];
3525 ["Offset of field: imaging::N_PHOTON_PER_FRAME"]
3526 [::std::mem::offset_of!(imaging, N_PHOTON_PER_FRAME) - 48usize];
3527 ["Offset of field: imaging::d__wave_PUPIL"]
3528 [::std::mem::offset_of!(imaging, d__wave_PUPIL) - 56usize];
3529 ["Offset of field: imaging::d__frame"][::std::mem::offset_of!(imaging, d__frame) - 64usize];
3530 ["Offset of field: imaging::zenith"][::std::mem::offset_of!(imaging, zenith) - 72usize];
3531 ["Offset of field: imaging::azimuth"][::std::mem::offset_of!(imaging, azimuth) - 76usize];
3532 ["Offset of field: imaging::theta_x"][::std::mem::offset_of!(imaging, theta_x) - 80usize];
3533 ["Offset of field: imaging::theta_y"][::std::mem::offset_of!(imaging, theta_y) - 84usize];
3534 ["Offset of field: imaging::d__zenith"][::std::mem::offset_of!(imaging, d__zenith) - 88usize];
3535 ["Offset of field: imaging::d__azimuth"][::std::mem::offset_of!(imaging, d__azimuth) - 96usize];
3536 ["Offset of field: imaging::d__theta_x"]
3537 [::std::mem::offset_of!(imaging, d__theta_x) - 104usize];
3538 ["Offset of field: imaging::d__theta_y"]
3539 [::std::mem::offset_of!(imaging, d__theta_y) - 112usize];
3540 ["Offset of field: imaging::pixel_scale"]
3541 [::std::mem::offset_of!(imaging, pixel_scale) - 120usize];
3542 ["Offset of field: imaging::photoelectron_gain"]
3543 [::std::mem::offset_of!(imaging, photoelectron_gain) - 124usize];
3544 ["Offset of field: imaging::absolute_pointing"]
3545 [::std::mem::offset_of!(imaging, absolute_pointing) - 128usize];
3546 ["Offset of field: imaging::devStates"][::std::mem::offset_of!(imaging, devStates) - 136usize];
3547};
3548extern "C" {
3549 #[link_name = "\u{1}_ZN7imaging5setupEiiiff"]
3550 pub fn imaging_setup(
3551 this: *mut imaging,
3552 __N_PX_PUPIL: ::std::os::raw::c_int,
3553 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3554 DFT_osf: ::std::os::raw::c_int,
3555 IMAGE_osf: f32,
3556 CAMERA_osf: f32,
3557 );
3558}
3559extern "C" {
3560 #[link_name = "\u{1}_ZN7imaging5setupEiiiffi"]
3561 pub fn imaging_setup1(
3562 this: *mut imaging,
3563 __N_PX_PUPIL: ::std::os::raw::c_int,
3564 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3565 DFT_osf: ::std::os::raw::c_int,
3566 IMAGE_osf: f32,
3567 CAMERA_osf: f32,
3568 __N_SOURCE: ::std::os::raw::c_int,
3569 );
3570}
3571extern "C" {
3572 #[link_name = "\u{1}_ZN7imaging5setupEiiiifi"]
3573 pub fn imaging_setup2(
3574 this: *mut imaging,
3575 __N_PX_PUPIL: ::std::os::raw::c_int,
3576 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3577 DFT_osf: ::std::os::raw::c_int,
3578 N_PX_IMAGE_: ::std::os::raw::c_int,
3579 CAMERA_osf: f32,
3580 __N_SOURCE: ::std::os::raw::c_int,
3581 );
3582}
3583extern "C" {
3584 #[link_name = "\u{1}_ZN7imaging5setupEiiiiii"]
3585 pub fn imaging_setup3(
3586 this: *mut imaging,
3587 __N_PX_PUPIL: ::std::os::raw::c_int,
3588 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3589 DFT_osf: ::std::os::raw::c_int,
3590 N_PX_IMAGE_: ::std::os::raw::c_int,
3591 BIN_IMAGE: ::std::os::raw::c_int,
3592 __N_SOURCE: ::std::os::raw::c_int,
3593 );
3594}
3595extern "C" {
3596 #[link_name = "\u{1}_ZN7imaging24setupSegmentPistonSensorEiiiiii"]
3597 pub fn imaging_setupSegmentPistonSensor(
3598 this: *mut imaging,
3599 __N_PX_PUPIL: ::std::os::raw::c_int,
3600 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3601 _N_DFT_: ::std::os::raw::c_int,
3602 N_PX_IMAGE_: ::std::os::raw::c_int,
3603 _BIN_IMAGE_: ::std::os::raw::c_int,
3604 __N_SOURCE: ::std::os::raw::c_int,
3605 );
3606}
3607extern "C" {
3608 #[link_name = "\u{1}_ZN7imaging7cleanupEv"]
3609 pub fn imaging_cleanup(this: *mut imaging);
3610}
3611extern "C" {
3612 #[link_name = "\u{1}_ZN7imaging26cleanupSegmentPistonSensorEv"]
3613 pub fn imaging_cleanupSegmentPistonSensor(this: *mut imaging);
3614}
3615extern "C" {
3616 #[link_name = "\u{1}_ZN7imaging22set_pointing_directionEPfS0_"]
3617 pub fn imaging_set_pointing_direction(this: *mut imaging, zen: *mut f32, azim: *mut f32);
3618}
3619extern "C" {
3620 #[link_name = "\u{1}_ZN7imaging5resetEv"]
3621 pub fn imaging_reset(this: *mut imaging);
3622}
3623extern "C" {
3624 #[link_name = "\u{1}_ZN7imaging9reset_rngEi"]
3625 pub fn imaging_reset_rng(this: *mut imaging, SEED: ::std::os::raw::c_int);
3626}
3627extern "C" {
3628 #[link_name = "\u{1}_ZN7imaging9propagateEP6source"]
3629 pub fn imaging_propagate(this: *mut imaging, src: *mut source);
3630}
3631extern "C" {
3632 #[link_name = "\u{1}_ZN7imaging13propagate_cpxEP6source"]
3633 pub fn imaging_propagate_cpx(this: *mut imaging, src: *mut source);
3634}
3635extern "C" {
3636 #[link_name = "\u{1}_ZN7imaging18propagateNoOverlapEP6source"]
3637 pub fn imaging_propagateNoOverlap(this: *mut imaging, src: *mut source);
3638}
3639extern "C" {
3640 #[link_name = "\u{1}_ZN7imaging22propagateNoOverlapBareEP6source"]
3641 pub fn imaging_propagateNoOverlapBare(this: *mut imaging, src: *mut source);
3642}
3643extern "C" {
3644 #[link_name = "\u{1}_ZN7imaging21propagateNoOverlapSPSEP6sourceff"]
3645 pub fn imaging_propagateNoOverlapSPS(
3646 this: *mut imaging,
3647 src: *mut source,
3648 d: f32,
3649 wavenumber: f32,
3650 );
3651}
3652extern "C" {
3653 #[link_name = "\u{1}_ZN7imaging12propagateTT7EP6source"]
3654 pub fn imaging_propagateTT7(this: *mut imaging, src: *mut source);
3655}
3656extern "C" {
3657 #[link_name = "\u{1}_ZN7imaging12propagateTT7EP6sourcePi"]
3658 pub fn imaging_propagateTT71(
3659 this: *mut imaging,
3660 src: *mut source,
3661 d__piston_mask: *mut ::std::os::raw::c_int,
3662 );
3663}
3664extern "C" {
3665 #[link_name = "\u{1}_ZN7imaging25propagateThroughFieldStopEP6sourcef"]
3666 pub fn imaging_propagateThroughFieldStop(
3667 this: *mut imaging,
3668 src: *mut source,
3669 field_stop_diam: f32,
3670 );
3671}
3672extern "C" {
3673 #[link_name = "\u{1}_ZN7imaging23propagateThroughPyramidEP6sourcef"]
3674 pub fn imaging_propagateThroughPyramid(this: *mut imaging, src: *mut source, alpha: f32);
3675}
3676extern "C" {
3677 #[link_name = "\u{1}_ZN7imaging32propagateThroughModulatedPyramidEP6sourcefif"]
3678 pub fn imaging_propagateThroughModulatedPyramid(
3679 this: *mut imaging,
3680 src: *mut source,
3681 modulation: f32,
3682 modulation_sampling: ::std::os::raw::c_int,
3683 alpha: f32,
3684 );
3685}
3686extern "C" {
3687 #[link_name = "\u{1}_ZN7imaging7readoutEff"]
3688 pub fn imaging_readout(this: *mut imaging, exposureTime: f32, readOutNoiseRms: f32);
3689}
3690extern "C" {
3691 #[link_name = "\u{1}_ZN7imaging17noiseless_readoutEf"]
3692 pub fn imaging_noiseless_readout(this: *mut imaging, exposureTime: f32);
3693}
3694extern "C" {
3695 #[link_name = "\u{1}_ZN7imaging7readoutEffff"]
3696 pub fn imaging_readout1(
3697 this: *mut imaging,
3698 exposureTime: f32,
3699 readOutNoiseRms: f32,
3700 nBackgroundPhoton: f32,
3701 noiseFactor: f32,
3702 );
3703}
3704extern "C" {
3705 #[link_name = "\u{1}_ZN7imaging12strehl_ratioEPS_"]
3706 pub fn imaging_strehl_ratio(this: *mut imaging, ref_: *mut imaging) -> f32;
3707}
3708extern "C" {
3709 #[link_name = "\u{1}_ZN7imaging4infoEv"]
3710 pub fn imaging_info(this: *mut imaging);
3711}
3712extern "C" {
3713 #[link_name = "\u{1}_ZN7imaging10frame2fileEPKc"]
3714 pub fn imaging_frame2file(this: *mut imaging, filename: *const ::std::os::raw::c_char);
3715}
3716extern "C" {
3717 #[link_name = "\u{1}_ZN7imaging10show_frameEPc"]
3718 pub fn imaging_show_frame(this: *mut imaging, filename: *mut ::std::os::raw::c_char);
3719}
3720extern "C" {
3721 #[link_name = "\u{1}_ZN7imaging10show_frameEPcPS_"]
3722 pub fn imaging_show_frame1(
3723 this: *mut imaging,
3724 filename: *mut ::std::os::raw::c_char,
3725 ref_: *mut imaging,
3726 );
3727}
3728impl imaging {
3729 #[inline]
3730 pub unsafe fn setup(
3731 &mut self,
3732 __N_PX_PUPIL: ::std::os::raw::c_int,
3733 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3734 DFT_osf: ::std::os::raw::c_int,
3735 IMAGE_osf: f32,
3736 CAMERA_osf: f32,
3737 ) {
3738 imaging_setup(
3739 self,
3740 __N_PX_PUPIL,
3741 __N_SIDE_LENSLET,
3742 DFT_osf,
3743 IMAGE_osf,
3744 CAMERA_osf,
3745 )
3746 }
3747 #[inline]
3748 pub unsafe fn setup1(
3749 &mut self,
3750 __N_PX_PUPIL: ::std::os::raw::c_int,
3751 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3752 DFT_osf: ::std::os::raw::c_int,
3753 IMAGE_osf: f32,
3754 CAMERA_osf: f32,
3755 __N_SOURCE: ::std::os::raw::c_int,
3756 ) {
3757 imaging_setup1(
3758 self,
3759 __N_PX_PUPIL,
3760 __N_SIDE_LENSLET,
3761 DFT_osf,
3762 IMAGE_osf,
3763 CAMERA_osf,
3764 __N_SOURCE,
3765 )
3766 }
3767 #[inline]
3768 pub unsafe fn setup2(
3769 &mut self,
3770 __N_PX_PUPIL: ::std::os::raw::c_int,
3771 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3772 DFT_osf: ::std::os::raw::c_int,
3773 N_PX_IMAGE_: ::std::os::raw::c_int,
3774 CAMERA_osf: f32,
3775 __N_SOURCE: ::std::os::raw::c_int,
3776 ) {
3777 imaging_setup2(
3778 self,
3779 __N_PX_PUPIL,
3780 __N_SIDE_LENSLET,
3781 DFT_osf,
3782 N_PX_IMAGE_,
3783 CAMERA_osf,
3784 __N_SOURCE,
3785 )
3786 }
3787 #[inline]
3788 pub unsafe fn setup3(
3789 &mut self,
3790 __N_PX_PUPIL: ::std::os::raw::c_int,
3791 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3792 DFT_osf: ::std::os::raw::c_int,
3793 N_PX_IMAGE_: ::std::os::raw::c_int,
3794 BIN_IMAGE: ::std::os::raw::c_int,
3795 __N_SOURCE: ::std::os::raw::c_int,
3796 ) {
3797 imaging_setup3(
3798 self,
3799 __N_PX_PUPIL,
3800 __N_SIDE_LENSLET,
3801 DFT_osf,
3802 N_PX_IMAGE_,
3803 BIN_IMAGE,
3804 __N_SOURCE,
3805 )
3806 }
3807 #[inline]
3808 pub unsafe fn setupSegmentPistonSensor(
3809 &mut self,
3810 __N_PX_PUPIL: ::std::os::raw::c_int,
3811 __N_SIDE_LENSLET: ::std::os::raw::c_int,
3812 _N_DFT_: ::std::os::raw::c_int,
3813 N_PX_IMAGE_: ::std::os::raw::c_int,
3814 _BIN_IMAGE_: ::std::os::raw::c_int,
3815 __N_SOURCE: ::std::os::raw::c_int,
3816 ) {
3817 imaging_setupSegmentPistonSensor(
3818 self,
3819 __N_PX_PUPIL,
3820 __N_SIDE_LENSLET,
3821 _N_DFT_,
3822 N_PX_IMAGE_,
3823 _BIN_IMAGE_,
3824 __N_SOURCE,
3825 )
3826 }
3827 #[inline]
3828 pub unsafe fn cleanup(&mut self) {
3829 imaging_cleanup(self)
3830 }
3831 #[inline]
3832 pub unsafe fn cleanupSegmentPistonSensor(&mut self) {
3833 imaging_cleanupSegmentPistonSensor(self)
3834 }
3835 #[inline]
3836 pub unsafe fn set_pointing_direction(&mut self, zen: *mut f32, azim: *mut f32) {
3837 imaging_set_pointing_direction(self, zen, azim)
3838 }
3839 #[inline]
3840 pub unsafe fn reset(&mut self) {
3841 imaging_reset(self)
3842 }
3843 #[inline]
3844 pub unsafe fn reset_rng(&mut self, SEED: ::std::os::raw::c_int) {
3845 imaging_reset_rng(self, SEED)
3846 }
3847 #[inline]
3848 pub unsafe fn propagate(&mut self, src: *mut source) {
3849 imaging_propagate(self, src)
3850 }
3851 #[inline]
3852 pub unsafe fn propagate_cpx(&mut self, src: *mut source) {
3853 imaging_propagate_cpx(self, src)
3854 }
3855 #[inline]
3856 pub unsafe fn propagateNoOverlap(&mut self, src: *mut source) {
3857 imaging_propagateNoOverlap(self, src)
3858 }
3859 #[inline]
3860 pub unsafe fn propagateNoOverlapBare(&mut self, src: *mut source) {
3861 imaging_propagateNoOverlapBare(self, src)
3862 }
3863 #[inline]
3864 pub unsafe fn propagateNoOverlapSPS(&mut self, src: *mut source, d: f32, wavenumber: f32) {
3865 imaging_propagateNoOverlapSPS(self, src, d, wavenumber)
3866 }
3867 #[inline]
3868 pub unsafe fn propagateTT7(&mut self, src: *mut source) {
3869 imaging_propagateTT7(self, src)
3870 }
3871 #[inline]
3872 pub unsafe fn propagateTT71(
3873 &mut self,
3874 src: *mut source,
3875 d__piston_mask: *mut ::std::os::raw::c_int,
3876 ) {
3877 imaging_propagateTT71(self, src, d__piston_mask)
3878 }
3879 #[inline]
3880 pub unsafe fn propagateThroughFieldStop(&mut self, src: *mut source, field_stop_diam: f32) {
3881 imaging_propagateThroughFieldStop(self, src, field_stop_diam)
3882 }
3883 #[inline]
3884 pub unsafe fn propagateThroughPyramid(&mut self, src: *mut source, alpha: f32) {
3885 imaging_propagateThroughPyramid(self, src, alpha)
3886 }
3887 #[inline]
3888 pub unsafe fn propagateThroughModulatedPyramid(
3889 &mut self,
3890 src: *mut source,
3891 modulation: f32,
3892 modulation_sampling: ::std::os::raw::c_int,
3893 alpha: f32,
3894 ) {
3895 imaging_propagateThroughModulatedPyramid(self, src, modulation, modulation_sampling, alpha)
3896 }
3897 #[inline]
3898 pub unsafe fn readout(&mut self, exposureTime: f32, readOutNoiseRms: f32) {
3899 imaging_readout(self, exposureTime, readOutNoiseRms)
3900 }
3901 #[inline]
3902 pub unsafe fn noiseless_readout(&mut self, exposureTime: f32) {
3903 imaging_noiseless_readout(self, exposureTime)
3904 }
3905 #[inline]
3906 pub unsafe fn readout1(
3907 &mut self,
3908 exposureTime: f32,
3909 readOutNoiseRms: f32,
3910 nBackgroundPhoton: f32,
3911 noiseFactor: f32,
3912 ) {
3913 imaging_readout1(
3914 self,
3915 exposureTime,
3916 readOutNoiseRms,
3917 nBackgroundPhoton,
3918 noiseFactor,
3919 )
3920 }
3921 #[inline]
3922 pub unsafe fn strehl_ratio(&mut self, ref_: *mut imaging) -> f32 {
3923 imaging_strehl_ratio(self, ref_)
3924 }
3925 #[inline]
3926 pub unsafe fn info(&mut self) {
3927 imaging_info(self)
3928 }
3929 #[inline]
3930 pub unsafe fn frame2file(&mut self, filename: *const ::std::os::raw::c_char) {
3931 imaging_frame2file(self, filename)
3932 }
3933 #[inline]
3934 pub unsafe fn show_frame(&mut self, filename: *mut ::std::os::raw::c_char) {
3935 imaging_show_frame(self, filename)
3936 }
3937 #[inline]
3938 pub unsafe fn show_frame1(
3939 &mut self,
3940 filename: *mut ::std::os::raw::c_char,
3941 ref_: *mut imaging,
3942 ) {
3943 imaging_show_frame1(self, filename, ref_)
3944 }
3945}
3946#[repr(C)]
3947#[derive(Debug, Copy, Clone)]
3948pub struct centroiding {
3949 pub _N_SIDE_LENSLET_: ::std::os::raw::c_int,
3950 pub N_LENSLET: ::std::os::raw::c_int,
3951 pub N_SOURCE: ::std::os::raw::c_int,
3952 pub d__c: *mut f32,
3953 pub d__cx: *mut f32,
3954 pub d__cy: *mut f32,
3955 pub d__mass: *mut f32,
3956 pub lenslet_mask: *mut ::std::os::raw::c_char,
3957 pub MASK_SET: ::std::os::raw::c_char,
3958 pub n_data: ::std::os::raw::c_int,
3959 pub DEV_SHARED_MEM: ::std::os::raw::c_int,
3960 pub DEV_MAX_THREADS: ::std::os::raw::c_int,
3961 pub handle: cublasHandle_t,
3962 pub status: cublasStatus_t,
3963}
3964#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3965const _: () = {
3966 ["Size of centroiding"][::std::mem::size_of::<centroiding>() - 88usize];
3967 ["Alignment of centroiding"][::std::mem::align_of::<centroiding>() - 8usize];
3968 ["Offset of field: centroiding::_N_SIDE_LENSLET_"]
3969 [::std::mem::offset_of!(centroiding, _N_SIDE_LENSLET_) - 0usize];
3970 ["Offset of field: centroiding::N_LENSLET"]
3971 [::std::mem::offset_of!(centroiding, N_LENSLET) - 4usize];
3972 ["Offset of field: centroiding::N_SOURCE"]
3973 [::std::mem::offset_of!(centroiding, N_SOURCE) - 8usize];
3974 ["Offset of field: centroiding::d__c"][::std::mem::offset_of!(centroiding, d__c) - 16usize];
3975 ["Offset of field: centroiding::d__cx"][::std::mem::offset_of!(centroiding, d__cx) - 24usize];
3976 ["Offset of field: centroiding::d__cy"][::std::mem::offset_of!(centroiding, d__cy) - 32usize];
3977 ["Offset of field: centroiding::d__mass"]
3978 [::std::mem::offset_of!(centroiding, d__mass) - 40usize];
3979 ["Offset of field: centroiding::lenslet_mask"]
3980 [::std::mem::offset_of!(centroiding, lenslet_mask) - 48usize];
3981 ["Offset of field: centroiding::MASK_SET"]
3982 [::std::mem::offset_of!(centroiding, MASK_SET) - 56usize];
3983 ["Offset of field: centroiding::n_data"][::std::mem::offset_of!(centroiding, n_data) - 60usize];
3984 ["Offset of field: centroiding::DEV_SHARED_MEM"]
3985 [::std::mem::offset_of!(centroiding, DEV_SHARED_MEM) - 64usize];
3986 ["Offset of field: centroiding::DEV_MAX_THREADS"]
3987 [::std::mem::offset_of!(centroiding, DEV_MAX_THREADS) - 68usize];
3988 ["Offset of field: centroiding::handle"][::std::mem::offset_of!(centroiding, handle) - 72usize];
3989 ["Offset of field: centroiding::status"][::std::mem::offset_of!(centroiding, status) - 80usize];
3990};
3991extern "C" {
3992 #[link_name = "\u{1}_ZN11centroiding5setupEii"]
3993 pub fn centroiding_setup(
3994 this: *mut centroiding,
3995 _N_SIDE_LENSLET: ::std::os::raw::c_int,
3996 _N_SOURCE: ::std::os::raw::c_int,
3997 );
3998}
3999extern "C" {
4000 #[link_name = "\u{1}_ZN11centroiding7cleanupEv"]
4001 pub fn centroiding_cleanup(this: *mut centroiding);
4002}
4003extern "C" {
4004 #[link_name = "\u{1}_ZN11centroiding8get_dataEP7imaging"]
4005 pub fn centroiding_get_data(this: *mut centroiding, wfs: *mut imaging);
4006}
4007extern "C" {
4008 #[link_name = "\u{1}_ZN11centroiding8get_dataEPfi"]
4009 pub fn centroiding_get_data1(this: *mut centroiding, frame: *mut f32, N: ::std::os::raw::c_int);
4010}
4011extern "C" {
4012 #[link_name = "\u{1}_ZN11centroiding8get_dataEPfifff"]
4013 pub fn centroiding_get_data2(
4014 this: *mut centroiding,
4015 frame: *mut f32,
4016 N: ::std::os::raw::c_int,
4017 cx0: f32,
4018 cy0: f32,
4019 units: f32,
4020 );
4021}
4022extern "C" {
4023 #[link_name = "\u{1}_ZN11centroiding8get_dataEPfiS0_S0_fPc"]
4024 pub fn centroiding_get_data3(
4025 this: *mut centroiding,
4026 frame: *mut f32,
4027 N: ::std::os::raw::c_int,
4028 cx0: *mut f32,
4029 cy0: *mut f32,
4030 units: f32,
4031 valid_lenset: *mut ::std::os::raw::c_char,
4032 );
4033}
4034extern "C" {
4035 #[link_name = "\u{1}_ZN11centroiding14show_centroidsEPc"]
4036 pub fn centroiding_show_centroids(
4037 this: *mut centroiding,
4038 filename: *mut ::std::os::raw::c_char,
4039 );
4040}
4041extern "C" {
4042 #[link_name = "\u{1}_ZN11centroiding9show_fluxEPc"]
4043 pub fn centroiding_show_flux(this: *mut centroiding, filename: *mut ::std::os::raw::c_char);
4044}
4045extern "C" {
4046 #[link_name = "\u{1}_ZN11centroiding14fried_geometryEP4maskS1_if"]
4047 pub fn centroiding_fried_geometry(
4048 this: *mut centroiding,
4049 dm: *mut mask,
4050 pupil: *mut mask,
4051 n: ::std::os::raw::c_int,
4052 threshold: f32,
4053 );
4054}
4055extern "C" {
4056 #[link_name = "\u{1}_ZN11centroiding6filterEPf"]
4057 pub fn centroiding_filter(this: *mut centroiding, F: *mut f32);
4058}
4059extern "C" {
4060 #[link_name = "\u{1}_ZN11centroiding7noisifyEf"]
4061 pub fn centroiding_noisify(this: *mut centroiding, stddev: f32);
4062}
4063extern "C" {
4064 #[link_name = "\u{1}_ZN11centroiding5resetEv"]
4065 pub fn centroiding_reset(this: *mut centroiding);
4066}
4067impl centroiding {
4068 #[inline]
4069 pub unsafe fn setup(
4070 &mut self,
4071 _N_SIDE_LENSLET: ::std::os::raw::c_int,
4072 _N_SOURCE: ::std::os::raw::c_int,
4073 ) {
4074 centroiding_setup(self, _N_SIDE_LENSLET, _N_SOURCE)
4075 }
4076 #[inline]
4077 pub unsafe fn cleanup(&mut self) {
4078 centroiding_cleanup(self)
4079 }
4080 #[inline]
4081 pub unsafe fn get_data(&mut self, wfs: *mut imaging) {
4082 centroiding_get_data(self, wfs)
4083 }
4084 #[inline]
4085 pub unsafe fn get_data1(&mut self, frame: *mut f32, N: ::std::os::raw::c_int) {
4086 centroiding_get_data1(self, frame, N)
4087 }
4088 #[inline]
4089 pub unsafe fn get_data2(
4090 &mut self,
4091 frame: *mut f32,
4092 N: ::std::os::raw::c_int,
4093 cx0: f32,
4094 cy0: f32,
4095 units: f32,
4096 ) {
4097 centroiding_get_data2(self, frame, N, cx0, cy0, units)
4098 }
4099 #[inline]
4100 pub unsafe fn get_data3(
4101 &mut self,
4102 frame: *mut f32,
4103 N: ::std::os::raw::c_int,
4104 cx0: *mut f32,
4105 cy0: *mut f32,
4106 units: f32,
4107 valid_lenset: *mut ::std::os::raw::c_char,
4108 ) {
4109 centroiding_get_data3(self, frame, N, cx0, cy0, units, valid_lenset)
4110 }
4111 #[inline]
4112 pub unsafe fn show_centroids(&mut self, filename: *mut ::std::os::raw::c_char) {
4113 centroiding_show_centroids(self, filename)
4114 }
4115 #[inline]
4116 pub unsafe fn show_flux(&mut self, filename: *mut ::std::os::raw::c_char) {
4117 centroiding_show_flux(self, filename)
4118 }
4119 #[inline]
4120 pub unsafe fn fried_geometry(
4121 &mut self,
4122 dm: *mut mask,
4123 pupil: *mut mask,
4124 n: ::std::os::raw::c_int,
4125 threshold: f32,
4126 ) {
4127 centroiding_fried_geometry(self, dm, pupil, n, threshold)
4128 }
4129 #[inline]
4130 pub unsafe fn filter(&mut self, F: *mut f32) {
4131 centroiding_filter(self, F)
4132 }
4133 #[inline]
4134 pub unsafe fn noisify(&mut self, stddev: f32) {
4135 centroiding_noisify(self, stddev)
4136 }
4137 #[inline]
4138 pub unsafe fn reset(&mut self) {
4139 centroiding_reset(self)
4140 }
4141}
4142#[repr(C)]
4143#[derive(Debug, Copy, Clone)]
4144pub struct shackHartmann {
4145 pub N_WFS: ::std::os::raw::c_int,
4146 pub N_SIDE_LENSLET: ::std::os::raw::c_int,
4147 pub N_LENSLET: ::std::os::raw::c_int,
4148 pub N_ACTUATOR: ::std::os::raw::c_int,
4149 pub N_SLOPE: ::std::os::raw::c_int,
4150 pub d__c0: *mut f32,
4151 pub d__cx0: *mut f32,
4152 pub d__cy0: *mut f32,
4153 pub valid_lenslet: mask,
4154 pub valid_actuator: mask,
4155 pub camera: imaging,
4156 pub data_proc: centroiding,
4157 pub DFT_osf: ::std::os::raw::c_int,
4158 pub lenslet_pitch: f32,
4159 pub pixel_scale: f32,
4160 pub intensity_threshold: f32,
4161 pub slopes_gain: f32,
4162}
4163#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4164const _: () = {
4165 ["Size of shackHartmann"][::std::mem::size_of::<shackHartmann>() - 464usize];
4166 ["Alignment of shackHartmann"][::std::mem::align_of::<shackHartmann>() - 8usize];
4167 ["Offset of field: shackHartmann::N_WFS"]
4168 [::std::mem::offset_of!(shackHartmann, N_WFS) - 0usize];
4169 ["Offset of field: shackHartmann::N_SIDE_LENSLET"]
4170 [::std::mem::offset_of!(shackHartmann, N_SIDE_LENSLET) - 4usize];
4171 ["Offset of field: shackHartmann::N_LENSLET"]
4172 [::std::mem::offset_of!(shackHartmann, N_LENSLET) - 8usize];
4173 ["Offset of field: shackHartmann::N_ACTUATOR"]
4174 [::std::mem::offset_of!(shackHartmann, N_ACTUATOR) - 12usize];
4175 ["Offset of field: shackHartmann::N_SLOPE"]
4176 [::std::mem::offset_of!(shackHartmann, N_SLOPE) - 16usize];
4177 ["Offset of field: shackHartmann::d__c0"]
4178 [::std::mem::offset_of!(shackHartmann, d__c0) - 24usize];
4179 ["Offset of field: shackHartmann::d__cx0"]
4180 [::std::mem::offset_of!(shackHartmann, d__cx0) - 32usize];
4181 ["Offset of field: shackHartmann::d__cy0"]
4182 [::std::mem::offset_of!(shackHartmann, d__cy0) - 40usize];
4183 ["Offset of field: shackHartmann::valid_lenslet"]
4184 [::std::mem::offset_of!(shackHartmann, valid_lenslet) - 48usize];
4185 ["Offset of field: shackHartmann::valid_actuator"]
4186 [::std::mem::offset_of!(shackHartmann, valid_actuator) - 128usize];
4187 ["Offset of field: shackHartmann::camera"]
4188 [::std::mem::offset_of!(shackHartmann, camera) - 208usize];
4189 ["Offset of field: shackHartmann::data_proc"]
4190 [::std::mem::offset_of!(shackHartmann, data_proc) - 352usize];
4191 ["Offset of field: shackHartmann::DFT_osf"]
4192 [::std::mem::offset_of!(shackHartmann, DFT_osf) - 440usize];
4193 ["Offset of field: shackHartmann::lenslet_pitch"]
4194 [::std::mem::offset_of!(shackHartmann, lenslet_pitch) - 444usize];
4195 ["Offset of field: shackHartmann::pixel_scale"]
4196 [::std::mem::offset_of!(shackHartmann, pixel_scale) - 448usize];
4197 ["Offset of field: shackHartmann::intensity_threshold"]
4198 [::std::mem::offset_of!(shackHartmann, intensity_threshold) - 452usize];
4199 ["Offset of field: shackHartmann::slopes_gain"]
4200 [::std::mem::offset_of!(shackHartmann, slopes_gain) - 456usize];
4201};
4202extern "C" {
4203 #[link_name = "\u{1}_ZN13shackHartmann5setupEiifiiii"]
4204 pub fn shackHartmann_setup(
4205 this: *mut shackHartmann,
4206 N_SIDE_LENSLET: ::std::os::raw::c_int,
4207 N_PX_LENSLET: ::std::os::raw::c_int,
4208 d: f32,
4209 DFT_osf_: ::std::os::raw::c_int,
4210 N_PX_IMAGE: ::std::os::raw::c_int,
4211 BIN_IMAGE: ::std::os::raw::c_int,
4212 N_GS: ::std::os::raw::c_int,
4213 );
4214}
4215extern "C" {
4216 #[link_name = "\u{1}_ZN13shackHartmann7cleanupEv"]
4217 pub fn shackHartmann_cleanup(this: *mut shackHartmann);
4218}
4219extern "C" {
4220 #[link_name = "\u{1}_ZN13shackHartmann22identify_valid_lensletEP6sourcef"]
4221 pub fn shackHartmann_identify_valid_lenslet(
4222 this: *mut shackHartmann,
4223 src: *mut source,
4224 threshold: f32,
4225 );
4226}
4227extern "C" {
4228 #[link_name = "\u{1}_ZN13shackHartmann20set_reference_slopesEP6source"]
4229 pub fn shackHartmann_set_reference_slopes(this: *mut shackHartmann, src: *mut source);
4230}
4231extern "C" {
4232 #[link_name = "\u{1}_ZN13shackHartmann9calibrateEP6sourcef"]
4233 pub fn shackHartmann_calibrate(this: *mut shackHartmann, src: *mut source, threshold: f32);
4234}
4235extern "C" {
4236 #[link_name = "\u{1}_ZN13shackHartmann9propagateEP6source"]
4237 pub fn shackHartmann_propagate(this: *mut shackHartmann, gs: *mut source);
4238}
4239extern "C" {
4240 #[link_name = "\u{1}_ZN13shackHartmann9propagateEP6sourcePi"]
4241 pub fn shackHartmann_propagate1(
4242 this: *mut shackHartmann,
4243 gs: *mut source,
4244 maks: *mut ::std::os::raw::c_int,
4245 );
4246}
4247extern "C" {
4248 #[link_name = "\u{1}_ZN13shackHartmann7processEv"]
4249 pub fn shackHartmann_process(this: *mut shackHartmann);
4250}
4251extern "C" {
4252 #[link_name = "\u{1}_ZN13shackHartmann7analyzeEP6source"]
4253 pub fn shackHartmann_analyze(this: *mut shackHartmann, gs: *mut source);
4254}
4255extern "C" {
4256 #[link_name = "\u{1}_ZN13shackHartmann26get_valid_reference_slopesEPf"]
4257 pub fn shackHartmann_get_valid_reference_slopes(
4258 this: *mut shackHartmann,
4259 d__valid_slopes: *mut f32,
4260 );
4261}
4262extern "C" {
4263 #[link_name = "\u{1}_ZN13shackHartmann16get_valid_slopesEPf"]
4264 pub fn shackHartmann_get_valid_slopes(this: *mut shackHartmann, d__valid_slopes: *mut f32);
4265}
4266extern "C" {
4267 #[link_name = "\u{1}_ZN13shackHartmann13masked_slopesEPfP4mask"]
4268 pub fn shackHartmann_masked_slopes(
4269 this: *mut shackHartmann,
4270 d__valid_slopes: *mut f32,
4271 lenslet_mask: *mut mask,
4272 );
4273}
4274extern "C" {
4275 #[link_name = "\u{1}_ZN13shackHartmann21get_valid_slopes_normEPf"]
4276 pub fn shackHartmann_get_valid_slopes_norm(
4277 this: *mut shackHartmann,
4278 d__valid_slopes_norm: *mut f32,
4279 );
4280}
4281extern "C" {
4282 #[link_name = "\u{1}_ZN13shackHartmann17get_frame_dev_ptrEv"]
4283 pub fn shackHartmann_get_frame_dev_ptr(this: *mut shackHartmann) -> *mut f32;
4284}
4285extern "C" {
4286 #[link_name = "\u{1}_ZN13shackHartmann14update_lensletEPf"]
4287 pub fn shackHartmann_update_lenslet(this: *mut shackHartmann, filter: *mut f32);
4288}
4289impl shackHartmann {
4290 #[inline]
4291 pub unsafe fn setup(
4292 &mut self,
4293 N_SIDE_LENSLET: ::std::os::raw::c_int,
4294 N_PX_LENSLET: ::std::os::raw::c_int,
4295 d: f32,
4296 DFT_osf_: ::std::os::raw::c_int,
4297 N_PX_IMAGE: ::std::os::raw::c_int,
4298 BIN_IMAGE: ::std::os::raw::c_int,
4299 N_GS: ::std::os::raw::c_int,
4300 ) {
4301 shackHartmann_setup(
4302 self,
4303 N_SIDE_LENSLET,
4304 N_PX_LENSLET,
4305 d,
4306 DFT_osf_,
4307 N_PX_IMAGE,
4308 BIN_IMAGE,
4309 N_GS,
4310 )
4311 }
4312 #[inline]
4313 pub unsafe fn cleanup(&mut self) {
4314 shackHartmann_cleanup(self)
4315 }
4316 #[inline]
4317 pub unsafe fn identify_valid_lenslet(&mut self, src: *mut source, threshold: f32) {
4318 shackHartmann_identify_valid_lenslet(self, src, threshold)
4319 }
4320 #[inline]
4321 pub unsafe fn set_reference_slopes(&mut self, src: *mut source) {
4322 shackHartmann_set_reference_slopes(self, src)
4323 }
4324 #[inline]
4325 pub unsafe fn calibrate(&mut self, src: *mut source, threshold: f32) {
4326 shackHartmann_calibrate(self, src, threshold)
4327 }
4328 #[inline]
4329 pub unsafe fn propagate(&mut self, gs: *mut source) {
4330 shackHartmann_propagate(self, gs)
4331 }
4332 #[inline]
4333 pub unsafe fn propagate1(&mut self, gs: *mut source, maks: *mut ::std::os::raw::c_int) {
4334 shackHartmann_propagate1(self, gs, maks)
4335 }
4336 #[inline]
4337 pub unsafe fn process(&mut self) {
4338 shackHartmann_process(self)
4339 }
4340 #[inline]
4341 pub unsafe fn analyze(&mut self, gs: *mut source) {
4342 shackHartmann_analyze(self, gs)
4343 }
4344 #[inline]
4345 pub unsafe fn get_valid_reference_slopes(&mut self, d__valid_slopes: *mut f32) {
4346 shackHartmann_get_valid_reference_slopes(self, d__valid_slopes)
4347 }
4348 #[inline]
4349 pub unsafe fn get_valid_slopes(&mut self, d__valid_slopes: *mut f32) {
4350 shackHartmann_get_valid_slopes(self, d__valid_slopes)
4351 }
4352 #[inline]
4353 pub unsafe fn masked_slopes(&mut self, d__valid_slopes: *mut f32, lenslet_mask: *mut mask) {
4354 shackHartmann_masked_slopes(self, d__valid_slopes, lenslet_mask)
4355 }
4356 #[inline]
4357 pub unsafe fn get_valid_slopes_norm(&mut self, d__valid_slopes_norm: *mut f32) {
4358 shackHartmann_get_valid_slopes_norm(self, d__valid_slopes_norm)
4359 }
4360 #[inline]
4361 pub unsafe fn get_frame_dev_ptr(&mut self) -> *mut f32 {
4362 shackHartmann_get_frame_dev_ptr(self)
4363 }
4364 #[inline]
4365 pub unsafe fn update_lenslet(&mut self, filter: *mut f32) {
4366 shackHartmann_update_lenslet(self, filter)
4367 }
4368}
4369#[repr(C)]
4370#[derive(Debug, Copy, Clone)]
4371pub struct geometricShackHartmann {
4372 pub N_WFS: ::std::os::raw::c_int,
4373 pub N_SIDE_LENSLET: ::std::os::raw::c_int,
4374 pub N_LENSLET: ::std::os::raw::c_int,
4375 pub N_ACTUATOR: ::std::os::raw::c_int,
4376 pub N_SLOPE: ::std::os::raw::c_int,
4377 pub d__c0: *mut f32,
4378 pub d__cx0: *mut f32,
4379 pub d__cy0: *mut f32,
4380 pub valid_lenslet: mask,
4381 pub valid_actuator: mask,
4382 pub camera: imaging,
4383 pub data_proc: centroiding,
4384 pub DFT_osf: ::std::os::raw::c_int,
4385 pub lenslet_pitch: f32,
4386 pub pixel_scale: f32,
4387 pub intensity_threshold: f32,
4388 pub slopes_gain: f32,
4389 pub _d__c_: *mut f32,
4390 pub _d__cx_: *mut f32,
4391 pub _d__cy_: *mut f32,
4392 pub N_FRAME: ::std::os::raw::c_int,
4393 pub handle: cublasHandle_t,
4394}
4395#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4396const _: () = {
4397 ["Size of geometricShackHartmann"][::std::mem::size_of::<geometricShackHartmann>() - 504usize];
4398 ["Alignment of geometricShackHartmann"]
4399 [::std::mem::align_of::<geometricShackHartmann>() - 8usize];
4400 ["Offset of field: geometricShackHartmann::N_WFS"]
4401 [::std::mem::offset_of!(geometricShackHartmann, N_WFS) - 0usize];
4402 ["Offset of field: geometricShackHartmann::N_SIDE_LENSLET"]
4403 [::std::mem::offset_of!(geometricShackHartmann, N_SIDE_LENSLET) - 4usize];
4404 ["Offset of field: geometricShackHartmann::N_LENSLET"]
4405 [::std::mem::offset_of!(geometricShackHartmann, N_LENSLET) - 8usize];
4406 ["Offset of field: geometricShackHartmann::N_ACTUATOR"]
4407 [::std::mem::offset_of!(geometricShackHartmann, N_ACTUATOR) - 12usize];
4408 ["Offset of field: geometricShackHartmann::N_SLOPE"]
4409 [::std::mem::offset_of!(geometricShackHartmann, N_SLOPE) - 16usize];
4410 ["Offset of field: geometricShackHartmann::d__c0"]
4411 [::std::mem::offset_of!(geometricShackHartmann, d__c0) - 24usize];
4412 ["Offset of field: geometricShackHartmann::d__cx0"]
4413 [::std::mem::offset_of!(geometricShackHartmann, d__cx0) - 32usize];
4414 ["Offset of field: geometricShackHartmann::d__cy0"]
4415 [::std::mem::offset_of!(geometricShackHartmann, d__cy0) - 40usize];
4416 ["Offset of field: geometricShackHartmann::valid_lenslet"]
4417 [::std::mem::offset_of!(geometricShackHartmann, valid_lenslet) - 48usize];
4418 ["Offset of field: geometricShackHartmann::valid_actuator"]
4419 [::std::mem::offset_of!(geometricShackHartmann, valid_actuator) - 128usize];
4420 ["Offset of field: geometricShackHartmann::camera"]
4421 [::std::mem::offset_of!(geometricShackHartmann, camera) - 208usize];
4422 ["Offset of field: geometricShackHartmann::data_proc"]
4423 [::std::mem::offset_of!(geometricShackHartmann, data_proc) - 352usize];
4424 ["Offset of field: geometricShackHartmann::DFT_osf"]
4425 [::std::mem::offset_of!(geometricShackHartmann, DFT_osf) - 440usize];
4426 ["Offset of field: geometricShackHartmann::lenslet_pitch"]
4427 [::std::mem::offset_of!(geometricShackHartmann, lenslet_pitch) - 444usize];
4428 ["Offset of field: geometricShackHartmann::pixel_scale"]
4429 [::std::mem::offset_of!(geometricShackHartmann, pixel_scale) - 448usize];
4430 ["Offset of field: geometricShackHartmann::intensity_threshold"]
4431 [::std::mem::offset_of!(geometricShackHartmann, intensity_threshold) - 452usize];
4432 ["Offset of field: geometricShackHartmann::slopes_gain"]
4433 [::std::mem::offset_of!(geometricShackHartmann, slopes_gain) - 456usize];
4434 ["Offset of field: geometricShackHartmann::_d__c_"]
4435 [::std::mem::offset_of!(geometricShackHartmann, _d__c_) - 464usize];
4436 ["Offset of field: geometricShackHartmann::_d__cx_"]
4437 [::std::mem::offset_of!(geometricShackHartmann, _d__cx_) - 472usize];
4438 ["Offset of field: geometricShackHartmann::_d__cy_"]
4439 [::std::mem::offset_of!(geometricShackHartmann, _d__cy_) - 480usize];
4440 ["Offset of field: geometricShackHartmann::N_FRAME"]
4441 [::std::mem::offset_of!(geometricShackHartmann, N_FRAME) - 488usize];
4442 ["Offset of field: geometricShackHartmann::handle"]
4443 [::std::mem::offset_of!(geometricShackHartmann, handle) - 496usize];
4444};
4445extern "C" {
4446 #[link_name = "\u{1}_ZN22geometricShackHartmann5setupEifi"]
4447 pub fn geometricShackHartmann_setup(
4448 this: *mut geometricShackHartmann,
4449 N_SIDE_LENSLET: ::std::os::raw::c_int,
4450 d: f32,
4451 N_GS: ::std::os::raw::c_int,
4452 );
4453}
4454extern "C" {
4455 #[link_name = "\u{1}_ZN22geometricShackHartmann7cleanupEv"]
4456 pub fn geometricShackHartmann_cleanup(this: *mut geometricShackHartmann);
4457}
4458extern "C" {
4459 #[link_name = "\u{1}_ZN22geometricShackHartmann22identify_valid_lensletEP6sourcef"]
4460 pub fn geometricShackHartmann_identify_valid_lenslet(
4461 this: *mut geometricShackHartmann,
4462 src: *mut source,
4463 threshold: f32,
4464 );
4465}
4466extern "C" {
4467 #[link_name = "\u{1}_ZN22geometricShackHartmann20set_reference_slopesEP6source"]
4468 pub fn geometricShackHartmann_set_reference_slopes(
4469 this: *mut geometricShackHartmann,
4470 src: *mut source,
4471 );
4472}
4473extern "C" {
4474 #[link_name = "\u{1}_ZN22geometricShackHartmann9calibrateEP6sourcef"]
4475 pub fn geometricShackHartmann_calibrate(
4476 this: *mut geometricShackHartmann,
4477 src: *mut source,
4478 threshold: f32,
4479 );
4480}
4481extern "C" {
4482 #[link_name = "\u{1}_ZN22geometricShackHartmann9propagateEP6source"]
4483 pub fn geometricShackHartmann_propagate(this: *mut geometricShackHartmann, gs: *mut source);
4484}
4485extern "C" {
4486 #[link_name = "\u{1}_ZN22geometricShackHartmann9propagateEP6sourcePi"]
4487 pub fn geometricShackHartmann_propagate1(
4488 this: *mut geometricShackHartmann,
4489 gs: *mut source,
4490 maks: *mut ::std::os::raw::c_int,
4491 );
4492}
4493extern "C" {
4494 #[link_name = "\u{1}_ZN22geometricShackHartmann7processEv"]
4495 pub fn geometricShackHartmann_process(this: *mut geometricShackHartmann);
4496}
4497extern "C" {
4498 #[link_name = "\u{1}_ZN22geometricShackHartmann7analyzeEP6source"]
4499 pub fn geometricShackHartmann_analyze(this: *mut geometricShackHartmann, gs: *mut source);
4500}
4501extern "C" {
4502 #[link_name = "\u{1}_ZN22geometricShackHartmann26get_valid_reference_slopesEPf"]
4503 pub fn geometricShackHartmann_get_valid_reference_slopes(
4504 this: *mut geometricShackHartmann,
4505 d__valid_slopes: *mut f32,
4506 );
4507}
4508extern "C" {
4509 #[link_name = "\u{1}_ZN22geometricShackHartmann16get_valid_slopesEPf"]
4510 pub fn geometricShackHartmann_get_valid_slopes(
4511 this: *mut geometricShackHartmann,
4512 d__valid_slopes: *mut f32,
4513 );
4514}
4515extern "C" {
4516 #[link_name = "\u{1}_ZN22geometricShackHartmann13masked_slopesEPfP4mask"]
4517 pub fn geometricShackHartmann_masked_slopes(
4518 this: *mut geometricShackHartmann,
4519 d__valid_slopes: *mut f32,
4520 lenslet_mask: *mut mask,
4521 );
4522}
4523extern "C" {
4524 #[link_name = "\u{1}_ZN22geometricShackHartmann21get_valid_slopes_normEPf"]
4525 pub fn geometricShackHartmann_get_valid_slopes_norm(
4526 this: *mut geometricShackHartmann,
4527 d__valid_slopes_norm: *mut f32,
4528 );
4529}
4530extern "C" {
4531 #[link_name = "\u{1}_ZN22geometricShackHartmann13folded_slopesEPfP4mask"]
4532 pub fn geometricShackHartmann_folded_slopes(
4533 this: *mut geometricShackHartmann,
4534 d__valid_slopes: *mut f32,
4535 lenslet_mask: *mut mask,
4536 );
4537}
4538extern "C" {
4539 #[link_name = "\u{1}_ZN22geometricShackHartmann5resetEv"]
4540 pub fn geometricShackHartmann_reset(this: *mut geometricShackHartmann);
4541}
4542impl geometricShackHartmann {
4543 #[inline]
4544 pub unsafe fn setup(
4545 &mut self,
4546 N_SIDE_LENSLET: ::std::os::raw::c_int,
4547 d: f32,
4548 N_GS: ::std::os::raw::c_int,
4549 ) {
4550 geometricShackHartmann_setup(self, N_SIDE_LENSLET, d, N_GS)
4551 }
4552 #[inline]
4553 pub unsafe fn cleanup(&mut self) {
4554 geometricShackHartmann_cleanup(self)
4555 }
4556 #[inline]
4557 pub unsafe fn identify_valid_lenslet(&mut self, src: *mut source, threshold: f32) {
4558 geometricShackHartmann_identify_valid_lenslet(self, src, threshold)
4559 }
4560 #[inline]
4561 pub unsafe fn set_reference_slopes(&mut self, src: *mut source) {
4562 geometricShackHartmann_set_reference_slopes(self, src)
4563 }
4564 #[inline]
4565 pub unsafe fn calibrate(&mut self, src: *mut source, threshold: f32) {
4566 geometricShackHartmann_calibrate(self, src, threshold)
4567 }
4568 #[inline]
4569 pub unsafe fn propagate(&mut self, gs: *mut source) {
4570 geometricShackHartmann_propagate(self, gs)
4571 }
4572 #[inline]
4573 pub unsafe fn propagate1(&mut self, gs: *mut source, maks: *mut ::std::os::raw::c_int) {
4574 geometricShackHartmann_propagate1(self, gs, maks)
4575 }
4576 #[inline]
4577 pub unsafe fn process(&mut self) {
4578 geometricShackHartmann_process(self)
4579 }
4580 #[inline]
4581 pub unsafe fn analyze(&mut self, gs: *mut source) {
4582 geometricShackHartmann_analyze(self, gs)
4583 }
4584 #[inline]
4585 pub unsafe fn get_valid_reference_slopes(&mut self, d__valid_slopes: *mut f32) {
4586 geometricShackHartmann_get_valid_reference_slopes(self, d__valid_slopes)
4587 }
4588 #[inline]
4589 pub unsafe fn get_valid_slopes(&mut self, d__valid_slopes: *mut f32) {
4590 geometricShackHartmann_get_valid_slopes(self, d__valid_slopes)
4591 }
4592 #[inline]
4593 pub unsafe fn masked_slopes(&mut self, d__valid_slopes: *mut f32, lenslet_mask: *mut mask) {
4594 geometricShackHartmann_masked_slopes(self, d__valid_slopes, lenslet_mask)
4595 }
4596 #[inline]
4597 pub unsafe fn get_valid_slopes_norm(&mut self, d__valid_slopes_norm: *mut f32) {
4598 geometricShackHartmann_get_valid_slopes_norm(self, d__valid_slopes_norm)
4599 }
4600 #[inline]
4601 pub unsafe fn folded_slopes(&mut self, d__valid_slopes: *mut f32, lenslet_mask: *mut mask) {
4602 geometricShackHartmann_folded_slopes(self, d__valid_slopes, lenslet_mask)
4603 }
4604 #[inline]
4605 pub unsafe fn reset(&mut self) {
4606 geometricShackHartmann_reset(self)
4607 }
4608}
4609#[repr(C)]
4610#[derive(Debug, Copy, Clone)]
4611pub struct modes {
4612 pub d__x_BM: *mut f64,
4613 pub d__y_BM: *mut f64,
4614 pub d__BM: *mut f64,
4615 pub d__BMS: *mut f64,
4616 pub BM_radius: f64,
4617 pub BM_N_SAMPLE: ::std::os::raw::c_int,
4618 pub d__BM_buffer: *mut f64,
4619 pub n_mode: ::std::os::raw::c_int,
4620 pub b: *mut rtd,
4621 pub d__b: *mut rtd,
4622 pub N: ::std::os::raw::c_int,
4623 pub filename: [::std::os::raw::c_char; 256usize],
4624 pub N_SET: ::std::os::raw::c_int,
4625 pub N_MODE: ::std::os::raw::c_int,
4626 pub d__s2b: *mut ::std::os::raw::c_int,
4627}
4628#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4629const _: () = {
4630 ["Size of modes"][::std::mem::size_of::<modes>() - 360usize];
4631 ["Alignment of modes"][::std::mem::align_of::<modes>() - 8usize];
4632 ["Offset of field: modes::d__x_BM"][::std::mem::offset_of!(modes, d__x_BM) - 0usize];
4633 ["Offset of field: modes::d__y_BM"][::std::mem::offset_of!(modes, d__y_BM) - 8usize];
4634 ["Offset of field: modes::d__BM"][::std::mem::offset_of!(modes, d__BM) - 16usize];
4635 ["Offset of field: modes::d__BMS"][::std::mem::offset_of!(modes, d__BMS) - 24usize];
4636 ["Offset of field: modes::BM_radius"][::std::mem::offset_of!(modes, BM_radius) - 32usize];
4637 ["Offset of field: modes::BM_N_SAMPLE"][::std::mem::offset_of!(modes, BM_N_SAMPLE) - 40usize];
4638 ["Offset of field: modes::d__BM_buffer"][::std::mem::offset_of!(modes, d__BM_buffer) - 48usize];
4639 ["Offset of field: modes::n_mode"][::std::mem::offset_of!(modes, n_mode) - 56usize];
4640 ["Offset of field: modes::b"][::std::mem::offset_of!(modes, b) - 64usize];
4641 ["Offset of field: modes::d__b"][::std::mem::offset_of!(modes, d__b) - 72usize];
4642 ["Offset of field: modes::N"][::std::mem::offset_of!(modes, N) - 80usize];
4643 ["Offset of field: modes::filename"][::std::mem::offset_of!(modes, filename) - 84usize];
4644 ["Offset of field: modes::N_SET"][::std::mem::offset_of!(modes, N_SET) - 340usize];
4645 ["Offset of field: modes::N_MODE"][::std::mem::offset_of!(modes, N_MODE) - 344usize];
4646 ["Offset of field: modes::d__s2b"][::std::mem::offset_of!(modes, d__s2b) - 352usize];
4647};
4648extern "C" {
4649 #[link_name = "\u{1}_ZN5modes5setupEPcii"]
4650 pub fn modes_setup(
4651 this: *mut modes,
4652 filename: *mut ::std::os::raw::c_char,
4653 N: ::std::os::raw::c_int,
4654 n_mode: ::std::os::raw::c_int,
4655 );
4656}
4657extern "C" {
4658 #[link_name = "\u{1}_ZN5modes5setupEidiiPiPdii"]
4659 pub fn modes_setup1(
4660 this: *mut modes,
4661 _BM_N_SAMPLE_: ::std::os::raw::c_int,
4662 _BM_radius_: f64,
4663 _N_SET_: ::std::os::raw::c_int,
4664 _N_MODE_: ::std::os::raw::c_int,
4665 s2b: *mut ::std::os::raw::c_int,
4666 buffer: *mut f64,
4667 _N_: ::std::os::raw::c_int,
4668 _n_mode_: ::std::os::raw::c_int,
4669 );
4670}
4671extern "C" {
4672 #[link_name = "\u{1}_ZN5modes7cleanupEv"]
4673 pub fn modes_cleanup(this: *mut modes);
4674}
4675extern "C" {
4676 #[link_name = "\u{1}_ZN5modes4loadEv"]
4677 pub fn modes_load(this: *mut modes);
4678}
4679extern "C" {
4680 #[link_name = "\u{1}_ZN5modes4loadEidiiPiPd"]
4681 pub fn modes_load1(
4682 this: *mut modes,
4683 _BM_N_SAMPLE_: ::std::os::raw::c_int,
4684 _BM_radius_: f64,
4685 _N_SET_: ::std::os::raw::c_int,
4686 _N_MODE_: ::std::os::raw::c_int,
4687 s2b: *mut ::std::os::raw::c_int,
4688 buffer: *mut f64,
4689 );
4690}
4691extern "C" {
4692 #[link_name = "\u{1}_ZN5modes11reset_modesEPd"]
4693 pub fn modes_reset_modes(this: *mut modes, buffer: *mut f64);
4694}
4695extern "C" {
4696 #[link_name = "\u{1}_ZN5modes6updateEPd"]
4697 pub fn modes_update(this: *mut modes, b: *mut rtd);
4698}
4699impl modes {
4700 #[inline]
4701 pub unsafe fn setup(
4702 &mut self,
4703 filename: *mut ::std::os::raw::c_char,
4704 N: ::std::os::raw::c_int,
4705 n_mode: ::std::os::raw::c_int,
4706 ) {
4707 modes_setup(self, filename, N, n_mode)
4708 }
4709 #[inline]
4710 pub unsafe fn setup1(
4711 &mut self,
4712 _BM_N_SAMPLE_: ::std::os::raw::c_int,
4713 _BM_radius_: f64,
4714 _N_SET_: ::std::os::raw::c_int,
4715 _N_MODE_: ::std::os::raw::c_int,
4716 s2b: *mut ::std::os::raw::c_int,
4717 buffer: *mut f64,
4718 _N_: ::std::os::raw::c_int,
4719 _n_mode_: ::std::os::raw::c_int,
4720 ) {
4721 modes_setup1(
4722 self,
4723 _BM_N_SAMPLE_,
4724 _BM_radius_,
4725 _N_SET_,
4726 _N_MODE_,
4727 s2b,
4728 buffer,
4729 _N_,
4730 _n_mode_,
4731 )
4732 }
4733 #[inline]
4734 pub unsafe fn cleanup(&mut self) {
4735 modes_cleanup(self)
4736 }
4737 #[inline]
4738 pub unsafe fn load(&mut self) {
4739 modes_load(self)
4740 }
4741 #[inline]
4742 pub unsafe fn load1(
4743 &mut self,
4744 _BM_N_SAMPLE_: ::std::os::raw::c_int,
4745 _BM_radius_: f64,
4746 _N_SET_: ::std::os::raw::c_int,
4747 _N_MODE_: ::std::os::raw::c_int,
4748 s2b: *mut ::std::os::raw::c_int,
4749 buffer: *mut f64,
4750 ) {
4751 modes_load1(
4752 self,
4753 _BM_N_SAMPLE_,
4754 _BM_radius_,
4755 _N_SET_,
4756 _N_MODE_,
4757 s2b,
4758 buffer,
4759 )
4760 }
4761 #[inline]
4762 pub unsafe fn reset_modes(&mut self, buffer: *mut f64) {
4763 modes_reset_modes(self, buffer)
4764 }
4765 #[inline]
4766 pub unsafe fn update(&mut self, b: *mut rtd) {
4767 modes_update(self, b)
4768 }
4769}
4770#[repr(C)]
4771#[derive(Debug, Copy, Clone)]
4772pub struct gmt_m1 {
4773 pub M_ID: ::std::os::raw::c_int,
4774 pub D_assembly: rtd,
4775 pub D_clear: rtd,
4776 pub D_full: rtd,
4777 pub ri: rtd,
4778 pub beta: rtd,
4779 pub L: rtd,
4780 pub area0: rtd,
4781 pub area_fraction: rtd,
4782 pub area0_px: f32,
4783 pub area: rtd,
4784 pub N: ::std::os::raw::c_int,
4785 pub depth: rtd,
4786 pub aperture_CS: coordinate_system,
4787 pub conic_CS: coordinate_system,
4788 pub conic_origin: [vector; 7usize],
4789 pub d__conic_origin: *mut vector,
4790 pub conic_c: rtd,
4791 pub conic_k: rtd,
4792 pub d__conic_c: *mut rtd,
4793 pub d__conic_k: *mut rtd,
4794 pub rigid_body_CS: coordinate_system,
4795 pub motion_CS: coordinate_system,
4796 pub height: rtd,
4797 pub V: *mut mask,
4798 pub idx_offset: ::std::os::raw::c_int,
4799 pub ZS: *mut zernikeS,
4800 pub d__piston_mask: *mut ::std::os::raw::c_int,
4801 pub TT_CS: coordinate_system,
4802 pub d__C: *mut f64,
4803 pub d__D: *mut f64,
4804 pub handle: cublasHandle_t,
4805 pub d__valid_segments: *mut ::std::os::raw::c_char,
4806 pub BS: modes,
4807 pub d__segment_reflectivity: *mut f32,
4808}
4809#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4810const _: () = {
4811 ["Size of gmt_m1"][::std::mem::size_of::<gmt_m1>() - 1192usize];
4812 ["Alignment of gmt_m1"][::std::mem::align_of::<gmt_m1>() - 8usize];
4813 ["Offset of field: gmt_m1::M_ID"][::std::mem::offset_of!(gmt_m1, M_ID) - 0usize];
4814 ["Offset of field: gmt_m1::D_assembly"][::std::mem::offset_of!(gmt_m1, D_assembly) - 8usize];
4815 ["Offset of field: gmt_m1::D_clear"][::std::mem::offset_of!(gmt_m1, D_clear) - 16usize];
4816 ["Offset of field: gmt_m1::D_full"][::std::mem::offset_of!(gmt_m1, D_full) - 24usize];
4817 ["Offset of field: gmt_m1::ri"][::std::mem::offset_of!(gmt_m1, ri) - 32usize];
4818 ["Offset of field: gmt_m1::beta"][::std::mem::offset_of!(gmt_m1, beta) - 40usize];
4819 ["Offset of field: gmt_m1::L"][::std::mem::offset_of!(gmt_m1, L) - 48usize];
4820 ["Offset of field: gmt_m1::area0"][::std::mem::offset_of!(gmt_m1, area0) - 56usize];
4821 ["Offset of field: gmt_m1::area_fraction"]
4822 [::std::mem::offset_of!(gmt_m1, area_fraction) - 64usize];
4823 ["Offset of field: gmt_m1::area0_px"][::std::mem::offset_of!(gmt_m1, area0_px) - 72usize];
4824 ["Offset of field: gmt_m1::area"][::std::mem::offset_of!(gmt_m1, area) - 80usize];
4825 ["Offset of field: gmt_m1::N"][::std::mem::offset_of!(gmt_m1, N) - 88usize];
4826 ["Offset of field: gmt_m1::depth"][::std::mem::offset_of!(gmt_m1, depth) - 96usize];
4827 ["Offset of field: gmt_m1::aperture_CS"]
4828 [::std::mem::offset_of!(gmt_m1, aperture_CS) - 104usize];
4829 ["Offset of field: gmt_m1::conic_CS"][::std::mem::offset_of!(gmt_m1, conic_CS) - 192usize];
4830 ["Offset of field: gmt_m1::conic_origin"]
4831 [::std::mem::offset_of!(gmt_m1, conic_origin) - 280usize];
4832 ["Offset of field: gmt_m1::d__conic_origin"]
4833 [::std::mem::offset_of!(gmt_m1, d__conic_origin) - 448usize];
4834 ["Offset of field: gmt_m1::conic_c"][::std::mem::offset_of!(gmt_m1, conic_c) - 456usize];
4835 ["Offset of field: gmt_m1::conic_k"][::std::mem::offset_of!(gmt_m1, conic_k) - 464usize];
4836 ["Offset of field: gmt_m1::d__conic_c"][::std::mem::offset_of!(gmt_m1, d__conic_c) - 472usize];
4837 ["Offset of field: gmt_m1::d__conic_k"][::std::mem::offset_of!(gmt_m1, d__conic_k) - 480usize];
4838 ["Offset of field: gmt_m1::rigid_body_CS"]
4839 [::std::mem::offset_of!(gmt_m1, rigid_body_CS) - 488usize];
4840 ["Offset of field: gmt_m1::motion_CS"][::std::mem::offset_of!(gmt_m1, motion_CS) - 576usize];
4841 ["Offset of field: gmt_m1::height"][::std::mem::offset_of!(gmt_m1, height) - 664usize];
4842 ["Offset of field: gmt_m1::V"][::std::mem::offset_of!(gmt_m1, V) - 672usize];
4843 ["Offset of field: gmt_m1::idx_offset"][::std::mem::offset_of!(gmt_m1, idx_offset) - 680usize];
4844 ["Offset of field: gmt_m1::ZS"][::std::mem::offset_of!(gmt_m1, ZS) - 688usize];
4845 ["Offset of field: gmt_m1::d__piston_mask"]
4846 [::std::mem::offset_of!(gmt_m1, d__piston_mask) - 696usize];
4847 ["Offset of field: gmt_m1::TT_CS"][::std::mem::offset_of!(gmt_m1, TT_CS) - 704usize];
4848 ["Offset of field: gmt_m1::d__C"][::std::mem::offset_of!(gmt_m1, d__C) - 792usize];
4849 ["Offset of field: gmt_m1::d__D"][::std::mem::offset_of!(gmt_m1, d__D) - 800usize];
4850 ["Offset of field: gmt_m1::handle"][::std::mem::offset_of!(gmt_m1, handle) - 808usize];
4851 ["Offset of field: gmt_m1::d__valid_segments"]
4852 [::std::mem::offset_of!(gmt_m1, d__valid_segments) - 816usize];
4853 ["Offset of field: gmt_m1::BS"][::std::mem::offset_of!(gmt_m1, BS) - 824usize];
4854 ["Offset of field: gmt_m1::d__segment_reflectivity"]
4855 [::std::mem::offset_of!(gmt_m1, d__segment_reflectivity) - 1184usize];
4856};
4857extern "C" {
4858 #[link_name = "\u{1}_ZN6gmt_m15setupEv"]
4859 pub fn gmt_m1_setup(this: *mut gmt_m1);
4860}
4861extern "C" {
4862 #[link_name = "\u{1}_ZN6gmt_m15setupEPcii"]
4863 pub fn gmt_m1_setup1(
4864 this: *mut gmt_m1,
4865 _filename_: *mut ::std::os::raw::c_char,
4866 _N_: ::std::os::raw::c_int,
4867 _n_mode_: ::std::os::raw::c_int,
4868 );
4869}
4870extern "C" {
4871 #[link_name = "\u{1}_ZN6gmt_m15setupEP8zernikeS"]
4872 pub fn gmt_m1_setup2(this: *mut gmt_m1, ZS: *mut zernikeS);
4873}
4874extern "C" {
4875 #[link_name = "\u{1}_ZN6gmt_m17cleanupEv"]
4876 pub fn gmt_m1_cleanup(this: *mut gmt_m1);
4877}
4878extern "C" {
4879 #[link_name = "\u{1}_ZN6gmt_m16updateE6vectorS0_i"]
4880 pub fn gmt_m1_update(
4881 this: *mut gmt_m1,
4882 _origin_: vector,
4883 _euler_angles_: vector,
4884 idx: ::std::os::raw::c_int,
4885 );
4886}
4887extern "C" {
4888 #[link_name = "\u{1}_ZN6gmt_m15resetEv"]
4889 pub fn gmt_m1_reset(this: *mut gmt_m1);
4890}
4891extern "C" {
4892 #[link_name = "\u{1}_ZN6gmt_m15traceEP6bundle"]
4893 pub fn gmt_m1_trace(this: *mut gmt_m1, rays: *mut bundle);
4894}
4895extern "C" {
4896 #[link_name = "\u{1}_ZN6gmt_m18traceallEP6bundle"]
4897 pub fn gmt_m1_traceall(this: *mut gmt_m1, rays: *mut bundle);
4898}
4899extern "C" {
4900 #[link_name = "\u{1}_ZN6gmt_m18blockingEP6bundle"]
4901 pub fn gmt_m1_blocking(this: *mut gmt_m1, rays: *mut bundle);
4902}
4903extern "C" {
4904 #[link_name = "\u{1}_ZN6gmt_m114global_tiptiltEff"]
4905 pub fn gmt_m1_global_tiptilt(this: *mut gmt_m1, tip: f32, tilt: f32);
4906}
4907extern "C" {
4908 #[link_name = "\u{1}_ZN6gmt_m116test_ray_tracingEv"]
4909 pub fn gmt_m1_test_ray_tracing(this: *mut gmt_m1);
4910}
4911extern "C" {
4912 #[link_name = "\u{1}_ZN6gmt_m15trackEPfS0_S0_ii"]
4913 pub fn gmt_m1_track(
4914 this: *mut gmt_m1,
4915 x: *mut f32,
4916 y: *mut f32,
4917 z: *mut f32,
4918 N: ::std::os::raw::c_int,
4919 idx: ::std::os::raw::c_int,
4920 );
4921}
4922extern "C" {
4923 #[link_name = "\u{1}_ZN6gmt_m16locateEPfS0_S0_ii"]
4924 pub fn gmt_m1_locate(
4925 this: *mut gmt_m1,
4926 x: *mut f32,
4927 y: *mut f32,
4928 z: *mut f32,
4929 N: ::std::os::raw::c_int,
4930 idx: ::std::os::raw::c_int,
4931 );
4932}
4933extern "C" {
4934 #[link_name = "\u{1}_ZN6gmt_m16removeEPii"]
4935 pub fn gmt_m1_remove(
4936 this: *mut gmt_m1,
4937 seg_ID: *mut ::std::os::raw::c_int,
4938 N_ID: ::std::os::raw::c_int,
4939 );
4940}
4941extern "C" {
4942 #[link_name = "\u{1}_ZN6gmt_m14keepEPii"]
4943 pub fn gmt_m1_keep(
4944 this: *mut gmt_m1,
4945 seg_ID: *mut ::std::os::raw::c_int,
4946 N_ID: ::std::os::raw::c_int,
4947 );
4948}
4949extern "C" {
4950 #[link_name = "\u{1}_ZN6gmt_m114update_conic_cEPd"]
4951 pub fn gmt_m1_update_conic_c(this: *mut gmt_m1, _conic_c_: *mut rtd);
4952}
4953extern "C" {
4954 #[link_name = "\u{1}_ZN6gmt_m114update_conic_kEPd"]
4955 pub fn gmt_m1_update_conic_k(this: *mut gmt_m1, _conic_k_: *mut rtd);
4956}
4957extern "C" {
4958 #[link_name = "\u{1}_ZN6gmt_m116set_reflectivityEPf"]
4959 pub fn gmt_m1_set_reflectivity(this: *mut gmt_m1, reflectivity: *mut f32);
4960}
4961extern "C" {
4962 #[link_name = "\u{1}_ZN6gmt_m16presetEP6bundled"]
4963 pub fn gmt_m1_preset(this: *mut gmt_m1, rays: *mut bundle, margin: rtd);
4964}
4965extern "C" {
4966 #[link_name = "\u{1}_ZN6gmt_m117edge_sensors_dataEv"]
4967 pub fn gmt_m1_edge_sensors_data(this: *mut gmt_m1);
4968}
4969impl gmt_m1 {
4970 #[inline]
4971 pub unsafe fn setup(&mut self) {
4972 gmt_m1_setup(self)
4973 }
4974 #[inline]
4975 pub unsafe fn setup1(
4976 &mut self,
4977 _filename_: *mut ::std::os::raw::c_char,
4978 _N_: ::std::os::raw::c_int,
4979 _n_mode_: ::std::os::raw::c_int,
4980 ) {
4981 gmt_m1_setup1(self, _filename_, _N_, _n_mode_)
4982 }
4983 #[inline]
4984 pub unsafe fn setup2(&mut self, ZS: *mut zernikeS) {
4985 gmt_m1_setup2(self, ZS)
4986 }
4987 #[inline]
4988 pub unsafe fn cleanup(&mut self) {
4989 gmt_m1_cleanup(self)
4990 }
4991 #[inline]
4992 pub unsafe fn update(
4993 &mut self,
4994 _origin_: vector,
4995 _euler_angles_: vector,
4996 idx: ::std::os::raw::c_int,
4997 ) {
4998 gmt_m1_update(self, _origin_, _euler_angles_, idx)
4999 }
5000 #[inline]
5001 pub unsafe fn reset(&mut self) {
5002 gmt_m1_reset(self)
5003 }
5004 #[inline]
5005 pub unsafe fn trace(&mut self, rays: *mut bundle) {
5006 gmt_m1_trace(self, rays)
5007 }
5008 #[inline]
5009 pub unsafe fn traceall(&mut self, rays: *mut bundle) {
5010 gmt_m1_traceall(self, rays)
5011 }
5012 #[inline]
5013 pub unsafe fn blocking(&mut self, rays: *mut bundle) {
5014 gmt_m1_blocking(self, rays)
5015 }
5016 #[inline]
5017 pub unsafe fn global_tiptilt(&mut self, tip: f32, tilt: f32) {
5018 gmt_m1_global_tiptilt(self, tip, tilt)
5019 }
5020 #[inline]
5021 pub unsafe fn test_ray_tracing(&mut self) {
5022 gmt_m1_test_ray_tracing(self)
5023 }
5024 #[inline]
5025 pub unsafe fn track(
5026 &mut self,
5027 x: *mut f32,
5028 y: *mut f32,
5029 z: *mut f32,
5030 N: ::std::os::raw::c_int,
5031 idx: ::std::os::raw::c_int,
5032 ) {
5033 gmt_m1_track(self, x, y, z, N, idx)
5034 }
5035 #[inline]
5036 pub unsafe fn locate(
5037 &mut self,
5038 x: *mut f32,
5039 y: *mut f32,
5040 z: *mut f32,
5041 N: ::std::os::raw::c_int,
5042 idx: ::std::os::raw::c_int,
5043 ) {
5044 gmt_m1_locate(self, x, y, z, N, idx)
5045 }
5046 #[inline]
5047 pub unsafe fn remove(
5048 &mut self,
5049 seg_ID: *mut ::std::os::raw::c_int,
5050 N_ID: ::std::os::raw::c_int,
5051 ) {
5052 gmt_m1_remove(self, seg_ID, N_ID)
5053 }
5054 #[inline]
5055 pub unsafe fn keep(&mut self, seg_ID: *mut ::std::os::raw::c_int, N_ID: ::std::os::raw::c_int) {
5056 gmt_m1_keep(self, seg_ID, N_ID)
5057 }
5058 #[inline]
5059 pub unsafe fn update_conic_c(&mut self, _conic_c_: *mut rtd) {
5060 gmt_m1_update_conic_c(self, _conic_c_)
5061 }
5062 #[inline]
5063 pub unsafe fn update_conic_k(&mut self, _conic_k_: *mut rtd) {
5064 gmt_m1_update_conic_k(self, _conic_k_)
5065 }
5066 #[inline]
5067 pub unsafe fn set_reflectivity(&mut self, reflectivity: *mut f32) {
5068 gmt_m1_set_reflectivity(self, reflectivity)
5069 }
5070 #[inline]
5071 pub unsafe fn preset(&mut self, rays: *mut bundle, margin: rtd) {
5072 gmt_m1_preset(self, rays, margin)
5073 }
5074 #[inline]
5075 pub unsafe fn edge_sensors_data(&mut self) {
5076 gmt_m1_edge_sensors_data(self)
5077 }
5078}
5079#[repr(C)]
5080#[derive(Debug, Copy, Clone)]
5081pub struct gmt_m2 {
5082 pub M_ID: ::std::os::raw::c_int,
5083 pub D_assembly: rtd,
5084 pub D_clear: rtd,
5085 pub D_full: rtd,
5086 pub ri: rtd,
5087 pub beta: rtd,
5088 pub L: rtd,
5089 pub area0: rtd,
5090 pub area_fraction: rtd,
5091 pub area0_px: f32,
5092 pub area: rtd,
5093 pub N: ::std::os::raw::c_int,
5094 pub depth: rtd,
5095 pub aperture_CS: coordinate_system,
5096 pub conic_CS: coordinate_system,
5097 pub conic_origin: [vector; 7usize],
5098 pub d__conic_origin: *mut vector,
5099 pub conic_c: rtd,
5100 pub conic_k: rtd,
5101 pub d__conic_c: *mut rtd,
5102 pub d__conic_k: *mut rtd,
5103 pub rigid_body_CS: coordinate_system,
5104 pub motion_CS: coordinate_system,
5105 pub height: rtd,
5106 pub V: *mut mask,
5107 pub idx_offset: ::std::os::raw::c_int,
5108 pub ZS: *mut zernikeS,
5109 pub d__piston_mask: *mut ::std::os::raw::c_int,
5110 pub TT_CS: coordinate_system,
5111 pub d__C: *mut f64,
5112 pub d__D: *mut f64,
5113 pub handle: cublasHandle_t,
5114 pub d__valid_segments: *mut ::std::os::raw::c_char,
5115 pub BS: modes,
5116 pub d__segment_reflectivity: *mut f32,
5117}
5118#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5119const _: () = {
5120 ["Size of gmt_m2"][::std::mem::size_of::<gmt_m2>() - 1192usize];
5121 ["Alignment of gmt_m2"][::std::mem::align_of::<gmt_m2>() - 8usize];
5122 ["Offset of field: gmt_m2::M_ID"][::std::mem::offset_of!(gmt_m2, M_ID) - 0usize];
5123 ["Offset of field: gmt_m2::D_assembly"][::std::mem::offset_of!(gmt_m2, D_assembly) - 8usize];
5124 ["Offset of field: gmt_m2::D_clear"][::std::mem::offset_of!(gmt_m2, D_clear) - 16usize];
5125 ["Offset of field: gmt_m2::D_full"][::std::mem::offset_of!(gmt_m2, D_full) - 24usize];
5126 ["Offset of field: gmt_m2::ri"][::std::mem::offset_of!(gmt_m2, ri) - 32usize];
5127 ["Offset of field: gmt_m2::beta"][::std::mem::offset_of!(gmt_m2, beta) - 40usize];
5128 ["Offset of field: gmt_m2::L"][::std::mem::offset_of!(gmt_m2, L) - 48usize];
5129 ["Offset of field: gmt_m2::area0"][::std::mem::offset_of!(gmt_m2, area0) - 56usize];
5130 ["Offset of field: gmt_m2::area_fraction"]
5131 [::std::mem::offset_of!(gmt_m2, area_fraction) - 64usize];
5132 ["Offset of field: gmt_m2::area0_px"][::std::mem::offset_of!(gmt_m2, area0_px) - 72usize];
5133 ["Offset of field: gmt_m2::area"][::std::mem::offset_of!(gmt_m2, area) - 80usize];
5134 ["Offset of field: gmt_m2::N"][::std::mem::offset_of!(gmt_m2, N) - 88usize];
5135 ["Offset of field: gmt_m2::depth"][::std::mem::offset_of!(gmt_m2, depth) - 96usize];
5136 ["Offset of field: gmt_m2::aperture_CS"]
5137 [::std::mem::offset_of!(gmt_m2, aperture_CS) - 104usize];
5138 ["Offset of field: gmt_m2::conic_CS"][::std::mem::offset_of!(gmt_m2, conic_CS) - 192usize];
5139 ["Offset of field: gmt_m2::conic_origin"]
5140 [::std::mem::offset_of!(gmt_m2, conic_origin) - 280usize];
5141 ["Offset of field: gmt_m2::d__conic_origin"]
5142 [::std::mem::offset_of!(gmt_m2, d__conic_origin) - 448usize];
5143 ["Offset of field: gmt_m2::conic_c"][::std::mem::offset_of!(gmt_m2, conic_c) - 456usize];
5144 ["Offset of field: gmt_m2::conic_k"][::std::mem::offset_of!(gmt_m2, conic_k) - 464usize];
5145 ["Offset of field: gmt_m2::d__conic_c"][::std::mem::offset_of!(gmt_m2, d__conic_c) - 472usize];
5146 ["Offset of field: gmt_m2::d__conic_k"][::std::mem::offset_of!(gmt_m2, d__conic_k) - 480usize];
5147 ["Offset of field: gmt_m2::rigid_body_CS"]
5148 [::std::mem::offset_of!(gmt_m2, rigid_body_CS) - 488usize];
5149 ["Offset of field: gmt_m2::motion_CS"][::std::mem::offset_of!(gmt_m2, motion_CS) - 576usize];
5150 ["Offset of field: gmt_m2::height"][::std::mem::offset_of!(gmt_m2, height) - 664usize];
5151 ["Offset of field: gmt_m2::V"][::std::mem::offset_of!(gmt_m2, V) - 672usize];
5152 ["Offset of field: gmt_m2::idx_offset"][::std::mem::offset_of!(gmt_m2, idx_offset) - 680usize];
5153 ["Offset of field: gmt_m2::ZS"][::std::mem::offset_of!(gmt_m2, ZS) - 688usize];
5154 ["Offset of field: gmt_m2::d__piston_mask"]
5155 [::std::mem::offset_of!(gmt_m2, d__piston_mask) - 696usize];
5156 ["Offset of field: gmt_m2::TT_CS"][::std::mem::offset_of!(gmt_m2, TT_CS) - 704usize];
5157 ["Offset of field: gmt_m2::d__C"][::std::mem::offset_of!(gmt_m2, d__C) - 792usize];
5158 ["Offset of field: gmt_m2::d__D"][::std::mem::offset_of!(gmt_m2, d__D) - 800usize];
5159 ["Offset of field: gmt_m2::handle"][::std::mem::offset_of!(gmt_m2, handle) - 808usize];
5160 ["Offset of field: gmt_m2::d__valid_segments"]
5161 [::std::mem::offset_of!(gmt_m2, d__valid_segments) - 816usize];
5162 ["Offset of field: gmt_m2::BS"][::std::mem::offset_of!(gmt_m2, BS) - 824usize];
5163 ["Offset of field: gmt_m2::d__segment_reflectivity"]
5164 [::std::mem::offset_of!(gmt_m2, d__segment_reflectivity) - 1184usize];
5165};
5166extern "C" {
5167 #[link_name = "\u{1}_ZN6gmt_m25setupEv"]
5168 pub fn gmt_m2_setup(this: *mut gmt_m2);
5169}
5170extern "C" {
5171 #[link_name = "\u{1}_ZN6gmt_m25setupEPcii"]
5172 pub fn gmt_m2_setup1(
5173 this: *mut gmt_m2,
5174 _filename_: *mut ::std::os::raw::c_char,
5175 _N_: ::std::os::raw::c_int,
5176 _n_mode_: ::std::os::raw::c_int,
5177 );
5178}
5179extern "C" {
5180 #[link_name = "\u{1}_ZN6gmt_m25setupEP8zernikeS"]
5181 pub fn gmt_m2_setup2(this: *mut gmt_m2, ZS: *mut zernikeS);
5182}
5183extern "C" {
5184 #[link_name = "\u{1}_ZN6gmt_m27cleanupEv"]
5185 pub fn gmt_m2_cleanup(this: *mut gmt_m2);
5186}
5187extern "C" {
5188 #[link_name = "\u{1}_ZN6gmt_m26updateE6vectorS0_i"]
5189 pub fn gmt_m2_update(
5190 this: *mut gmt_m2,
5191 _origin_: vector,
5192 _euler_angles_: vector,
5193 idx: ::std::os::raw::c_int,
5194 );
5195}
5196extern "C" {
5197 #[link_name = "\u{1}_ZN6gmt_m25resetEv"]
5198 pub fn gmt_m2_reset(this: *mut gmt_m2);
5199}
5200extern "C" {
5201 #[link_name = "\u{1}_ZN6gmt_m25traceEP6bundle"]
5202 pub fn gmt_m2_trace(this: *mut gmt_m2, rays: *mut bundle);
5203}
5204extern "C" {
5205 #[link_name = "\u{1}_ZN6gmt_m28traceallEP6bundle"]
5206 pub fn gmt_m2_traceall(this: *mut gmt_m2, rays: *mut bundle);
5207}
5208extern "C" {
5209 #[link_name = "\u{1}_ZN6gmt_m28blockingEP6bundle"]
5210 pub fn gmt_m2_blocking(this: *mut gmt_m2, rays: *mut bundle);
5211}
5212extern "C" {
5213 #[link_name = "\u{1}_ZN6gmt_m214global_tiptiltEff"]
5214 pub fn gmt_m2_global_tiptilt(this: *mut gmt_m2, tip: f32, tilt: f32);
5215}
5216extern "C" {
5217 #[link_name = "\u{1}_ZN6gmt_m216test_ray_tracingEv"]
5218 pub fn gmt_m2_test_ray_tracing(this: *mut gmt_m2);
5219}
5220extern "C" {
5221 #[link_name = "\u{1}_ZN6gmt_m25trackEPfS0_S0_ii"]
5222 pub fn gmt_m2_track(
5223 this: *mut gmt_m2,
5224 x: *mut f32,
5225 y: *mut f32,
5226 z: *mut f32,
5227 N: ::std::os::raw::c_int,
5228 idx: ::std::os::raw::c_int,
5229 );
5230}
5231extern "C" {
5232 #[link_name = "\u{1}_ZN6gmt_m26locateEPfS0_S0_ii"]
5233 pub fn gmt_m2_locate(
5234 this: *mut gmt_m2,
5235 x: *mut f32,
5236 y: *mut f32,
5237 z: *mut f32,
5238 N: ::std::os::raw::c_int,
5239 idx: ::std::os::raw::c_int,
5240 );
5241}
5242extern "C" {
5243 #[link_name = "\u{1}_ZN6gmt_m26removeEPii"]
5244 pub fn gmt_m2_remove(
5245 this: *mut gmt_m2,
5246 seg_ID: *mut ::std::os::raw::c_int,
5247 N_ID: ::std::os::raw::c_int,
5248 );
5249}
5250extern "C" {
5251 #[link_name = "\u{1}_ZN6gmt_m24keepEPii"]
5252 pub fn gmt_m2_keep(
5253 this: *mut gmt_m2,
5254 seg_ID: *mut ::std::os::raw::c_int,
5255 N_ID: ::std::os::raw::c_int,
5256 );
5257}
5258extern "C" {
5259 #[link_name = "\u{1}_ZN6gmt_m214update_conic_cEPd"]
5260 pub fn gmt_m2_update_conic_c(this: *mut gmt_m2, _conic_c_: *mut rtd);
5261}
5262extern "C" {
5263 #[link_name = "\u{1}_ZN6gmt_m214update_conic_kEPd"]
5264 pub fn gmt_m2_update_conic_k(this: *mut gmt_m2, _conic_k_: *mut rtd);
5265}
5266extern "C" {
5267 #[link_name = "\u{1}_ZN6gmt_m216set_reflectivityEPf"]
5268 pub fn gmt_m2_set_reflectivity(this: *mut gmt_m2, reflectivity: *mut f32);
5269}
5270extern "C" {
5271 #[link_name = "\u{1}_ZN6gmt_m216pointing_neutralEff"]
5272 pub fn gmt_m2_pointing_neutral(this: *mut gmt_m2, tip: f32, tilt: f32);
5273}
5274extern "C" {
5275 #[link_name = "\u{1}_ZN6gmt_m212coma_neutralEff"]
5276 pub fn gmt_m2_coma_neutral(this: *mut gmt_m2, tip: f32, tilt: f32);
5277}
5278impl gmt_m2 {
5279 #[inline]
5280 pub unsafe fn setup(&mut self) {
5281 gmt_m2_setup(self)
5282 }
5283 #[inline]
5284 pub unsafe fn setup1(
5285 &mut self,
5286 _filename_: *mut ::std::os::raw::c_char,
5287 _N_: ::std::os::raw::c_int,
5288 _n_mode_: ::std::os::raw::c_int,
5289 ) {
5290 gmt_m2_setup1(self, _filename_, _N_, _n_mode_)
5291 }
5292 #[inline]
5293 pub unsafe fn setup2(&mut self, ZS: *mut zernikeS) {
5294 gmt_m2_setup2(self, ZS)
5295 }
5296 #[inline]
5297 pub unsafe fn cleanup(&mut self) {
5298 gmt_m2_cleanup(self)
5299 }
5300 #[inline]
5301 pub unsafe fn update(
5302 &mut self,
5303 _origin_: vector,
5304 _euler_angles_: vector,
5305 idx: ::std::os::raw::c_int,
5306 ) {
5307 gmt_m2_update(self, _origin_, _euler_angles_, idx)
5308 }
5309 #[inline]
5310 pub unsafe fn reset(&mut self) {
5311 gmt_m2_reset(self)
5312 }
5313 #[inline]
5314 pub unsafe fn trace(&mut self, rays: *mut bundle) {
5315 gmt_m2_trace(self, rays)
5316 }
5317 #[inline]
5318 pub unsafe fn traceall(&mut self, rays: *mut bundle) {
5319 gmt_m2_traceall(self, rays)
5320 }
5321 #[inline]
5322 pub unsafe fn blocking(&mut self, rays: *mut bundle) {
5323 gmt_m2_blocking(self, rays)
5324 }
5325 #[inline]
5326 pub unsafe fn global_tiptilt(&mut self, tip: f32, tilt: f32) {
5327 gmt_m2_global_tiptilt(self, tip, tilt)
5328 }
5329 #[inline]
5330 pub unsafe fn test_ray_tracing(&mut self) {
5331 gmt_m2_test_ray_tracing(self)
5332 }
5333 #[inline]
5334 pub unsafe fn track(
5335 &mut self,
5336 x: *mut f32,
5337 y: *mut f32,
5338 z: *mut f32,
5339 N: ::std::os::raw::c_int,
5340 idx: ::std::os::raw::c_int,
5341 ) {
5342 gmt_m2_track(self, x, y, z, N, idx)
5343 }
5344 #[inline]
5345 pub unsafe fn locate(
5346 &mut self,
5347 x: *mut f32,
5348 y: *mut f32,
5349 z: *mut f32,
5350 N: ::std::os::raw::c_int,
5351 idx: ::std::os::raw::c_int,
5352 ) {
5353 gmt_m2_locate(self, x, y, z, N, idx)
5354 }
5355 #[inline]
5356 pub unsafe fn remove(
5357 &mut self,
5358 seg_ID: *mut ::std::os::raw::c_int,
5359 N_ID: ::std::os::raw::c_int,
5360 ) {
5361 gmt_m2_remove(self, seg_ID, N_ID)
5362 }
5363 #[inline]
5364 pub unsafe fn keep(&mut self, seg_ID: *mut ::std::os::raw::c_int, N_ID: ::std::os::raw::c_int) {
5365 gmt_m2_keep(self, seg_ID, N_ID)
5366 }
5367 #[inline]
5368 pub unsafe fn update_conic_c(&mut self, _conic_c_: *mut rtd) {
5369 gmt_m2_update_conic_c(self, _conic_c_)
5370 }
5371 #[inline]
5372 pub unsafe fn update_conic_k(&mut self, _conic_k_: *mut rtd) {
5373 gmt_m2_update_conic_k(self, _conic_k_)
5374 }
5375 #[inline]
5376 pub unsafe fn set_reflectivity(&mut self, reflectivity: *mut f32) {
5377 gmt_m2_set_reflectivity(self, reflectivity)
5378 }
5379 #[inline]
5380 pub unsafe fn pointing_neutral(&mut self, tip: f32, tilt: f32) {
5381 gmt_m2_pointing_neutral(self, tip, tilt)
5382 }
5383 #[inline]
5384 pub unsafe fn coma_neutral(&mut self, tip: f32, tilt: f32) {
5385 gmt_m2_coma_neutral(self, tip, tilt)
5386 }
5387}
5388#[repr(C)]
5389#[derive(Debug, Copy, Clone)]
5390pub struct layer {
5391 pub altitude: f32,
5392 pub xi0: f32,
5393 pub wind_speed: f32,
5394 pub wind_direction: f32,
5395 pub vx: f32,
5396 pub vy: f32,
5397 pub WIDTH_LAYER: f32,
5398 pub LENGTH_LAYER: f32,
5399 pub N_WIDTH_LAYER: ::std::os::raw::c_int,
5400 pub N_LENGTH_LAYER: ::std::os::raw::c_int,
5401}
5402#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5403const _: () = {
5404 ["Size of layer"][::std::mem::size_of::<layer>() - 40usize];
5405 ["Alignment of layer"][::std::mem::align_of::<layer>() - 4usize];
5406 ["Offset of field: layer::altitude"][::std::mem::offset_of!(layer, altitude) - 0usize];
5407 ["Offset of field: layer::xi0"][::std::mem::offset_of!(layer, xi0) - 4usize];
5408 ["Offset of field: layer::wind_speed"][::std::mem::offset_of!(layer, wind_speed) - 8usize];
5409 ["Offset of field: layer::wind_direction"]
5410 [::std::mem::offset_of!(layer, wind_direction) - 12usize];
5411 ["Offset of field: layer::vx"][::std::mem::offset_of!(layer, vx) - 16usize];
5412 ["Offset of field: layer::vy"][::std::mem::offset_of!(layer, vy) - 20usize];
5413 ["Offset of field: layer::WIDTH_LAYER"][::std::mem::offset_of!(layer, WIDTH_LAYER) - 24usize];
5414 ["Offset of field: layer::LENGTH_LAYER"][::std::mem::offset_of!(layer, LENGTH_LAYER) - 28usize];
5415 ["Offset of field: layer::N_WIDTH_LAYER"]
5416 [::std::mem::offset_of!(layer, N_WIDTH_LAYER) - 32usize];
5417 ["Offset of field: layer::N_LENGTH_LAYER"]
5418 [::std::mem::offset_of!(layer, N_LENGTH_LAYER) - 36usize];
5419};
5420extern "C" {
5421 #[link_name = "\u{1}_ZN5layer5setupEfffffifif"]
5422 pub fn layer_setup(
5423 this: *mut layer,
5424 _altitude: f32,
5425 _xi0: f32,
5426 _wind_speed_: f32,
5427 _wind_direction: f32,
5428 W: f32,
5429 N_W: ::std::os::raw::c_int,
5430 field_size: f32,
5431 OSF: ::std::os::raw::c_int,
5432 duration: f32,
5433 ) -> ::std::os::raw::c_int;
5434}
5435impl layer {
5436 #[inline]
5437 pub unsafe fn setup(
5438 &mut self,
5439 _altitude: f32,
5440 _xi0: f32,
5441 _wind_speed_: f32,
5442 _wind_direction: f32,
5443 W: f32,
5444 N_W: ::std::os::raw::c_int,
5445 field_size: f32,
5446 OSF: ::std::os::raw::c_int,
5447 duration: f32,
5448 ) -> ::std::os::raw::c_int {
5449 layer_setup(
5450 self,
5451 _altitude,
5452 _xi0,
5453 _wind_speed_,
5454 _wind_direction,
5455 W,
5456 N_W,
5457 field_size,
5458 OSF,
5459 duration,
5460 )
5461 }
5462}
5463#[repr(C)]
5464#[derive(Debug, Copy, Clone)]
5465pub struct profile {
5466 pub L0: f32,
5467 pub l0: f32,
5468 pub L: f32,
5469 pub f: f32,
5470 pub delta: f32,
5471 pub N_k: f32,
5472 pub N_a: f32,
5473 pub kmin: f32,
5474 pub altitude: *mut f32,
5475 pub xi0: *mut f32,
5476 pub wind_speed: *mut f32,
5477 pub wind_direction: *mut f32,
5478}
5479#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5480const _: () = {
5481 ["Size of profile"][::std::mem::size_of::<profile>() - 64usize];
5482 ["Alignment of profile"][::std::mem::align_of::<profile>() - 8usize];
5483 ["Offset of field: profile::L0"][::std::mem::offset_of!(profile, L0) - 0usize];
5484 ["Offset of field: profile::l0"][::std::mem::offset_of!(profile, l0) - 4usize];
5485 ["Offset of field: profile::L"][::std::mem::offset_of!(profile, L) - 8usize];
5486 ["Offset of field: profile::f"][::std::mem::offset_of!(profile, f) - 12usize];
5487 ["Offset of field: profile::delta"][::std::mem::offset_of!(profile, delta) - 16usize];
5488 ["Offset of field: profile::N_k"][::std::mem::offset_of!(profile, N_k) - 20usize];
5489 ["Offset of field: profile::N_a"][::std::mem::offset_of!(profile, N_a) - 24usize];
5490 ["Offset of field: profile::kmin"][::std::mem::offset_of!(profile, kmin) - 28usize];
5491 ["Offset of field: profile::altitude"][::std::mem::offset_of!(profile, altitude) - 32usize];
5492 ["Offset of field: profile::xi0"][::std::mem::offset_of!(profile, xi0) - 40usize];
5493 ["Offset of field: profile::wind_speed"][::std::mem::offset_of!(profile, wind_speed) - 48usize];
5494 ["Offset of field: profile::wind_direction"]
5495 [::std::mem::offset_of!(profile, wind_direction) - 56usize];
5496};
5497extern "C" {
5498 #[link_name = "\u{1}_ZN7profile5setupEPfS0_S0_S0_i"]
5499 pub fn profile_setup(
5500 this: *mut profile,
5501 altitude: *mut f32,
5502 xi0: *mut f32,
5503 wind_speed: *mut f32,
5504 wind_direction: *mut f32,
5505 N_LAYER: ::std::os::raw::c_int,
5506 );
5507}
5508extern "C" {
5509 #[link_name = "\u{1}_ZN7profile7cleanupEv"]
5510 pub fn profile_cleanup(this: *mut profile);
5511}
5512impl profile {
5513 #[inline]
5514 pub unsafe fn setup(
5515 &mut self,
5516 altitude: *mut f32,
5517 xi0: *mut f32,
5518 wind_speed: *mut f32,
5519 wind_direction: *mut f32,
5520 N_LAYER: ::std::os::raw::c_int,
5521 ) {
5522 profile_setup(self, altitude, xi0, wind_speed, wind_direction, N_LAYER)
5523 }
5524 #[inline]
5525 pub unsafe fn cleanup(&mut self) {
5526 profile_cleanup(self)
5527 }
5528}
5529#[repr(C)]
5530#[derive(Debug, Copy, Clone)]
5531pub struct atmosphere {
5532 pub photometric_band: *mut ::std::os::raw::c_char,
5533 pub wavelength: f32,
5534 pub r0: f32,
5535 pub wavenumber: f32,
5536 pub N_LAYER: ::std::os::raw::c_int,
5537 pub field_size: f32,
5538 pub layers_OSF: ::std::os::raw::c_int,
5539 pub layers_duration: f32,
5540 pub layers_tau0: f32,
5541 pub W: f32,
5542 pub N_W: ::std::os::raw::c_int,
5543 pub phase_screen_LAYER: *mut f32,
5544 pub N_DURATION: ::std::os::raw::c_int,
5545 pub LOCAL_RAND_SEED: ::std::os::raw::c_int,
5546 pub ID: ::std::os::raw::c_int,
5547 pub EPH: f32,
5548 pub d__phase_screen_LAYER: *mut f32,
5549 pub N_PHASE_LAYER: ::std::os::raw::c_ulong,
5550 pub mmap_size: usize,
5551 pub zeta1: *mut f32,
5552 pub eta1: *mut f32,
5553 pub zeta2: *mut f32,
5554 pub eta2: *mut f32,
5555 pub devStates: *mut curandState,
5556 pub turbulence: profile,
5557 pub d__turbulence: *mut profile,
5558 pub layers: *mut layer,
5559 pub d__layers: *mut layer,
5560}
5561#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5562const _: () = {
5563 ["Size of atmosphere"][::std::mem::size_of::<atmosphere>() - 224usize];
5564 ["Alignment of atmosphere"][::std::mem::align_of::<atmosphere>() - 8usize];
5565 ["Offset of field: atmosphere::photometric_band"]
5566 [::std::mem::offset_of!(atmosphere, photometric_band) - 0usize];
5567 ["Offset of field: atmosphere::wavelength"]
5568 [::std::mem::offset_of!(atmosphere, wavelength) - 8usize];
5569 ["Offset of field: atmosphere::r0"][::std::mem::offset_of!(atmosphere, r0) - 12usize];
5570 ["Offset of field: atmosphere::wavenumber"]
5571 [::std::mem::offset_of!(atmosphere, wavenumber) - 16usize];
5572 ["Offset of field: atmosphere::N_LAYER"][::std::mem::offset_of!(atmosphere, N_LAYER) - 20usize];
5573 ["Offset of field: atmosphere::field_size"]
5574 [::std::mem::offset_of!(atmosphere, field_size) - 24usize];
5575 ["Offset of field: atmosphere::layers_OSF"]
5576 [::std::mem::offset_of!(atmosphere, layers_OSF) - 28usize];
5577 ["Offset of field: atmosphere::layers_duration"]
5578 [::std::mem::offset_of!(atmosphere, layers_duration) - 32usize];
5579 ["Offset of field: atmosphere::layers_tau0"]
5580 [::std::mem::offset_of!(atmosphere, layers_tau0) - 36usize];
5581 ["Offset of field: atmosphere::W"][::std::mem::offset_of!(atmosphere, W) - 40usize];
5582 ["Offset of field: atmosphere::N_W"][::std::mem::offset_of!(atmosphere, N_W) - 44usize];
5583 ["Offset of field: atmosphere::phase_screen_LAYER"]
5584 [::std::mem::offset_of!(atmosphere, phase_screen_LAYER) - 48usize];
5585 ["Offset of field: atmosphere::N_DURATION"]
5586 [::std::mem::offset_of!(atmosphere, N_DURATION) - 56usize];
5587 ["Offset of field: atmosphere::LOCAL_RAND_SEED"]
5588 [::std::mem::offset_of!(atmosphere, LOCAL_RAND_SEED) - 60usize];
5589 ["Offset of field: atmosphere::ID"][::std::mem::offset_of!(atmosphere, ID) - 64usize];
5590 ["Offset of field: atmosphere::EPH"][::std::mem::offset_of!(atmosphere, EPH) - 68usize];
5591 ["Offset of field: atmosphere::d__phase_screen_LAYER"]
5592 [::std::mem::offset_of!(atmosphere, d__phase_screen_LAYER) - 72usize];
5593 ["Offset of field: atmosphere::N_PHASE_LAYER"]
5594 [::std::mem::offset_of!(atmosphere, N_PHASE_LAYER) - 80usize];
5595 ["Offset of field: atmosphere::mmap_size"]
5596 [::std::mem::offset_of!(atmosphere, mmap_size) - 88usize];
5597 ["Offset of field: atmosphere::zeta1"][::std::mem::offset_of!(atmosphere, zeta1) - 96usize];
5598 ["Offset of field: atmosphere::eta1"][::std::mem::offset_of!(atmosphere, eta1) - 104usize];
5599 ["Offset of field: atmosphere::zeta2"][::std::mem::offset_of!(atmosphere, zeta2) - 112usize];
5600 ["Offset of field: atmosphere::eta2"][::std::mem::offset_of!(atmosphere, eta2) - 120usize];
5601 ["Offset of field: atmosphere::devStates"]
5602 [::std::mem::offset_of!(atmosphere, devStates) - 128usize];
5603 ["Offset of field: atmosphere::turbulence"]
5604 [::std::mem::offset_of!(atmosphere, turbulence) - 136usize];
5605 ["Offset of field: atmosphere::d__turbulence"]
5606 [::std::mem::offset_of!(atmosphere, d__turbulence) - 200usize];
5607 ["Offset of field: atmosphere::layers"][::std::mem::offset_of!(atmosphere, layers) - 208usize];
5608 ["Offset of field: atmosphere::d__layers"]
5609 [::std::mem::offset_of!(atmosphere, d__layers) - 216usize];
5610};
5611extern "C" {
5612 #[link_name = "\u{1}_ZN10atmosphere5setupEffiPfS0_S0_S0_"]
5613 pub fn atmosphere_setup(
5614 this: *mut atmosphere,
5615 r0_: f32,
5616 L0: f32,
5617 N_LAYER: ::std::os::raw::c_int,
5618 altitude: *mut f32,
5619 xi0: *mut f32,
5620 wind_speed: *mut f32,
5621 wind_direction: *mut f32,
5622 );
5623}
5624extern "C" {
5625 #[link_name = "\u{1}_ZN10atmosphere5setupEffiPfS0_S0_S0_fiff"]
5626 pub fn atmosphere_setup1(
5627 this: *mut atmosphere,
5628 r0_: f32,
5629 L0: f32,
5630 N_LAYER: ::std::os::raw::c_int,
5631 altitude: *mut f32,
5632 xi0: *mut f32,
5633 wind_speed: *mut f32,
5634 wind_direction: *mut f32,
5635 _L_: f32,
5636 _NXY_PUPIL_: ::std::os::raw::c_int,
5637 field_size: f32,
5638 duration: f32,
5639 );
5640}
5641extern "C" {
5642 #[link_name = "\u{1}_ZN10atmosphere5setupEffiPfS0_S0_S0_fiffPKci"]
5643 pub fn atmosphere_setup2(
5644 this: *mut atmosphere,
5645 r0_: f32,
5646 L0: f32,
5647 _NLAYER: ::std::os::raw::c_int,
5648 altitude: *mut f32,
5649 xi0: *mut f32,
5650 wind_speed: *mut f32,
5651 wind_direction: *mut f32,
5652 _L_: f32,
5653 _NXY_PUPIL_: ::std::os::raw::c_int,
5654 field_size: f32,
5655 duration: f32,
5656 fullpath_to_phasescreens: *const ::std::os::raw::c_char,
5657 _N_DURATION: ::std::os::raw::c_int,
5658 );
5659}
5660extern "C" {
5661 #[link_name = "\u{1}_ZN10atmosphere9gmt_setupEv"]
5662 pub fn atmosphere_gmt_setup(this: *mut atmosphere);
5663}
5664extern "C" {
5665 #[link_name = "\u{1}_ZN10atmosphere9gmt_setupEff"]
5666 pub fn atmosphere_gmt_setup1(this: *mut atmosphere, r0_: f32, L0: f32);
5667}
5668extern "C" {
5669 #[link_name = "\u{1}_ZN10atmosphere9gmt_setupEfffiff"]
5670 pub fn atmosphere_gmt_setup2(
5671 this: *mut atmosphere,
5672 r0_: f32,
5673 L0: f32,
5674 _L_: f32,
5675 _NXY_PUPIL_: ::std::os::raw::c_int,
5676 field_size: f32,
5677 duration: f32,
5678 );
5679}
5680extern "C" {
5681 #[link_name = "\u{1}_ZN10atmosphere9gmt_setupEfffiffPKci"]
5682 pub fn atmosphere_gmt_setup3(
5683 this: *mut atmosphere,
5684 r0_: f32,
5685 L0: f32,
5686 _L_: f32,
5687 _NXY_PUPIL_: ::std::os::raw::c_int,
5688 field_size: f32,
5689 duration: f32,
5690 fullpath_to_phasescreens: *const ::std::os::raw::c_char,
5691 _N_DURATION: ::std::os::raw::c_int,
5692 );
5693}
5694extern "C" {
5695 #[link_name = "\u{1}_ZN10atmosphere9gmt_setupEffi"]
5696 pub fn atmosphere_gmt_setup4(
5697 this: *mut atmosphere,
5698 r0_: f32,
5699 L0: f32,
5700 _RAND_SEED_: ::std::os::raw::c_int,
5701 );
5702}
5703extern "C" {
5704 #[link_name = "\u{1}_ZN10atmosphere9gmt_setupEfffiffi"]
5705 pub fn atmosphere_gmt_setup5(
5706 this: *mut atmosphere,
5707 r0_: f32,
5708 L0: f32,
5709 _L_: f32,
5710 _NXY_PUPIL_: ::std::os::raw::c_int,
5711 field_size: f32,
5712 duration: f32,
5713 _RAND_SEED_: ::std::os::raw::c_int,
5714 );
5715}
5716extern "C" {
5717 #[link_name = "\u{1}_ZN10atmosphere9gmt_setupEfffiffPKcii"]
5718 pub fn atmosphere_gmt_setup6(
5719 this: *mut atmosphere,
5720 r0_: f32,
5721 L0: f32,
5722 _L_: f32,
5723 _NXY_PUPIL_: ::std::os::raw::c_int,
5724 field_size: f32,
5725 duration: f32,
5726 fullpath_to_phasescreens: *const ::std::os::raw::c_char,
5727 _N_DURATION: ::std::os::raw::c_int,
5728 _RAND_SEED_: ::std::os::raw::c_int,
5729 );
5730}
5731extern "C" {
5732 #[link_name = "\u{1}_ZN10atmosphere10gmt_set_idEi"]
5733 pub fn atmosphere_gmt_set_id(this: *mut atmosphere, _ID_: ::std::os::raw::c_int);
5734}
5735extern "C" {
5736 #[link_name = "\u{1}_ZN10atmosphere11gmt_set_ephEf"]
5737 pub fn atmosphere_gmt_set_eph(this: *mut atmosphere, _EPH_: f32);
5738}
5739extern "C" {
5740 #[link_name = "\u{1}_ZN10atmosphere7cleanupEv"]
5741 pub fn atmosphere_cleanup(this: *mut atmosphere);
5742}
5743extern "C" {
5744 #[link_name = "\u{1}_ZN10atmosphere4infoEv"]
5745 pub fn atmosphere_info(this: *mut atmosphere);
5746}
5747extern "C" {
5748 #[link_name = "\u{1}_ZN10atmosphere5resetEv"]
5749 pub fn atmosphere_reset(this: *mut atmosphere);
5750}
5751extern "C" {
5752 #[link_name = "\u{1}_ZN10atmosphere23save_layer_phasescreensEPKci"]
5753 pub fn atmosphere_save_layer_phasescreens(
5754 this: *mut atmosphere,
5755 fullpath_to_phasescreens: *const ::std::os::raw::c_char,
5756 _N_DURATION: ::std::os::raw::c_int,
5757 );
5758}
5759extern "C" {
5760 #[link_name = "\u{1}_ZN10atmosphere16get_phase_screenEPfPKfS2_iP6sourcef"]
5761 pub fn atmosphere_get_phase_screen(
5762 this: *mut atmosphere,
5763 phase_screen: *mut f32,
5764 x: *const f32,
5765 y: *const f32,
5766 N_xy: ::std::os::raw::c_int,
5767 src: *mut source,
5768 time: f32,
5769 );
5770}
5771extern "C" {
5772 #[link_name = "\u{1}_ZN10atmosphere16get_phase_screenEPKfS1_iP6sourcef"]
5773 pub fn atmosphere_get_phase_screen1(
5774 this: *mut atmosphere,
5775 x: *const f32,
5776 y: *const f32,
5777 N_xy: ::std::os::raw::c_int,
5778 src: *mut source,
5779 time: f32,
5780 );
5781}
5782extern "C" {
5783 #[link_name = "\u{1}_ZN10atmosphere16get_phase_screenEfifiP6sourcef"]
5784 pub fn atmosphere_get_phase_screen2(
5785 this: *mut atmosphere,
5786 delta_x: f32,
5787 N_x: ::std::os::raw::c_int,
5788 delta_y: f32,
5789 N_y: ::std::os::raw::c_int,
5790 src: *mut source,
5791 time: f32,
5792 );
5793}
5794extern "C" {
5795 #[link_name = "\u{1}_ZN10atmosphere16get_phase_screenEPffifiP6sourcef"]
5796 pub fn atmosphere_get_phase_screen3(
5797 this: *mut atmosphere,
5798 phase_screen: *mut f32,
5799 delta_x: f32,
5800 N_x: ::std::os::raw::c_int,
5801 delta_y: f32,
5802 N_y: ::std::os::raw::c_int,
5803 src: *mut source,
5804 time: f32,
5805 );
5806}
5807extern "C" {
5808 #[link_name = "\u{1}_ZN10atmosphere16get_phase_screenEP6sourcefifif"]
5809 pub fn atmosphere_get_phase_screen4(
5810 this: *mut atmosphere,
5811 src: *mut source,
5812 delta_x: f32,
5813 N_x: ::std::os::raw::c_int,
5814 delta_y: f32,
5815 N_y: ::std::os::raw::c_int,
5816 time: f32,
5817 );
5818}
5819extern "C" {
5820 #[link_name = "\u{1}_ZN10atmosphere16get_phase_screenEP6sourcefififf"]
5821 pub fn atmosphere_get_phase_screen5(
5822 this: *mut atmosphere,
5823 src: *mut source,
5824 delta_x: f32,
5825 N_x: ::std::os::raw::c_int,
5826 delta_y: f32,
5827 N_y: ::std::os::raw::c_int,
5828 time: f32,
5829 exponent: f32,
5830 );
5831}
5832extern "C" {
5833 #[link_name = "\u{1}_ZN10atmosphere16get_phase_screenEP6sourceififif"]
5834 pub fn atmosphere_get_phase_screen6(
5835 this: *mut atmosphere,
5836 src: *mut source,
5837 N_SRC: ::std::os::raw::c_int,
5838 delta_x: f32,
5839 N_x: ::std::os::raw::c_int,
5840 delta_y: f32,
5841 N_y: ::std::os::raw::c_int,
5842 time: f32,
5843 );
5844}
5845extern "C" {
5846 #[link_name = "\u{1}_ZN10atmosphere16get_phase_screenEP6sourcef"]
5847 pub fn atmosphere_get_phase_screen7(this: *mut atmosphere, src: *mut source, time: f32);
5848}
5849extern "C" {
5850 #[link_name = "\u{1}_ZN10atmosphere25get_phase_screen_gradientEPfS0_S0_S0_iP6sourcef"]
5851 pub fn atmosphere_get_phase_screen_gradient(
5852 this: *mut atmosphere,
5853 sx: *mut f32,
5854 sy: *mut f32,
5855 x: *mut f32,
5856 y: *mut f32,
5857 Nxy: ::std::os::raw::c_int,
5858 src: *mut source,
5859 time: f32,
5860 );
5861}
5862extern "C" {
5863 #[link_name = "\u{1}_ZN10atmosphere25get_phase_screen_gradientEPfS0_ifP6sourcef"]
5864 pub fn atmosphere_get_phase_screen_gradient1(
5865 this: *mut atmosphere,
5866 sx: *mut f32,
5867 sy: *mut f32,
5868 NL: ::std::os::raw::c_int,
5869 d: f32,
5870 src: *mut source,
5871 time: f32,
5872 );
5873}
5874extern "C" {
5875 #[link_name = "\u{1}_ZN10atmosphere25get_phase_screen_gradientEPfS0_iPcfP6sourcef"]
5876 pub fn atmosphere_get_phase_screen_gradient2(
5877 this: *mut atmosphere,
5878 sx: *mut f32,
5879 sy: *mut f32,
5880 NL: ::std::os::raw::c_int,
5881 valid_lenslet: *mut ::std::os::raw::c_char,
5882 d: f32,
5883 src: *mut source,
5884 time: f32,
5885 );
5886}
5887extern "C" {
5888 #[link_name = "\u{1}_ZN10atmosphere25get_phase_screen_gradientEP11centroidingifP6sourcef"]
5889 pub fn atmosphere_get_phase_screen_gradient3(
5890 this: *mut atmosphere,
5891 cog: *mut centroiding,
5892 NL: ::std::os::raw::c_int,
5893 d: f32,
5894 src: *mut source,
5895 time: f32,
5896 );
5897}
5898extern "C" {
5899 #[link_name = "\u{1}_ZN10atmosphere41get_phase_screen_gradient_rolling_shutterEP11centroidingifP6sourceff"]
5900 pub fn atmosphere_get_phase_screen_gradient_rolling_shutter(
5901 this: *mut atmosphere,
5902 cog: *mut centroiding,
5903 NL: ::std::os::raw::c_int,
5904 d: f32,
5905 src: *mut source,
5906 time: f32,
5907 delay: f32,
5908 );
5909}
5910extern "C" {
5911 #[link_name = "\u{1}_ZN10atmosphere25get_phase_screen_gradientEP11centroidingifP6sourceif"]
5912 pub fn atmosphere_get_phase_screen_gradient4(
5913 this: *mut atmosphere,
5914 cog: *mut centroiding,
5915 NL: ::std::os::raw::c_int,
5916 d: f32,
5917 src: *mut source,
5918 N_SRC: ::std::os::raw::c_int,
5919 time: f32,
5920 );
5921}
5922extern "C" {
5923 #[link_name = "\u{1}_ZN10atmosphere25get_phase_screen_gradientEP11centroidingiPcfP6sourceif"]
5924 pub fn atmosphere_get_phase_screen_gradient5(
5925 this: *mut atmosphere,
5926 cog: *mut centroiding,
5927 NL: ::std::os::raw::c_int,
5928 valid_lenslet: *mut ::std::os::raw::c_char,
5929 d: f32,
5930 src: *mut source,
5931 N_SRC: ::std::os::raw::c_int,
5932 time: f32,
5933 );
5934}
5935extern "C" {
5936 #[link_name = "\u{1}_ZN10atmosphere31get_phase_screen_circ_centroidsEP11centroidingfP6sourceif"]
5937 pub fn atmosphere_get_phase_screen_circ_centroids(
5938 this: *mut atmosphere,
5939 cog: *mut centroiding,
5940 R: f32,
5941 src: *mut source,
5942 N_SRC: ::std::os::raw::c_int,
5943 time: f32,
5944 );
5945}
5946extern "C" {
5947 #[link_name = "\u{1}_ZN10atmosphere38get_phase_screen_circ_uplink_centroidsEP11centroidingfP6sourceifc"]
5948 pub fn atmosphere_get_phase_screen_circ_uplink_centroids(
5949 this: *mut atmosphere,
5950 cog: *mut centroiding,
5951 R: f32,
5952 src: *mut source,
5953 N_SRC: ::std::os::raw::c_int,
5954 time: f32,
5955 focused: ::std::os::raw::c_char,
5956 );
5957}
5958extern "C" {
5959 #[link_name = "\u{1}_ZN10atmosphere10rayTracingEPKfS1_PfiPK6sourcef"]
5960 pub fn atmosphere_rayTracing(
5961 this: *mut atmosphere,
5962 x_PUPIL: *const f32,
5963 y_PUPIL: *const f32,
5964 phase_screen_PUPIL: *mut f32,
5965 NXY_PUPIL: ::std::os::raw::c_int,
5966 src: *const source,
5967 tau: f32,
5968 );
5969}
5970extern "C" {
5971 #[link_name = "\u{1}_ZN10atmosphere10rayTracingEP6sourcefifif"]
5972 pub fn atmosphere_rayTracing1(
5973 this: *mut atmosphere,
5974 src: *mut source,
5975 delta_x: f32,
5976 N_X: ::std::os::raw::c_int,
5977 delta_y: f32,
5978 N_Y: ::std::os::raw::c_int,
5979 tau: f32,
5980 );
5981}
5982impl atmosphere {
5983 #[inline]
5984 pub unsafe fn setup(
5985 &mut self,
5986 r0_: f32,
5987 L0: f32,
5988 N_LAYER: ::std::os::raw::c_int,
5989 altitude: *mut f32,
5990 xi0: *mut f32,
5991 wind_speed: *mut f32,
5992 wind_direction: *mut f32,
5993 ) {
5994 atmosphere_setup(
5995 self,
5996 r0_,
5997 L0,
5998 N_LAYER,
5999 altitude,
6000 xi0,
6001 wind_speed,
6002 wind_direction,
6003 )
6004 }
6005 #[inline]
6006 pub unsafe fn setup1(
6007 &mut self,
6008 r0_: f32,
6009 L0: f32,
6010 N_LAYER: ::std::os::raw::c_int,
6011 altitude: *mut f32,
6012 xi0: *mut f32,
6013 wind_speed: *mut f32,
6014 wind_direction: *mut f32,
6015 _L_: f32,
6016 _NXY_PUPIL_: ::std::os::raw::c_int,
6017 field_size: f32,
6018 duration: f32,
6019 ) {
6020 atmosphere_setup1(
6021 self,
6022 r0_,
6023 L0,
6024 N_LAYER,
6025 altitude,
6026 xi0,
6027 wind_speed,
6028 wind_direction,
6029 _L_,
6030 _NXY_PUPIL_,
6031 field_size,
6032 duration,
6033 )
6034 }
6035 #[inline]
6036 pub unsafe fn setup2(
6037 &mut self,
6038 r0_: f32,
6039 L0: f32,
6040 _NLAYER: ::std::os::raw::c_int,
6041 altitude: *mut f32,
6042 xi0: *mut f32,
6043 wind_speed: *mut f32,
6044 wind_direction: *mut f32,
6045 _L_: f32,
6046 _NXY_PUPIL_: ::std::os::raw::c_int,
6047 field_size: f32,
6048 duration: f32,
6049 fullpath_to_phasescreens: *const ::std::os::raw::c_char,
6050 _N_DURATION: ::std::os::raw::c_int,
6051 ) {
6052 atmosphere_setup2(
6053 self,
6054 r0_,
6055 L0,
6056 _NLAYER,
6057 altitude,
6058 xi0,
6059 wind_speed,
6060 wind_direction,
6061 _L_,
6062 _NXY_PUPIL_,
6063 field_size,
6064 duration,
6065 fullpath_to_phasescreens,
6066 _N_DURATION,
6067 )
6068 }
6069 #[inline]
6070 pub unsafe fn gmt_setup(&mut self) {
6071 atmosphere_gmt_setup(self)
6072 }
6073 #[inline]
6074 pub unsafe fn gmt_setup1(&mut self, r0_: f32, L0: f32) {
6075 atmosphere_gmt_setup1(self, r0_, L0)
6076 }
6077 #[inline]
6078 pub unsafe fn gmt_setup2(
6079 &mut self,
6080 r0_: f32,
6081 L0: f32,
6082 _L_: f32,
6083 _NXY_PUPIL_: ::std::os::raw::c_int,
6084 field_size: f32,
6085 duration: f32,
6086 ) {
6087 atmosphere_gmt_setup2(self, r0_, L0, _L_, _NXY_PUPIL_, field_size, duration)
6088 }
6089 #[inline]
6090 pub unsafe fn gmt_setup3(
6091 &mut self,
6092 r0_: f32,
6093 L0: f32,
6094 _L_: f32,
6095 _NXY_PUPIL_: ::std::os::raw::c_int,
6096 field_size: f32,
6097 duration: f32,
6098 fullpath_to_phasescreens: *const ::std::os::raw::c_char,
6099 _N_DURATION: ::std::os::raw::c_int,
6100 ) {
6101 atmosphere_gmt_setup3(
6102 self,
6103 r0_,
6104 L0,
6105 _L_,
6106 _NXY_PUPIL_,
6107 field_size,
6108 duration,
6109 fullpath_to_phasescreens,
6110 _N_DURATION,
6111 )
6112 }
6113 #[inline]
6114 pub unsafe fn gmt_setup4(&mut self, r0_: f32, L0: f32, _RAND_SEED_: ::std::os::raw::c_int) {
6115 atmosphere_gmt_setup4(self, r0_, L0, _RAND_SEED_)
6116 }
6117 #[inline]
6118 pub unsafe fn gmt_setup5(
6119 &mut self,
6120 r0_: f32,
6121 L0: f32,
6122 _L_: f32,
6123 _NXY_PUPIL_: ::std::os::raw::c_int,
6124 field_size: f32,
6125 duration: f32,
6126 _RAND_SEED_: ::std::os::raw::c_int,
6127 ) {
6128 atmosphere_gmt_setup5(
6129 self,
6130 r0_,
6131 L0,
6132 _L_,
6133 _NXY_PUPIL_,
6134 field_size,
6135 duration,
6136 _RAND_SEED_,
6137 )
6138 }
6139 #[inline]
6140 pub unsafe fn gmt_setup6(
6141 &mut self,
6142 r0_: f32,
6143 L0: f32,
6144 _L_: f32,
6145 _NXY_PUPIL_: ::std::os::raw::c_int,
6146 field_size: f32,
6147 duration: f32,
6148 fullpath_to_phasescreens: *const ::std::os::raw::c_char,
6149 _N_DURATION: ::std::os::raw::c_int,
6150 _RAND_SEED_: ::std::os::raw::c_int,
6151 ) {
6152 atmosphere_gmt_setup6(
6153 self,
6154 r0_,
6155 L0,
6156 _L_,
6157 _NXY_PUPIL_,
6158 field_size,
6159 duration,
6160 fullpath_to_phasescreens,
6161 _N_DURATION,
6162 _RAND_SEED_,
6163 )
6164 }
6165 #[inline]
6166 pub unsafe fn gmt_set_id(&mut self, _ID_: ::std::os::raw::c_int) {
6167 atmosphere_gmt_set_id(self, _ID_)
6168 }
6169 #[inline]
6170 pub unsafe fn gmt_set_eph(&mut self, _EPH_: f32) {
6171 atmosphere_gmt_set_eph(self, _EPH_)
6172 }
6173 #[inline]
6174 pub unsafe fn cleanup(&mut self) {
6175 atmosphere_cleanup(self)
6176 }
6177 #[inline]
6178 pub unsafe fn info(&mut self) {
6179 atmosphere_info(self)
6180 }
6181 #[inline]
6182 pub unsafe fn reset(&mut self) {
6183 atmosphere_reset(self)
6184 }
6185 #[inline]
6186 pub unsafe fn save_layer_phasescreens(
6187 &mut self,
6188 fullpath_to_phasescreens: *const ::std::os::raw::c_char,
6189 _N_DURATION: ::std::os::raw::c_int,
6190 ) {
6191 atmosphere_save_layer_phasescreens(self, fullpath_to_phasescreens, _N_DURATION)
6192 }
6193 #[inline]
6194 pub unsafe fn get_phase_screen(
6195 &mut self,
6196 phase_screen: *mut f32,
6197 x: *const f32,
6198 y: *const f32,
6199 N_xy: ::std::os::raw::c_int,
6200 src: *mut source,
6201 time: f32,
6202 ) {
6203 atmosphere_get_phase_screen(self, phase_screen, x, y, N_xy, src, time)
6204 }
6205 #[inline]
6206 pub unsafe fn get_phase_screen1(
6207 &mut self,
6208 x: *const f32,
6209 y: *const f32,
6210 N_xy: ::std::os::raw::c_int,
6211 src: *mut source,
6212 time: f32,
6213 ) {
6214 atmosphere_get_phase_screen1(self, x, y, N_xy, src, time)
6215 }
6216 #[inline]
6217 pub unsafe fn get_phase_screen2(
6218 &mut self,
6219 delta_x: f32,
6220 N_x: ::std::os::raw::c_int,
6221 delta_y: f32,
6222 N_y: ::std::os::raw::c_int,
6223 src: *mut source,
6224 time: f32,
6225 ) {
6226 atmosphere_get_phase_screen2(self, delta_x, N_x, delta_y, N_y, src, time)
6227 }
6228 #[inline]
6229 pub unsafe fn get_phase_screen3(
6230 &mut self,
6231 phase_screen: *mut f32,
6232 delta_x: f32,
6233 N_x: ::std::os::raw::c_int,
6234 delta_y: f32,
6235 N_y: ::std::os::raw::c_int,
6236 src: *mut source,
6237 time: f32,
6238 ) {
6239 atmosphere_get_phase_screen3(self, phase_screen, delta_x, N_x, delta_y, N_y, src, time)
6240 }
6241 #[inline]
6242 pub unsafe fn get_phase_screen4(
6243 &mut self,
6244 src: *mut source,
6245 delta_x: f32,
6246 N_x: ::std::os::raw::c_int,
6247 delta_y: f32,
6248 N_y: ::std::os::raw::c_int,
6249 time: f32,
6250 ) {
6251 atmosphere_get_phase_screen4(self, src, delta_x, N_x, delta_y, N_y, time)
6252 }
6253 #[inline]
6254 pub unsafe fn get_phase_screen5(
6255 &mut self,
6256 src: *mut source,
6257 delta_x: f32,
6258 N_x: ::std::os::raw::c_int,
6259 delta_y: f32,
6260 N_y: ::std::os::raw::c_int,
6261 time: f32,
6262 exponent: f32,
6263 ) {
6264 atmosphere_get_phase_screen5(self, src, delta_x, N_x, delta_y, N_y, time, exponent)
6265 }
6266 #[inline]
6267 pub unsafe fn get_phase_screen6(
6268 &mut self,
6269 src: *mut source,
6270 N_SRC: ::std::os::raw::c_int,
6271 delta_x: f32,
6272 N_x: ::std::os::raw::c_int,
6273 delta_y: f32,
6274 N_y: ::std::os::raw::c_int,
6275 time: f32,
6276 ) {
6277 atmosphere_get_phase_screen6(self, src, N_SRC, delta_x, N_x, delta_y, N_y, time)
6278 }
6279 #[inline]
6280 pub unsafe fn get_phase_screen7(&mut self, src: *mut source, time: f32) {
6281 atmosphere_get_phase_screen7(self, src, time)
6282 }
6283 #[inline]
6284 pub unsafe fn get_phase_screen_gradient(
6285 &mut self,
6286 sx: *mut f32,
6287 sy: *mut f32,
6288 x: *mut f32,
6289 y: *mut f32,
6290 Nxy: ::std::os::raw::c_int,
6291 src: *mut source,
6292 time: f32,
6293 ) {
6294 atmosphere_get_phase_screen_gradient(self, sx, sy, x, y, Nxy, src, time)
6295 }
6296 #[inline]
6297 pub unsafe fn get_phase_screen_gradient1(
6298 &mut self,
6299 sx: *mut f32,
6300 sy: *mut f32,
6301 NL: ::std::os::raw::c_int,
6302 d: f32,
6303 src: *mut source,
6304 time: f32,
6305 ) {
6306 atmosphere_get_phase_screen_gradient1(self, sx, sy, NL, d, src, time)
6307 }
6308 #[inline]
6309 pub unsafe fn get_phase_screen_gradient2(
6310 &mut self,
6311 sx: *mut f32,
6312 sy: *mut f32,
6313 NL: ::std::os::raw::c_int,
6314 valid_lenslet: *mut ::std::os::raw::c_char,
6315 d: f32,
6316 src: *mut source,
6317 time: f32,
6318 ) {
6319 atmosphere_get_phase_screen_gradient2(self, sx, sy, NL, valid_lenslet, d, src, time)
6320 }
6321 #[inline]
6322 pub unsafe fn get_phase_screen_gradient3(
6323 &mut self,
6324 cog: *mut centroiding,
6325 NL: ::std::os::raw::c_int,
6326 d: f32,
6327 src: *mut source,
6328 time: f32,
6329 ) {
6330 atmosphere_get_phase_screen_gradient3(self, cog, NL, d, src, time)
6331 }
6332 #[inline]
6333 pub unsafe fn get_phase_screen_gradient_rolling_shutter(
6334 &mut self,
6335 cog: *mut centroiding,
6336 NL: ::std::os::raw::c_int,
6337 d: f32,
6338 src: *mut source,
6339 time: f32,
6340 delay: f32,
6341 ) {
6342 atmosphere_get_phase_screen_gradient_rolling_shutter(self, cog, NL, d, src, time, delay)
6343 }
6344 #[inline]
6345 pub unsafe fn get_phase_screen_gradient4(
6346 &mut self,
6347 cog: *mut centroiding,
6348 NL: ::std::os::raw::c_int,
6349 d: f32,
6350 src: *mut source,
6351 N_SRC: ::std::os::raw::c_int,
6352 time: f32,
6353 ) {
6354 atmosphere_get_phase_screen_gradient4(self, cog, NL, d, src, N_SRC, time)
6355 }
6356 #[inline]
6357 pub unsafe fn get_phase_screen_gradient5(
6358 &mut self,
6359 cog: *mut centroiding,
6360 NL: ::std::os::raw::c_int,
6361 valid_lenslet: *mut ::std::os::raw::c_char,
6362 d: f32,
6363 src: *mut source,
6364 N_SRC: ::std::os::raw::c_int,
6365 time: f32,
6366 ) {
6367 atmosphere_get_phase_screen_gradient5(self, cog, NL, valid_lenslet, d, src, N_SRC, time)
6368 }
6369 #[inline]
6370 pub unsafe fn get_phase_screen_circ_centroids(
6371 &mut self,
6372 cog: *mut centroiding,
6373 R: f32,
6374 src: *mut source,
6375 N_SRC: ::std::os::raw::c_int,
6376 time: f32,
6377 ) {
6378 atmosphere_get_phase_screen_circ_centroids(self, cog, R, src, N_SRC, time)
6379 }
6380 #[inline]
6381 pub unsafe fn get_phase_screen_circ_uplink_centroids(
6382 &mut self,
6383 cog: *mut centroiding,
6384 R: f32,
6385 src: *mut source,
6386 N_SRC: ::std::os::raw::c_int,
6387 time: f32,
6388 focused: ::std::os::raw::c_char,
6389 ) {
6390 atmosphere_get_phase_screen_circ_uplink_centroids(self, cog, R, src, N_SRC, time, focused)
6391 }
6392 #[inline]
6393 pub unsafe fn rayTracing(
6394 &mut self,
6395 x_PUPIL: *const f32,
6396 y_PUPIL: *const f32,
6397 phase_screen_PUPIL: *mut f32,
6398 NXY_PUPIL: ::std::os::raw::c_int,
6399 src: *const source,
6400 tau: f32,
6401 ) {
6402 atmosphere_rayTracing(
6403 self,
6404 x_PUPIL,
6405 y_PUPIL,
6406 phase_screen_PUPIL,
6407 NXY_PUPIL,
6408 src,
6409 tau,
6410 )
6411 }
6412 #[inline]
6413 pub unsafe fn rayTracing1(
6414 &mut self,
6415 src: *mut source,
6416 delta_x: f32,
6417 N_X: ::std::os::raw::c_int,
6418 delta_y: f32,
6419 N_Y: ::std::os::raw::c_int,
6420 tau: f32,
6421 ) {
6422 atmosphere_rayTracing1(self, src, delta_x, N_X, delta_y, N_Y, tau)
6423 }
6424}
6425#[repr(C)]
6426#[derive(Debug, Copy, Clone)]
6427pub struct aaStats {
6428 pub N: ::std::os::raw::c_int,
6429 pub N2: ::std::os::raw::c_int,
6430 pub NU: ::std::os::raw::c_int,
6431 pub NU2: ::std::os::raw::c_int,
6432 pub NF: ::std::os::raw::c_int,
6433 pub NF2: ::std::os::raw::c_int,
6434 pub psd_size: ::std::os::raw::c_int,
6435 pub cov_size: ::std::os::raw::c_int,
6436 pub ind_size: ::std::os::raw::c_int,
6437 pub d__psd: *mut float2,
6438 pub d__cov: *mut f32,
6439 pub d__alpha: *mut f32,
6440 pub d__beta: *mut f32,
6441 pub n_full: f32,
6442 pub n_comp: f32,
6443 pub b_full: f32,
6444 pub b_comp: f32,
6445 pub cov_eval_et: f32,
6446 pub sampling: f32,
6447 pub plan: cufftHandle,
6448 pub N_SRC2: ::std::os::raw::c_int,
6449}
6450#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6451const _: () = {
6452 ["Size of aaStats"][::std::mem::size_of::<aaStats>() - 104usize];
6453 ["Alignment of aaStats"][::std::mem::align_of::<aaStats>() - 8usize];
6454 ["Offset of field: aaStats::N"][::std::mem::offset_of!(aaStats, N) - 0usize];
6455 ["Offset of field: aaStats::N2"][::std::mem::offset_of!(aaStats, N2) - 4usize];
6456 ["Offset of field: aaStats::NU"][::std::mem::offset_of!(aaStats, NU) - 8usize];
6457 ["Offset of field: aaStats::NU2"][::std::mem::offset_of!(aaStats, NU2) - 12usize];
6458 ["Offset of field: aaStats::NF"][::std::mem::offset_of!(aaStats, NF) - 16usize];
6459 ["Offset of field: aaStats::NF2"][::std::mem::offset_of!(aaStats, NF2) - 20usize];
6460 ["Offset of field: aaStats::psd_size"][::std::mem::offset_of!(aaStats, psd_size) - 24usize];
6461 ["Offset of field: aaStats::cov_size"][::std::mem::offset_of!(aaStats, cov_size) - 28usize];
6462 ["Offset of field: aaStats::ind_size"][::std::mem::offset_of!(aaStats, ind_size) - 32usize];
6463 ["Offset of field: aaStats::d__psd"][::std::mem::offset_of!(aaStats, d__psd) - 40usize];
6464 ["Offset of field: aaStats::d__cov"][::std::mem::offset_of!(aaStats, d__cov) - 48usize];
6465 ["Offset of field: aaStats::d__alpha"][::std::mem::offset_of!(aaStats, d__alpha) - 56usize];
6466 ["Offset of field: aaStats::d__beta"][::std::mem::offset_of!(aaStats, d__beta) - 64usize];
6467 ["Offset of field: aaStats::n_full"][::std::mem::offset_of!(aaStats, n_full) - 72usize];
6468 ["Offset of field: aaStats::n_comp"][::std::mem::offset_of!(aaStats, n_comp) - 76usize];
6469 ["Offset of field: aaStats::b_full"][::std::mem::offset_of!(aaStats, b_full) - 80usize];
6470 ["Offset of field: aaStats::b_comp"][::std::mem::offset_of!(aaStats, b_comp) - 84usize];
6471 ["Offset of field: aaStats::cov_eval_et"]
6472 [::std::mem::offset_of!(aaStats, cov_eval_et) - 88usize];
6473 ["Offset of field: aaStats::sampling"][::std::mem::offset_of!(aaStats, sampling) - 92usize];
6474 ["Offset of field: aaStats::plan"][::std::mem::offset_of!(aaStats, plan) - 96usize];
6475 ["Offset of field: aaStats::N_SRC2"][::std::mem::offset_of!(aaStats, N_SRC2) - 100usize];
6476};
6477extern "C" {
6478 #[link_name = "\u{1}_ZN7aaStats5setupEiPK10atmospherefPK6sourcei"]
6479 pub fn aaStats_setup(
6480 this: *mut aaStats,
6481 N: ::std::os::raw::c_int,
6482 atm: *const atmosphere,
6483 lenslet_pitch: f32,
6484 src: *const source,
6485 N_SRC: ::std::os::raw::c_int,
6486 );
6487}
6488extern "C" {
6489 #[link_name = "\u{1}_ZN7aaStats7cleanupEv"]
6490 pub fn aaStats_cleanup(this: *mut aaStats);
6491}
6492extern "C" {
6493 #[link_name = "\u{1}_ZN7aaStats4infoEif"]
6494 pub fn aaStats_info(this: *mut aaStats, kappa: ::std::os::raw::c_int, d: f32);
6495}
6496extern "C" {
6497 #[link_name = "\u{1}_ZN7aaStats8varianceEv"]
6498 pub fn aaStats_variance(this: *mut aaStats) -> f32;
6499}
6500extern "C" {
6501 #[link_name = "\u{1}_ZN7aaStats6toFileEPc"]
6502 pub fn aaStats_toFile(this: *mut aaStats, filename: *mut ::std::os::raw::c_char);
6503}
6504impl aaStats {
6505 #[inline]
6506 pub unsafe fn setup(
6507 &mut self,
6508 N: ::std::os::raw::c_int,
6509 atm: *const atmosphere,
6510 lenslet_pitch: f32,
6511 src: *const source,
6512 N_SRC: ::std::os::raw::c_int,
6513 ) {
6514 aaStats_setup(self, N, atm, lenslet_pitch, src, N_SRC)
6515 }
6516 #[inline]
6517 pub unsafe fn cleanup(&mut self) {
6518 aaStats_cleanup(self)
6519 }
6520 #[inline]
6521 pub unsafe fn info(&mut self, kappa: ::std::os::raw::c_int, d: f32) {
6522 aaStats_info(self, kappa, d)
6523 }
6524 #[inline]
6525 pub unsafe fn variance(&mut self) -> f32 {
6526 aaStats_variance(self)
6527 }
6528 #[inline]
6529 pub unsafe fn toFile(&mut self, filename: *mut ::std::os::raw::c_char) {
6530 aaStats_toFile(self, filename)
6531 }
6532}
6533#[repr(C)]
6534#[derive(Debug, Copy, Clone)]
6535pub struct paStats {
6536 pub osf: ::std::os::raw::c_int,
6537 pub M: ::std::os::raw::c_int,
6538 pub shift: ::std::os::raw::c_int,
6539 pub M_LAYER: *mut ::std::os::raw::c_int,
6540 pub N: ::std::os::raw::c_int,
6541 pub N2: ::std::os::raw::c_int,
6542 pub NU: ::std::os::raw::c_int,
6543 pub NU2: ::std::os::raw::c_int,
6544 pub NF: ::std::os::raw::c_int,
6545 pub NF2: ::std::os::raw::c_int,
6546 pub psd_size: ::std::os::raw::c_int,
6547 pub cov_size: ::std::os::raw::c_int,
6548 pub ind_size: ::std::os::raw::c_int,
6549 pub d__psd: *mut float2,
6550 pub d__cov: *mut f32,
6551 pub d__alpha: *mut f32,
6552 pub d__beta: *mut f32,
6553 pub n_full: f32,
6554 pub n_comp: f32,
6555 pub b_full: f32,
6556 pub b_comp: f32,
6557 pub cov_eval_et: f32,
6558 pub sampling: f32,
6559 pub plan: cufftHandle,
6560 pub N_SRC2: ::std::os::raw::c_int,
6561}
6562#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6563const _: () = {
6564 ["Size of paStats"][::std::mem::size_of::<paStats>() - 128usize];
6565 ["Alignment of paStats"][::std::mem::align_of::<paStats>() - 8usize];
6566 ["Offset of field: paStats::osf"][::std::mem::offset_of!(paStats, osf) - 0usize];
6567 ["Offset of field: paStats::M"][::std::mem::offset_of!(paStats, M) - 4usize];
6568 ["Offset of field: paStats::shift"][::std::mem::offset_of!(paStats, shift) - 8usize];
6569 ["Offset of field: paStats::M_LAYER"][::std::mem::offset_of!(paStats, M_LAYER) - 16usize];
6570 ["Offset of field: paStats::N"][::std::mem::offset_of!(paStats, N) - 24usize];
6571 ["Offset of field: paStats::N2"][::std::mem::offset_of!(paStats, N2) - 28usize];
6572 ["Offset of field: paStats::NU"][::std::mem::offset_of!(paStats, NU) - 32usize];
6573 ["Offset of field: paStats::NU2"][::std::mem::offset_of!(paStats, NU2) - 36usize];
6574 ["Offset of field: paStats::NF"][::std::mem::offset_of!(paStats, NF) - 40usize];
6575 ["Offset of field: paStats::NF2"][::std::mem::offset_of!(paStats, NF2) - 44usize];
6576 ["Offset of field: paStats::psd_size"][::std::mem::offset_of!(paStats, psd_size) - 48usize];
6577 ["Offset of field: paStats::cov_size"][::std::mem::offset_of!(paStats, cov_size) - 52usize];
6578 ["Offset of field: paStats::ind_size"][::std::mem::offset_of!(paStats, ind_size) - 56usize];
6579 ["Offset of field: paStats::d__psd"][::std::mem::offset_of!(paStats, d__psd) - 64usize];
6580 ["Offset of field: paStats::d__cov"][::std::mem::offset_of!(paStats, d__cov) - 72usize];
6581 ["Offset of field: paStats::d__alpha"][::std::mem::offset_of!(paStats, d__alpha) - 80usize];
6582 ["Offset of field: paStats::d__beta"][::std::mem::offset_of!(paStats, d__beta) - 88usize];
6583 ["Offset of field: paStats::n_full"][::std::mem::offset_of!(paStats, n_full) - 96usize];
6584 ["Offset of field: paStats::n_comp"][::std::mem::offset_of!(paStats, n_comp) - 100usize];
6585 ["Offset of field: paStats::b_full"][::std::mem::offset_of!(paStats, b_full) - 104usize];
6586 ["Offset of field: paStats::b_comp"][::std::mem::offset_of!(paStats, b_comp) - 108usize];
6587 ["Offset of field: paStats::cov_eval_et"]
6588 [::std::mem::offset_of!(paStats, cov_eval_et) - 112usize];
6589 ["Offset of field: paStats::sampling"][::std::mem::offset_of!(paStats, sampling) - 116usize];
6590 ["Offset of field: paStats::plan"][::std::mem::offset_of!(paStats, plan) - 120usize];
6591 ["Offset of field: paStats::N_SRC2"][::std::mem::offset_of!(paStats, N_SRC2) - 124usize];
6592};
6593extern "C" {
6594 #[link_name = "\u{1}_ZN7paStats5setupEiiiPK10atmospherefP6sourceiPKS3_i"]
6595 pub fn paStats_setup(
6596 this: *mut paStats,
6597 M_: ::std::os::raw::c_int,
6598 N_: ::std::os::raw::c_int,
6599 osf_: ::std::os::raw::c_int,
6600 atm: *const atmosphere,
6601 lenslet_pitch: f32,
6602 phase_src: *mut source,
6603 N_P_SRC: ::std::os::raw::c_int,
6604 slopes_src: *const source,
6605 N_S_SRC: ::std::os::raw::c_int,
6606 );
6607}
6608extern "C" {
6609 #[link_name = "\u{1}_ZN7paStats5setupEiiiPK10atmospherefPK6sourceif"]
6610 pub fn paStats_setup1(
6611 this: *mut paStats,
6612 M_: ::std::os::raw::c_int,
6613 N_: ::std::os::raw::c_int,
6614 osf_: ::std::os::raw::c_int,
6615 atm: *const atmosphere,
6616 lenslet_pitch: f32,
6617 slopes_src: *const source,
6618 N_S_SRC: ::std::os::raw::c_int,
6619 z_radius: f32,
6620 );
6621}
6622extern "C" {
6623 #[link_name = "\u{1}_ZN7paStats7cleanupEv"]
6624 pub fn paStats_cleanup(this: *mut paStats);
6625}
6626extern "C" {
6627 #[link_name = "\u{1}_ZN7paStats4infoEif"]
6628 pub fn paStats_info(this: *mut paStats, kappa: ::std::os::raw::c_int, d: f32);
6629}
6630extern "C" {
6631 #[link_name = "\u{1}_ZN7paStats3MVMEPfS0_ffifiP10atmosphereP6sourceiS4_i"]
6632 pub fn paStats_MVM(
6633 this: *mut paStats,
6634 out_vector: *mut f32,
6635 in_vector: *mut f32,
6636 d1: f32,
6637 g1: f32,
6638 N1: ::std::os::raw::c_int,
6639 d2: f32,
6640 N2: ::std::os::raw::c_int,
6641 atm: *mut atmosphere,
6642 phase_src: *mut source,
6643 N_P_SRC: ::std::os::raw::c_int,
6644 slopes_src: *mut source,
6645 N_S_SRC: ::std::os::raw::c_int,
6646 );
6647}
6648extern "C" {
6649 #[link_name = "\u{1}_ZN7paStats6toFileEPc"]
6650 pub fn paStats_toFile(this: *mut paStats, filename: *mut ::std::os::raw::c_char);
6651}
6652extern "C" {
6653 #[link_name = "\u{1}_ZN7paStats8varianceEv"]
6654 pub fn paStats_variance(this: *mut paStats);
6655}
6656impl paStats {
6657 #[inline]
6658 pub unsafe fn setup(
6659 &mut self,
6660 M_: ::std::os::raw::c_int,
6661 N_: ::std::os::raw::c_int,
6662 osf_: ::std::os::raw::c_int,
6663 atm: *const atmosphere,
6664 lenslet_pitch: f32,
6665 phase_src: *mut source,
6666 N_P_SRC: ::std::os::raw::c_int,
6667 slopes_src: *const source,
6668 N_S_SRC: ::std::os::raw::c_int,
6669 ) {
6670 paStats_setup(
6671 self,
6672 M_,
6673 N_,
6674 osf_,
6675 atm,
6676 lenslet_pitch,
6677 phase_src,
6678 N_P_SRC,
6679 slopes_src,
6680 N_S_SRC,
6681 )
6682 }
6683 #[inline]
6684 pub unsafe fn setup1(
6685 &mut self,
6686 M_: ::std::os::raw::c_int,
6687 N_: ::std::os::raw::c_int,
6688 osf_: ::std::os::raw::c_int,
6689 atm: *const atmosphere,
6690 lenslet_pitch: f32,
6691 slopes_src: *const source,
6692 N_S_SRC: ::std::os::raw::c_int,
6693 z_radius: f32,
6694 ) {
6695 paStats_setup1(
6696 self,
6697 M_,
6698 N_,
6699 osf_,
6700 atm,
6701 lenslet_pitch,
6702 slopes_src,
6703 N_S_SRC,
6704 z_radius,
6705 )
6706 }
6707 #[inline]
6708 pub unsafe fn cleanup(&mut self) {
6709 paStats_cleanup(self)
6710 }
6711 #[inline]
6712 pub unsafe fn info(&mut self, kappa: ::std::os::raw::c_int, d: f32) {
6713 paStats_info(self, kappa, d)
6714 }
6715 #[inline]
6716 pub unsafe fn MVM(
6717 &mut self,
6718 out_vector: *mut f32,
6719 in_vector: *mut f32,
6720 d1: f32,
6721 g1: f32,
6722 N1: ::std::os::raw::c_int,
6723 d2: f32,
6724 N2: ::std::os::raw::c_int,
6725 atm: *mut atmosphere,
6726 phase_src: *mut source,
6727 N_P_SRC: ::std::os::raw::c_int,
6728 slopes_src: *mut source,
6729 N_S_SRC: ::std::os::raw::c_int,
6730 ) {
6731 paStats_MVM(
6732 self, out_vector, in_vector, d1, g1, N1, d2, N2, atm, phase_src, N_P_SRC, slopes_src,
6733 N_S_SRC,
6734 )
6735 }
6736 #[inline]
6737 pub unsafe fn toFile(&mut self, filename: *mut ::std::os::raw::c_char) {
6738 paStats_toFile(self, filename)
6739 }
6740 #[inline]
6741 pub unsafe fn variance(&mut self) {
6742 paStats_variance(self)
6743 }
6744}
6745#[repr(C)]
6746#[derive(Debug, Copy, Clone)]
6747pub struct BTBT {
6748 pub M: ::std::os::raw::c_int,
6749 pub N: ::std::os::raw::c_int,
6750 pub MT: ::std::os::raw::c_int,
6751 pub MT2: ::std::os::raw::c_int,
6752 pub NT: ::std::os::raw::c_int,
6753 pub NT2: ::std::os::raw::c_int,
6754 pub NU: ::std::os::raw::c_int,
6755 pub NU2: ::std::os::raw::c_int,
6756 pub NDFT: ::std::os::raw::c_int,
6757 pub HALF_NDFT: ::std::os::raw::c_int,
6758 pub NU_TOTAL: ::std::os::raw::c_int,
6759 pub NF: ::std::os::raw::c_int,
6760 pub NF2: ::std::os::raw::c_int,
6761 pub ind_size: ::std::os::raw::c_int,
6762 pub cov_size: ::std::os::raw::c_int,
6763 pub mask: *mut ::std::os::raw::c_char,
6764 pub d__cov: *mut float2,
6765 pub d__b: *mut float2,
6766 pub d__c: *mut float2,
6767 pub d__alpha: *mut f32,
6768 pub d__beta: *mut f32,
6769 pub n_full: f32,
6770 pub n_comp: f32,
6771 pub b_full: f32,
6772 pub b_comp: f32,
6773 pub cov_eval_et: f32,
6774 pub d__mu: *mut ::std::os::raw::c_uint,
6775 pub d__xi: *mut ::std::os::raw::c_uint,
6776 pub raster_plan: cufftHandle,
6777 pub MVM_input_plan: cufftHandle,
6778 pub MVM_output_plan: cufftHandle,
6779}
6780#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6781const _: () = {
6782 ["Size of BTBT"][::std::mem::size_of::<BTBT>() - 168usize];
6783 ["Alignment of BTBT"][::std::mem::align_of::<BTBT>() - 8usize];
6784 ["Offset of field: BTBT::M"][::std::mem::offset_of!(BTBT, M) - 0usize];
6785 ["Offset of field: BTBT::N"][::std::mem::offset_of!(BTBT, N) - 4usize];
6786 ["Offset of field: BTBT::MT"][::std::mem::offset_of!(BTBT, MT) - 8usize];
6787 ["Offset of field: BTBT::MT2"][::std::mem::offset_of!(BTBT, MT2) - 12usize];
6788 ["Offset of field: BTBT::NT"][::std::mem::offset_of!(BTBT, NT) - 16usize];
6789 ["Offset of field: BTBT::NT2"][::std::mem::offset_of!(BTBT, NT2) - 20usize];
6790 ["Offset of field: BTBT::NU"][::std::mem::offset_of!(BTBT, NU) - 24usize];
6791 ["Offset of field: BTBT::NU2"][::std::mem::offset_of!(BTBT, NU2) - 28usize];
6792 ["Offset of field: BTBT::NDFT"][::std::mem::offset_of!(BTBT, NDFT) - 32usize];
6793 ["Offset of field: BTBT::HALF_NDFT"][::std::mem::offset_of!(BTBT, HALF_NDFT) - 36usize];
6794 ["Offset of field: BTBT::NU_TOTAL"][::std::mem::offset_of!(BTBT, NU_TOTAL) - 40usize];
6795 ["Offset of field: BTBT::NF"][::std::mem::offset_of!(BTBT, NF) - 44usize];
6796 ["Offset of field: BTBT::NF2"][::std::mem::offset_of!(BTBT, NF2) - 48usize];
6797 ["Offset of field: BTBT::ind_size"][::std::mem::offset_of!(BTBT, ind_size) - 52usize];
6798 ["Offset of field: BTBT::cov_size"][::std::mem::offset_of!(BTBT, cov_size) - 56usize];
6799 ["Offset of field: BTBT::mask"][::std::mem::offset_of!(BTBT, mask) - 64usize];
6800 ["Offset of field: BTBT::d__cov"][::std::mem::offset_of!(BTBT, d__cov) - 72usize];
6801 ["Offset of field: BTBT::d__b"][::std::mem::offset_of!(BTBT, d__b) - 80usize];
6802 ["Offset of field: BTBT::d__c"][::std::mem::offset_of!(BTBT, d__c) - 88usize];
6803 ["Offset of field: BTBT::d__alpha"][::std::mem::offset_of!(BTBT, d__alpha) - 96usize];
6804 ["Offset of field: BTBT::d__beta"][::std::mem::offset_of!(BTBT, d__beta) - 104usize];
6805 ["Offset of field: BTBT::n_full"][::std::mem::offset_of!(BTBT, n_full) - 112usize];
6806 ["Offset of field: BTBT::n_comp"][::std::mem::offset_of!(BTBT, n_comp) - 116usize];
6807 ["Offset of field: BTBT::b_full"][::std::mem::offset_of!(BTBT, b_full) - 120usize];
6808 ["Offset of field: BTBT::b_comp"][::std::mem::offset_of!(BTBT, b_comp) - 124usize];
6809 ["Offset of field: BTBT::cov_eval_et"][::std::mem::offset_of!(BTBT, cov_eval_et) - 128usize];
6810 ["Offset of field: BTBT::d__mu"][::std::mem::offset_of!(BTBT, d__mu) - 136usize];
6811 ["Offset of field: BTBT::d__xi"][::std::mem::offset_of!(BTBT, d__xi) - 144usize];
6812 ["Offset of field: BTBT::raster_plan"][::std::mem::offset_of!(BTBT, raster_plan) - 152usize];
6813 ["Offset of field: BTBT::MVM_input_plan"]
6814 [::std::mem::offset_of!(BTBT, MVM_input_plan) - 156usize];
6815 ["Offset of field: BTBT::MVM_output_plan"]
6816 [::std::mem::offset_of!(BTBT, MVM_output_plan) - 160usize];
6817};
6818extern "C" {
6819 #[link_name = "\u{1}_ZN4BTBT5setupEi"]
6820 pub fn BTBT_setup(this: *mut BTBT, n_x: ::std::os::raw::c_int);
6821}
6822extern "C" {
6823 #[link_name = "\u{1}_ZN4BTBT5setupEiiiPf"]
6824 pub fn BTBT_setup1(
6825 this: *mut BTBT,
6826 M_: ::std::os::raw::c_int,
6827 N_: ::std::os::raw::c_int,
6828 NT_: ::std::os::raw::c_int,
6829 d__cov_: *mut f32,
6830 );
6831}
6832extern "C" {
6833 #[link_name = "\u{1}_ZN4BTBT5setupEiiiiPf"]
6834 pub fn BTBT_setup2(
6835 this: *mut BTBT,
6836 M_: ::std::os::raw::c_int,
6837 N_: ::std::os::raw::c_int,
6838 MT_: ::std::os::raw::c_int,
6839 NT_: ::std::os::raw::c_int,
6840 d__cov_: *mut f32,
6841 );
6842}
6843extern "C" {
6844 #[link_name = "\u{1}_ZN4BTBT7cleanupEv"]
6845 pub fn BTBT_cleanup(this: *mut BTBT);
6846}
6847extern "C" {
6848 #[link_name = "\u{1}_ZN4BTBT4infoEv"]
6849 pub fn BTBT_info(this: *mut BTBT);
6850}
6851extern "C" {
6852 #[link_name = "\u{1}_ZN4BTBT3MVMEPfS0_"]
6853 pub fn BTBT_MVM(this: *mut BTBT, y: *mut f32, x: *mut f32);
6854}
6855extern "C" {
6856 #[link_name = "\u{1}_ZN4BTBT5MVM_iEPfS0_"]
6857 pub fn BTBT_MVM_i(this: *mut BTBT, y: *mut f32, x: *mut f32);
6858}
6859extern "C" {
6860 #[link_name = "\u{1}_ZN4BTBT6MVM_iiEPfS0_"]
6861 pub fn BTBT_MVM_ii(this: *mut BTBT, y: *mut f32, x: *mut f32);
6862}
6863extern "C" {
6864 #[link_name = "\u{1}_ZN4BTBT7MVM_iiiEPfS0_"]
6865 pub fn BTBT_MVM_iii(this: *mut BTBT, y: *mut f32, x: *mut f32);
6866}
6867extern "C" {
6868 #[link_name = "\u{1}_ZN4BTBT6MVM_ivEPfS0_"]
6869 pub fn BTBT_MVM_iv(this: *mut BTBT, y: *mut f32, x: *mut f32);
6870}
6871extern "C" {
6872 #[link_name = "\u{1}_ZN4BTBT5MVM_vEPfS0_"]
6873 pub fn BTBT_MVM_v(this: *mut BTBT, y: *mut f32, x: *mut f32);
6874}
6875impl BTBT {
6876 #[inline]
6877 pub unsafe fn setup(&mut self, n_x: ::std::os::raw::c_int) {
6878 BTBT_setup(self, n_x)
6879 }
6880 #[inline]
6881 pub unsafe fn setup1(
6882 &mut self,
6883 M_: ::std::os::raw::c_int,
6884 N_: ::std::os::raw::c_int,
6885 NT_: ::std::os::raw::c_int,
6886 d__cov_: *mut f32,
6887 ) {
6888 BTBT_setup1(self, M_, N_, NT_, d__cov_)
6889 }
6890 #[inline]
6891 pub unsafe fn setup2(
6892 &mut self,
6893 M_: ::std::os::raw::c_int,
6894 N_: ::std::os::raw::c_int,
6895 MT_: ::std::os::raw::c_int,
6896 NT_: ::std::os::raw::c_int,
6897 d__cov_: *mut f32,
6898 ) {
6899 BTBT_setup2(self, M_, N_, MT_, NT_, d__cov_)
6900 }
6901 #[inline]
6902 pub unsafe fn cleanup(&mut self) {
6903 BTBT_cleanup(self)
6904 }
6905 #[inline]
6906 pub unsafe fn info(&mut self) {
6907 BTBT_info(self)
6908 }
6909 #[inline]
6910 pub unsafe fn MVM(&mut self, y: *mut f32, x: *mut f32) {
6911 BTBT_MVM(self, y, x)
6912 }
6913 #[inline]
6914 pub unsafe fn MVM_i(&mut self, y: *mut f32, x: *mut f32) {
6915 BTBT_MVM_i(self, y, x)
6916 }
6917 #[inline]
6918 pub unsafe fn MVM_ii(&mut self, y: *mut f32, x: *mut f32) {
6919 BTBT_MVM_ii(self, y, x)
6920 }
6921 #[inline]
6922 pub unsafe fn MVM_iii(&mut self, y: *mut f32, x: *mut f32) {
6923 BTBT_MVM_iii(self, y, x)
6924 }
6925 #[inline]
6926 pub unsafe fn MVM_iv(&mut self, y: *mut f32, x: *mut f32) {
6927 BTBT_MVM_iv(self, y, x)
6928 }
6929 #[inline]
6930 pub unsafe fn MVM_v(&mut self, y: *mut f32, x: *mut f32) {
6931 BTBT_MVM_v(self, y, x)
6932 }
6933}
6934#[repr(C)]
6935#[derive(Debug, Copy, Clone)]
6936pub struct GBTBT {
6937 pub M: ::std::os::raw::c_int,
6938 pub N: ::std::os::raw::c_int,
6939 pub NT: ::std::os::raw::c_int,
6940 pub NT2: ::std::os::raw::c_int,
6941 pub NDFT: ::std::os::raw::c_int,
6942 pub HALF_NDFT: ::std::os::raw::c_int,
6943 pub NU_TOTAL: ::std::os::raw::c_int,
6944 pub NF: ::std::os::raw::c_int,
6945 pub NF2: ::std::os::raw::c_int,
6946 pub ind_size: ::std::os::raw::c_int,
6947 pub cov_size: ::std::os::raw::c_int,
6948 pub MT2_TOTAL: ::std::os::raw::c_int,
6949 pub MT_size: ::std::os::raw::c_int,
6950 pub MAX_MT: ::std::os::raw::c_int,
6951 pub MT: *mut ::std::os::raw::c_int,
6952 pub MT2: *mut ::std::os::raw::c_int,
6953 pub NU: *mut ::std::os::raw::c_int,
6954 pub NU2: *mut ::std::os::raw::c_int,
6955 pub CS_MT2: *mut ::std::os::raw::c_int,
6956 pub d__MT: *mut ::std::os::raw::c_int,
6957 pub d__MT2: *mut ::std::os::raw::c_int,
6958 pub d__NU: *mut ::std::os::raw::c_int,
6959 pub d__NU2: *mut ::std::os::raw::c_int,
6960 pub d__CS_MT2: *mut ::std::os::raw::c_int,
6961 pub mask: *mut ::std::os::raw::c_char,
6962 pub d__cov: *mut float2,
6963 pub d__b: *mut float2,
6964 pub d__c: *mut float2,
6965 pub d__alpha: *mut f32,
6966 pub d__beta: *mut f32,
6967 pub n_full: f32,
6968 pub n_comp: f32,
6969 pub b_full: f32,
6970 pub b_comp: f32,
6971 pub cov_eval_et: f32,
6972 pub d__mu: *mut ::std::os::raw::c_uint,
6973 pub d__xi: *mut ::std::os::raw::c_uint,
6974 pub raster_plan: cufftHandle,
6975 pub MVM_input_plan: cufftHandle,
6976 pub MVM_output_plan: cufftHandle,
6977}
6978#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6979const _: () = {
6980 ["Size of GBTBT"][::std::mem::size_of::<GBTBT>() - 240usize];
6981 ["Alignment of GBTBT"][::std::mem::align_of::<GBTBT>() - 8usize];
6982 ["Offset of field: GBTBT::M"][::std::mem::offset_of!(GBTBT, M) - 0usize];
6983 ["Offset of field: GBTBT::N"][::std::mem::offset_of!(GBTBT, N) - 4usize];
6984 ["Offset of field: GBTBT::NT"][::std::mem::offset_of!(GBTBT, NT) - 8usize];
6985 ["Offset of field: GBTBT::NT2"][::std::mem::offset_of!(GBTBT, NT2) - 12usize];
6986 ["Offset of field: GBTBT::NDFT"][::std::mem::offset_of!(GBTBT, NDFT) - 16usize];
6987 ["Offset of field: GBTBT::HALF_NDFT"][::std::mem::offset_of!(GBTBT, HALF_NDFT) - 20usize];
6988 ["Offset of field: GBTBT::NU_TOTAL"][::std::mem::offset_of!(GBTBT, NU_TOTAL) - 24usize];
6989 ["Offset of field: GBTBT::NF"][::std::mem::offset_of!(GBTBT, NF) - 28usize];
6990 ["Offset of field: GBTBT::NF2"][::std::mem::offset_of!(GBTBT, NF2) - 32usize];
6991 ["Offset of field: GBTBT::ind_size"][::std::mem::offset_of!(GBTBT, ind_size) - 36usize];
6992 ["Offset of field: GBTBT::cov_size"][::std::mem::offset_of!(GBTBT, cov_size) - 40usize];
6993 ["Offset of field: GBTBT::MT2_TOTAL"][::std::mem::offset_of!(GBTBT, MT2_TOTAL) - 44usize];
6994 ["Offset of field: GBTBT::MT_size"][::std::mem::offset_of!(GBTBT, MT_size) - 48usize];
6995 ["Offset of field: GBTBT::MAX_MT"][::std::mem::offset_of!(GBTBT, MAX_MT) - 52usize];
6996 ["Offset of field: GBTBT::MT"][::std::mem::offset_of!(GBTBT, MT) - 56usize];
6997 ["Offset of field: GBTBT::MT2"][::std::mem::offset_of!(GBTBT, MT2) - 64usize];
6998 ["Offset of field: GBTBT::NU"][::std::mem::offset_of!(GBTBT, NU) - 72usize];
6999 ["Offset of field: GBTBT::NU2"][::std::mem::offset_of!(GBTBT, NU2) - 80usize];
7000 ["Offset of field: GBTBT::CS_MT2"][::std::mem::offset_of!(GBTBT, CS_MT2) - 88usize];
7001 ["Offset of field: GBTBT::d__MT"][::std::mem::offset_of!(GBTBT, d__MT) - 96usize];
7002 ["Offset of field: GBTBT::d__MT2"][::std::mem::offset_of!(GBTBT, d__MT2) - 104usize];
7003 ["Offset of field: GBTBT::d__NU"][::std::mem::offset_of!(GBTBT, d__NU) - 112usize];
7004 ["Offset of field: GBTBT::d__NU2"][::std::mem::offset_of!(GBTBT, d__NU2) - 120usize];
7005 ["Offset of field: GBTBT::d__CS_MT2"][::std::mem::offset_of!(GBTBT, d__CS_MT2) - 128usize];
7006 ["Offset of field: GBTBT::mask"][::std::mem::offset_of!(GBTBT, mask) - 136usize];
7007 ["Offset of field: GBTBT::d__cov"][::std::mem::offset_of!(GBTBT, d__cov) - 144usize];
7008 ["Offset of field: GBTBT::d__b"][::std::mem::offset_of!(GBTBT, d__b) - 152usize];
7009 ["Offset of field: GBTBT::d__c"][::std::mem::offset_of!(GBTBT, d__c) - 160usize];
7010 ["Offset of field: GBTBT::d__alpha"][::std::mem::offset_of!(GBTBT, d__alpha) - 168usize];
7011 ["Offset of field: GBTBT::d__beta"][::std::mem::offset_of!(GBTBT, d__beta) - 176usize];
7012 ["Offset of field: GBTBT::n_full"][::std::mem::offset_of!(GBTBT, n_full) - 184usize];
7013 ["Offset of field: GBTBT::n_comp"][::std::mem::offset_of!(GBTBT, n_comp) - 188usize];
7014 ["Offset of field: GBTBT::b_full"][::std::mem::offset_of!(GBTBT, b_full) - 192usize];
7015 ["Offset of field: GBTBT::b_comp"][::std::mem::offset_of!(GBTBT, b_comp) - 196usize];
7016 ["Offset of field: GBTBT::cov_eval_et"][::std::mem::offset_of!(GBTBT, cov_eval_et) - 200usize];
7017 ["Offset of field: GBTBT::d__mu"][::std::mem::offset_of!(GBTBT, d__mu) - 208usize];
7018 ["Offset of field: GBTBT::d__xi"][::std::mem::offset_of!(GBTBT, d__xi) - 216usize];
7019 ["Offset of field: GBTBT::raster_plan"][::std::mem::offset_of!(GBTBT, raster_plan) - 224usize];
7020 ["Offset of field: GBTBT::MVM_input_plan"]
7021 [::std::mem::offset_of!(GBTBT, MVM_input_plan) - 228usize];
7022 ["Offset of field: GBTBT::MVM_output_plan"]
7023 [::std::mem::offset_of!(GBTBT, MVM_output_plan) - 232usize];
7024};
7025extern "C" {
7026 #[link_name = "\u{1}_ZN5GBTBT5setupEi"]
7027 pub fn GBTBT_setup(this: *mut GBTBT, n_x: ::std::os::raw::c_int);
7028}
7029extern "C" {
7030 #[link_name = "\u{1}_ZN5GBTBT5setupEiiiPKf"]
7031 pub fn GBTBT_setup1(
7032 this: *mut GBTBT,
7033 M_: ::std::os::raw::c_int,
7034 N_: ::std::os::raw::c_int,
7035 NT_: ::std::os::raw::c_int,
7036 d__cov_: *const f32,
7037 );
7038}
7039extern "C" {
7040 #[link_name = "\u{1}_ZN5GBTBT5setupEiiiiPKf"]
7041 pub fn GBTBT_setup2(
7042 this: *mut GBTBT,
7043 M_: ::std::os::raw::c_int,
7044 N_: ::std::os::raw::c_int,
7045 MT_: ::std::os::raw::c_int,
7046 NT_: ::std::os::raw::c_int,
7047 d__cov_: *const f32,
7048 );
7049}
7050extern "C" {
7051 #[link_name = "\u{1}_ZN5GBTBT5setupEiiPiiPKf"]
7052 pub fn GBTBT_setup3(
7053 this: *mut GBTBT,
7054 M_: ::std::os::raw::c_int,
7055 N_: ::std::os::raw::c_int,
7056 MT_: *mut ::std::os::raw::c_int,
7057 NT_: ::std::os::raw::c_int,
7058 d__cov_: *const f32,
7059 );
7060}
7061extern "C" {
7062 #[link_name = "\u{1}_ZN5GBTBT7cleanupEv"]
7063 pub fn GBTBT_cleanup(this: *mut GBTBT);
7064}
7065extern "C" {
7066 #[link_name = "\u{1}_ZN5GBTBT4infoEv"]
7067 pub fn GBTBT_info(this: *mut GBTBT);
7068}
7069extern "C" {
7070 #[link_name = "\u{1}_ZN5GBTBT3MVMEPfS0_"]
7071 pub fn GBTBT_MVM(this: *mut GBTBT, y: *mut f32, x: *mut f32);
7072}
7073impl GBTBT {
7074 #[inline]
7075 pub unsafe fn setup(&mut self, n_x: ::std::os::raw::c_int) {
7076 GBTBT_setup(self, n_x)
7077 }
7078 #[inline]
7079 pub unsafe fn setup1(
7080 &mut self,
7081 M_: ::std::os::raw::c_int,
7082 N_: ::std::os::raw::c_int,
7083 NT_: ::std::os::raw::c_int,
7084 d__cov_: *const f32,
7085 ) {
7086 GBTBT_setup1(self, M_, N_, NT_, d__cov_)
7087 }
7088 #[inline]
7089 pub unsafe fn setup2(
7090 &mut self,
7091 M_: ::std::os::raw::c_int,
7092 N_: ::std::os::raw::c_int,
7093 MT_: ::std::os::raw::c_int,
7094 NT_: ::std::os::raw::c_int,
7095 d__cov_: *const f32,
7096 ) {
7097 GBTBT_setup2(self, M_, N_, MT_, NT_, d__cov_)
7098 }
7099 #[inline]
7100 pub unsafe fn setup3(
7101 &mut self,
7102 M_: ::std::os::raw::c_int,
7103 N_: ::std::os::raw::c_int,
7104 MT_: *mut ::std::os::raw::c_int,
7105 NT_: ::std::os::raw::c_int,
7106 d__cov_: *const f32,
7107 ) {
7108 GBTBT_setup3(self, M_, N_, MT_, NT_, d__cov_)
7109 }
7110 #[inline]
7111 pub unsafe fn cleanup(&mut self) {
7112 GBTBT_cleanup(self)
7113 }
7114 #[inline]
7115 pub unsafe fn info(&mut self) {
7116 GBTBT_info(self)
7117 }
7118 #[inline]
7119 pub unsafe fn MVM(&mut self, y: *mut f32, x: *mut f32) {
7120 GBTBT_MVM(self, y, x)
7121 }
7122}
7123#[repr(C)]
7124#[derive(Debug, Copy, Clone)]
7125pub struct iterativeSolvers {
7126 pub d__vectors: *mut f32,
7127 pub q: *mut f32,
7128 pub x: *mut f32,
7129 pub r: *mut f32,
7130 pub p: *mut f32,
7131 pub z: *mut f32,
7132 pub nu_i: *mut f32,
7133 pub nu_im1: *mut f32,
7134 pub nu_ip1: *mut f32,
7135 pub w_i: *mut f32,
7136 pub w_im1: *mut f32,
7137 pub w_im2: *mut f32,
7138 pub rnorm: f32,
7139 pub rel_rnorm: f32,
7140 pub mean_time_per_iteration: f32,
7141 pub RTOL: f32,
7142 pub ATOL: f32,
7143 pub N: ::std::os::raw::c_int,
7144 pub N_ITERATION: ::std::os::raw::c_int,
7145 pub cvgce_iteration: ::std::os::raw::c_int,
7146 pub tid: stopwatch,
7147 pub handle: cublasHandle_t,
7148 pub status: cublasStatus_t,
7149 pub VERBOSE: ::std::os::raw::c_char,
7150}
7151#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7152const _: () = {
7153 ["Size of iterativeSolvers"][::std::mem::size_of::<iterativeSolvers>() - 168usize];
7154 ["Alignment of iterativeSolvers"][::std::mem::align_of::<iterativeSolvers>() - 8usize];
7155 ["Offset of field: iterativeSolvers::d__vectors"]
7156 [::std::mem::offset_of!(iterativeSolvers, d__vectors) - 0usize];
7157 ["Offset of field: iterativeSolvers::q"][::std::mem::offset_of!(iterativeSolvers, q) - 8usize];
7158 ["Offset of field: iterativeSolvers::x"][::std::mem::offset_of!(iterativeSolvers, x) - 16usize];
7159 ["Offset of field: iterativeSolvers::r"][::std::mem::offset_of!(iterativeSolvers, r) - 24usize];
7160 ["Offset of field: iterativeSolvers::p"][::std::mem::offset_of!(iterativeSolvers, p) - 32usize];
7161 ["Offset of field: iterativeSolvers::z"][::std::mem::offset_of!(iterativeSolvers, z) - 40usize];
7162 ["Offset of field: iterativeSolvers::nu_i"]
7163 [::std::mem::offset_of!(iterativeSolvers, nu_i) - 48usize];
7164 ["Offset of field: iterativeSolvers::nu_im1"]
7165 [::std::mem::offset_of!(iterativeSolvers, nu_im1) - 56usize];
7166 ["Offset of field: iterativeSolvers::nu_ip1"]
7167 [::std::mem::offset_of!(iterativeSolvers, nu_ip1) - 64usize];
7168 ["Offset of field: iterativeSolvers::w_i"]
7169 [::std::mem::offset_of!(iterativeSolvers, w_i) - 72usize];
7170 ["Offset of field: iterativeSolvers::w_im1"]
7171 [::std::mem::offset_of!(iterativeSolvers, w_im1) - 80usize];
7172 ["Offset of field: iterativeSolvers::w_im2"]
7173 [::std::mem::offset_of!(iterativeSolvers, w_im2) - 88usize];
7174 ["Offset of field: iterativeSolvers::rnorm"]
7175 [::std::mem::offset_of!(iterativeSolvers, rnorm) - 96usize];
7176 ["Offset of field: iterativeSolvers::rel_rnorm"]
7177 [::std::mem::offset_of!(iterativeSolvers, rel_rnorm) - 100usize];
7178 ["Offset of field: iterativeSolvers::mean_time_per_iteration"]
7179 [::std::mem::offset_of!(iterativeSolvers, mean_time_per_iteration) - 104usize];
7180 ["Offset of field: iterativeSolvers::RTOL"]
7181 [::std::mem::offset_of!(iterativeSolvers, RTOL) - 108usize];
7182 ["Offset of field: iterativeSolvers::ATOL"]
7183 [::std::mem::offset_of!(iterativeSolvers, ATOL) - 112usize];
7184 ["Offset of field: iterativeSolvers::N"]
7185 [::std::mem::offset_of!(iterativeSolvers, N) - 116usize];
7186 ["Offset of field: iterativeSolvers::N_ITERATION"]
7187 [::std::mem::offset_of!(iterativeSolvers, N_ITERATION) - 120usize];
7188 ["Offset of field: iterativeSolvers::cvgce_iteration"]
7189 [::std::mem::offset_of!(iterativeSolvers, cvgce_iteration) - 124usize];
7190 ["Offset of field: iterativeSolvers::tid"]
7191 [::std::mem::offset_of!(iterativeSolvers, tid) - 128usize];
7192 ["Offset of field: iterativeSolvers::handle"]
7193 [::std::mem::offset_of!(iterativeSolvers, handle) - 152usize];
7194 ["Offset of field: iterativeSolvers::status"]
7195 [::std::mem::offset_of!(iterativeSolvers, status) - 160usize];
7196 ["Offset of field: iterativeSolvers::VERBOSE"]
7197 [::std::mem::offset_of!(iterativeSolvers, VERBOSE) - 164usize];
7198};
7199extern "C" {
7200 #[link_name = "\u{1}_ZN16iterativeSolvers8cg_setupEi"]
7201 pub fn iterativeSolvers_cg_setup(this: *mut iterativeSolvers, n_vector: ::std::os::raw::c_int);
7202}
7203extern "C" {
7204 #[link_name = "\u{1}_ZN16iterativeSolvers9pcg_setupEi"]
7205 pub fn iterativeSolvers_pcg_setup(this: *mut iterativeSolvers, n_vector: ::std::os::raw::c_int);
7206}
7207extern "C" {
7208 #[link_name = "\u{1}_ZN16iterativeSolvers12minres_setupEi"]
7209 pub fn iterativeSolvers_minres_setup(
7210 this: *mut iterativeSolvers,
7211 n_vector: ::std::os::raw::c_int,
7212 );
7213}
7214extern "C" {
7215 #[link_name = "\u{1}_ZN16iterativeSolvers7cleanupEv"]
7216 pub fn iterativeSolvers_cleanup(this: *mut iterativeSolvers);
7217}
7218extern "C" {
7219 #[link_name = "\u{1}_ZN16iterativeSolvers2cgEPfP4BTBTS0_iS0_"]
7220 pub fn iterativeSolvers_cg(
7221 this: *mut iterativeSolvers,
7222 x: *mut f32,
7223 A: *mut BTBT,
7224 b: *mut f32,
7225 max_it: ::std::os::raw::c_int,
7226 x0: *mut f32,
7227 );
7228}
7229extern "C" {
7230 #[link_name = "\u{1}_ZN16iterativeSolvers3pcgEPfP4BTBTS0_iS0_f"]
7231 pub fn iterativeSolvers_pcg(
7232 this: *mut iterativeSolvers,
7233 x: *mut f32,
7234 A: *mut BTBT,
7235 b: *mut f32,
7236 max_it: ::std::os::raw::c_int,
7237 x0: *mut f32,
7238 ip: f32,
7239 );
7240}
7241extern "C" {
7242 #[link_name = "\u{1}_ZN16iterativeSolvers9sym_orthoEPfS0_S0_S0_S0_"]
7243 pub fn iterativeSolvers_sym_ortho(
7244 this: *mut iterativeSolvers,
7245 c: *mut f32,
7246 s: *mut f32,
7247 r: *mut f32,
7248 a: *mut f32,
7249 b: *mut f32,
7250 );
7251}
7252extern "C" {
7253 #[link_name = "\u{1}_ZN16iterativeSolvers12lanczos_stepEPfS0_S0_P4BTBTS0_S0_f"]
7254 pub fn iterativeSolvers_lanczos_step(
7255 this: *mut iterativeSolvers,
7256 alpha: *mut f32,
7257 beta: *mut f32,
7258 nu_kp1: *mut f32,
7259 A: *mut BTBT,
7260 nu_k: *mut f32,
7261 nu_km1: *mut f32,
7262 sigma: f32,
7263 );
7264}
7265extern "C" {
7266 #[link_name = "\u{1}_ZN16iterativeSolvers12minres_vorstEPfP4BTBTS0_S0_"]
7267 pub fn iterativeSolvers_minres_vorst(
7268 this: *mut iterativeSolvers,
7269 x: *mut f32,
7270 A: *mut BTBT,
7271 b: *mut f32,
7272 x0: *mut f32,
7273 );
7274}
7275extern "C" {
7276 #[link_name = "\u{1}_ZN16iterativeSolvers12minres_vorstEPfP4BTBTS0_iS0_"]
7277 pub fn iterativeSolvers_minres_vorst1(
7278 this: *mut iterativeSolvers,
7279 x: *mut f32,
7280 A: *mut BTBT,
7281 b: *mut f32,
7282 max_it: ::std::os::raw::c_int,
7283 x0: *mut f32,
7284 );
7285}
7286extern "C" {
7287 #[link_name = "\u{1}_ZN16iterativeSolvers12minres_vorstEPfP4BTBTS0_fS0_"]
7288 pub fn iterativeSolvers_minres_vorst2(
7289 this: *mut iterativeSolvers,
7290 x: *mut f32,
7291 A: *mut BTBT,
7292 b: *mut f32,
7293 rtol: f32,
7294 x0: *mut f32,
7295 );
7296}
7297extern "C" {
7298 #[link_name = "\u{1}_ZN16iterativeSolvers13pminres_vorstEPfP4BTBTS0_iS0_f"]
7299 pub fn iterativeSolvers_pminres_vorst(
7300 this: *mut iterativeSolvers,
7301 x: *mut f32,
7302 A: *mut BTBT,
7303 b: *mut f32,
7304 max_it: ::std::os::raw::c_int,
7305 x0: *mut f32,
7306 ip: f32,
7307 );
7308}
7309extern "C" {
7310 #[link_name = "\u{1}_ZN16iterativeSolvers12minres_vorstEPfS0_P4BTBTS0_iS0_"]
7311 pub fn iterativeSolvers_minres_vorst3(
7312 this: *mut iterativeSolvers,
7313 x: *mut f32,
7314 res: *mut f32,
7315 A: *mut BTBT,
7316 b: *mut f32,
7317 max_it: ::std::os::raw::c_int,
7318 x0: *mut f32,
7319 );
7320}
7321extern "C" {
7322 #[link_name = "\u{1}_ZN16iterativeSolvers11minres_choiEPfP4BTBTS0_iS0_"]
7323 pub fn iterativeSolvers_minres_choi(
7324 this: *mut iterativeSolvers,
7325 x: *mut f32,
7326 A: *mut BTBT,
7327 b: *mut f32,
7328 max_it: ::std::os::raw::c_int,
7329 x0: *mut f32,
7330 );
7331}
7332impl iterativeSolvers {
7333 #[inline]
7334 pub unsafe fn cg_setup(&mut self, n_vector: ::std::os::raw::c_int) {
7335 iterativeSolvers_cg_setup(self, n_vector)
7336 }
7337 #[inline]
7338 pub unsafe fn pcg_setup(&mut self, n_vector: ::std::os::raw::c_int) {
7339 iterativeSolvers_pcg_setup(self, n_vector)
7340 }
7341 #[inline]
7342 pub unsafe fn minres_setup(&mut self, n_vector: ::std::os::raw::c_int) {
7343 iterativeSolvers_minres_setup(self, n_vector)
7344 }
7345 #[inline]
7346 pub unsafe fn cleanup(&mut self) {
7347 iterativeSolvers_cleanup(self)
7348 }
7349 #[inline]
7350 pub unsafe fn cg(
7351 &mut self,
7352 x: *mut f32,
7353 A: *mut BTBT,
7354 b: *mut f32,
7355 max_it: ::std::os::raw::c_int,
7356 x0: *mut f32,
7357 ) {
7358 iterativeSolvers_cg(self, x, A, b, max_it, x0)
7359 }
7360 #[inline]
7361 pub unsafe fn pcg(
7362 &mut self,
7363 x: *mut f32,
7364 A: *mut BTBT,
7365 b: *mut f32,
7366 max_it: ::std::os::raw::c_int,
7367 x0: *mut f32,
7368 ip: f32,
7369 ) {
7370 iterativeSolvers_pcg(self, x, A, b, max_it, x0, ip)
7371 }
7372 #[inline]
7373 pub unsafe fn sym_ortho(
7374 &mut self,
7375 c: *mut f32,
7376 s: *mut f32,
7377 r: *mut f32,
7378 a: *mut f32,
7379 b: *mut f32,
7380 ) {
7381 iterativeSolvers_sym_ortho(self, c, s, r, a, b)
7382 }
7383 #[inline]
7384 pub unsafe fn lanczos_step(
7385 &mut self,
7386 alpha: *mut f32,
7387 beta: *mut f32,
7388 nu_kp1: *mut f32,
7389 A: *mut BTBT,
7390 nu_k: *mut f32,
7391 nu_km1: *mut f32,
7392 sigma: f32,
7393 ) {
7394 iterativeSolvers_lanczos_step(self, alpha, beta, nu_kp1, A, nu_k, nu_km1, sigma)
7395 }
7396 #[inline]
7397 pub unsafe fn minres_vorst(&mut self, x: *mut f32, A: *mut BTBT, b: *mut f32, x0: *mut f32) {
7398 iterativeSolvers_minres_vorst(self, x, A, b, x0)
7399 }
7400 #[inline]
7401 pub unsafe fn minres_vorst1(
7402 &mut self,
7403 x: *mut f32,
7404 A: *mut BTBT,
7405 b: *mut f32,
7406 max_it: ::std::os::raw::c_int,
7407 x0: *mut f32,
7408 ) {
7409 iterativeSolvers_minres_vorst1(self, x, A, b, max_it, x0)
7410 }
7411 #[inline]
7412 pub unsafe fn minres_vorst2(
7413 &mut self,
7414 x: *mut f32,
7415 A: *mut BTBT,
7416 b: *mut f32,
7417 rtol: f32,
7418 x0: *mut f32,
7419 ) {
7420 iterativeSolvers_minres_vorst2(self, x, A, b, rtol, x0)
7421 }
7422 #[inline]
7423 pub unsafe fn pminres_vorst(
7424 &mut self,
7425 x: *mut f32,
7426 A: *mut BTBT,
7427 b: *mut f32,
7428 max_it: ::std::os::raw::c_int,
7429 x0: *mut f32,
7430 ip: f32,
7431 ) {
7432 iterativeSolvers_pminres_vorst(self, x, A, b, max_it, x0, ip)
7433 }
7434 #[inline]
7435 pub unsafe fn minres_vorst3(
7436 &mut self,
7437 x: *mut f32,
7438 res: *mut f32,
7439 A: *mut BTBT,
7440 b: *mut f32,
7441 max_it: ::std::os::raw::c_int,
7442 x0: *mut f32,
7443 ) {
7444 iterativeSolvers_minres_vorst3(self, x, res, A, b, max_it, x0)
7445 }
7446 #[inline]
7447 pub unsafe fn minres_choi(
7448 &mut self,
7449 x: *mut f32,
7450 A: *mut BTBT,
7451 b: *mut f32,
7452 max_it: ::std::os::raw::c_int,
7453 x0: *mut f32,
7454 ) {
7455 iterativeSolvers_minres_choi(self, x, A, b, max_it, x0)
7456 }
7457}
7458#[repr(C)]
7459#[derive(Debug, Copy, Clone)]
7460pub struct LMMSE {
7461 pub d__idx: *mut ::std::os::raw::c_int,
7462 pub PS_E_N_PX: ::std::os::raw::c_int,
7463 pub N_guide_star: ::std::os::raw::c_int,
7464 pub N_mmse_star: ::std::os::raw::c_int,
7465 pub offset: ::std::os::raw::c_int,
7466 pub N_SIDE_LENSLET_: ::std::os::raw::c_int,
7467 pub NP: ::std::os::raw::c_int,
7468 pub NS: ::std::os::raw::c_int,
7469 pub osf: ::std::os::raw::c_int,
7470 pub d__ce: *mut f32,
7471 pub d__phase_est: *mut f32,
7472 pub d__phase_est_c: *mut f32,
7473 pub d__phase_est_i: *mut f32,
7474 pub d__x: *mut f32,
7475 pub d__zp_x: *mut f32,
7476 pub aa: aaStats,
7477 pub aaCov: BTBT,
7478 pub pa: paStats,
7479 pub paCov: GBTBT,
7480 pub iSolve: iterativeSolvers,
7481 pub tid: stopwatch,
7482 pub nnz: ::std::os::raw::c_int,
7483 pub NI: ::std::os::raw::c_int,
7484 pub csrValH: *mut f32,
7485 pub csrColIndH: *mut ::std::os::raw::c_int,
7486 pub csrRowPtrH: *mut ::std::os::raw::c_int,
7487 pub alpha: f32,
7488 pub beta: f32,
7489 pub elapsed_time: f32,
7490 pub cudaStat: cudaError_t,
7491 pub status: cusparseStatus_t,
7492 pub handle: cusparseHandle_t,
7493 pub descr: cusparseMatDescr_t,
7494 pub start: cudaEvent_t,
7495 pub stop: cudaEvent_t,
7496}
7497#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7498const _: () = {
7499 ["Size of LMMSE"][::std::mem::size_of::<LMMSE>() - 1008usize];
7500 ["Alignment of LMMSE"][::std::mem::align_of::<LMMSE>() - 8usize];
7501 ["Offset of field: LMMSE::d__idx"][::std::mem::offset_of!(LMMSE, d__idx) - 0usize];
7502 ["Offset of field: LMMSE::PS_E_N_PX"][::std::mem::offset_of!(LMMSE, PS_E_N_PX) - 8usize];
7503 ["Offset of field: LMMSE::N_guide_star"][::std::mem::offset_of!(LMMSE, N_guide_star) - 12usize];
7504 ["Offset of field: LMMSE::N_mmse_star"][::std::mem::offset_of!(LMMSE, N_mmse_star) - 16usize];
7505 ["Offset of field: LMMSE::offset"][::std::mem::offset_of!(LMMSE, offset) - 20usize];
7506 ["Offset of field: LMMSE::N_SIDE_LENSLET_"]
7507 [::std::mem::offset_of!(LMMSE, N_SIDE_LENSLET_) - 24usize];
7508 ["Offset of field: LMMSE::NP"][::std::mem::offset_of!(LMMSE, NP) - 28usize];
7509 ["Offset of field: LMMSE::NS"][::std::mem::offset_of!(LMMSE, NS) - 32usize];
7510 ["Offset of field: LMMSE::osf"][::std::mem::offset_of!(LMMSE, osf) - 36usize];
7511 ["Offset of field: LMMSE::d__ce"][::std::mem::offset_of!(LMMSE, d__ce) - 40usize];
7512 ["Offset of field: LMMSE::d__phase_est"][::std::mem::offset_of!(LMMSE, d__phase_est) - 48usize];
7513 ["Offset of field: LMMSE::d__phase_est_c"]
7514 [::std::mem::offset_of!(LMMSE, d__phase_est_c) - 56usize];
7515 ["Offset of field: LMMSE::d__phase_est_i"]
7516 [::std::mem::offset_of!(LMMSE, d__phase_est_i) - 64usize];
7517 ["Offset of field: LMMSE::d__x"][::std::mem::offset_of!(LMMSE, d__x) - 72usize];
7518 ["Offset of field: LMMSE::d__zp_x"][::std::mem::offset_of!(LMMSE, d__zp_x) - 80usize];
7519 ["Offset of field: LMMSE::aa"][::std::mem::offset_of!(LMMSE, aa) - 88usize];
7520 ["Offset of field: LMMSE::aaCov"][::std::mem::offset_of!(LMMSE, aaCov) - 192usize];
7521 ["Offset of field: LMMSE::pa"][::std::mem::offset_of!(LMMSE, pa) - 360usize];
7522 ["Offset of field: LMMSE::paCov"][::std::mem::offset_of!(LMMSE, paCov) - 488usize];
7523 ["Offset of field: LMMSE::iSolve"][::std::mem::offset_of!(LMMSE, iSolve) - 728usize];
7524 ["Offset of field: LMMSE::tid"][::std::mem::offset_of!(LMMSE, tid) - 896usize];
7525 ["Offset of field: LMMSE::nnz"][::std::mem::offset_of!(LMMSE, nnz) - 920usize];
7526 ["Offset of field: LMMSE::NI"][::std::mem::offset_of!(LMMSE, NI) - 924usize];
7527 ["Offset of field: LMMSE::csrValH"][::std::mem::offset_of!(LMMSE, csrValH) - 928usize];
7528 ["Offset of field: LMMSE::csrColIndH"][::std::mem::offset_of!(LMMSE, csrColIndH) - 936usize];
7529 ["Offset of field: LMMSE::csrRowPtrH"][::std::mem::offset_of!(LMMSE, csrRowPtrH) - 944usize];
7530 ["Offset of field: LMMSE::alpha"][::std::mem::offset_of!(LMMSE, alpha) - 952usize];
7531 ["Offset of field: LMMSE::beta"][::std::mem::offset_of!(LMMSE, beta) - 956usize];
7532 ["Offset of field: LMMSE::elapsed_time"]
7533 [::std::mem::offset_of!(LMMSE, elapsed_time) - 960usize];
7534 ["Offset of field: LMMSE::cudaStat"][::std::mem::offset_of!(LMMSE, cudaStat) - 964usize];
7535 ["Offset of field: LMMSE::status"][::std::mem::offset_of!(LMMSE, status) - 968usize];
7536 ["Offset of field: LMMSE::handle"][::std::mem::offset_of!(LMMSE, handle) - 976usize];
7537 ["Offset of field: LMMSE::descr"][::std::mem::offset_of!(LMMSE, descr) - 984usize];
7538 ["Offset of field: LMMSE::start"][::std::mem::offset_of!(LMMSE, start) - 992usize];
7539 ["Offset of field: LMMSE::stop"][::std::mem::offset_of!(LMMSE, stop) - 1000usize];
7540};
7541extern "C" {
7542 #[link_name = "\u{1}_ZN5LMMSE5setupEP10atmosphereP6sourceS3_fiPc"]
7543 pub fn LMMSE_setup(
7544 this: *mut LMMSE,
7545 atm: *mut atmosphere,
7546 guide_star: *mut source,
7547 mmse_star: *mut source,
7548 sampling: f32,
7549 N: ::std::os::raw::c_int,
7550 solver_id: *mut ::std::os::raw::c_char,
7551 );
7552}
7553extern "C" {
7554 #[link_name = "\u{1}_ZN5LMMSE5setupEP10atmosphereP6sourceS3_fiP4maskPc"]
7555 pub fn LMMSE_setup1(
7556 this: *mut LMMSE,
7557 atm: *mut atmosphere,
7558 guide_star: *mut source,
7559 mmse_star: *mut source,
7560 sampling: f32,
7561 N: ::std::os::raw::c_int,
7562 pupil: *mut mask,
7563 solver_id: *mut ::std::os::raw::c_char,
7564 );
7565}
7566extern "C" {
7567 #[link_name = "\u{1}_ZN5LMMSE5setupEP10atmosphereP6sourceS3_fiP4maskPci"]
7568 pub fn LMMSE_setup2(
7569 this: *mut LMMSE,
7570 atm: *mut atmosphere,
7571 guide_star: *mut source,
7572 mmse_star: *mut source,
7573 sampling: f32,
7574 N: ::std::os::raw::c_int,
7575 pupil: *mut mask,
7576 solver_id: *mut ::std::os::raw::c_char,
7577 wavefront_osf: ::std::os::raw::c_int,
7578 );
7579}
7580extern "C" {
7581 #[link_name = "\u{1}_ZN5LMMSE5setupEP10atmosphereP6sourcefiP4maskPcif"]
7582 pub fn LMMSE_setup3(
7583 this: *mut LMMSE,
7584 atm: *mut atmosphere,
7585 guide_star: *mut source,
7586 sampling: f32,
7587 _N_SIDE_LENSLET_: ::std::os::raw::c_int,
7588 pupil: *mut mask,
7589 solver_id: *mut ::std::os::raw::c_char,
7590 wavefront_osf: ::std::os::raw::c_int,
7591 z_radius: f32,
7592 );
7593}
7594extern "C" {
7595 #[link_name = "\u{1}_ZN5LMMSE5setupEP10atmosphereP6sourceS3_P13shackHartmannPc"]
7596 pub fn LMMSE_setup4(
7597 this: *mut LMMSE,
7598 atm: *mut atmosphere,
7599 guide_star: *mut source,
7600 mmse_star: *mut source,
7601 wfs: *mut shackHartmann,
7602 solver_id: *mut ::std::os::raw::c_char,
7603 );
7604}
7605extern "C" {
7606 #[link_name = "\u{1}_ZN5LMMSE5setupEP10atmosphereP6sourceS3_P13shackHartmannPciP4mask"]
7607 pub fn LMMSE_setup5(
7608 this: *mut LMMSE,
7609 atm: *mut atmosphere,
7610 guide_star: *mut source,
7611 mmse_star: *mut source,
7612 wfs: *mut shackHartmann,
7613 solver_id: *mut ::std::os::raw::c_char,
7614 osf_: ::std::os::raw::c_int,
7615 pupil_: *mut mask,
7616 );
7617}
7618extern "C" {
7619 #[link_name = "\u{1}_ZN5LMMSE7cleanupEv"]
7620 pub fn LMMSE_cleanup(this: *mut LMMSE);
7621}
7622extern "C" {
7623 #[link_name = "\u{1}_ZN5LMMSE14estimation_oldEPfiS0_"]
7624 pub fn LMMSE_estimation_old(
7625 this: *mut LMMSE,
7626 d__c: *mut f32,
7627 nMaxIteration: ::std::os::raw::c_int,
7628 d__x0: *mut f32,
7629 );
7630}
7631extern "C" {
7632 #[link_name = "\u{1}_ZN5LMMSE14estimation_oldEPfi"]
7633 pub fn LMMSE_estimation_old1(
7634 this: *mut LMMSE,
7635 d__c: *mut f32,
7636 nMaxIteration: ::std::os::raw::c_int,
7637 );
7638}
7639extern "C" {
7640 #[link_name = "\u{1}_ZN5LMMSE10estimationEPK11centroiding"]
7641 pub fn LMMSE_estimation(this: *mut LMMSE, cog: *const centroiding);
7642}
7643extern "C" {
7644 #[link_name = "\u{1}_ZN5LMMSE10estimationEP13shackHartmann"]
7645 pub fn LMMSE_estimation1(this: *mut LMMSE, wfs: *mut shackHartmann);
7646}
7647extern "C" {
7648 #[link_name = "\u{1}_ZN5LMMSE5resetEv"]
7649 pub fn LMMSE_reset(this: *mut LMMSE);
7650}
7651extern "C" {
7652 #[link_name = "\u{1}_ZN5LMMSE17set_phase_est_ptrEPf"]
7653 pub fn LMMSE_set_phase_est_ptr(this: *mut LMMSE, data_ptr: *mut f32);
7654}
7655extern "C" {
7656 #[link_name = "\u{1}_ZN5LMMSE6toFileEPKc"]
7657 pub fn LMMSE_toFile(this: *mut LMMSE, filename: *const ::std::os::raw::c_char);
7658}
7659impl LMMSE {
7660 #[inline]
7661 pub unsafe fn setup(
7662 &mut self,
7663 atm: *mut atmosphere,
7664 guide_star: *mut source,
7665 mmse_star: *mut source,
7666 sampling: f32,
7667 N: ::std::os::raw::c_int,
7668 solver_id: *mut ::std::os::raw::c_char,
7669 ) {
7670 LMMSE_setup(self, atm, guide_star, mmse_star, sampling, N, solver_id)
7671 }
7672 #[inline]
7673 pub unsafe fn setup1(
7674 &mut self,
7675 atm: *mut atmosphere,
7676 guide_star: *mut source,
7677 mmse_star: *mut source,
7678 sampling: f32,
7679 N: ::std::os::raw::c_int,
7680 pupil: *mut mask,
7681 solver_id: *mut ::std::os::raw::c_char,
7682 ) {
7683 LMMSE_setup1(
7684 self, atm, guide_star, mmse_star, sampling, N, pupil, solver_id,
7685 )
7686 }
7687 #[inline]
7688 pub unsafe fn setup2(
7689 &mut self,
7690 atm: *mut atmosphere,
7691 guide_star: *mut source,
7692 mmse_star: *mut source,
7693 sampling: f32,
7694 N: ::std::os::raw::c_int,
7695 pupil: *mut mask,
7696 solver_id: *mut ::std::os::raw::c_char,
7697 wavefront_osf: ::std::os::raw::c_int,
7698 ) {
7699 LMMSE_setup2(
7700 self,
7701 atm,
7702 guide_star,
7703 mmse_star,
7704 sampling,
7705 N,
7706 pupil,
7707 solver_id,
7708 wavefront_osf,
7709 )
7710 }
7711 #[inline]
7712 pub unsafe fn setup3(
7713 &mut self,
7714 atm: *mut atmosphere,
7715 guide_star: *mut source,
7716 sampling: f32,
7717 _N_SIDE_LENSLET_: ::std::os::raw::c_int,
7718 pupil: *mut mask,
7719 solver_id: *mut ::std::os::raw::c_char,
7720 wavefront_osf: ::std::os::raw::c_int,
7721 z_radius: f32,
7722 ) {
7723 LMMSE_setup3(
7724 self,
7725 atm,
7726 guide_star,
7727 sampling,
7728 _N_SIDE_LENSLET_,
7729 pupil,
7730 solver_id,
7731 wavefront_osf,
7732 z_radius,
7733 )
7734 }
7735 #[inline]
7736 pub unsafe fn setup4(
7737 &mut self,
7738 atm: *mut atmosphere,
7739 guide_star: *mut source,
7740 mmse_star: *mut source,
7741 wfs: *mut shackHartmann,
7742 solver_id: *mut ::std::os::raw::c_char,
7743 ) {
7744 LMMSE_setup4(self, atm, guide_star, mmse_star, wfs, solver_id)
7745 }
7746 #[inline]
7747 pub unsafe fn setup5(
7748 &mut self,
7749 atm: *mut atmosphere,
7750 guide_star: *mut source,
7751 mmse_star: *mut source,
7752 wfs: *mut shackHartmann,
7753 solver_id: *mut ::std::os::raw::c_char,
7754 osf_: ::std::os::raw::c_int,
7755 pupil_: *mut mask,
7756 ) {
7757 LMMSE_setup5(
7758 self, atm, guide_star, mmse_star, wfs, solver_id, osf_, pupil_,
7759 )
7760 }
7761 #[inline]
7762 pub unsafe fn cleanup(&mut self) {
7763 LMMSE_cleanup(self)
7764 }
7765 #[inline]
7766 pub unsafe fn estimation_old(
7767 &mut self,
7768 d__c: *mut f32,
7769 nMaxIteration: ::std::os::raw::c_int,
7770 d__x0: *mut f32,
7771 ) {
7772 LMMSE_estimation_old(self, d__c, nMaxIteration, d__x0)
7773 }
7774 #[inline]
7775 pub unsafe fn estimation_old1(&mut self, d__c: *mut f32, nMaxIteration: ::std::os::raw::c_int) {
7776 LMMSE_estimation_old1(self, d__c, nMaxIteration)
7777 }
7778 #[inline]
7779 pub unsafe fn estimation(&mut self, cog: *const centroiding) {
7780 LMMSE_estimation(self, cog)
7781 }
7782 #[inline]
7783 pub unsafe fn estimation1(&mut self, wfs: *mut shackHartmann) {
7784 LMMSE_estimation1(self, wfs)
7785 }
7786 #[inline]
7787 pub unsafe fn reset(&mut self) {
7788 LMMSE_reset(self)
7789 }
7790 #[inline]
7791 pub unsafe fn set_phase_est_ptr(&mut self, data_ptr: *mut f32) {
7792 LMMSE_set_phase_est_ptr(self, data_ptr)
7793 }
7794 #[inline]
7795 pub unsafe fn toFile(&mut self, filename: *const ::std::os::raw::c_char) {
7796 LMMSE_toFile(self, filename)
7797 }
7798}
7799#[repr(C)]
7800#[derive(Debug, Copy, Clone)]
7801pub struct pyramid {
7802 pub N_PX_LENSLET: ::std::os::raw::c_int,
7803 pub N_SIDE_LENSLET: ::std::os::raw::c_int,
7804 pub modulation: f32,
7805 pub modulation_sampling: ::std::os::raw::c_int,
7806 pub camera: imaging,
7807 pub alpha: f32,
7808}
7809#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7810const _: () = {
7811 ["Size of pyramid"][::std::mem::size_of::<pyramid>() - 168usize];
7812 ["Alignment of pyramid"][::std::mem::align_of::<pyramid>() - 8usize];
7813 ["Offset of field: pyramid::N_PX_LENSLET"]
7814 [::std::mem::offset_of!(pyramid, N_PX_LENSLET) - 0usize];
7815 ["Offset of field: pyramid::N_SIDE_LENSLET"]
7816 [::std::mem::offset_of!(pyramid, N_SIDE_LENSLET) - 4usize];
7817 ["Offset of field: pyramid::modulation"][::std::mem::offset_of!(pyramid, modulation) - 8usize];
7818 ["Offset of field: pyramid::modulation_sampling"]
7819 [::std::mem::offset_of!(pyramid, modulation_sampling) - 12usize];
7820 ["Offset of field: pyramid::camera"][::std::mem::offset_of!(pyramid, camera) - 16usize];
7821 ["Offset of field: pyramid::alpha"][::std::mem::offset_of!(pyramid, alpha) - 160usize];
7822};
7823extern "C" {
7824 #[link_name = "\u{1}_ZN7pyramid5setupEiififi"]
7825 pub fn pyramid_setup(
7826 this: *mut pyramid,
7827 N_PX_PUPIL: ::std::os::raw::c_int,
7828 _N_PUPIL_SAMPLING_: ::std::os::raw::c_int,
7829 _modulation_: f32,
7830 _modulation_sampling_: ::std::os::raw::c_int,
7831 _alpha_: f32,
7832 N_GS: ::std::os::raw::c_int,
7833 );
7834}
7835extern "C" {
7836 #[link_name = "\u{1}_ZN7pyramid7cleanupEv"]
7837 pub fn pyramid_cleanup(this: *mut pyramid);
7838}
7839impl pyramid {
7840 #[inline]
7841 pub unsafe fn setup(
7842 &mut self,
7843 N_PX_PUPIL: ::std::os::raw::c_int,
7844 _N_PUPIL_SAMPLING_: ::std::os::raw::c_int,
7845 _modulation_: f32,
7846 _modulation_sampling_: ::std::os::raw::c_int,
7847 _alpha_: f32,
7848 N_GS: ::std::os::raw::c_int,
7849 ) {
7850 pyramid_setup(
7851 self,
7852 N_PX_PUPIL,
7853 _N_PUPIL_SAMPLING_,
7854 _modulation_,
7855 _modulation_sampling_,
7856 _alpha_,
7857 N_GS,
7858 )
7859 }
7860 #[inline]
7861 pub unsafe fn cleanup(&mut self) {
7862 pyramid_cleanup(self)
7863 }
7864}
7865#[repr(C)]
7866#[derive(Debug, Copy, Clone)]
7867pub struct segmentPistonSensor {
7868 pub ri: f32,
7869 pub ro: f32,
7870 pub lenslet_height: f32,
7871 pub lenslet_size: f32,
7872 pub lenslet: complex_amplitude,
7873 pub lenslet_mask: mask,
7874 pub lenslet_src: source,
7875 pub dispersion: f32,
7876 pub N_LAMBDA: ::std::os::raw::c_int,
7877 pub N_GS: ::std::os::raw::c_int,
7878 pub pixel_scale: f32,
7879 pub field_of_view: f32,
7880 pub camera: imaging,
7881 pub camera_array: *mut imaging,
7882 pub nyquist_factor: f32,
7883 pub BIN_IMAGE: ::std::os::raw::c_int,
7884 pub N_PX_LENSLET: ::std::os::raw::c_int,
7885 pub N_PX_LENSLET2: ::std::os::raw::c_int,
7886 pub N_PX: ::std::os::raw::c_int,
7887 pub N_PX2: ::std::os::raw::c_int,
7888 pub N_PX_IMAGE: ::std::os::raw::c_int,
7889 pub N_LENSLET: ::std::os::raw::c_int,
7890 pub N_LENSLET2: ::std::os::raw::c_int,
7891 pub FFT: imaging,
7892 pub fft_src: source,
7893 pub fft_phase: *mut f32,
7894 pub fft_mask: mask,
7895 pub D_px: ::std::os::raw::c_int,
7896 pub D_px2: ::std::os::raw::c_int,
7897 pub m2px: f32,
7898 pub R: f32,
7899 pub lambda0: f32,
7900 pub spectral_bandwidth: f32,
7901}
7902#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7903const _: () = {
7904 ["Size of segmentPistonSensor"][::std::mem::size_of::<segmentPistonSensor>() - 1384usize];
7905 ["Alignment of segmentPistonSensor"][::std::mem::align_of::<segmentPistonSensor>() - 8usize];
7906 ["Offset of field: segmentPistonSensor::ri"]
7907 [::std::mem::offset_of!(segmentPistonSensor, ri) - 0usize];
7908 ["Offset of field: segmentPistonSensor::ro"]
7909 [::std::mem::offset_of!(segmentPistonSensor, ro) - 4usize];
7910 ["Offset of field: segmentPistonSensor::lenslet_height"]
7911 [::std::mem::offset_of!(segmentPistonSensor, lenslet_height) - 8usize];
7912 ["Offset of field: segmentPistonSensor::lenslet_size"]
7913 [::std::mem::offset_of!(segmentPistonSensor, lenslet_size) - 12usize];
7914 ["Offset of field: segmentPistonSensor::lenslet"]
7915 [::std::mem::offset_of!(segmentPistonSensor, lenslet) - 16usize];
7916 ["Offset of field: segmentPistonSensor::lenslet_mask"]
7917 [::std::mem::offset_of!(segmentPistonSensor, lenslet_mask) - 64usize];
7918 ["Offset of field: segmentPistonSensor::lenslet_src"]
7919 [::std::mem::offset_of!(segmentPistonSensor, lenslet_src) - 144usize];
7920 ["Offset of field: segmentPistonSensor::dispersion"]
7921 [::std::mem::offset_of!(segmentPistonSensor, dispersion) - 528usize];
7922 ["Offset of field: segmentPistonSensor::N_LAMBDA"]
7923 [::std::mem::offset_of!(segmentPistonSensor, N_LAMBDA) - 532usize];
7924 ["Offset of field: segmentPistonSensor::N_GS"]
7925 [::std::mem::offset_of!(segmentPistonSensor, N_GS) - 536usize];
7926 ["Offset of field: segmentPistonSensor::pixel_scale"]
7927 [::std::mem::offset_of!(segmentPistonSensor, pixel_scale) - 540usize];
7928 ["Offset of field: segmentPistonSensor::field_of_view"]
7929 [::std::mem::offset_of!(segmentPistonSensor, field_of_view) - 544usize];
7930 ["Offset of field: segmentPistonSensor::camera"]
7931 [::std::mem::offset_of!(segmentPistonSensor, camera) - 552usize];
7932 ["Offset of field: segmentPistonSensor::camera_array"]
7933 [::std::mem::offset_of!(segmentPistonSensor, camera_array) - 696usize];
7934 ["Offset of field: segmentPistonSensor::nyquist_factor"]
7935 [::std::mem::offset_of!(segmentPistonSensor, nyquist_factor) - 704usize];
7936 ["Offset of field: segmentPistonSensor::BIN_IMAGE"]
7937 [::std::mem::offset_of!(segmentPistonSensor, BIN_IMAGE) - 708usize];
7938 ["Offset of field: segmentPistonSensor::N_PX_LENSLET"]
7939 [::std::mem::offset_of!(segmentPistonSensor, N_PX_LENSLET) - 712usize];
7940 ["Offset of field: segmentPistonSensor::N_PX_LENSLET2"]
7941 [::std::mem::offset_of!(segmentPistonSensor, N_PX_LENSLET2) - 716usize];
7942 ["Offset of field: segmentPistonSensor::N_PX"]
7943 [::std::mem::offset_of!(segmentPistonSensor, N_PX) - 720usize];
7944 ["Offset of field: segmentPistonSensor::N_PX2"]
7945 [::std::mem::offset_of!(segmentPistonSensor, N_PX2) - 724usize];
7946 ["Offset of field: segmentPistonSensor::N_PX_IMAGE"]
7947 [::std::mem::offset_of!(segmentPistonSensor, N_PX_IMAGE) - 728usize];
7948 ["Offset of field: segmentPistonSensor::N_LENSLET"]
7949 [::std::mem::offset_of!(segmentPistonSensor, N_LENSLET) - 732usize];
7950 ["Offset of field: segmentPistonSensor::N_LENSLET2"]
7951 [::std::mem::offset_of!(segmentPistonSensor, N_LENSLET2) - 736usize];
7952 ["Offset of field: segmentPistonSensor::FFT"]
7953 [::std::mem::offset_of!(segmentPistonSensor, FFT) - 744usize];
7954 ["Offset of field: segmentPistonSensor::fft_src"]
7955 [::std::mem::offset_of!(segmentPistonSensor, fft_src) - 888usize];
7956 ["Offset of field: segmentPistonSensor::fft_phase"]
7957 [::std::mem::offset_of!(segmentPistonSensor, fft_phase) - 1272usize];
7958 ["Offset of field: segmentPistonSensor::fft_mask"]
7959 [::std::mem::offset_of!(segmentPistonSensor, fft_mask) - 1280usize];
7960 ["Offset of field: segmentPistonSensor::D_px"]
7961 [::std::mem::offset_of!(segmentPistonSensor, D_px) - 1360usize];
7962 ["Offset of field: segmentPistonSensor::D_px2"]
7963 [::std::mem::offset_of!(segmentPistonSensor, D_px2) - 1364usize];
7964 ["Offset of field: segmentPistonSensor::m2px"]
7965 [::std::mem::offset_of!(segmentPistonSensor, m2px) - 1368usize];
7966 ["Offset of field: segmentPistonSensor::R"]
7967 [::std::mem::offset_of!(segmentPistonSensor, R) - 1372usize];
7968 ["Offset of field: segmentPistonSensor::lambda0"]
7969 [::std::mem::offset_of!(segmentPistonSensor, lambda0) - 1376usize];
7970 ["Offset of field: segmentPistonSensor::spectral_bandwidth"]
7971 [::std::mem::offset_of!(segmentPistonSensor, spectral_bandwidth) - 1380usize];
7972};
7973extern "C" {
7974 #[link_name = "\u{1}_ZN19segmentPistonSensor5setupEP6gmt_m1P6sourcefff"]
7975 pub fn segmentPistonSensor_setup(
7976 this: *mut segmentPistonSensor,
7977 M1: *mut gmt_m1,
7978 src: *mut source,
7979 dispersion: f32,
7980 field_of_view: f32,
7981 _nyquist_factor_: f32,
7982 );
7983}
7984extern "C" {
7985 #[link_name = "\u{1}_ZN19segmentPistonSensor5setupEP6gmt_m1P6sourcefffi"]
7986 pub fn segmentPistonSensor_setup1(
7987 this: *mut segmentPistonSensor,
7988 M1: *mut gmt_m1,
7989 src: *mut source,
7990 dispersion: f32,
7991 field_of_view: f32,
7992 _nyquist_factor_: f32,
7993 _BIN_IMAGE_: ::std::os::raw::c_int,
7994 );
7995}
7996extern "C" {
7997 #[link_name = "\u{1}_ZN19segmentPistonSensor5setupEP6gmt_m1P6sourceffff"]
7998 pub fn segmentPistonSensor_setup2(
7999 this: *mut segmentPistonSensor,
8000 M1: *mut gmt_m1,
8001 src: *mut source,
8002 _lenslet_size_: f32,
8003 dispersion: f32,
8004 field_of_view: f32,
8005 _nyquist_factor_: f32,
8006 );
8007}
8008extern "C" {
8009 #[link_name = "\u{1}_ZN19segmentPistonSensor5setupEP6gmt_m1P6sourceffffi"]
8010 pub fn segmentPistonSensor_setup3(
8011 this: *mut segmentPistonSensor,
8012 M1: *mut gmt_m1,
8013 src: *mut source,
8014 _lenslet_size_: f32,
8015 dispersion: f32,
8016 field_of_view: f32,
8017 _nyquist_factor_: f32,
8018 _BIN_IMAGE_: ::std::os::raw::c_int,
8019 );
8020}
8021extern "C" {
8022 #[link_name = "\u{1}_ZN19segmentPistonSensor9setup_altEP6gmt_m1P6sourcefffi"]
8023 pub fn segmentPistonSensor_setup_alt(
8024 this: *mut segmentPistonSensor,
8025 M1: *mut gmt_m1,
8026 src: *mut source,
8027 dispersion: f32,
8028 field_of_view: f32,
8029 _nyquist_factor_: f32,
8030 _BIN_IMAGE_: ::std::os::raw::c_int,
8031 );
8032}
8033extern "C" {
8034 #[link_name = "\u{1}_ZN19segmentPistonSensor7cleanupEv"]
8035 pub fn segmentPistonSensor_cleanup(this: *mut segmentPistonSensor);
8036}
8037extern "C" {
8038 #[link_name = "\u{1}_ZN19segmentPistonSensor11cleanup_altEv"]
8039 pub fn segmentPistonSensor_cleanup_alt(this: *mut segmentPistonSensor);
8040}
8041extern "C" {
8042 #[link_name = "\u{1}_ZN19segmentPistonSensor9propagateEP6source"]
8043 pub fn segmentPistonSensor_propagate(this: *mut segmentPistonSensor, src: *mut source);
8044}
8045extern "C" {
8046 #[link_name = "\u{1}_ZN19segmentPistonSensor9propagateEP6sourcef"]
8047 pub fn segmentPistonSensor_propagate1(
8048 this: *mut segmentPistonSensor,
8049 src: *mut source,
8050 middle_mask_width: f32,
8051 );
8052}
8053extern "C" {
8054 #[link_name = "\u{1}_ZN19segmentPistonSensor13propagate_altEP6source"]
8055 pub fn segmentPistonSensor_propagate_alt(this: *mut segmentPistonSensor, src: *mut source);
8056}
8057extern "C" {
8058 #[link_name = "\u{1}_ZN19segmentPistonSensor7readoutEfff"]
8059 pub fn segmentPistonSensor_readout(
8060 this: *mut segmentPistonSensor,
8061 exposureTime: f32,
8062 readoutNoiseRms: f32,
8063 nBackgroundPhoton: f32,
8064 );
8065}
8066extern "C" {
8067 #[link_name = "\u{1}_ZN19segmentPistonSensor3fftEv"]
8068 pub fn segmentPistonSensor_fft(this: *mut segmentPistonSensor);
8069}
8070extern "C" {
8071 #[link_name = "\u{1}_ZN19segmentPistonSensor4infoEv"]
8072 pub fn segmentPistonSensor_info(this: *mut segmentPistonSensor);
8073}
8074impl segmentPistonSensor {
8075 #[inline]
8076 pub unsafe fn setup(
8077 &mut self,
8078 M1: *mut gmt_m1,
8079 src: *mut source,
8080 dispersion: f32,
8081 field_of_view: f32,
8082 _nyquist_factor_: f32,
8083 ) {
8084 segmentPistonSensor_setup(self, M1, src, dispersion, field_of_view, _nyquist_factor_)
8085 }
8086 #[inline]
8087 pub unsafe fn setup1(
8088 &mut self,
8089 M1: *mut gmt_m1,
8090 src: *mut source,
8091 dispersion: f32,
8092 field_of_view: f32,
8093 _nyquist_factor_: f32,
8094 _BIN_IMAGE_: ::std::os::raw::c_int,
8095 ) {
8096 segmentPistonSensor_setup1(
8097 self,
8098 M1,
8099 src,
8100 dispersion,
8101 field_of_view,
8102 _nyquist_factor_,
8103 _BIN_IMAGE_,
8104 )
8105 }
8106 #[inline]
8107 pub unsafe fn setup2(
8108 &mut self,
8109 M1: *mut gmt_m1,
8110 src: *mut source,
8111 _lenslet_size_: f32,
8112 dispersion: f32,
8113 field_of_view: f32,
8114 _nyquist_factor_: f32,
8115 ) {
8116 segmentPistonSensor_setup2(
8117 self,
8118 M1,
8119 src,
8120 _lenslet_size_,
8121 dispersion,
8122 field_of_view,
8123 _nyquist_factor_,
8124 )
8125 }
8126 #[inline]
8127 pub unsafe fn setup3(
8128 &mut self,
8129 M1: *mut gmt_m1,
8130 src: *mut source,
8131 _lenslet_size_: f32,
8132 dispersion: f32,
8133 field_of_view: f32,
8134 _nyquist_factor_: f32,
8135 _BIN_IMAGE_: ::std::os::raw::c_int,
8136 ) {
8137 segmentPistonSensor_setup3(
8138 self,
8139 M1,
8140 src,
8141 _lenslet_size_,
8142 dispersion,
8143 field_of_view,
8144 _nyquist_factor_,
8145 _BIN_IMAGE_,
8146 )
8147 }
8148 #[inline]
8149 pub unsafe fn setup_alt(
8150 &mut self,
8151 M1: *mut gmt_m1,
8152 src: *mut source,
8153 dispersion: f32,
8154 field_of_view: f32,
8155 _nyquist_factor_: f32,
8156 _BIN_IMAGE_: ::std::os::raw::c_int,
8157 ) {
8158 segmentPistonSensor_setup_alt(
8159 self,
8160 M1,
8161 src,
8162 dispersion,
8163 field_of_view,
8164 _nyquist_factor_,
8165 _BIN_IMAGE_,
8166 )
8167 }
8168 #[inline]
8169 pub unsafe fn cleanup(&mut self) {
8170 segmentPistonSensor_cleanup(self)
8171 }
8172 #[inline]
8173 pub unsafe fn cleanup_alt(&mut self) {
8174 segmentPistonSensor_cleanup_alt(self)
8175 }
8176 #[inline]
8177 pub unsafe fn propagate(&mut self, src: *mut source) {
8178 segmentPistonSensor_propagate(self, src)
8179 }
8180 #[inline]
8181 pub unsafe fn propagate1(&mut self, src: *mut source, middle_mask_width: f32) {
8182 segmentPistonSensor_propagate1(self, src, middle_mask_width)
8183 }
8184 #[inline]
8185 pub unsafe fn propagate_alt(&mut self, src: *mut source) {
8186 segmentPistonSensor_propagate_alt(self, src)
8187 }
8188 #[inline]
8189 pub unsafe fn readout(
8190 &mut self,
8191 exposureTime: f32,
8192 readoutNoiseRms: f32,
8193 nBackgroundPhoton: f32,
8194 ) {
8195 segmentPistonSensor_readout(self, exposureTime, readoutNoiseRms, nBackgroundPhoton)
8196 }
8197 #[inline]
8198 pub unsafe fn fft(&mut self) {
8199 segmentPistonSensor_fft(self)
8200 }
8201 #[inline]
8202 pub unsafe fn info(&mut self) {
8203 segmentPistonSensor_info(self)
8204 }
8205}