#pragma once

//

// GGML Tensor Library

//

// This documentation is still a work in progress.

// If you wish some specific topics to be covered, feel free to drop a comment:

//

// https://github.com/ggerganov/whisper.cpp/issues/40

//

// ## Overview

//

// This library implements:

//

// - a set of tensor operations

// - automatic differentiation

// - basic optimization algorithms

//

// The aim of this library is to provide a minimalistic approach for various machine learning tasks. This includes,

// but is not limited to, the following:

//

// - linear regression

// - support vector machines

// - neural networks

//

// The library allows the user to define a certain function using the available tensor operations. This function

// definition is represented internally via a computation graph. Each tensor operation in the function definition

// corresponds to a node in the graph. Having the computation graph defined, the user can choose to compute the

// function's value and/or its gradient with respect to the input variables. Optionally, the function can be optimized

// using one of the available optimization algorithms.

//

// For example, here we define the function: f(x) = a*x^2 + b

//

// {

// struct ggml_init_params params = {

// .mem_size = 16*1024*1024,

// .mem_buffer = NULL,

// };

//

// // memory allocation happens here

// struct ggml_context * ctx = ggml_init(params);

//

// struct ggml_tensor * x = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);

//

// ggml_set_param(ctx, x); // x is an input variable

//

// struct ggml_tensor * a = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);

// struct ggml_tensor * b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);

// struct ggml_tensor * x2 = ggml_mul(ctx, x, x);

// struct ggml_tensor * f = ggml_add(ctx, ggml_mul(ctx, a, x2), b);

//

// ...

// }

//

// Notice that the function definition above does not involve any actual computation. The computation is performed only

// when the user explicitly requests it. For example, to compute the function's value at x = 2.0:

//

// {

// ...

//

// struct ggml_cgraph * gf = ggml_new_graph(ctx);

// ggml_build_forward_expand(gf, f);

//

// // set the input variable and parameter values

// ggml_set_f32(x, 2.0f);

// ggml_set_f32(a, 3.0f);

// ggml_set_f32(b, 4.0f);

//

// ggml_graph_compute_with_ctx(ctx, &gf, n_threads);

//

// printf("f = %f\n", ggml_get_f32_1d(f, 0));

//

// ...

// }

//

// The actual computation is performed in the ggml_graph_compute() function.

//

// The ggml_new_tensor_...() functions create new tensors. They are allocated in the memory buffer provided to the

// ggml_init() function. You have to be careful not to exceed the memory buffer size. Therefore, you have to know

// in advance how much memory you need for your computation. Alternatively, you can allocate a large enough memory

// and after defining the computation graph, call the ggml_used_mem() function to find out how much memory was

// actually needed.

//

// The ggml_set_param() function marks a tensor as an input variable. This is used by the automatic

// differentiation and optimization algorithms.

//

// The described approach allows to define the function graph once and then compute its forward or backward graphs

// multiple times. All computations will use the same memory buffer allocated in the ggml_init() function. This way

// the user can avoid the memory allocation overhead at runtime.

//

// The library supports multi-dimensional tensors - up to 4 dimensions. The FP16 and FP32 data types are first class

// citizens, but in theory the library can be extended to support FP8 and integer data types.

//

// Each tensor operation produces a new tensor. Initially the library was envisioned to support only the use of unary

// and binary operations. Most of the available operations fall into one of these two categories. With time, it became

// clear that the library needs to support more complex operations. The way to support these operations is not clear

// yet, but a few examples are demonstrated in the following operations:

//

// - ggml_permute()

// - ggml_conv_1d_1s()

// - ggml_conv_1d_2s()

//

// For each tensor operator, the library implements a forward and backward computation function. The forward function

// computes the output tensor value given the input tensor values. The backward function computes the adjoint of the

// input tensors given the adjoint of the output tensor. For a detailed explanation of what this means, take a

// calculus class, or watch the following video:

//

// What is Automatic Differentiation?

// https://www.youtube.com/watch?v=wG_nF1awSSY

//

//

// ## Tensor data (struct ggml_tensor)

//

// The tensors are stored in memory via the ggml_tensor struct. The structure provides information about the size of

// the tensor, the data type, and the memory buffer where the tensor data is stored. Additionally, it contains

// pointers to the "source" tensors - i.e. the tensors that were used to compute the current tensor. For example:

//

// {

