ghostflow-ffi 1.0.0

C FFI bindings for GhostFlow ML framework
Documentation 
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#ifndef GHOSTFLOW_H
#define GHOSTFLOW_H

#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

/**
 * Error codes
 */
typedef enum GhostFlowError {
  Success = 0,
  InvalidShape = 1,
  InvalidData = 2,
  NullPointer = 3,
  AllocationFailed = 4,
  ComputationFailed = 5,
  Unknown = 99,
} GhostFlowError;

/**
 * Opaque handle to a GhostFlow tensor
 */
typedef struct GhostFlowTensor {
  uint8_t _private[0];
} GhostFlowTensor;

/**
 * Initialize GhostFlow library
 */
enum GhostFlowError ghostflow_init(void);

/**
 * Get GhostFlow version string
 */
const char *ghostflow_version(void);

/**
 * Free a version string
 */
void ghostflow_free_string(char *s);

/**
 * Create a new tensor from data
 *
 * # Arguments
 * * `data` - Pointer to float array
 * * `data_len` - Length of data array
 * * `shape` - Pointer to shape array
 * * `shape_len` - Length of shape array
 * * `out` - Output pointer to store the created tensor
 *
 * # Returns
 * Error code
 */
enum GhostFlowError ghostflow_tensor_create(const float *data,
                                            uintptr_t data_len,
                                            const uintptr_t *shape,
                                            uintptr_t shape_len,
                                            struct GhostFlowTensor **out);

/**
 * Create a tensor filled with zeros
 */
enum GhostFlowError ghostflow_tensor_zeros(const uintptr_t *shape,
                                           uintptr_t shape_len,
                                           struct GhostFlowTensor **out);

/**
 * Create a tensor filled with ones
 */
enum GhostFlowError ghostflow_tensor_ones(const uintptr_t *shape,
                                          uintptr_t shape_len,
                                          struct GhostFlowTensor **out);

/**
 * Free a tensor
 */
void ghostflow_tensor_free(struct GhostFlowTensor *tensor);

/**
 * Get tensor shape
 */
enum GhostFlowError ghostflow_tensor_shape(const struct GhostFlowTensor *tensor,
                                           uintptr_t *out_shape,
                                           uintptr_t *out_ndim);

/**
 * Get tensor data
 */
enum GhostFlowError ghostflow_tensor_data(const struct GhostFlowTensor *tensor,
                                          float *out_data,
                                          uintptr_t *out_len);

/**
 * Add two tensors
 */
enum GhostFlowError ghostflow_tensor_add(const struct GhostFlowTensor *a,
                                         const struct GhostFlowTensor *b,
                                         struct GhostFlowTensor **out);

/**
 * Multiply two tensors element-wise
 */
enum GhostFlowError ghostflow_tensor_mul(const struct GhostFlowTensor *a,
                                         const struct GhostFlowTensor *b,
                                         struct GhostFlowTensor **out);

/**
 * Matrix multiplication
 */
enum GhostFlowError ghostflow_tensor_matmul(const struct GhostFlowTensor *a,
                                            const struct GhostFlowTensor *b,
                                            struct GhostFlowTensor **out);

/**
 * Reshape a tensor
 */
enum GhostFlowError ghostflow_tensor_reshape(const struct GhostFlowTensor *tensor,
                                             const uintptr_t *new_shape,
                                             uintptr_t new_shape_len,
                                             struct GhostFlowTensor **out);

/**
 * Get last error message
 */
const char *ghostflow_get_last_error(void);

#endif /* GHOSTFLOW_H */