@stdlib/blas-base-ccopy 0.0.8 → 0.1.0

package/CITATION.cff

@@ -0,0 +1,30 @@
+cff-version: 1.2.0
+title: stdlib
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+
+type: software
+
+authors:
+  - name: The Stdlib Authors
+    url: https://github.com/stdlib-js/stdlib/graphs/contributors
+
+repository-code: https://github.com/stdlib-js/stdlib
+url: https://stdlib.io
+
+abstract: |
+  Standard library for JavaScript and Node.js.
+
+keywords:
+  - JavaScript
+  - Node.js
+  - TypeScript
+  - standard library
+  - scientific computing
+  - numerical computing
+  - statistical computing
+
+license: Apache-2.0 AND BSL-1.0
+
+date-released: 2016

package/NOTICE

@@ -1 +1 @@
-Copyright (c) 2016-2022 The Stdlib Authors.
+Copyright (c) 2016-2023 The Stdlib Authors.

package/README.md

@@ -18,6 +18,17 @@ limitations under the License.
 
 -->
 
+
+<details>
+  <summary>
+    About stdlib...
+  </summary>
+  <p>We believe in a future in which the web is a preferred environment for numerical computation. To help realize this future, we've built stdlib. stdlib is a standard library, with an emphasis on numerical and scientific computation, written in JavaScript (and C) for execution in browsers and in Node.js.</p>
+  <p>The library is fully decomposable, being architected in such a way that you can swap out and mix and match APIs and functionality to cater to your exact preferences and use cases.</p>
+  <p>When you use stdlib, you can be absolutely certain that you are using the most thorough, rigorous, well-written, studied, documented, tested, measured, and high-quality code out there.</p>
+  <p>To join us in bringing numerical computing to the web, get started by checking us out on <a href="https://github.com/stdlib-js/stdlib">GitHub</a>, and please consider <a href="https://opencollective.com/stdlib">financially supporting stdlib</a>. We greatly appreciate your continued support!</p>
+</details>
+
 # ccopy
 
 [![NPM version][npm-image]][npm-url] [![Build Status][test-image]][test-url] [![Coverage Status][coverage-image]][coverage-url] <!-- [![dependencies][dependencies-image]][dependencies-url] -->
@@ -68,26 +79,23 @@ var im = imagf( z );
 
 The function has the following parameters:
 
--   **N**: number of values to copy.
+-   **N**: number of indexed elements.
 -   **x**: input [`Complex64Array`][@stdlib/array/complex64].
 -   **strideX**: index increment for `x`.
 -   **y**: destination [`Complex64Array`][@stdlib/array/complex64].
 -   **strideY**: index increment for `y`.
 
-The `N` and `stride` parameters determine how values from `x` are copied into `y`. For example, to copy in reverse order every other value in `x` into the first `N` elements of `y`,
+The `N` and stride parameters determine how values from `x` are copied into `y`. For example, to copy in reverse order every other value in `x` into the first `N` elements of `y`,
 
 ```javascript
 var Complex64Array = require( '@stdlib/array-complex64' );
-var floor = require( '@stdlib/math-base-special-floor' );
 var realf = require( '@stdlib/complex-realf' );
 var imagf = require( '@stdlib/complex-imagf' );
 
 var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 var y = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-var N = floor( x.length / 2 );
-
-ccopy( N, x, -2, y, 1 );
+ccopy( 2, x, -2, y, 1 );
 
 var z = y.get( 0 );
 // returns <Complex64>
@@ -158,7 +166,7 @@ The function has the following additional parameters:
 -   **offsetX**: starting index for `x`.
 -   **offsetY**: starting index for `y`.
 
-While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying `buffer`, the `offsetX` and `offsetY` parameters support indexing semantics based on starting indices. For example, to copy every other value in `x` starting from the second value into the last `N` elements in `y` where `x[i] = y[n]`, `x[i+2] = y[n-1]`,...,
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying `buffer`, the offset parameters support indexing semantics based on starting indices. For example, to copy every other value in `x` starting from the second value into the last `N` elements in `y` where `x[i] = y[n]`, `x[i+2] = y[n-1]`,...,
 
 ```javascript
 var Complex64Array = require( '@stdlib/array-complex64' );