// struct ggml_tensor * c = ggml_add(ctx, a, b);

//

// assert(c->src[0] == a);

// assert(c->src[1] == b);

// }

//

// The multi-dimensional tensors are stored in row-major order. The ggml_tensor struct contains fields for the

// number of elements in each dimension ("ne") as well as the number of bytes ("nb", a.k.a. stride). This allows

// to store tensors that are not contiguous in memory, which is useful for operations such as transposition and

// permutation. All tensor operations have to take the stride into account and not assume that the tensor is

// contiguous in memory.

//

// The data of the tensor is accessed via the "data" pointer. For example:

//

// {

// const int nx = 2;

// const int ny = 3;

//

// struct ggml_tensor * a = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, nx, ny);

//

// for (int y = 0; y < ny; y++) {

// for (int x = 0; x < nx; x++) {

// *(float *) ((char *) a->data + y*a->nb[1] + x*a->nb[0]) = x + y;

// }

// }

//

// ...

// }

//

// Alternatively, there are helper functions, such as ggml_get_f32_1d() and ggml_set_f32_1d() that can be used.

//

// ## The matrix multiplication operator (ggml_mul_mat)

//

// TODO

//

//

// ## Multi-threading

//

// TODO

//

//

// ## Overview of ggml.c

//

// TODO

//

//

// ## SIMD optimizations

//

// TODO

//

//

// ## Debugging ggml

//

// TODO

//

//

#ifdef GGML_SHARED

# if defined(_WIN32) && !defined(__MINGW32__)

# ifdef GGML_BUILD

# define GGML_API __declspec(dllexport)

# else

# define GGML_API __declspec(dllimport)

# endif

# else

# define GGML_API __attribute__ ((visibility ("default")))

# endif

#else

# define GGML_API

#endif

// TODO: support for clang

#ifdef __GNUC__

# define GGML_DEPRECATED(func, hint) func __attribute__((deprecated(hint)))

#elif defined(_MSC_VER)

# define GGML_DEPRECATED(func, hint) __declspec(deprecated(hint)) func

#else

# define GGML_DEPRECATED(func, hint) func

#endif

#ifndef __GNUC__

# define GGML_ATTRIBUTE_FORMAT(...)

#elif defined(__MINGW32__)

# define GGML_ATTRIBUTE_FORMAT(...) __attribute__((format(gnu_printf, __VA_ARGS__)))

#else

# define GGML_ATTRIBUTE_FORMAT(...) __attribute__((format(printf, __VA_ARGS__)))

#endif

#include <stdint.h>

#include <stddef.h>

#include <stdbool.h>

#define GGML_FILE_MAGIC 0x67676d6c // "ggml"

#define GGML_FILE_VERSION 1

#define GGML_QNT_VERSION 2 // bump this on quantization format changes

#define GGML_QNT_VERSION_FACTOR 1000 // do not change this

#define GGML_MAX_DIMS 4

#define GGML_MAX_PARAMS 2048

#define GGML_MAX_CONTEXTS 64

#define GGML_MAX_SRC 10

#define GGML_MAX_NAME 64

#define GGML_MAX_OP_PARAMS 64

#define GGML_DEFAULT_N_THREADS 4

#define GGML_DEFAULT_GRAPH_SIZE 2048

#if UINTPTR_MAX == 0xFFFFFFFF

#define GGML_MEM_ALIGN 4

#else

#define GGML_MEM_ALIGN 16

#endif

#define GGML_EXIT_SUCCESS 0

#define GGML_EXIT_ABORTED 1

#define GGUF_MAGIC "GGUF"

#define GGUF_VERSION 3

#define GGUF_DEFAULT_ALIGNMENT 32

#define GGML_UNUSED(x) (void)(x)

#define GGML_PAD(x, n) (((x) + (n) - 1) & ~((n) - 1))

#define GGML_ASSERT(x) \

