Prev Up Home Liboil Reference Manual Next

Simple Arithmetic

Simple Arithmetic — Aritmetic operations

Synopsis




void        oil_abs_f32_f32                 (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_abs_f64_f64                 (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_abs_u16_s16                 (uint16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_abs_u32_s32                 (uint32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_abs_u8_s8                   (uint8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_average2_u8                 (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr1,
                                             const uint8_t *s2,
                                             int sstr2,
                                             int n);
void        oil_multsum_f32                 (float *dest,
                                             const float *src1,
                                             int sstr1,
                                             const float *src2,
                                             int sstr2,
                                             int n);
void        oil_multsum_f64                 (double *dest,
                                             const double *src1,
                                             int sstr1,
                                             const double *src2,
                                             int sstr2,
                                             int n);
void        oil_scalaradd_f32               (float *d,
                                             int dstr,
                                             const float *s1,
                                             int sstr,
                                             const float *s2_1,
                                             int n);
void        oil_scalaradd_f64               (double *d,
                                             int dstr,
                                             const double *s1,
                                             int sstr,
                                             const double *s2_1,
                                             int n);
void        oil_scalaradd_s16               (int16_t *d,
                                             int dstr,
                                             const int16_t *s1,
                                             int sstr,
                                             const int16_t *s2_1,
                                             int n);
void        oil_scalaradd_s32               (int32_t *d,
                                             int dstr,
                                             const int32_t *s1,
                                             int sstr,
                                             const int32_t *s2_1,
                                             int n);
void        oil_scalaradd_s8                (int8_t *d,
                                             int dstr,
                                             const int8_t *s1,
                                             int sstr,
                                             const int8_t *s2_1,
                                             int n);
void        oil_scalaradd_u16               (uint16_t *d,
                                             int dstr,
                                             const uint16_t *s1,
                                             int sstr,
                                             const uint16_t *s2_1,
                                             int n);
void        oil_scalaradd_u32               (uint32_t *d,
                                             int dstr,
                                             const uint32_t *s1,
                                             int sstr,
                                             const uint32_t *s2_1,
                                             int n);
void        oil_scalaradd_u8                (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr,
                                             const uint8_t *s2_1,
                                             int n);
void        oil_scalarmult_f32              (float *d,
                                             int dstr,
                                             const float *s1,
                                             int sstr,
                                             const float *s2_1,
                                             int n);
void        oil_scalarmult_f64              (double *d,
                                             int dstr,
                                             const double *s1,
                                             int sstr,
                                             const double *s2_1,
                                             int n);
void        oil_scalarmult_s16              (int16_t *d,
                                             int dstr,
                                             const int16_t *s1,
                                             int sstr,
                                             const int16_t *s2_1,
                                             int n);
void        oil_scalarmult_s32              (int32_t *d,
                                             int dstr,
                                             const int32_t *s1,
                                             int sstr,
                                             const int32_t *s2_1,
                                             int n);
void        oil_scalarmult_s8               (int8_t *d,
                                             int dstr,
                                             const int8_t *s1,
                                             int sstr,
                                             const int8_t *s2_1,
                                             int n);
void        oil_scalarmult_u16              (uint16_t *d,
                                             int dstr,
                                             const uint16_t *s1,
                                             int sstr,
                                             const uint16_t *s2_1,
                                             int n);
void        oil_scalarmult_u32              (uint32_t *d,
                                             int dstr,
                                             const uint32_t *s1,
                                             int sstr,
                                             const uint32_t *s2_1,
                                             int n);
void        oil_scalarmult_u8               (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr,
                                             const uint8_t *s2_1,
                                             int n);
void        oil_vectoradd_f32               (float *d,
                                             int dstr,
                                             const float *s1,
                                             int sstr1,
                                             const float *s2,
                                             int sstr2,
                                             int n,
                                             const float *s3_1,
                                             const float *s4_1);
void        oil_vectoradd_f64               (double *d,
                                             int dstr,
                                             const double *s1,
                                             int sstr1,
                                             const double *s2,
                                             int sstr2,
                                             int n,
                                             const double *s3_1,
                                             const double *s4_1);
void        oil_vectoradd_s16               (int16_t *d,
                                             int dstr,
                                             const int16_t *s1,
                                             int sstr1,
                                             const int16_t *s2,
                                             int sstr2,
                                             int n,
                                             const int16_t *s3_1,
                                             const int16_t *s4_1);
void        oil_vectoradd_s32               (int32_t *d,
                                             int dstr,
                                             const int32_t *s1,
                                             int sstr1,
                                             const int32_t *s2,
                                             int sstr2,
                                             int n,
                                             const int32_t *s3_1,
                                             const int32_t *s4_1);
void        oil_vectoradd_s8                (int8_t *d,
                                             int dstr,
                                             const int8_t *s1,
                                             int sstr1,
                                             const int8_t *s2,
                                             int sstr2,
                                             int n,
                                             const int8_t *s3_1,
                                             const int8_t *s4_1);
void        oil_vectoradd_u16               (uint16_t *d,
                                             int dstr,
                                             const uint16_t *s1,
                                             int sstr1,
                                             const uint16_t *s2,
                                             int sstr2,
                                             int n,
                                             const uint16_t *s3_1,
                                             const uint16_t *s4_1);
void        oil_vectoradd_u32               (uint32_t *d,
                                             int dstr,
                                             const uint32_t *s1,
                                             int sstr1,
                                             const uint32_t *s2,
                                             int sstr2,
                                             int n,
                                             const uint32_t *s3_1,
                                             const uint32_t *s4_1);
void        oil_vectoradd_u8                (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr1,
                                             const uint8_t *s2,
                                             int sstr2,
                                             int n,
                                             const uint8_t *s3_1,
                                             const uint8_t *s4_1);
void        oil_vectoradd_s_s8              (int8_t *d,
                                             int dstr,
                                             const int8_t *s1,
                                             int sstr1,
                                             const int8_t *s2,
                                             int sstr2,
                                             int n);
void        oil_vectoradd_s_u8              (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr1,
                                             const uint8_t *s2,
                                             int sstr2,
                                             int n);
void        oil_vectoradd_s_s16             (int16_t *d,
                                             int dstr,
                                             const int16_t *s1,
                                             int sstr1,
                                             const int16_t *s2,
                                             int sstr2,
                                             int n);
void        oil_vectoradd_s_u16             (uint16_t *d,
                                             int dstr,
                                             const uint16_t *s1,
                                             int sstr1,
                                             const uint16_t *s2,
                                             int sstr2,
                                             int n);
void        oil_vectoradd_s_f32             (float *d,
                                             int dstr,
                                             const float *s1,
                                             int sstr1,
                                             const float *s2,
                                             int sstr2,
                                             int n);
void        oil_vectoradd_s_f64             (double *d,
                                             int dstr,
                                             const double *s1,
                                             int sstr1,
                                             const double *s2,
                                             int sstr2,
                                             int n);
void        oil_squaresum_f64               (double *d,
                                             const double *s,
                                             int n);
void        oil_sum_f64                     (double *d_1,
                                             const double *s,
                                             int sstr,
                                             int n);
void        oil_add_f32                     (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);
void        oil_divide_f32                  (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);
void        oil_floor_f32                   (float *d,
                                             const float *s,
                                             int n);
void        oil_inverse_f32                 (float *d,
                                             const float *s,
                                             int n);
void        oil_maximum_f32                 (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);
void        oil_minimum_f32                 (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);
void        oil_multiply_f32                (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);
void        oil_negative_f32                (float *d,
                                             const float *s,
                                             int n);
void        oil_scalaradd_f32_ns            (float *d,
                                             const float *s1,
                                             const float *s2_1,
                                             int n);
void        oil_scalarmultiply_f32_ns       (float *d,
                                             const float *s1,
                                             const float *s2_1,
                                             int n);
void        oil_sign_f32                    (float *d,
                                             const float *s,
                                             int n);
void        oil_subtract_f32                (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);

Description

Details

oil_abs_f32_f32 ()

void        oil_abs_f32_f32                 (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

Calculates the absolute value of each element in the source array and writes it into the destination array.

dest : destination array
dstr : stride of destination elements
src : source array
sstr : stride of source elements
n : number of elements in arrays

oil_abs_f64_f64 ()

void        oil_abs_f64_f64                 (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

Calculates the absolute value of each element in the source array and writes it into the destination array.

dest : destination array
dstr : stride of destination elements
src : source array
sstr : stride of source elements
n : number of elements in arrays

oil_abs_u16_s16 ()

void        oil_abs_u16_s16                 (uint16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

Calculates the absolute value of each element in the source array and writes it into the destination array.

dest : destination array
dstr : stride of destination elements
src : source array
sstr : stride of source elements
n : number of elements in arrays

oil_abs_u32_s32 ()

void        oil_abs_u32_s32                 (uint32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

Calculates the absolute value of each element in the source array and writes it into the destination array.

dest : destination array
dstr : stride of destination elements
src : source array
sstr : stride of source elements
n : number of elements in arrays

oil_abs_u8_s8 ()

void        oil_abs_u8_s8                   (uint8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

Calculates the absolute value of each element in the source array and writes it into the destination array.

dest : destination array
dstr : stride of destination elements
src : source array
sstr : stride of source elements
n : number of elements in arrays

oil_average2_u8 ()

void        oil_average2_u8                 (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr1,
                                             const uint8_t *s2,
                                             int sstr2,
                                             int n);

Averages each element in s1 and s2 and places the result in d.

FIXME: This class is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :

oil_multsum_f32 ()

void        oil_multsum_f32                 (float *dest,
                                             const float *src1,
                                             int sstr1,
                                             const float *src2,
                                             int sstr2,
                                             int n);

Multiplies each element in src1 and src2 and sums the results over the entire array, and places the sum into dest.

dest :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_multsum_f64 ()

void        oil_multsum_f64                 (double *dest,
                                             const double *src1,
                                             int sstr1,
                                             const double *src2,
                                             int sstr2,
                                             int n);

Multiplies each element in src1 and src2 and sums the results over the entire array, and places the sum into dest.

dest :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_scalaradd_f32 ()

void        oil_scalaradd_f32               (float *d,
                                             int dstr,
                                             const float *s1,
                                             int sstr,
                                             const float *s2_1,
                                             int n);

Adds the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalaradd_f64 ()

void        oil_scalaradd_f64               (double *d,
                                             int dstr,
                                             const double *s1,
                                             int sstr,
                                             const double *s2_1,
                                             int n);

Adds the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalaradd_s16 ()

void        oil_scalaradd_s16               (int16_t *d,
                                             int dstr,
                                             const int16_t *s1,
                                             int sstr,
                                             const int16_t *s2_1,
                                             int n);

Adds the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalaradd_s32 ()

void        oil_scalaradd_s32               (int32_t *d,
                                             int dstr,
                                             const int32_t *s1,
                                             int sstr,
                                             const int32_t *s2_1,
                                             int n);

Adds the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalaradd_s8 ()

void        oil_scalaradd_s8                (int8_t *d,
                                             int dstr,
                                             const int8_t *s1,
                                             int sstr,
                                             const int8_t *s2_1,
                                             int n);

Adds the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalaradd_u16 ()

void        oil_scalaradd_u16               (uint16_t *d,
                                             int dstr,
                                             const uint16_t *s1,
                                             int sstr,
                                             const uint16_t *s2_1,
                                             int n);

Adds the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalaradd_u32 ()

void        oil_scalaradd_u32               (uint32_t *d,
                                             int dstr,
                                             const uint32_t *s1,
                                             int sstr,
                                             const uint32_t *s2_1,
                                             int n);

Adds the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalaradd_u8 ()

void        oil_scalaradd_u8                (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr,
                                             const uint8_t *s2_1,
                                             int n);

Adds the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalarmult_f32 ()

void        oil_scalarmult_f32              (float *d,
                                             int dstr,
                                             const float *s1,
                                             int sstr,
                                             const float *s2_1,
                                             int n);

Multiplies the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalarmult_f64 ()

void        oil_scalarmult_f64              (double *d,
                                             int dstr,
                                             const double *s1,
                                             int sstr,
                                             const double *s2_1,
                                             int n);

Multiplies the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalarmult_s16 ()

void        oil_scalarmult_s16              (int16_t *d,
                                             int dstr,
                                             const int16_t *s1,
                                             int sstr,
                                             const int16_t *s2_1,
                                             int n);

Multiplies the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalarmult_s32 ()

void        oil_scalarmult_s32              (int32_t *d,
                                             int dstr,
                                             const int32_t *s1,
                                             int sstr,
                                             const int32_t *s2_1,
                                             int n);

Multiplies the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalarmult_s8 ()

void        oil_scalarmult_s8               (int8_t *d,
                                             int dstr,
                                             const int8_t *s1,
                                             int sstr,
                                             const int8_t *s2_1,
                                             int n);

Multiplies the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalarmult_u16 ()

void        oil_scalarmult_u16              (uint16_t *d,
                                             int dstr,
                                             const uint16_t *s1,
                                             int sstr,
                                             const uint16_t *s2_1,
                                             int n);

Multiplies the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalarmult_u32 ()

void        oil_scalarmult_u32              (uint32_t *d,
                                             int dstr,
                                             const uint32_t *s1,
                                             int sstr,
                                             const uint32_t *s2_1,
                                             int n);

Multiplies the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_scalarmult_u8 ()

void        oil_scalarmult_u8               (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr,
                                             const uint8_t *s2_1,
                                             int n);

Multiplies the constant value s2_1 to each value in s1 and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr :
s2_1 :
n :

oil_vectoradd_f32 ()

void        oil_vectoradd_f32               (float *d,
                                             int dstr,
                                             const float *s1,
                                             int sstr1,
                                             const float *s2,
                                             int sstr2,
                                             int n,
                                             const float *s3_1,
                                             const float *s4_1);

Multiplies the constant s3_1 with each element of s1 and multiplies the constant s4_1 with each element of s2 and adds the two results together and places the final result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_f64 ()

void        oil_vectoradd_f64               (double *d,
                                             int dstr,
                                             const double *s1,
                                             int sstr1,
                                             const double *s2,
                                             int sstr2,
                                             int n,
                                             const double *s3_1,
                                             const double *s4_1);

Multiplies the constant s3_1 with each element of s1 and multiplies the constant s4_1 with each element of s2 and adds the two results together and places the final result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_s16 ()

void        oil_vectoradd_s16               (int16_t *d,
                                             int dstr,
                                             const int16_t *s1,
                                             int sstr1,
                                             const int16_t *s2,
                                             int sstr2,
                                             int n,
                                             const int16_t *s3_1,
                                             const int16_t *s4_1);

Multiplies the constant s3_1 with each element of s1 and multiplies the constant s4_1 with each element of s2 and adds the two results together and places the final result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_s32 ()

void        oil_vectoradd_s32               (int32_t *d,
                                             int dstr,
                                             const int32_t *s1,
                                             int sstr1,
                                             const int32_t *s2,
                                             int sstr2,
                                             int n,
                                             const int32_t *s3_1,
                                             const int32_t *s4_1);

Multiplies the constant s3_1 with each element of s1 and multiplies the constant s4_1 with each element of s2 and adds the two results together and places the final result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_s8 ()

void        oil_vectoradd_s8                (int8_t *d,
                                             int dstr,
                                             const int8_t *s1,
                                             int sstr1,
                                             const int8_t *s2,
                                             int sstr2,
                                             int n,
                                             const int8_t *s3_1,
                                             const int8_t *s4_1);

Multiplies the constant s3_1 with each element of s1 and multiplies the constant s4_1 with each element of s2 and adds the two results together and places the final result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_u16 ()

void        oil_vectoradd_u16               (uint16_t *d,
                                             int dstr,
                                             const uint16_t *s1,
                                             int sstr1,
                                             const uint16_t *s2,
                                             int sstr2,
                                             int n,
                                             const uint16_t *s3_1,
                                             const uint16_t *s4_1);

Multiplies the constant s3_1 with each element of s1 and multiplies the constant s4_1 with each element of s2 and adds the two results together and places the final result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_u32 ()

void        oil_vectoradd_u32               (uint32_t *d,
                                             int dstr,
                                             const uint32_t *s1,
                                             int sstr1,
                                             const uint32_t *s2,
                                             int sstr2,
                                             int n,
                                             const uint32_t *s3_1,
                                             const uint32_t *s4_1);

Multiplies the constant s3_1 with each element of s1 and multiplies the constant s4_1 with each element of s2 and adds the two results together and places the final result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_u8 ()

void        oil_vectoradd_u8                (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr1,
                                             const uint8_t *s2,
                                             int sstr2,
                                             int n,
                                             const uint8_t *s3_1,
                                             const uint8_t *s4_1);

Multiplies the constant s3_1 with each element of s1 and multiplies the constant s4_1 with each element of s2 and adds the two results together and places the final result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_s_s8 ()

void        oil_vectoradd_s_s8              (int8_t *d,
                                             int dstr,
                                             const int8_t *s1,
                                             int sstr1,
                                             const int8_t *s2,
                                             int sstr2,
                                             int n);

Adds each element of s1 to s2 and clamps the result to the range of the type and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :

oil_vectoradd_s_u8 ()

void        oil_vectoradd_s_u8              (uint8_t *d,
                                             int dstr,
                                             const uint8_t *s1,
                                             int sstr1,
                                             const uint8_t *s2,
                                             int sstr2,
                                             int n);

Adds each element of s1 to s2 and clamps the result to the range of the type and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :

oil_vectoradd_s_s16 ()

void        oil_vectoradd_s_s16             (int16_t *d,
                                             int dstr,
                                             const int16_t *s1,
                                             int sstr1,
                                             const int16_t *s2,
                                             int sstr2,
                                             int n);

Adds each element of s1 to s2 and clamps the result to the range of the type and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :

oil_vectoradd_s_u16 ()

void        oil_vectoradd_s_u16             (uint16_t *d,
                                             int dstr,
                                             const uint16_t *s1,
                                             int sstr1,
                                             const uint16_t *s2,
                                             int sstr2,
                                             int n);

Adds each element of s1 to s2 and clamps the result to the range of the type and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :

oil_vectoradd_s_f32 ()

void        oil_vectoradd_s_f32             (float *d,
                                             int dstr,
                                             const float *s1,
                                             int sstr1,
                                             const float *s2,
                                             int sstr2,
                                             int n);

Adds each element of s1 to s2 and clamps the result to the range [-1,1] and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :

oil_vectoradd_s_f64 ()

void        oil_vectoradd_s_f64             (double *d,
                                             int dstr,
                                             const double *s1,
                                             int sstr1,
                                             const double *s2,
                                             int sstr2,
                                             int n);

Adds each element of s1 to s2 and clamps the result to the range [-1,1] and places the result in d.

FIXME: This function is difficult to optimize and will likely be replaced.

d :
dstr :
s1 :
sstr1 :
s2 :
sstr2 :
n :

oil_squaresum_f64 ()

void        oil_squaresum_f64               (double *d,
                                             const double *s,
                                             int n);

Sums the square of each element in s and places the result in dest.

d :
s :
n :

oil_sum_f64 ()

void        oil_sum_f64                     (double *d_1,
                                             const double *s,
                                             int sstr,
                                             int n);

Sums the elements in the source array and places the result in d.

d_1 : destination
s : source array
sstr : stride of source elements
n : number of elements

oil_add_f32 ()

void        oil_add_f32                     (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);

Adds elements in s2 and s1 and places the result in d.

d : destination
s1 : source 1
s2 : source 2
n : number of elements

oil_divide_f32 ()

void        oil_divide_f32                  (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);

Divides elements in s1 by s2 and places the result in d.

d : destination
s1 : source 1
s2 : source 2
n : number of elements

oil_floor_f32 ()

void        oil_floor_f32                   (float *d,
                                             const float *s,
                                             int n);

Calculates the greatest integer less than or equal to each element in s and places the result in d.

d : destination
s : source
n : number of elements

oil_inverse_f32 ()

void        oil_inverse_f32                 (float *d,
                                             const float *s,
                                             int n);

Calculates the multiplicative inverse of each element in s and places the result in d.

d : destination
s : source
n : number of elements

oil_maximum_f32 ()

void        oil_maximum_f32                 (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);

Places the greater of s1 and s2 in d.

d : destination
s1 : source 1
s2 : source 2
n : number of elements

oil_minimum_f32 ()

void        oil_minimum_f32                 (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);

Places the lesser of s1 and s2 in d.

d : destination
s1 : source 1
s2 : source 2
n : number of elements

oil_multiply_f32 ()

void        oil_multiply_f32                (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);

Multiplies elements in s1 and s2 and places the result in d.

d : destination
s1 : source 1
s2 : source 2
n : number of elements

oil_negative_f32 ()

void        oil_negative_f32                (float *d,
                                             const float *s,
                                             int n);

Negates each element in s and places the result in d.

d : destination
s : source
n : number of elements

oil_scalaradd_f32_ns ()

void        oil_scalaradd_f32_ns            (float *d,
                                             const float *s1,
                                             const float *s2_1,
                                             int n);

Adds the constant value s2_1 to each source element and places the result in d.

d : destination
s1 : source
s2_1 : source
n : number of elements

oil_scalarmultiply_f32_ns ()

void        oil_scalarmultiply_f32_ns       (float *d,
                                             const float *s1,
                                             const float *s2_1,
                                             int n);

Multiplies the constant value s2_1 and each source element and places the result in d.

d : destination
s1 : source
s2_1 : source
n : number of elements

oil_sign_f32 ()

void        oil_sign_f32                    (float *d,
                                             const float *s,
                                             int n);

Calculates the sign of each element in s and places the result in d.

d : destination
s : source
n : number of elements

oil_subtract_f32 ()

void        oil_subtract_f32                (float *d,
                                             const float *s1,
                                             const float *s2,
                                             int n);

Subtracts elements in s2 from s1 and places the result in d.

d : destination
s1 : source 1
s2 : source 2
n : number of elements
<< Copying Simple Arithmetic on Blocks >>