Big News: Socket raises $60M Series C at a $1B valuation to secure software supply chains for AI-driven development.Announcement →
Sign In

@stdlib/strided-base-binary

Package Overview
Dependencies
Maintainers
4
Versions
13
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@stdlib/strided-base-binary - npm Package Compare versions

Comparing version
0.0.1
 to
0.0.2
+88
include/stdlib/strided/base/binary.h
/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Header file containing function declarations for strided array functions which apply a binary callback.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_H
#define STDLIB_STRIDED_BASE_BINARY_H
#include "binary/macros.h"
#include "binary/typedefs.h"
// Note: keep in alphabetical order...
#include "binary/bb_b.h"
#include "binary/bb_d.h"
#include "binary/bb_d_as_dd_d.h"
#include "binary/bb_f.h"
#include "binary/bb_f_as_dd_d.h"
#include "binary/bb_f_as_ff_f.h"
#include "binary/bb_i.h"
#include "binary/bb_i_as_ii_i.h"
#include "binary/bb_k.h"
#include "binary/bb_k_as_kk_k.h"
#include "binary/bb_t.h"
#include "binary/bb_t_as_tt_t.h"
#include "binary/bb_u.h"
#include "binary/bb_u_as_uu_u.h"
#include "binary/dd_d.h"
#include "binary/ff_f_as_dd_d.h"
#include "binary/ff_f.h"
#include "binary/ii_d.h"
#include "binary/ii_d_as_dd_d.h"
#include "binary/ii_i.h"
#include "binary/kk_d.h"
#include "binary/kk_d_as_dd_d.h"
#include "binary/kk_f.h"
#include "binary/kk_f_as_dd_d.h"
#include "binary/kk_f_as_ff_f.h"
#include "binary/kk_i.h"
#include "binary/kk_i_as_ii_i.h"
#include "binary/kk_k.h"
#include "binary/ss_d.h"
#include "binary/ss_d_as_dd_d.h"
#include "binary/ss_f.h"
#include "binary/ss_f_as_dd_d.h"
#include "binary/ss_f_as_ff_f.h"
#include "binary/ss_i.h"
#include "binary/ss_i_as_ii_i.h"
#include "binary/ss_k.h"
#include "binary/ss_k_as_kk_k.h"
#include "binary/ss_s.h"
#include "binary/tt_d.h"
#include "binary/tt_d_as_dd_d.h"
#include "binary/tt_f.h"
#include "binary/tt_f_as_dd_d.h"
#include "binary/tt_f_as_ff_f.h"
#include "binary/tt_i.h"
#include "binary/tt_i_as_ii_i.h"
#include "binary/tt_t.h"
#include "binary/tt_u.h"
#include "binary/tt_u_as_uu_u.h"
#include "binary/uu_d.h"
#include "binary/uu_d_as_dd_d.h"
#include "binary/uu_u.h"
#endif // !STDLIB_STRIDED_BASE_BINARY_H
+40
include/stdlib/strided/base/binary/bb_b.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_B_H
#define STDLIB_STRIDED_BASE_BINARY_BB_B_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 8-bit integers to unsigned 8-bit integer strided input arrays and assigns results to elements in an unsigned 8-bit integer strided output array.
*/
void stdlib_strided_bb_b( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_B_H
+40
include/stdlib/strided/base/binary/bb_d_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_D_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_BB_D_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to unsigned 8-bit integer strided input arrays and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_bb_d_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_D_AS_DD_D_H
+40
include/stdlib/strided/base/binary/bb_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_D_H
#define STDLIB_STRIDED_BASE_BINARY_BB_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 8-bit integers to unsigned 8-bit integer strided input arrays, casts the callback's unsigned 8-bit integer return value to a double-precision floating-point number, and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_bb_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_D_H
+40
include/stdlib/strided/base/binary/bb_f_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_F_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_BB_F_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to unsigned 8-bit integer strided input arrays, casts the callback's double-precision floating-point return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_bb_f_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_F_AS_DD_D_H
+40
include/stdlib/strided/base/binary/bb_f_as_ff_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_F_AS_FF_F_H
#define STDLIB_STRIDED_BASE_BINARY_BB_F_AS_FF_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning single-precision floating-point numbers to unsigned 8-bit integer strided input arrays and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_bb_f_as_ff_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_F_AS_FF_F_H
+40
include/stdlib/strided/base/binary/bb_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_F_H
#define STDLIB_STRIDED_BASE_BINARY_BB_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 8-bit integers to unsigned 8-bit integer strided input arrays, casts the callback's unsigned 8-bit integer return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_bb_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_F_H
+40
include/stdlib/strided/base/binary/bb_i_as_ii_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_I_AS_II_I_H
#define STDLIB_STRIDED_BASE_BINARY_BB_I_AS_II_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 32-bit integers to unsigned 8-bit integer strided input arrays and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_bb_i_as_ii_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_I_AS_II_I_H
+40
include/stdlib/strided/base/binary/bb_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_I_H
#define STDLIB_STRIDED_BASE_BINARY_BB_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 8-bit integers to unsigned 8-bit integer strided input arrays, casts the callback's unsigned 8-bit integer return value to a signed 32-bit integer, and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_bb_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_I_H
+40
include/stdlib/strided/base/binary/bb_k_as_kk_k.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_K_AS_KK_K_H
#define STDLIB_STRIDED_BASE_BINARY_BB_K_AS_KK_K_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 16-bit integers to unsigned 8-bit integer strided input arrays and assigns results to elements in a signed 16-bit integer strided output array.
*/
void stdlib_strided_bb_k_as_kk_k( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_K_AS_KK_K_H
+40
include/stdlib/strided/base/binary/bb_k.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_K_H
#define STDLIB_STRIDED_BASE_BINARY_BB_K_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 8-bit integers to unsigned 8-bit integer strided input arrays, casts the callback's unsigned 8-bit integer return value to a signed 16-bit integer, and assigns results to elements in a signed 16-bit integer strided output array.
*/
void stdlib_strided_bb_k( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_K_H
+40
include/stdlib/strided/base/binary/bb_t_as_tt_t.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_T_AS_TT_T_H
#define STDLIB_STRIDED_BASE_BINARY_BB_T_AS_TT_T_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 16-bit integers to unsigned 8-bit integer strided input arrays and assigns results to elements in an unsigned 16-bit integer strided output array.
*/
void stdlib_strided_bb_t_as_tt_t( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_T_AS_TT_T_H
+40
include/stdlib/strided/base/binary/bb_t.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_T_H
#define STDLIB_STRIDED_BASE_BINARY_BB_T_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 8-bit integers to unsigned 8-bit integer strided input arrays, casts the callback's unsigned 8-bit integer return value to an unsigned 16-bit integer, and assigns results to elements in an unsigned 16-bit integer strided output array.
*/
void stdlib_strided_bb_t( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_T_H
+40
include/stdlib/strided/base/binary/bb_u_as_uu_u.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_U_AS_UU_U_H
#define STDLIB_STRIDED_BASE_BINARY_BB_U_AS_UU_U_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 32-bit integers to unsigned 8-bit integer strided input arrays and assigns results to elements in an unsigned 32-bit integer strided output array.
*/
void stdlib_strided_bb_u_as_uu_u( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_U_AS_UU_U_H
+40
include/stdlib/strided/base/binary/bb_u.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_BB_U_H
#define STDLIB_STRIDED_BASE_BINARY_BB_U_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 8-bit integers to unsigned 8-bit integer strided input arrays, casts the callback's unsigned 8-bit integer return value to an unsigned 32-bit integer, and assigns results to elements in an unsigned 32-bit integer strided output array.
*/
void stdlib_strided_bb_u( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_BB_U_H
+40
include/stdlib/strided/base/binary/dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to double-precision floating-point strided input arrays and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_DD_D_H
+40
include/stdlib/strided/base/binary/ff_f_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_FF_F_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_FF_F_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to single-precision floating-point strided input arrays, casts the callback's double-precision floating-point return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_ff_f_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_FF_F_AS_DD_D_H
+40
include/stdlib/strided/base/binary/ff_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_FF_F_H
#define STDLIB_STRIDED_BASE_BINARY_FF_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning single-precision floating-point numbers to single-precision floating-point strided input arrays and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_ff_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_FF_F_H
+40
include/stdlib/strided/base/binary/ii_d_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_II_D_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_II_D_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to signed 32-bit integer strided input arrays and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_ii_d_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_II_D_AS_DD_D_H
+40
include/stdlib/strided/base/binary/ii_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_II_D_H
#define STDLIB_STRIDED_BASE_BINARY_II_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 32-bit integers to signed 32-bit integer strided input arrays, casts the callback's signed 32-bit integer return value to a double-precision floating-point number, and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_ii_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_II_D_H
+40
include/stdlib/strided/base/binary/ii_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_II_I_H
#define STDLIB_STRIDED_BASE_BINARY_II_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 32-bit integers to signed 32-bit integer strided input arrays and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_ii_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_II_I_H
+40
include/stdlib/strided/base/binary/kk_d_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_KK_D_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_KK_D_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to signed 16-bit integer strided input arrays and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_kk_d_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_KK_D_AS_DD_D_H
+40
include/stdlib/strided/base/binary/kk_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_KK_D_H
#define STDLIB_STRIDED_BASE_BINARY_KK_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 16-bit integers to signed 16-bit integer strided input arrays, casts the callback's signed 16-bit integer return value to a double-precision floating-point number, and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_kk_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_KK_D_H
+40
include/stdlib/strided/base/binary/kk_f_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_KK_F_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_KK_F_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to signed 16-bit integer strided input arrays, casts the callback's double-precision floating-point return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_kk_f_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_KK_F_AS_DD_D_H
+40
include/stdlib/strided/base/binary/kk_f_as_ff_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_KK_F_AS_FF_F_H
#define STDLIB_STRIDED_BASE_BINARY_KK_F_AS_FF_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning single-precision floating-point numbers to signed 16-bit integer strided input arrays and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_kk_f_as_ff_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_KK_F_AS_FF_F_H
+40
include/stdlib/strided/base/binary/kk_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_KK_F_H
#define STDLIB_STRIDED_BASE_BINARY_KK_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 16-bit integers to signed 16-bit integer strided input arrays, casts the callback's signed 16-bit integer return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_kk_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_KK_F_H
+40
include/stdlib/strided/base/binary/kk_i_as_ii_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_KK_I_AS_II_I_H
#define STDLIB_STRIDED_BASE_BINARY_KK_I_AS_II_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 32-bit integers to signed 16-bit integer strided input arrays and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_kk_i_as_ii_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_KK_I_AS_II_I_H
+40
include/stdlib/strided/base/binary/kk_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_KK_I_H
#define STDLIB_STRIDED_BASE_BINARY_KK_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 16-bit integers to signed 16-bit integer strided input arrays, casts the callback's signed 16-bit integer return value to a signed 32-bit integer, and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_kk_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_KK_I_H
+40
include/stdlib/strided/base/binary/kk_k.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_KK_K_H
#define STDLIB_STRIDED_BASE_BINARY_KK_K_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 16-bit integers to signed 16-bit integer strided input arrays and assigns results to elements in a signed 16-bit integer strided output array.
*/
void stdlib_strided_kk_k( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_KK_K_H
+213
include/stdlib/strided/base/binary/macros.h
/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Header file containing strided array macros for loops involving "binary" functions or expressions.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_MACROS_H
#define STDLIB_STRIDED_BASE_BINARY_MACROS_H
#include <stdint.h>
/**
* Macro containing the preamble for a loop which operates on strided array elements.
*
* @example
* STDLIB_STRIDED_BINARY_LOOP_PREMABLE {
* // Loop body...
* }
*/
#define STDLIB_STRIDED_BINARY_LOOP_PREAMBLE \
uint8_t *ip1 = arrays[ 0 ]; \
uint8_t *ip2 = arrays[ 1 ]; \
uint8_t *op1 = arrays[ 2 ]; \
int64_t is1 = strides[ 0 ]; \
int64_t is2 = strides[ 1 ]; \
int64_t os1 = strides[ 2 ]; \
int64_t n = shape[ 0 ]; \
int64_t i; \
if ( n <= 0 ) { \
return; \
} \
if ( is1 < 0 ) { \
ip1 += (1-n) * is1; \
} \
if ( is2 < 0 ) { \
ip2 += (1-n) * is2; \
} \
if ( os1 < 0 ) { \
op1 += (1-n) * os1; \
} \
for ( i = 0; i < n; i++, ip1 += is1, ip2 += is2, op1 += os1 )
/**
* Macro containing the preamble for a loop which operates on strided array elements and updates two strided output arrays.
*
* @example
* STDLIB_STRIDED_BINARY_LOOP_TWO_OUT_PREMABLE {
* // Loop body...
* }
*/
#define STDLIB_STRIDED_BINARY_LOOP_TWO_OUT_PREAMBLE \
uint8_t *ip1 = arrays[ 0 ]; \
uint8_t *ip2 = arrays[ 1 ]; \
uint8_t *op1 = arrays[ 2 ]; \
uint8_t *op2 = arrays[ 3 ]; \
int64_t is1 = strides[ 0 ]; \
int64_t is2 = strides[ 1 ]; \
int64_t os1 = strides[ 2 ]; \
int64_t os2 = strides[ 3 ]; \
int64_t n = shape[ 0 ]; \
int64_t i; \
if ( n <= 0 ) { \
return; \
} \
if ( is1 < 0 ) { \
ip1 += (1-n) * is1; \
} \
if ( is2 < 0 ) { \
ip2 += (1-n) * is2; \
} \
if ( os1 < 0 ) { \
op1 += (1-n) * os1; \
} \
if ( os2 < 0 ) { \
op2 += (1-n) * os2; \
} \
for ( i = 0; i < n; i++, ip1 += is1, ip2 += is2, op1 += os1, op2 += os2 )
/**
* Macro for a binary loop which inlines an expression.
*
* ## Notes
*
* - Retrieves each strided array element according to type `tin` via pointers `ip1` and `ip2` as `in1` and `in2`, respectively.
* - Creates a pointer `tout *out` to the output strided array element.
* - Expects a provided expression to operate on `tin in1` and `tin in2` and to store the result in `tout *out`.
*
* @param tin input type
* @param tout output type
* @param expr expression to inline
*
* @example
* STDLIB_STRIDED_BINARY_LOOP_INLINE( double, double, *out = in1 * in2 )
*/
#define STDLIB_STRIDED_BINARY_LOOP_INLINE( tin, tout, expr ) \
STDLIB_STRIDED_BINARY_LOOP_PREAMBLE { \
const tin in1 = *(tin *)ip1; \
const tin in2 = *(tin *)ip2; \
tout *out = (tout *)op1; \
expr; \
}
/**
* Macro for a binary loop which invokes a callback.
*
* ## Notes
*
* - Retrieves each strided array element according to type `tin` via a pointer `ip`.
* - Explicitly casts each function `f` invocation result to `tout`.
* - Stores the result in an output strided array via the pointer `op1`.
*
* @param tin input type
* @param tout output type
*
* @example
* STDLIB_STRIDED_BINARY_LOOP_CLBK( double, double )
*/
#define STDLIB_STRIDED_BINARY_LOOP_CLBK( tin, tout ) \
STDLIB_STRIDED_BINARY_LOOP_PREAMBLE { \
const tin x = *(tin *)ip1; \
const tin y = *(tin *)ip2; \
*(tout *)op1 = (tout)f( x, y ); \
}
/**
* Macro for a binary loop which invokes a callback requiring arguments be cast to a different type.
*
* ## Notes
*
* - Retrieves each strided array element according to type `tin` via a pointer `ip`.
* - Explicitly casts each function argument to `fin`.
* - Explicitly casts each function `f` invocation result to `tout`.
* - Stores the result in an output strided array via the pointer `op1`.
*
* @param tin input type
* @param tout output type
* @param fin callback argument type
*
* @example
* STDLIB_STRIDED_BINARY_LOOP_CLBK_ARG_CAST( float, float, double )
*/
#define STDLIB_STRIDED_BINARY_LOOP_CLBK_ARG_CAST( tin, tout, fin ) \
STDLIB_STRIDED_BINARY_LOOP_PREAMBLE { \
const tin x = *(tin *)ip1; \
const tin y = *(tin *)ip2; \
*(tout *)op1 = (tout)f( (fin)x, (fin)y ); \
}
/**
* Macro for a binary loop which invokes a callback while operating on mixed strided input arrays.
*
* ## Notes
*
* - Retrieves each strided array element according to type `tin` via a pointer `ip`.
* - Explicitly casts each function `f` invocation result to `tout`.
* - Stores the result in an output strided array via the pointer `op1`.
*
* @param tin1 data type for the first input strided array
* @param tin2 data type for the second input strided array
* @param tout output type
*
* @example
* STDLIB_STRIDED_BINARY_LOOP_CLBK_MIXED( double, uint32_t, double )
*/
#define STDLIB_STRIDED_BINARY_LOOP_CLBK_MIXED( tin1, tin2, tout ) \
STDLIB_STRIDED_BINARY_LOOP_PREAMBLE { \
const tin1 x = *(tin1 *)ip1; \
const tin2 y = *(tin2 *)ip2; \
*(tout *)op1 = (tout)f( x, y ); \
}
/**
* Macro for a binary loop which invokes a callback requiring arguments be cast to a different type while operating on mixed strided input arrays.
*
* ## Notes
*
* - Retrieves each strided array element according to type `tin` via a pointer `ip`.
* - Explicitly casts each function argument according to type `fin`.
* - Explicitly casts each function `f` invocation result to `tout`.
* - Stores the result in an output strided array via the pointer `op1`.
*
* @param tin1 data type for the first input strided array
* @param tin2 data type for the second input strided array
* @param tout output type
* @param fin1 data type for first callback argument
* @param fin2 data type for second callback argument
*
* @example
* STDLIB_STRIDED_BINARY_LOOP_CLBK_MIXED_ARG_CAST( float, uint16_t, double, uint32_t, float )
*/
#define STDLIB_STRIDED_BINARY_LOOP_CLBK_MIXED_ARG_CAST( tin1, tin2, tout, fin1, fin2 ) \
STDLIB_STRIDED_BINARY_LOOP_PREAMBLE { \
const tin1 x = *(tin1 *)ip1; \
const tin2 y = *(tin2 *)ip2; \
*(tout *)op1 = (tout)f( (fin1)x, (fin2)y ); \
}
#endif // !STDLIB_STRIDED_BASE_BINARY_MACROS_H
+40
include/stdlib/strided/base/binary/ss_d_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_D_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_SS_D_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to signed 8-bit integer strided input arrays and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_ss_d_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_D_AS_DD_D_H
+40
include/stdlib/strided/base/binary/ss_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_D_H
#define STDLIB_STRIDED_BASE_BINARY_SS_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 8-bit integers to signed 8-bit integer strided input arrays, casts the callback's signed 8-bit integer return value to a double-precision floating-point number, and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_ss_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_D_H
+40
include/stdlib/strided/base/binary/ss_f_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_F_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_SS_F_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to signed 8-bit integer strided input arrays, casts the callback's double-precision floating-point return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_ss_f_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_F_AS_DD_D_H
+40
include/stdlib/strided/base/binary/ss_f_as_ff_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_F_AS_FF_F_H
#define STDLIB_STRIDED_BASE_BINARY_SS_F_AS_FF_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning single-precision floating-point numbers to signed 8-bit integer strided input arrays and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_ss_f_as_ff_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_F_AS_FF_F_H
+40
include/stdlib/strided/base/binary/ss_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_F_H
#define STDLIB_STRIDED_BASE_BINARY_SS_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 8-bit integers to signed 8-bit integer strided input arrays, casts the callback's signed 8-bit integer return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_ss_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_F_H
+40
include/stdlib/strided/base/binary/ss_i_as_ii_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_I_AS_II_I_H
#define STDLIB_STRIDED_BASE_BINARY_SS_I_AS_II_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 32-bit integers to signed 8-bit integer strided input arrays and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_ss_i_as_ii_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_I_AS_II_I_H
+40
include/stdlib/strided/base/binary/ss_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_I_H
#define STDLIB_STRIDED_BASE_BINARY_SS_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 8-bit integers to signed 8-bit integer strided input arrays, casts the callback's signed 8-bit integer return value to a signed 32-bit integer, and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_ss_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_I_H
+40
include/stdlib/strided/base/binary/ss_k_as_kk_k.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_K_AS_KK_K_H
#define STDLIB_STRIDED_BASE_BINARY_SS_K_AS_KK_K_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 16-bit integers to signed 8-bit integer strided input arrays and assigns results to elements in a signed 16-bit integer strided output array.
*/
void stdlib_strided_ss_k_as_kk_k( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_K_AS_K_K_H
+40
include/stdlib/strided/base/binary/ss_k.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_K_H
#define STDLIB_STRIDED_BASE_BINARY_SS_K_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 8-bit integers to signed 8-bit integer strided input arrays, casts the callback's signed 8-bit integer return value to a signed 16-bit integer, and assigns results to elements in a signed 16-bit integer strided output array.
*/
void stdlib_strided_ss_k( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_K_H
+40
include/stdlib/strided/base/binary/ss_s.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_SS_S_H
#define STDLIB_STRIDED_BASE_BINARY_SS_S_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 8-bit integers to signed 8-bit integer strided input arrays and assigns results to elements in a signed 8-bit integer strided output array.
*/
void stdlib_strided_ss_s( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_SS_S_H
+40
include/stdlib/strided/base/binary/tt_d_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_D_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_TT_D_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to unsigned 16-bit integer strided input arrays and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_tt_d_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_D_AS_DD_D_H
+40
include/stdlib/strided/base/binary/tt_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_D_H
#define STDLIB_STRIDED_BASE_BINARY_TT_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 16-bit integers to unsigned 16-bit integer strided input arrays, casts the callback's unsigned 16-bit integer return value to a double-precision floating-point number, and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_tt_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_D_H
+40
include/stdlib/strided/base/binary/tt_f_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_F_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_TT_F_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to unsigned 16-bit integer strided input arrays, casts the callback's double-precision floating-point return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_tt_f_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_F_AS_DD_D_H
+40
include/stdlib/strided/base/binary/tt_f_as_ff_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_F_AS_FF_F_H
#define STDLIB_STRIDED_BASE_BINARY_TT_F_AS_FF_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning single-precision floating-point numbers to unsigned 16-bit integer strided input arrays and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_tt_f_as_ff_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_F_AS_FF_F_H
+40
include/stdlib/strided/base/binary/tt_f.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_F_H
#define STDLIB_STRIDED_BASE_BINARY_TT_F_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 16-bit integers to unsigned 16-bit integer strided input arrays, casts the callback's unsigned 16-bit integer return value to a single-precision floating-point number, and assigns results to elements in a single-precision floating-point strided output array.
*/
void stdlib_strided_tt_f( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_F_H
+40
include/stdlib/strided/base/binary/tt_i_as_ii_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_I_AS_II_I_H
#define STDLIB_STRIDED_BASE_BINARY_TT_I_AS_II_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning signed 32-bit integers to unsigned 16-bit integer strided input arrays and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_tt_i_as_ii_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_I_AS_II_I_H
+40
include/stdlib/strided/base/binary/tt_i.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_I_H
#define STDLIB_STRIDED_BASE_BINARY_TT_I_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 16-bit integers to unsigned 16-bit integer strided input arrays, casts the callback's unsigned 16-bit integer return value to a signed 32-bit integer, and assigns results to elements in a signed 32-bit integer strided output array.
*/
void stdlib_strided_tt_i( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_I_H
+40
include/stdlib/strided/base/binary/tt_t.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_T_H
#define STDLIB_STRIDED_BASE_BINARY_TT_T_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 16-bit integers to unsigned 16-bit integer strided input arrays and assigns results to elements in an unsigned 16-bit integer strided output array.
*/
void stdlib_strided_tt_t( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_T_H
+40
include/stdlib/strided/base/binary/tt_u_as_uu_u.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_U_AS_UU_U_H
#define STDLIB_STRIDED_BASE_BINARY_TT_U_AS_UU_U_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 32-bit integers to unsigned 16-bit integer strided input arrays and assigns results to elements in an unsigned 32-bit integer strided output array.
*/
void stdlib_strided_tt_u_as_uu_u( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_U_AS_UU_U_H
+40
include/stdlib/strided/base/binary/tt_u.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TT_U_H
#define STDLIB_STRIDED_BASE_BINARY_TT_U_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 16-bit integers to unsigned 16-bit integer strided input arrays, casts the callback's unsigned 16-bit integer return value to an unsigned 32-bit integer, and assigns results to elements in an unsigned 32-bit integer strided output array.
*/
void stdlib_strided_tt_u( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_TT_U_H
+117
include/stdlib/strided/base/binary/typedefs.h
/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Header file containing strided array type definitions for binary functions.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_TYPEDEFS_H
#define STDLIB_STRIDED_BASE_BINARY_TYPEDEFS_H
#include <stdint.h>
/**
* Function type for a function accepting and returning single-precision floating-point numbers.
*
* @param x first single-precision floating-point number
* @param y second single-precision floating-point number
* @return single-precision floating-point number
*/
typedef float BinaryFcnFloat32( const float x, const float y );
/**
* Function type for a function accepting and returning double-precision floating-point numbers.
*
* @param x first double-precision floating-point number
* @param y second double-precision floating-point number
* @return double-precision floating-point number
*/
typedef double BinaryFcnFloat64( const double x, const double y );
/**
* Function type for a function accepting and returning signed 64-bit integers.
*
* @param x first signed 64-bit integer
* @param y second signed 64-bit integer
* @return signed 64-bit integer
*/
typedef int64_t BinaryFcnInt64( const int64_t x, const int64_t y );
/**
* Function type for a function accepting and returning unsigned 64-bit integers.
*
* @param x first unsigned 64-bit integer
* @param y second unsigned 64-bit integer
* @return unsigned 64-bit integer
*/
typedef uint64_t BinaryFcnUint64( const uint64_t x, const uint64_t y );
/**
* Function type for a function accepting and returning signed 32-bit integers.
*
* @param x first signed 32-bit integer
* @param y second signed 32-bit integer
* @return signed 32-bit integer
*/
typedef int32_t BinaryFcnInt32( const int32_t x, const int32_t y );
/**
* Function type for a function accepting and returning unsigned 32-bit integers.
*
* @param x first unsigned 32-bit integer
* @param y second unsigned 32-bit integer
* @return unsigned 32-bit integer
*/
typedef uint32_t BinaryFcnUint32( const uint32_t x, const uint32_t y );
/**
* Function type for a function accepting and returning signed 16-bit integers.
*
* @param x first signed 16-bit integer
* @param y second signed 16-bit integer
* @return signed 16-bit integer
*/
typedef int16_t BinaryFcnInt16( const int16_t x, const int16_t y );
/**
* Function type for a function accepting and returning unsigned 16-bit integers.
*
* @param x first unsigned 16-bit integer
* @param y second unsigned 16-bit integer
* @return unsigned 16-bit integer
*/
typedef uint16_t BinaryFcnUint16( const uint16_t x, const uint16_t y );
/**
* Function type for a function accepting and returning signed 8-bit integers.
*
* @param x first signed 8-bit integer
* @param y second signed 8-bit integer
* @return signed 8-bit integer
*/
typedef int8_t BinaryFcnInt8( const int8_t x, const int8_t y );
/**
* Function type for a function accepting and returning unsigned 8-bit integers.
*
* @param x first unsigned 8-bit integer
* @param y second unsigned 8-bit integer
* @return unsigned 8-bit integer
*/
typedef uint8_t BinaryFcnUint8( const uint8_t x, const uint8_t y );
#endif // !STDLIB_STRIDED_BASE_BINARY_TYPEDEFS_H
+40
include/stdlib/strided/base/binary/uu_d_as_dd_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_UU_D_AS_DD_D_H
#define STDLIB_STRIDED_BASE_BINARY_UU_D_AS_DD_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning double-precision floating-point numbers to unsigned 32-bit integer strided input arrays and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_uu_d_as_dd_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_UU_D_AS_DD_D_H
+40
include/stdlib/strided/base/binary/uu_d.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_UU_D_H
#define STDLIB_STRIDED_BASE_BINARY_UU_D_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 32-bit integers to unsigned 32-bit integer strided input arrays, casts the callback's unsigned 32-bit integer return value to a double-precision floating-point number, and assigns results to elements in a double-precision floating-point strided output array.
*/
void stdlib_strided_uu_d( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_UU_D_H
+40
include/stdlib/strided/base/binary/uu_u.h
/**
* @license Apache-2.0
*
* Copyright (c) 2020 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STDLIB_STRIDED_BASE_BINARY_UU_U_H
#define STDLIB_STRIDED_BASE_BINARY_UU_U_H
#include <stdint.h>
/*
* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* Applies a binary callback accepting and returning unsigned 32-bit integers to unsigned 32-bit integer strided input arrays and assigns results to elements in an unsigned 32-bit integer strided output array.
*/
void stdlib_strided_uu_u( uint8_t *arrays[], int64_t *shape, int64_t *strides, void *fcn );
#ifdef __cplusplus
}
#endif
#endif // !STDLIB_STRIDED_BASE_BINARY_UU_U_H
+1
-1
package.json
{
"name": "@stdlib/strided-base-binary",
"version": "0.0.1",
"version": "0.0.2",
"description": "Apply a binary callback to elements in strided input arrays and assign results to elements in a strided output array.",

@@ -5,0 +5,0 @@ "license": "Apache-2.0",