do { \

if (!(x)) { \

fflush(stdout); \

fprintf(stderr, "GGML_ASSERT: %s:%d: %s\n", __FILE__, __LINE__, #x); \

ggml_print_backtrace(); \

abort(); \

} \

} while (0)

#ifndef NDEBUG

#define GGML_UNREACHABLE() GGML_ASSERT(!"statement should not be reached")

#elif defined(__GNUC__)

#define GGML_UNREACHABLE() __builtin_unreachable()

#else

#define GGML_UNREACHABLE() ((void) 0)

#endif

// used to copy the number of elements and stride in bytes of tensors into local variables.

// main purpose is to reduce code duplication and improve readability.

//

// example:

//

// GGML_TENSOR_LOCALS(int64_t, ne1, src1, ne);

// GGML_TENSOR_LOCALS(size_t, nb1, src1, nb);

//

#define GGML_TENSOR_LOCALS_1(type, prefix, pointer, array) \

const type prefix##0 = (pointer)->array[0]; \

GGML_UNUSED(prefix##0);

#define GGML_TENSOR_LOCALS_2(type, prefix, pointer, array) \

GGML_TENSOR_LOCALS_1 (type, prefix, pointer, array) \

const type prefix##1 = (pointer)->array[1]; \

GGML_UNUSED(prefix##1);

#define GGML_TENSOR_LOCALS_3(type, prefix, pointer, array) \

GGML_TENSOR_LOCALS_2 (type, prefix, pointer, array) \

const type prefix##2 = (pointer)->array[2]; \

GGML_UNUSED(prefix##2);

#define GGML_TENSOR_LOCALS(type, prefix, pointer, array) \

GGML_TENSOR_LOCALS_3 (type, prefix, pointer, array) \

const type prefix##3 = (pointer)->array[3]; \

GGML_UNUSED(prefix##3);

#define GGML_TENSOR_UNARY_OP_LOCALS \

#define GGML_TENSOR_BINARY_OP_LOCALS \

#ifdef __cplusplus

extern "C" {

#endif

#if defined(__ARM_NEON) && defined(__CUDACC__)

typedef half ggml_fp16_t;

#elif defined(__ARM_NEON) && !defined(_MSC_VER)

typedef __fp16 ggml_fp16_t;

#else

typedef uint16_t ggml_fp16_t;

#endif

// convert FP16 <-> FP32

GGML_API float ggml_fp16_to_fp32(ggml_fp16_t x);

GGML_API ggml_fp16_t ggml_fp32_to_fp16(float x);

GGML_API void ggml_fp16_to_fp32_row(const ggml_fp16_t * x, float * y, int n);

GGML_API void ggml_fp32_to_fp16_row(const float * x, ggml_fp16_t * y, int n);

struct ggml_object;

struct ggml_context;

enum ggml_type {

};

// precision

enum ggml_prec {

GGML_PREC_DEFAULT,

GGML_PREC_F32,

};

enum ggml_backend_type {

};

// model file types

enum ggml_ftype {

};

// available tensor operations:

enum ggml_op {

};

enum ggml_unary_op {

};

enum ggml_object_type {

};

enum ggml_log_level {

};

// ggml object

struct ggml_object {

};

static const size_t GGML_OBJECT_SIZE = sizeof(struct ggml_object);

// n-dimensional tensor

struct ggml_tensor {

};

static const size_t GGML_TENSOR_SIZE = sizeof(struct ggml_tensor);

// the compute plan that needs to be prepared for ggml_graph_compute()

// since https://github.com/ggerganov/ggml/issues/287

struct ggml_cplan {

};

enum ggml_cgraph_eval_order {

};

struct ggml_hash_set {

size_t size;

struct ggml_tensor ** keys;

};

// computation graph

struct ggml_cgraph {

};

// scratch buffer

struct ggml_scratch {

};

struct ggml_init_params {

};

// compute types

// NOTE: the INIT or FINALIZE pass is not scheduled unless explicitly enabled.

// This behavior was changed since https://github.com/ggerganov/llama.cpp/pull/1995.

enum ggml_task_type {

};

struct ggml_compute_params {

};

// misc

GGML_API void ggml_time_init(void); // call this once at the beginning of the program

GGML_API int64_t ggml_time_ms(void);

GGML_API int64_t ggml_time_us(void);

GGML_API int64_t ggml_cycles(void);

GGML_API int64_t ggml_cycles_per_ms(void);

GGML_API void ggml_print_backtrace(void);

GGML_API void ggml_numa_init(void); // call once for better performance on NUMA systems

GGML_API bool ggml_is_numa(void); // true if init detected that system has >1 NUMA node

GGML_API void ggml_print_object (const struct ggml_object * obj);

GGML_API void ggml_print_objects(const struct ggml_context * ctx);

GGML_API int64_t ggml_nelements (const struct ggml_tensor * tensor);

GGML_API int64_t ggml_nrows (const struct ggml_tensor * tensor);

GGML_API size_t ggml_nbytes (const struct ggml_tensor * tensor);

GGML_API size_t ggml_nbytes_pad (const struct ggml_tensor * tensor); // same as ggml_nbytes() but padded to GGML_MEM_ALIGN

GGML_API int ggml_blck_size(enum ggml_type type);

GGML_API size_t ggml_type_size(enum ggml_type type); // size in bytes for all elements in a block

GGML_API size_t ggml_row_size (enum ggml_type type, int64_t ne); // size in bytes for all elements in a row

GGML_DEPRECATED(

GGML_API double ggml_type_sizef(enum ggml_type type), // ggml_type_size()/ggml_blck_size() as float

"use ggml_row_size() instead");

GGML_API const char * ggml_type_name(enum ggml_type type);

GGML_API const char * ggml_op_name (enum ggml_op op);

GGML_API const char * ggml_op_symbol(enum ggml_op op);

GGML_API const char * ggml_unary_op_name(enum ggml_unary_op op);

GGML_API const char * ggml_op_desc(const struct ggml_tensor * t); // unary or op name

GGML_API size_t ggml_element_size(const struct ggml_tensor * tensor);

GGML_API bool ggml_is_quantized(enum ggml_type type);

// TODO: temporary until model loading of ggml examples is refactored

GGML_API enum ggml_type ggml_ftype_to_ggml_type(enum ggml_ftype ftype);

GGML_API bool ggml_is_transposed(const struct ggml_tensor * tensor);

GGML_API bool ggml_is_contiguous(const struct ggml_tensor * tensor);

GGML_API bool ggml_is_permuted (const struct ggml_tensor * tensor);

GGML_API bool ggml_is_scalar (const struct ggml_tensor * tensor);

GGML_API bool ggml_is_vector (const struct ggml_tensor * tensor);

GGML_API bool ggml_is_matrix (const struct ggml_tensor * tensor);

GGML_API bool ggml_is_3d (const struct ggml_tensor * tensor);

GGML_API int ggml_n_dims (const struct ggml_tensor * tensor); // returns 1 for scalars

GGML_API bool ggml_are_same_shape(const struct ggml_tensor * t0, const struct ggml_tensor * t1);

// use this to compute the memory overhead of a tensor

GGML_API size_t ggml_tensor_overhead(void);

// main

GGML_API struct ggml_context * ggml_init(struct ggml_init_params params);

GGML_API void ggml_free(struct ggml_context * ctx);

GGML_API size_t ggml_used_mem(const struct ggml_context * ctx);

GGML_API size_t ggml_set_scratch (struct ggml_context * ctx, struct ggml_scratch scratch);

GGML_API bool ggml_get_no_alloc(struct ggml_context * ctx);

GGML_API void ggml_set_no_alloc(struct ggml_context * ctx, bool no_alloc);

GGML_API void * ggml_get_mem_buffer (const struct ggml_context * ctx);

GGML_API size_t ggml_get_mem_size (const struct ggml_context * ctx);

GGML_API size_t ggml_get_max_tensor_size(const struct ggml_context * ctx);

GGML_API struct ggml_tensor * ggml_new_tensor(

const int64_t *ne);

GGML_API struct ggml_tensor * ggml_new_tensor_1d(

struct ggml_context * ctx,

enum ggml_type type,

int64_t ne0);

GGML_API struct ggml_tensor * ggml_new_tensor_2d(

int64_t ne1);

GGML_API struct ggml_tensor * ggml_new_tensor_3d(

int64_t ne2);

GGML_API struct ggml_tensor * ggml_new_tensor_4d(

int64_t ne3);

GGML_API struct ggml_tensor * ggml_new_i32(struct ggml_context * ctx, int32_t value);

GGML_API struct ggml_tensor * ggml_new_f32(struct ggml_context * ctx, float value);

GGML_API struct ggml_tensor * ggml_dup_tensor (struct ggml_context * ctx, const struct ggml_tensor * src);

GGML_API struct ggml_tensor * ggml_view_tensor(struct ggml_context * ctx, struct ggml_tensor * src);

// Context tensor enumeration and lookup

GGML_API struct ggml_tensor * ggml_get_first_tensor(struct ggml_context * ctx);

GGML_API struct ggml_tensor * ggml_get_next_tensor (struct ggml_context * ctx, struct ggml_tensor * tensor);

GGML_API struct ggml_tensor * ggml_get_tensor(struct ggml_context * ctx, const char * name);

GGML_API struct ggml_tensor * ggml_set_zero(struct ggml_tensor * tensor);

GGML_API struct ggml_tensor * ggml_set_i32 (struct ggml_tensor * tensor, int32_t value);

GGML_API struct ggml_tensor * ggml_set_f32 (struct ggml_tensor * tensor, float value);

// Converts a flat index into coordinates

GGML_API void ggml_unravel_index(const struct ggml_tensor * tensor, int64_t i, int64_t * i0, int64_t * i1, int64_t * i2, int64_t * i3);

GGML_API int32_t ggml_get_i32_1d(const struct ggml_tensor * tensor, int i);

GGML_API void ggml_set_i32_1d(const struct ggml_tensor * tensor, int i, int32_t value);

GGML_API int32_t ggml_get_i32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3);

GGML_API void ggml_set_i32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3, int32_t value);

GGML_API float ggml_get_f32_1d(const struct ggml_tensor * tensor, int i);

GGML_API void ggml_set_f32_1d(const struct ggml_tensor * tensor, int i, float value);

GGML_API float ggml_get_f32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3);

GGML_API void ggml_set_f32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3, float value);

GGML_API void * ggml_get_data (const struct ggml_tensor * tensor);

GGML_API float * ggml_get_data_f32(const struct ggml_tensor * tensor);

GGML_API enum ggml_unary_op ggml_get_unary_op(const struct ggml_tensor * tensor);

GGML_API const char * ggml_get_name (const struct ggml_tensor * tensor);

GGML_API struct ggml_tensor * ggml_set_name ( struct ggml_tensor * tensor, const char * name);

GGML_ATTRIBUTE_FORMAT(2, 3)

GGML_API struct ggml_tensor * ggml_format_name( struct ggml_tensor * tensor, const char * fmt, ...);

//

// operations on tensors with backpropagation

//

GGML_API struct ggml_tensor * ggml_dup(

struct ggml_context * ctx,

struct ggml_tensor * a);

// in-place, returns view(a)

GGML_API struct ggml_tensor * ggml_dup_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_add(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_add_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_add_cast(

enum ggml_type type);

GGML_API struct ggml_tensor * ggml_add1(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_add1_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

// dst = a

// view(dst, nb1, nb2, nb3, offset) += b

// return dst

GGML_API struct ggml_tensor * ggml_acc(

size_t offset);

GGML_API struct ggml_tensor * ggml_acc_inplace(

size_t offset);

GGML_API struct ggml_tensor * ggml_sub(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_sub_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_mul(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_mul_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_div(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_div_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_sqr(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sqr_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sqrt(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sqrt_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_log(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_log_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

// return scalar

GGML_API struct ggml_tensor * ggml_sum(

struct ggml_context * ctx,

struct ggml_tensor * a);

// sums along rows, with input shape [a,b,c,d] return shape [1,b,c,d]

GGML_API struct ggml_tensor * ggml_sum_rows(

struct ggml_context * ctx,

struct ggml_tensor * a);

// mean along rows

GGML_API struct ggml_tensor * ggml_mean(

struct ggml_context * ctx,

struct ggml_tensor * a);

// argmax along rows

GGML_API struct ggml_tensor * ggml_argmax(

struct ggml_context * ctx,

struct ggml_tensor * a);

// if a is the same shape as b, and a is not parameter, return a

// otherwise, return a new tensor: repeat(a) to fit in b

GGML_API struct ggml_tensor * ggml_repeat(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

// sums repetitions in a into shape of b

GGML_API struct ggml_tensor * ggml_repeat_back(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

// concat a and b on dim 2

// used in stable-diffusion

GGML_API struct ggml_tensor * ggml_concat(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_abs(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_abs_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sgn(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sgn_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_neg(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_neg_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_step(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_step_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_tanh(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_tanh_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_elu(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_elu_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_relu(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_leaky_relu(

struct ggml_context * ctx,

struct ggml_tensor * a, float negative_slope, bool inplace);

GGML_API struct ggml_tensor * ggml_relu_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_gelu(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_gelu_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_gelu_quick(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_gelu_quick_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);