feat: add internal C utilities

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: passed
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/every/src/internal/permute.c

@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2023 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.
+*/
+
+#include "stdlib/ndarray/base/every/internal/permute.h"
+#include <stdint.h>
+
+/**
+* Permutes an input array according to a provided index array.
+*
+* @param n    number of elements to permute
+* @param arr  input array
+* @param idx  permutation indices
+* @param out  output array
+*/
+void stdlib_ndarray_base_every_internal_permute( const int64_t n, const int64_t *arr, const int64_t *idx, int64_t *out ) {
+	int64_t i;
+	for ( i = 0; i < n; i++ ) {
+		out[ i ] = arr[ idx[i] ];
+	}
+}

lib/node_modules/@stdlib/ndarray/base/every/src/internal/range.c

@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2023 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.
+*/
+
+#include "stdlib/ndarray/base/every/internal/range.h"
+#include <stdint.h>
+
+/**
+* Writes `n` evenly spaced values from `0` to `n-1` to an output array.
+*
+* @param n    number of values to write
+* @param out  output array
+*/
+void stdlib_ndarray_base_every_internal_range( const int64_t n, int64_t *out ) {
+	int64_t i;
+	for ( i = 0; i < n; i++ ) {
+		out[ i ] = i;
+	}
+}

lib/node_modules/@stdlib/ndarray/base/every/src/internal/sort2ins.c

@@ -0,0 +1,79 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2023 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.
+*/
+
+#include "stdlib/ndarray/base/every/internal/sort2ins.h"
+#include <stdint.h>
+
+/**
+* Simultaneously sorts two arrays based on the sort order of the first array using insertion sort.
+*
+* ## Notes
+*
+* -   The first array is sorted in increasing order according to absolute value.
+* -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
+* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
+* -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
+*
+* @param n   number of elements
+* @param x   first array
+* @param y   second array
+*/
+void stdlib_ndarray_base_every_internal_sort2ins( const int64_t n, int64_t *x, int64_t *y ) {
+	int64_t avx;
+	int64_t aux;
+	int64_t ix;
+	int64_t iy;
+	int64_t jx;
+	int64_t jy;
+	int64_t vx;
+	int64_t vy;
+	int64_t ux;
+	int64_t i;
+
+	ix = 1;
+	iy = 1;
+
+	// Sort in increasing order...
+	for ( i = 1; i < n; i++ ) {
+		vx = x[ ix ];
+		avx = ( vx < 0 ) ? -vx : vx;
+
+		vy = y[ iy ];
+
+		jx = ix - 1;
+		jy = iy - 1;
+
+		// Shift all larger values to the left of the current element to the right...
+		while ( jx >= 0 ) {
+			ux = x[ jx ];
+			aux = ( ux < 0 ) ? -ux : ux;
+			if ( aux <= avx ) {
+				break;
+			}
+			x[ jx+1 ] = ux;
+			y[ jy+1 ] = y[ jy ];
+			jx -= 1;
+			jy -= 1;
+		}
+		x[ jx+1 ] = vx;
+		y[ jy+1 ] = vy;
+		ix += 1;
+		iy += 1;
+	}
+}