1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! ArrayFire is a high performance software library for parallel computing with an easy-to-use API.
//! ArrayFire abstracts away much of the details of programming parallel architectures by providing
//! a high-level container object, the [Array](./struct.Array.html), that represents data stored on
//! a CPU, GPU, FPGA, or other type of accelerator. This abstraction permits developers to write
//! massively parallel applications in a high-level language where they need not be concerned about
//! low-level optimizations that are frequently required to achieve high throughput on most parallel
//! architectures.

//! This crate provides Rust bindings for the ArrayFire library. Given below table shows the rust
//! bindings compatability with ArrayFire upstream.  If you find any bugs, please report them on
//! [github](https://github.com/arrayfire/arrayfire-rust/issues).
//!
//! | arrayfire-rust crate | ArrayFire Upstream |
//! |:--------------------:|:------------------:|
//! |         M.m.p1       |      M.m.p2        |
//!
//! Only, Major(M) & Minor(m) version numbers need to match. *p1* and *p2* are patch/fix updates
//! for `arrayfire-rust` & `ArrayFire` respectively, and they don't need to match.
//!
//! Please go through our [tutorials](http://arrayfire.org/arrayfire-rust/book/index.html) book for
//! more explanations on how to use ArrayFire to speedup your code.

#![doc(
    html_logo_url = "https://www.arrayfire.com/logos/arrayfire_logo_symbol.png",
    html_favicon_url = "https://www.arrayfire.com/logos/arrayfire.ico",
    html_root_url = "https://arrayfire.org/arrayfire-rust/arrayfire/index.html"
)]
#![warn(missing_docs)]
#![allow(non_camel_case_types)]

#[macro_use]
extern crate lazy_static;

pub use crate::core::*;
mod core;

#[cfg(feature = "algorithm")]
pub use crate::algorithm::*;
#[cfg(feature = "algorithm")]
mod algorithm;

#[cfg(feature = "blas")]
pub use crate::blas::*;
#[cfg(feature = "blas")]
mod blas;

#[cfg(feature = "graphics")]
pub use crate::graphics::Window;
#[cfg(feature = "graphics")]
mod graphics;

#[cfg(feature = "image")]
pub use crate::image::*;
#[cfg(feature = "image")]
mod image;

#[cfg(feature = "lapack")]
pub use crate::lapack::*;
#[cfg(feature = "lapack")]
mod lapack;

#[cfg(feature = "ml")]
pub use crate::ml::*;
#[cfg(feature = "ml")]
mod ml;

#[cfg(feature = "signal")]
pub use crate::signal::*;
#[cfg(feature = "signal")]
mod signal;

#[cfg(feature = "sparse")]
pub use crate::sparse::*;
#[cfg(feature = "sparse")]
mod sparse;

#[cfg(feature = "statistics")]
pub use crate::statistics::*;
#[cfg(feature = "statistics")]
mod statistics;

#[cfg(feature = "vision")]
pub use crate::vision::*;
#[cfg(feature = "vision")]
mod vision;

// headers that are not exposed through rust wrapper are given follows:
// compatible.h
// constants.h
// complex.h
// cuda.h
// opencl.h