@@ -203,21 +211,18 @@ var im = imagf( z );
 
 ```javascript
 var discreteUniform = require( '@stdlib/random-base-discrete-uniform' );
-var Complex64Array = require( '@stdlib/array-complex64' );
+var filledarrayBy = require( '@stdlib/array-filled-by' );
+var Complex64 = require( '@stdlib/complex-float32' );
 var ccopy = require( '@stdlib/blas-base-ccopy' );
 
-var re = discreteUniform.factory( 0, 10 );
-var im = discreteUniform.factory( -5, 5 );
-
-var x = new Complex64Array( 10 );
-var y = new Complex64Array( 10 );
-
-var i;
-for ( i = 0; i < x.length; i++ ) {
-    x.set( [ re(), im() ], i );
-    y.set( [ re(), im() ], i );
+function rand() {
+    return new Complex64( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
 }
+
+var x = filledarrayBy( 10, 'complex64', rand );
 console.log( x.get( 0 ).toString() );
+
+var y = filledarrayBy( 10, 'complex64', rand );
 console.log( y.get( 0 ).toString() );
 
 // Copy elements from `x` into `y` starting from the end of `y`:
@@ -237,7 +242,7 @@ console.log( y.get( y.length-1 ).toString() );
 
 ## See Also
 
--   <span class="package-name">[`@stdlib/blas/base/cswap`][@stdlib/blas/base/cswap]</span><span class="delimiter">: </span><span class="description">interchanges two complex single-precision floating-point vectors.</span>
+-   <span class="package-name">[`@stdlib/blas-base/cswap`][@stdlib/blas/base/cswap]</span><span class="delimiter">: </span><span class="description">interchanges two complex single-precision floating-point vectors.</span>
 
 </section>
 
@@ -269,7 +274,7 @@ See [LICENSE][stdlib-license].
 
 ## Copyright
 
-Copyright &copy; 2016-2022. The Stdlib [Authors][stdlib-authors].
+Copyright &copy; 2016-2023. The Stdlib [Authors][stdlib-authors].
 
 </section>
 
@@ -282,8 +287,8 @@ Copyright &copy; 2016-2022. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/blas-base-ccopy.svg
 [npm-url]: https://npmjs.org/package/@stdlib/blas-base-ccopy
 
-[test-image]: https://github.com/stdlib-js/blas-base-ccopy/actions/workflows/test.yml/badge.svg?branch=v0.0.8
-[test-url]: https://github.com/stdlib-js/blas-base-ccopy/actions/workflows/test.yml?query=branch:v0.0.8
+[test-image]: https://github.com/stdlib-js/blas-base-ccopy/actions/workflows/test.yml/badge.svg?branch=v0.1.0
+[test-url]: https://github.com/stdlib-js/blas-base-ccopy/actions/workflows/test.yml?query=branch:v0.1.0
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/blas-base-ccopy/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/blas-base-ccopy?branch=main
@@ -296,7 +301,7 @@ Copyright &copy; 2016-2022. The Stdlib [Authors][stdlib-authors].
 -->
 
 [chat-image]: https://img.shields.io/gitter/room/stdlib-js/stdlib.svg
-[chat-url]: https://gitter.im/stdlib-js/stdlib/
+[chat-url]: https://app.gitter.im/#/room/#stdlib-js_stdlib:gitter.im
 
 [stdlib]: https://github.com/stdlib-js/stdlib
 

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="../docs/types/index.d.ts" />
+import ccopy from '../docs/types/index';
+export = ccopy;

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";var x=function(e,i){return function(){return i||e((i={exports:{}}).exports,i),i.exports}};var j=x(function(H,w){
+var l=require('@stdlib/strided-base-reinterpret-complex64/dist');function h(e,i,o,s,a){var u,n,c,f,v,t,r;if(e<=0)return s;if(u=l(i,0),n=l(s,0),o===1&&a===1){for(r=0;r<e*2;r+=2)n[r]=u[r],n[r+1]=u[r+1];return s}for(o<0?v=2*(1-e)*o:v=0,a<0?t=2*(1-e)*a:t=0,c=o*2,f=a*2,r=0;r<e;r++)n[t]=u[v],n[t+1]=u[v+1],v+=c,t+=f;return s}w.exports=h
+});var _=x(function(I,R){
+var m=require('@stdlib/strided-base-reinterpret-complex64/dist');function k(e,i,o,s,a,u,n){var c,f,v,t,r,p,q;if(e<=0)return a;for(c=m(i,0),f=m(a,0),v=o*2,t=u*2,r=s*2,p=n*2,q=0;q<e;q++)f[p]=c[r],f[p+1]=c[r+1],r+=v,p+=t;return a}R.exports=k
+});var b=x(function(J,O){
+var z=require('@stdlib/utils-define-nonenumerable-read-only-property/dist'),E=j(),A=_();z(E,"ndarray",A);O.exports=E
+});var B=require("path").join,C=require('@stdlib/utils-try-require/dist'),D=require('@stdlib/assert-is-error/dist'),F=b(),y,g=C(B(__dirname,"./native.js"));D(g)?y=F:y=g;module.exports=y;
+/** @license Apache-2.0 */
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../lib/ccopy.js", "../lib/ndarray.js", "../lib/main.js", "../lib/index.js"],
+  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar reinterpret = require( '@stdlib/strided-base-reinterpret-complex64' );\n\n\n// MAIN //\n\n/**\n* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.\n*\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Complex64Array} x - input array\n* @param {integer} strideX - `x` stride length\n* @param {Complex64Array} y - output array\n* @param {integer} strideY - `y` stride length\n* @returns {Complex64Array} output array\n*\n* @example\n* var Complex64Array = require( '@stdlib/array-complex64' );\n* var realf = require( '@stdlib/complex-realf' );\n* var imagf = require( '@stdlib/complex-imagf' );\n*\n* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n* var y = new Complex64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n*\n* ccopy( x.length, x, 1, y, 1 );\n*\n* var z = y.get( 0 );\n* // returns <Complex64>\n*\n* var re = realf( z );\n* // returns 1.0\n*\n* var im = imagf( z );\n* // returns 2.0\n*/\nfunction ccopy( N, x, strideX, y, strideY ) {\n\tvar viewX;\n\tvar viewY;\n\tvar sx;\n\tvar sy;\n\tvar ix;\n\tvar iy;\n\tvar i;\n\n\tif ( N <= 0 ) {\n\t\treturn y;\n\t}\n\tviewX = reinterpret( x, 0 );\n\tviewY = reinterpret( y, 0 );\n\tif ( strideX === 1 && strideY === 1 ) {\n\t\tfor ( i = 0; i < N*2; i += 2 ) {\n\t\t\tviewY[ i ] = viewX[ i ];\n\t\t\tviewY[ i+1 ] = viewX[ i+1 ];\n\t\t}\n\t\treturn y;\n\t}\n\tif ( strideX < 0 ) {\n\t\tix = 2 * (1-N) * strideX;\n\t} else {\n\t\tix = 0;\n\t}\n\tif ( strideY < 0 ) {\n\t\tiy = 2 * (1-N) * strideY;\n\t} else {\n\t\tiy = 0;\n\t}\n\tsx = strideX * 2;\n\tsy = strideY * 2;\n\tfor ( i = 0; i < N; i++ ) {\n\t\tviewY[ iy ] = viewX[ ix ];\n\t\tviewY[ iy+1 ] = viewX[ ix+1 ];\n\t\tix += sx;\n\t\tiy += sy;\n\t}\n\treturn y;\n}\n\n\n// EXPORTS //\n\nmodule.exports = ccopy;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar reinterpret = require( '@stdlib/strided-base-reinterpret-complex64' );\n\n\n// MAIN //\n\n/**\n* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.\n*\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Complex64Array} x - input array\n* @param {integer} strideX - `x` stride length\n* @param {NonNegativeInteger} offsetX - starting `x` index\n* @param {Complex64Array} y - output array\n* @param {integer} strideY - `y` stride length\n* @param {NonNegativeInteger} offsetY - starting `y` index\n* @returns {Complex64Array} output array\n*\n* @example\n* var Complex64Array = require( '@stdlib/array-complex64' );\n* var realf = require( '@stdlib/complex-realf' );\n* var imagf = require( '@stdlib/complex-imagf' );\n*\n* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n* var y = new Complex64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n*\n* ccopy( x.length, x, 1, 0, y, 1, 0 );\n*\n* var z = y.get( 0 );\n* // returns <Complex64>\n*\n* var re = realf( z );\n* // returns 1.0\n*\n* var im = imagf( z );\n* // returns 2.0\n*/\nfunction ccopy( N, x, strideX, offsetX, y, strideY, offsetY ) {\n\tvar viewX;\n\tvar viewY;\n\tvar sx;\n\tvar sy;\n\tvar ix;\n\tvar iy;\n\tvar i;\n\n\tif ( N <= 0 ) {\n\t\treturn y;\n\t}\n\tviewX = reinterpret( x, 0 );\n\tviewY = reinterpret( y, 0 );\n\tsx = strideX * 2;\n\tsy = strideY * 2;\n\tix = offsetX * 2;\n\tiy = offsetY * 2;\n\tfor ( i = 0; i < N; i++ ) {\n\t\tviewY[ iy ] = viewX[ ix ];\n\t\tviewY[ iy+1 ] = viewX[ ix+1 ];\n\t\tix += sx;\n\t\tiy += sy;\n\t}\n\treturn y;\n}\n\n\n// EXPORTS //\n\nmodule.exports = ccopy;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar ccopy = require( './ccopy.js' );\nvar ndarray = require( './ndarray.js' );\n\n\n// MAIN //\n\nsetReadOnly( ccopy, 'ndarray', ndarray );\n\n\n// EXPORTS //\n\nmodule.exports = ccopy;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* BLAS level 1 routine to copy values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.\n*\n* @module @stdlib/blas-base-ccopy\n*\n* @example\n* var Complex64Array = require( '@stdlib/array-complex64' );\n* var realf = require( '@stdlib/complex-realf' );\n* var imagf = require( '@stdlib/complex-imagf' );\n* var ccopy = require( '@stdlib/blas-base-ccopy' );\n*\n* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n* var y = new Complex64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n*\n* ccopy( x.length, x, 1, y, 1 );\n*\n* var z = y.get( 0 );\n* // returns <Complex64>\n*\n* var re = realf( z );\n* // returns 1.0\n*\n* var im = imagf( z );\n* // returns 2.0\n*\n* @example\n* var Complex64Array = require( '@stdlib/array-complex64' );\n* var realf = require( '@stdlib/complex-realf' );\n* var imagf = require( '@stdlib/complex-imagf' );\n* var ccopy = require( '@stdlib/blas-base-ccopy' );\n*\n* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n* var y = new Complex64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n*\n* ccopy.ndarray( x.length, x, 1, 0, y, 1, 0 );\n*\n* var z = y.get( 0 );\n* // returns <Complex64>\n*\n* var re = realf( z );\n* // returns 1.0\n*\n* var im = imagf( z );\n* // returns 2.0\n*/\n\n// MODULES //\n\nvar join = require( 'path' ).join;\nvar tryRequire = require( '@stdlib/utils-try-require' );\nvar isError = require( '@stdlib/assert-is-error' );\nvar main = require( './main.js' );\n\n\n// MAIN //\n\nvar ccopy;\nvar tmp = tryRequire( join( __dirname, './native.js' ) );\nif ( isError( tmp ) ) {\n\tccopy = main;\n} else {\n\tccopy = tmp;\n}\n\n\n// EXPORTS //\n\nmodule.exports = ccopy;\n\n// exports: { \"ndarray\": \"ccopy.ndarray\" }\n"],
+  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAc,QAAS,4CAA6C,EAkCxE,SAASC,EAAOC,EAAGC,EAAGC,EAASC,EAAGC,EAAU,CAC3C,IAAIC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAEJ,GAAKX,GAAK,EACT,OAAOG,EAIR,GAFAE,EAAQP,EAAaG,EAAG,CAAE,EAC1BK,EAAQR,EAAaK,EAAG,CAAE,EACrBD,IAAY,GAAKE,IAAY,EAAI,CACrC,IAAMO,EAAI,EAAGA,EAAIX,EAAE,EAAGW,GAAK,EAC1BL,EAAOK,CAAE,EAAIN,EAAOM,CAAE,EACtBL,EAAOK,EAAE,CAAE,EAAIN,EAAOM,EAAE,CAAE,EAE3B,OAAOR,CACR,CAaA,IAZKD,EAAU,EACdO,EAAK,GAAK,EAAET,GAAKE,EAEjBO,EAAK,EAEDL,EAAU,EACdM,EAAK,GAAK,EAAEV,GAAKI,EAEjBM,EAAK,EAENH,EAAKL,EAAU,EACfM,EAAKJ,EAAU,EACTO,EAAI,EAAGA,EAAIX,EAAGW,IACnBL,EAAOI,CAAG,EAAIL,EAAOI,CAAG,EACxBH,EAAOI,EAAG,CAAE,EAAIL,EAAOI,EAAG,CAAE,EAC5BA,GAAMF,EACNG,GAAMF,EAEP,OAAOL,CACR,CAKAN,EAAO,QAAUE,ICrGjB,IAAAa,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAc,QAAS,4CAA6C,EAoCxE,SAASC,EAAOC,EAAGC,EAAGC,EAASC,EAASC,EAAGC,EAASC,EAAU,CAC7D,IAAIC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAEJ,GAAKb,GAAK,EACT,OAAOI,EAQR,IANAG,EAAQT,EAAaG,EAAG,CAAE,EAC1BO,EAAQV,EAAaM,EAAG,CAAE,EAC1BK,EAAKP,EAAU,EACfQ,EAAKL,EAAU,EACfM,EAAKR,EAAU,EACfS,EAAKN,EAAU,EACTO,EAAI,EAAGA,EAAIb,EAAGa,IACnBL,EAAOI,CAAG,EAAIL,EAAOI,CAAG,EACxBH,EAAOI,EAAG,CAAE,EAAIL,EAAOI,EAAG,CAAE,EAC5BA,GAAMF,EACNG,GAAMF,EAEP,OAAON,CACR,CAKAP,EAAO,QAAUE,ICxFjB,IAAAe,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAc,QAAS,uDAAwD,EAC/EC,EAAQ,IACRC,EAAU,IAKdF,EAAaC,EAAO,UAAWC,CAAQ,EAKvCH,EAAO,QAAUE,ICkCjB,IAAIE,EAAO,QAAS,MAAO,EAAE,KACzBC,EAAa,QAAS,2BAA4B,EAClDC,EAAU,QAAS,yBAA0B,EAC7CC,EAAO,IAKPC,EACAC,EAAMJ,EAAYD,EAAM,UAAW,aAAc,CAAE,EAClDE,EAASG,CAAI,EACjBD,EAAQD,EAERC,EAAQC,EAMT,OAAO,QAAUD",
+  "names": ["require_ccopy", "__commonJSMin", "exports", "module", "reinterpret", "ccopy", "N", "x", "strideX", "y", "strideY", "viewX", "viewY", "sx", "sy", "ix", "iy", "i", "require_ndarray", "__commonJSMin", "exports", "module", "reinterpret", "ccopy", "N", "x", "strideX", "offsetX", "y", "strideY", "offsetY", "viewX", "viewY", "sx", "sy", "ix", "iy", "i", "require_main", "__commonJSMin", "exports", "module", "setReadOnly", "ccopy", "ndarray", "join", "tryRequire", "isError", "main", "ccopy", "tmp"]
+}

package/docs/types/index.d.ts

@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-// TypeScript Version: 2.0
+// TypeScript Version: 4.1
 
 /// <reference types="@stdlib/types"/>
 
@@ -29,12 +29,12 @@ interface Routine {
 	/**
 	* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
 	*
-	* @param N - number of values to copy
+	* @param N - number of indexed elements
 	* @param x - input array
 	* @param strideX - `x` stride length
-	* @param y - destination array
+	* @param y - output array
 	* @param strideY - `y` stride length
-	* @returns `y`
+	* @returns output array
 	*
 	* @example
 	* var Complex64Array = require( `@stdlib/array/complex64` );
@@ -60,14 +60,14 @@ interface Routine {
 	/**
 	* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector using alternative indexing semantics.
 	*
-	* @param N - number of values to copy
+	* @param N - number of indexed elements
 	* @param x - input array
 	* @param strideX - `x` stride length
 	* @param offsetX - starting index for `x`
-	* @param y - destination array
+	* @param y - output array
 	* @param strideY - `y` stride length
 	* @param offsetY - starting index for `y`
-	* @returns `y`
+	* @returns output array
 	*
 	* @example
 	* var Complex64Array = require( `@stdlib/array/complex64` );
@@ -94,12 +94,12 @@ interface Routine {
 /**
 * Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
 *
-* @param N - number of values to copy
+* @param N - number of indexed elements
 * @param x - input array
 * @param strideX - `x` stride length
-* @param y - destination array
+* @param y - output array
 * @param strideY - `y` stride length
-* @returns `y`
+* @returns output array
 *
 * @example
 * var Complex64Array = require( `@stdlib/array/complex64` );

package/include.gypi

@@ -52,7 +52,7 @@
 
     # Source files:
     'src_files': [
-      '<(src_dir)/addon.cpp',
+      '<(src_dir)/addon.c',
       '<!@(node -e "var arr = require(\'@stdlib/utils-library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).src; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
     ],
 

package/lib/ccopy.js

@@ -20,7 +20,7 @@
 
 // MODULES //
 
-var Float32Array = require( '@stdlib/array-float32' );
+var reinterpret = require( '@stdlib/strided-base-reinterpret-complex64' );
 
 
 // MAIN //
@@ -28,12 +28,12 @@ var Float32Array = require( '@stdlib/array-float32' );
 /**
 * Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
 *
-* @param {PositiveInteger} N - number of values to copy
+* @param {PositiveInteger} N - number of indexed elements
 * @param {Complex64Array} x - input array
 * @param {integer} strideX - `x` stride length
-* @param {Complex64Array} y - destination array
+* @param {Complex64Array} y - output array
 * @param {integer} strideY - `y` stride length
-* @returns {Complex64Array} `y`
+* @returns {Complex64Array} output array
 *
 * @example
 * var Complex64Array = require( '@stdlib/array-complex64' );
@@ -66,8 +66,8 @@ function ccopy( N, x, strideX, y, strideY ) {
 	if ( N <= 0 ) {
 		return y;
 	}
-	viewX = new Float32Array( x.buffer, x.byteOffset, x.length*2 );
-	viewY = new Float32Array( y.buffer, y.byteOffset, y.length*2 );
+	viewX = reinterpret( x, 0 );
+	viewY = reinterpret( y, 0 );
 	if ( strideX === 1 && strideY === 1 ) {
 		for ( i = 0; i < N*2; i += 2 ) {
 			viewY[ i ] = viewX[ i ];

package/lib/ccopy.native.js

@@ -20,7 +20,7 @@
 
 // MODULES //
 
-var Float32Array = require( '@stdlib/array-float32' );
+var reinterpret = require( '@stdlib/strided-base-reinterpret-complex64' );
 var addon = require( './../src/addon.node' );
 
 
@@ -29,12 +29,12 @@ var addon = require( './../src/addon.node' );
 /**
 * Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
 *
-* @param {PositiveInteger} N - number of values to copy
+* @param {PositiveInteger} N - number of indexed elements
 * @param {Complex64Array} x - input array
 * @param {integer} strideX - `x` stride length
-* @param {Complex64Array} y - destination array
+* @param {Complex64Array} y - output array
 * @param {integer} strideY - `y` stride length
-* @returns {Complex64Array} `y`
+* @returns {Complex64Array} output array
 *
 * @example
 * var Complex64Array = require( '@stdlib/array-complex64' );
@@ -56,8 +56,8 @@ var addon = require( './../src/addon.node' );
 * // returns 2.0
 */
 function ccopy( N, x, strideX, y, strideY ) {
-	var viewX = new Float32Array( x.buffer, x.byteOffset, x.length*2 );
-	var viewY = new Float32Array( y.buffer, y.byteOffset, y.length*2 );
+	var viewX = reinterpret( x, 0 );
+	var viewY = reinterpret( y, 0 );
 	addon( N, viewX, strideX, viewY, strideY );
 	return y;
 }

package/lib/ndarray.js

@@ -20,7 +20,7 @@
 
 // MODULES //
 
-var Float32Array = require( '@stdlib/array-float32' );
+var reinterpret = require( '@stdlib/strided-base-reinterpret-complex64' );
 
 
 // MAIN //
@@ -28,14 +28,14 @@ var Float32Array = require( '@stdlib/array-float32' );
 /**
 * Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
 *
-* @param {PositiveInteger} N - number of values to copy
+* @param {PositiveInteger} N - number of indexed elements
 * @param {Complex64Array} x - input array
 * @param {integer} strideX - `x` stride length
 * @param {NonNegativeInteger} offsetX - starting `x` index
-* @param {Complex64Array} y - destination array
+* @param {Complex64Array} y - output array
 * @param {integer} strideY - `y` stride length
 * @param {NonNegativeInteger} offsetY - starting `y` index
-* @returns {Complex64Array} `y`
+* @returns {Complex64Array} output array
 *
 * @example
 * var Complex64Array = require( '@stdlib/array-complex64' );
@@ -68,8 +68,8 @@ function ccopy( N, x, strideX, offsetX, y, strideY, offsetY ) {
 	if ( N <= 0 ) {
 		return y;
 	}
-	viewX = new Float32Array( x.buffer, x.byteOffset, x.length*2 );
-	viewY = new Float32Array( y.buffer, y.byteOffset, y.length*2 );
+	viewX = reinterpret( x, 0 );
+	viewY = reinterpret( y, 0 );
 	sx = strideX * 2;
 	sy = strideY * 2;
 	ix = offsetX * 2;

package/lib/ndarray.native.js

@@ -20,7 +20,8 @@
 
 // MODULES //
 
-var Float32Array = require( '@stdlib/array-float32' );
+var reinterpret = require( '@stdlib/strided-base-reinterpret-complex64' );
+var minViewBufferIndex = require( '@stdlib/strided-base-min-view-buffer-index' );
 var addon = require( './../src/addon.node' );
 
 
@@ -29,14 +30,14 @@ var addon = require( './../src/addon.node' );
 /**
 * Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
 *
-* @param {PositiveInteger} N - number of values to copy
+* @param {PositiveInteger} N - number of indexed elements
 * @param {Complex64Array} x - input array
 * @param {integer} strideX - `x` stride length
 * @param {NonNegativeInteger} offsetX - starting `x` index
-* @param {Complex64Array} y - destination array
+* @param {Complex64Array} y - output array
 * @param {integer} strideY - `y` stride length
 * @param {NonNegativeInteger} offsetY - starting `y` index
-* @returns {Complex64Array} `y`
+* @returns {Complex64Array} output array
 *
 * @example
 * var Complex64Array = require( '@stdlib/array-complex64' );
@@ -60,14 +61,13 @@ var addon = require( './../src/addon.node' );
 function ccopy( N, x, strideX, offsetX, y, strideY, offsetY ) {
 	var viewX;
 	var viewY;
-	if ( strideX < 0 ) {
-		offsetX += (N-1) * strideX;
-	}
-	if ( strideY < 0 ) {
-		offsetY += (N-1) * strideY;
-	}
-	viewX = new Float32Array( x.buffer, x.byteOffset+(x.BYTES_PER_ELEMENT*offsetX), 2*(x.length-offsetX) ); // eslint-disable-line max-len
-	viewY = new Float32Array( y.buffer, y.byteOffset+(y.BYTES_PER_ELEMENT*offsetY), 2*(y.length-offsetY) ); // eslint-disable-line max-len
+
+	offsetX = minViewBufferIndex( N, strideX, offsetX );
+	offsetY = minViewBufferIndex( N, strideY, offsetY );
+
+	viewX = reinterpret( x, offsetX );
+	viewY = reinterpret( y, offsetY );
+
 	addon( N, viewX, strideX, viewY, strideY );
 	return y;
 }