├── .gitignore
├── .npmignore
├── .travis.yml
├── LICENSE
├── README.md
├── ndarray.js
├── package.json
└── test
    └── test.js


/.gitignore:
--------------------------------------------------------------------------------
 1 | lib-cov
 2 | *.seed
 3 | *.log
 4 | *.csv
 5 | *.dat
 6 | *.out
 7 | *.pid
 8 | *.gz
 9 | 
10 | pids
11 | logs
12 | results
13 | 
14 | npm-debug.log
15 | node_modules/*
16 | *.DS_Store


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
 1 | lib-cov
 2 | *.seed
 3 | *.log
 4 | *.csv
 5 | *.dat
 6 | *.out
 7 | *.pid
 8 | *.gz
 9 | 
10 | pids
11 | logs
12 | results
13 | 
14 | npm-debug.log
15 | node_modules/*
16 | *.DS_Store
17 | test/*


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "0.8"
4 |   - "0.10"
5 | before_install:
6 |   - npm install -g npm@~1.4.6
7 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | 
 2 | The MIT License (MIT)
 3 | 
 4 | Copyright (c) 2013-2016 Mikola Lysenko
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ndarray
  2 | =======
  3 | Modular multidimensional arrays for JavaScript. 
  4 | 
  5 | [![browser support](https://ci.testling.com/mikolalysenko/ndarray.png)
  6 | ](https://ci.testling.com/mikolalysenko/ndarray)
  7 | 
  8 | [![build status](https://secure.travis-ci.org/scijs/ndarray.png)](http://travis-ci.org/scijs/ndarray)
  9 | 
 10 | [![stable](https://rawgithub.com/hughsk/stability-badges/master/dist/frozen.svg)](http://github.com/hughsk/stability-badges)
 11 | 
 12 | ##### Browse a number of ndarray-compatible modules in the [scijs documentation](http://scijs.net/packages)
 13 | ##### Coming from MATLAB or numpy? See: [scijs/ndarray for MATLAB users](https://github.com/scijs/scijs-ndarray-for-matlab-users)
 14 | ##### [Big list of ndarray modules](https://github.com/scijs/ndarray/wiki/ndarray-module-list#core-module)
 15 | 
 16 | Introduction
 17 | ============
 18 | `ndarrays` provide higher dimensional views of 1D arrays.  For example, here is how you can turn a length 4 typed array into an nd-array:
 19 | 
 20 | ```javascript
 21 | var mat = ndarray(new Float64Array([1, 0, 0, 1]), [2,2])
 22 | 
 23 | //Now:
 24 | //
 25 | // mat = 1 0
 26 | //       0 1
 27 | //
 28 | ```
 29 | 
 30 | Once you have an nd-array you can access elements using `.set` and `.get`.  For example, here is an implementation of [Conway's game of life](http://en.wikipedia.org/wiki/Conway's_Game_of_Life) using ndarrays:
 31 | 
 32 | ```javascript
 33 | function stepLife(next_state, cur_state) {
 34 | 
 35 |   //Get array shape
 36 |   var nx = cur_state.shape[0], 
 37 |       ny = cur_state.shape[1]
 38 | 
 39 |   //Loop over all cells
 40 |   for(var i=1; i<nx-1; ++i) {
 41 |     for(var j=1; j<ny-1; ++j) {
 42 | 
 43 |       //Count neighbors
 44 |       var n = 0
 45 |       for(var dx=-1; dx<=1; ++dx) {
 46 |         for(var dy=-1; dy<=1; ++dy) {
 47 |           if(dx === 0 && dy === 0) {
 48 |             continue
 49 |           }
 50 |           n += cur_state.get(i+dx, j+dy)
 51 |         }
 52 |       }
 53 |       
 54 |       //Update state according to rule
 55 |       if(n === 3 || n === 3 + cur_state.get(i,j)) {
 56 |         next_state.set(i,j,1)
 57 |       } else {
 58 |         next_state.set(i,j,0)
 59 |       }
 60 |     }
 61 |   }
 62 | }
 63 | ```
 64 | 
 65 | You can also pull out views of ndarrays without copying the underlying elements.  Here is an example showing how to update part of a subarray:
 66 | 
 67 | ```javascript
 68 | var x = ndarray(new Float32Array(25), [5, 5])
 69 | var y = x.hi(4,4).lo(1,1)
 70 | 
 71 | for(var i=0; i<y.shape[0]; ++i) {
 72 |   for(var j=0; j<y.shape[1]; ++j) {
 73 |     y.set(i,j,1)
 74 |   }
 75 | }
 76 | 
 77 | //Now:
 78 | //    x = 0 0 0 0 0
 79 | //        0 1 1 1 0
 80 | //        0 1 1 1 0
 81 | //        0 1 1 1 0
 82 | //        0 0 0 0 0
 83 | ```
 84 | 
 85 | ndarrays can be transposed, flipped, sheared and sliced in constant time per operation. They are useful for representing images, audio, volume graphics, matrices, strings and much more. They work both in node.js and with [browserify](http://browserify.org/).
 86 | 
 87 | Install
 88 | =======
 89 | Install the library using [npm](http://npmjs.org):
 90 | 
 91 | ```sh
 92 | npm install ndarray
 93 | ```
 94 | 
 95 | You can also use ndarrays in a browser with any tool that follows the CommonJS/node module conventions.  The most direct way to do this is to use [browserify](https://github.com/substack/node-browserify).  If you want live-reloading for faster debugging, check out [beefy](https://github.com/chrisdickinson/beefy).
 96 | 
 97 | API
 98 | ===
 99 | Once you have ndarray installed, you can use it in your project as follows:
100 | 
101 | ```javascript
102 | var ndarray = require("ndarray")
103 | ```
104 | 
105 | ## Constructor
106 | 
107 | ### `ndarray(data[, shape, stride, offset])`
108 | The default `module.exports` method is the constructor for ndarrays.  It creates an n-dimensional array view wrapping an underlying storage type
109 | 
110 | * `data` is a 1D array storage.  It is either an instance of `Array`, a typed array, or an object that implements `get(), set(), .length`
111 | * `shape` is the shape of the view (Default: `data.length`)
112 | * `stride` is the resulting stride of the new array.  (Default: row major)
113 | * `offset` is the offset to start the view (Default: `0`)
114 | 
115 | **Returns** an n-dimensional array view of the buffer
116 | 
117 | ## Members
118 | 
119 | The central concept in `ndarray` is the idea of a view.  The way these work is very similar to [SciPy's array slices](http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html).  Views are affine projections to 1D storage types.  To better understand what this means, let's first look at the properties of the view object.  It has exactly 4 variables:
120 | 
121 | * `array.data` - The underlying 1D storage for the multidimensional array
122 | * `array.shape` - The shape of the typed array
123 | * `array.stride` - The layout of the typed array in memory
124 | * `array.offset` - The starting offset of the array in memory
125 | 
126 | Keeping a separate stride means that we can use the same data structure to support both [row major and column major storage](http://en.wikipedia.org/wiki/Row-major_order)
127 | 
128 | ## Element Access
129 | To access elements of the array, you can use the `set/get` methods:
130 | 
131 | ### `array.get(i,j,...)`
132 | Retrieves element `i,j,...` from the array.  In psuedocode, this is implemented as follows:
133 | 
134 | ```javascript
135 | function get(i,j,...) {
136 |   return this.data[this.offset + this.stride[0] * i + this.stride[1] * j + ... ]
137 | }
138 | ```
139 | 
140 | ### `array.set(i,j,...,v)`
141 | Sets element `i,j,...` to `v`. Again, in psuedocode this works like this:
142 | 
143 | ```javascript
144 | function set(i,j,...,v) {
145 |   return this.data[this.offset + this.stride[0] * i + this.stride[1] * j + ... ] = v
146 | }
147 | ```
148 | 
149 | ### `array.index(i,j, ...)`
150 | Retrieves the index of the cell in the underlying ndarray.  In JS,
151 | 
152 | ```javascript
153 | function index(i,j, ...) {
154 |   return this.offset + this.stride[0] * i + this.stride[1] * j + ...
155 | }
156 | ```
157 | 
158 | ## Properties
159 | The following properties are created using Object.defineProperty and do not take up any physical memory.  They can be useful in calculations involving ndarrays
160 | 
161 | ### `array.dtype`
162 | Returns a string representing the undelying data type of the ndarray.  Excluding generic data stores these types are compatible with [`typedarray-pool`](https://github.com/mikolalysenko/typedarray-pool).  This is mapped according to the following rules:
163 | 
164 | Data type | String
165 | --------: | :-----
166 | `Int8Array` | "int8"
167 | `Int16Array` | "int16"
168 | `Int32Array` | "int32"
169 | `Uint8Array` | "uint8"
170 | `Uint16Array` | "uint16"
171 | `Uint32Array` | "uint32"
172 | `BigInt64Array` | "bigint64"
173 | `BigUint64Array` | "biguint64"
174 | `Float32Array` | "float32"
175 | `Float64Array` | "float64"
176 | `Array` | "array"
177 | `Uint8ArrayClamped` | "uint8_clamped"
178 | `Buffer` | "buffer"
179 | Other | "generic"
180 | 
181 | Generic arrays access elements of the underlying 1D store using get()/set() instead of array accessors.
182 | 
183 | ### `array.size`
184 | Returns the size of the array in logical elements.
185 | 
186 | ### `array.order`
187 | Returns the order of the stride of the array, sorted in ascending length. The first element is the first index of the shortest stride and the last is the index the longest stride.
188 | 
189 | ### `array.dimension`
190 | Returns the dimension of the array.
191 | 
192 | ## Slicing
193 | Given a view, we can change the indexing by shifting, truncating or permuting the strides.  This lets us perform operations like array reversals or matrix transpose in **constant time** (well, technically `O(shape.length)`, but since shape.length is typically less than 4, it might as well be).  To make life simpler, the following interfaces are exposed:
194 | 
195 | ### `array.lo(i,j,k,...)`
196 | This creates a shifted view of the array.  Think of it as taking the upper left corner of the image and dragging it inward by an amount equal to `(i,j,k...)`.
197 | 
198 | ### `array.hi(i,j,k,...)`
199 | This does the dual of `array.lo()`.  Instead of shifting from the top-left, it truncates from the bottom-right of the array, returning a smaller array object.   Using `hi` and `lo` in combination lets you select ranges in the middle of an array.
200 | 
201 | **Note:**  `hi` and `lo` do not commute.   In general:
202 | 
203 | ```javascript
204 | a.hi(3,3).lo(3,3)  !=  a.lo(3,3).hi(3,3)
205 | ```
206 | 
207 | ### `array.step(i,j,k...)`
208 | Changes the stride length by rescaling.  Negative indices flip axes.  For example, here is how you create a reversed view of a 1D array:
209 | 
210 | ```javascript
211 | var reversed = a.step(-1)
212 | ```
213 | 
214 | You can also change the step size to be greater than 1 if you like, letting you skip entries of a list.  For example, here is how to split an array into even and odd components:
215 | 
216 | ```javascript
217 | var evens = a.step(2)
218 | var odds = a.lo(1).step(2)
219 | ```
220 | 
221 | ### `array.transpose(p0, p1, ...)`
222 | Finally, for higher dimensional arrays you can transpose the indices without replicating the data.  This has the effect of permuting the shape and stride values and placing the result in a new view of the same data.  For example, in a 2D array you can calculate the matrix transpose by:
223 | 
224 | ```javascript
225 | M.transpose(1, 0)
226 | ```
227 | 
228 | Or if you have a 3D volume image, you can shift the axes using more generic transformations:
229 | 
230 | ```javascript
231 | volume.transpose(2, 0, 1)
232 | ```
233 | 
234 | ### `array.pick(p0, p1, ...)`
235 | You can also pull out a subarray from an ndarray by fixing a particular axis.  The way this works is you specify the direction you are picking by giving a list of values.  For example, if you have an image stored as an nxmx3 array you can pull out the channel as follows:
236 | 
237 | ```javascript
238 | var red   = image.pick(null, null, 0)
239 | var green = image.pick(null, null, 1)
240 | var blue  = image.pick(null, null, 2)
241 | ```
242 | 
243 | As the above example illustrates, passing a negative or non-numeric value to a coordinate in pick skips that index.
244 | 
245 | # More information
246 | 
247 | For more discussion about ndarrays, here are some talks, tutorials and articles about them:
248 | 
249 | * [ndarray presentation](http://mikolalysenko.github.io/ndarray-presentation/)
250 | * [Implementing multidimensional arrays in JavaScript](http://0fps.wordpress.com/2013/05/22/implementing-multidimensional-arrays-in-javascript/)
251 | * [Cache oblivious array operations](http://0fps.wordpress.com/2013/05/28/cache-oblivious-array-operations/)
252 | * [Some experiments](https://github.com/mikolalysenko/ndarray-experiments)
253 | 
254 | License
255 | =======
256 | (c) 2013-2016 Mikola Lysenko. MIT License
257 | 


--------------------------------------------------------------------------------
/ndarray.js:
--------------------------------------------------------------------------------
  1 | var iota = require("iota-array")
  2 | var isBuffer = require("is-buffer")
  3 | 
  4 | var hasTypedArrays  = ((typeof Float64Array) !== "undefined")
  5 | 
  6 | function compare1st(a, b) {
  7 |   return a[0] - b[0]
  8 | }
  9 | 
 10 | function order() {
 11 |   var stride = this.stride
 12 |   var terms = new Array(stride.length)
 13 |   var i
 14 |   for(i=0; i<terms.length; ++i) {
 15 |     terms[i] = [Math.abs(stride[i]), i]
 16 |   }
 17 |   terms.sort(compare1st)
 18 |   var result = new Array(terms.length)
 19 |   for(i=0; i<result.length; ++i) {
 20 |     result[i] = terms[i][1]
 21 |   }
 22 |   return result
 23 | }
 24 | 
 25 | function compileConstructor(dtype, dimension) {
 26 |   var className = ["View", dimension, "d", dtype].join("")
 27 |   if(dimension < 0) {
 28 |     className = "View_Nil" + dtype
 29 |   }
 30 |   var useGetters = (dtype === "generic")
 31 | 
 32 |   if(dimension === -1) {
 33 |     //Special case for trivial arrays
 34 |     var code =
 35 |       "function "+className+"(a){this.data=a;};\
 36 | var proto="+className+".prototype;\
 37 | proto.dtype='"+dtype+"';\
 38 | proto.index=function(){return -1};\
 39 | proto.size=0;\
 40 | proto.dimension=-1;\
 41 | proto.shape=proto.stride=proto.order=[];\
 42 | proto.lo=proto.hi=proto.transpose=proto.step=\
 43 | function(){return new "+className+"(this.data);};\
 44 | proto.get=proto.set=function(){};\
 45 | proto.pick=function(){return null};\
 46 | return function construct_"+className+"(a){return new "+className+"(a);}"
 47 |     var procedure = new Function(code)
 48 |     return procedure()
 49 |   } else if(dimension === 0) {
 50 |     //Special case for 0d arrays
 51 |     var code =
 52 |       "function "+className+"(a,d) {\
 53 | this.data = a;\
 54 | this.offset = d\
 55 | };\
 56 | var proto="+className+".prototype;\
 57 | proto.dtype='"+dtype+"';\
 58 | proto.index=function(){return this.offset};\
 59 | proto.dimension=0;\
 60 | proto.size=1;\
 61 | proto.shape=\
 62 | proto.stride=\
 63 | proto.order=[];\
 64 | proto.lo=\
 65 | proto.hi=\
 66 | proto.transpose=\
 67 | proto.step=function "+className+"_copy() {\
 68 | return new "+className+"(this.data,this.offset)\
 69 | };\
 70 | proto.pick=function "+className+"_pick(){\
 71 | return TrivialArray(this.data);\
 72 | };\
 73 | proto.valueOf=proto.get=function "+className+"_get(){\
 74 | return "+(useGetters ? "this.data.get(this.offset)" : "this.data[this.offset]")+
 75 | "};\
 76 | proto.set=function "+className+"_set(v){\
 77 | return "+(useGetters ? "this.data.set(this.offset,v)" : "this.data[this.offset]=v")+"\
 78 | };\
 79 | return function construct_"+className+"(a,b,c,d){return new "+className+"(a,d)}"
 80 |     var procedure = new Function("TrivialArray", code)
 81 |     return procedure(CACHED_CONSTRUCTORS[dtype][0])
 82 |   }
 83 | 
 84 |   var code = ["'use strict'"]
 85 | 
 86 |   //Create constructor for view
 87 |   var indices = iota(dimension)
 88 |   var args = indices.map(function(i) { return "i"+i })
 89 |   var index_str = "this.offset+" + indices.map(function(i) {
 90 |         return "this.stride[" + i + "]*i" + i
 91 |       }).join("+")
 92 |   var shapeArg = indices.map(function(i) {
 93 |       return "b"+i
 94 |     }).join(",")
 95 |   var strideArg = indices.map(function(i) {
 96 |       return "c"+i
 97 |     }).join(",")
 98 |   code.push(
 99 |     "function "+className+"(a," + shapeArg + "," + strideArg + ",d){this.data=a",
100 |       "this.shape=[" + shapeArg + "]",
101 |       "this.stride=[" + strideArg + "]",
102 |       "this.offset=d|0}",
103 |     "var proto="+className+".prototype",
104 |     "proto.dtype='"+dtype+"'",
105 |     "proto.dimension="+dimension)
106 | 
107 |   //view.size:
108 |   code.push("Object.defineProperty(proto,'size',{get:function "+className+"_size(){\
109 | return "+indices.map(function(i) { return "this.shape["+i+"]" }).join("*"),
110 | "}})")
111 | 
112 |   //view.order:
113 |   if(dimension === 1) {
114 |     code.push("proto.order=[0]")
115 |   } else {
116 |     code.push("Object.defineProperty(proto,'order',{get:")
117 |     if(dimension < 4) {
118 |       code.push("function "+className+"_order(){")
119 |       if(dimension === 2) {
120 |         code.push("return (Math.abs(this.stride[0])>Math.abs(this.stride[1]))?[1,0]:[0,1]}})")
121 |       } else if(dimension === 3) {
122 |         code.push(
123 | "var s0=Math.abs(this.stride[0]),s1=Math.abs(this.stride[1]),s2=Math.abs(this.stride[2]);\
124 | if(s0>s1){\
125 | if(s1>s2){\
126 | return [2,1,0];\
127 | }else if(s0>s2){\
128 | return [1,2,0];\
129 | }else{\
130 | return [1,0,2];\
131 | }\
132 | }else if(s0>s2){\
133 | return [2,0,1];\
134 | }else if(s2>s1){\
135 | return [0,1,2];\
136 | }else{\
137 | return [0,2,1];\
138 | }}})")
139 |       }
140 |     } else {
141 |       code.push("ORDER})")
142 |     }
143 |   }
144 | 
145 |   //view.set(i0, ..., v):
146 |   code.push(
147 | "proto.set=function "+className+"_set("+args.join(",")+",v){")
148 |   if(useGetters) {
149 |     code.push("return this.data.set("+index_str+",v)}")
150 |   } else {
151 |     code.push("return this.data["+index_str+"]=v}")
152 |   }
153 | 
154 |   //view.get(i0, ...):
155 |   code.push("proto.get=function "+className+"_get("+args.join(",")+"){")
156 |   if(useGetters) {
157 |     code.push("return this.data.get("+index_str+")}")
158 |   } else {
159 |     code.push("return this.data["+index_str+"]}")
160 |   }
161 | 
162 |   //view.index:
163 |   code.push(
164 |     "proto.index=function "+className+"_index(", args.join(), "){return "+index_str+"}")
165 | 
166 |   //view.hi():
167 |   code.push("proto.hi=function "+className+"_hi("+args.join(",")+"){return new "+className+"(this.data,"+
168 |     indices.map(function(i) {
169 |       return ["(typeof i",i,"!=='number'||i",i,"<0)?this.shape[", i, "]:i", i,"|0"].join("")
170 |     }).join(",")+","+
171 |     indices.map(function(i) {
172 |       return "this.stride["+i + "]"
173 |     }).join(",")+",this.offset)}")
174 | 
175 |   //view.lo():
176 |   var a_vars = indices.map(function(i) { return "a"+i+"=this.shape["+i+"]" })
177 |   var c_vars = indices.map(function(i) { return "c"+i+"=this.stride["+i+"]" })
178 |   code.push("proto.lo=function "+className+"_lo("+args.join(",")+"){var b=this.offset,d=0,"+a_vars.join(",")+","+c_vars.join(","))
179 |   for(var i=0; i<dimension; ++i) {
180 |     code.push(
181 | "if(typeof i"+i+"==='number'&&i"+i+">=0){\
182 | d=i"+i+"|0;\
183 | b+=c"+i+"*d;\
184 | a"+i+"-=d}")
185 |   }
186 |   code.push("return new "+className+"(this.data,"+
187 |     indices.map(function(i) {
188 |       return "a"+i
189 |     }).join(",")+","+
190 |     indices.map(function(i) {
191 |       return "c"+i
192 |     }).join(",")+",b)}")
193 | 
194 |   //view.step():
195 |   code.push("proto.step=function "+className+"_step("+args.join(",")+"){var "+
196 |     indices.map(function(i) {
197 |       return "a"+i+"=this.shape["+i+"]"
198 |     }).join(",")+","+
199 |     indices.map(function(i) {
200 |       return "b"+i+"=this.stride["+i+"]"
201 |     }).join(",")+",c=this.offset,d=0,ceil=Math.ceil")
202 |   for(var i=0; i<dimension; ++i) {
203 |     code.push(
204 | "if(typeof i"+i+"==='number'){\
205 | d=i"+i+"|0;\
206 | if(d<0){\
207 | c+=b"+i+"*(a"+i+"-1);\
208 | a"+i+"=ceil(-a"+i+"/d)\
209 | }else{\
210 | a"+i+"=ceil(a"+i+"/d)\
211 | }\
212 | b"+i+"*=d\
213 | }")
214 |   }
215 |   code.push("return new "+className+"(this.data,"+
216 |     indices.map(function(i) {
217 |       return "a" + i
218 |     }).join(",")+","+
219 |     indices.map(function(i) {
220 |       return "b" + i
221 |     }).join(",")+",c)}")
222 | 
223 |   //view.transpose():
224 |   var tShape = new Array(dimension)
225 |   var tStride = new Array(dimension)
226 |   for(var i=0; i<dimension; ++i) {
227 |     tShape[i] = "a[i"+i+"]"
228 |     tStride[i] = "b[i"+i+"]"
229 |   }
230 |   code.push("proto.transpose=function "+className+"_transpose("+args+"){"+
231 |     args.map(function(n,idx) { return n + "=(" + n + "===undefined?" + idx + ":" + n + "|0)"}).join(";"),
232 |     "var a=this.shape,b=this.stride;return new "+className+"(this.data,"+tShape.join(",")+","+tStride.join(",")+",this.offset)}")
233 | 
234 |   //view.pick():
235 |   code.push("proto.pick=function "+className+"_pick("+args+"){var a=[],b=[],c=this.offset")
236 |   for(var i=0; i<dimension; ++i) {
237 |     code.push("if(typeof i"+i+"==='number'&&i"+i+">=0){c=(c+this.stride["+i+"]*i"+i+")|0}else{a.push(this.shape["+i+"]);b.push(this.stride["+i+"])}")
238 |   }
239 |   code.push("var ctor=CTOR_LIST[a.length+1];return ctor(this.data,a,b,c)}")
240 | 
241 |   //Add return statement
242 |   code.push("return function construct_"+className+"(data,shape,stride,offset){return new "+className+"(data,"+
243 |     indices.map(function(i) {
244 |       return "shape["+i+"]"
245 |     }).join(",")+","+
246 |     indices.map(function(i) {
247 |       return "stride["+i+"]"
248 |     }).join(",")+",offset)}")
249 | 
250 |   //Compile procedure
251 |   var procedure = new Function("CTOR_LIST", "ORDER", code.join("\n"))
252 |   return procedure(CACHED_CONSTRUCTORS[dtype], order)
253 | }
254 | 
255 | function arrayDType(data) {
256 |   if(isBuffer(data)) {
257 |     return "buffer"
258 |   }
259 |   if(hasTypedArrays) {
260 |     switch(Object.prototype.toString.call(data)) {
261 |       case "[object Float64Array]":
262 |         return "float64"
263 |       case "[object Float32Array]":
264 |         return "float32"
265 |       case "[object Int8Array]":
266 |         return "int8"
267 |       case "[object Int16Array]":
268 |         return "int16"
269 |       case "[object Int32Array]":
270 |         return "int32"
271 |       case "[object Uint8Array]":
272 |         return "uint8"
273 |       case "[object Uint16Array]":
274 |         return "uint16"
275 |       case "[object Uint32Array]":
276 |         return "uint32"
277 |       case "[object Uint8ClampedArray]":
278 |         return "uint8_clamped"
279 |       case "[object BigInt64Array]":
280 |         return "bigint64"
281 |       case "[object BigUint64Array]":
282 |         return "biguint64"
283 |     }
284 |   }
285 |   if(Array.isArray(data)) {
286 |     return "array"
287 |   }
288 |   return "generic"
289 | }
290 | 
291 | var CACHED_CONSTRUCTORS = {
292 |   "float32":[],
293 |   "float64":[],
294 |   "int8":[],
295 |   "int16":[],
296 |   "int32":[],
297 |   "uint8":[],
298 |   "uint16":[],
299 |   "uint32":[],
300 |   "array":[],
301 |   "uint8_clamped":[],
302 |   "bigint64": [],
303 |   "biguint64": [],
304 |   "buffer":[],
305 |   "generic":[]
306 | }
307 | 
308 | ;(function() {
309 |   for(var id in CACHED_CONSTRUCTORS) {
310 |     CACHED_CONSTRUCTORS[id].push(compileConstructor(id, -1))
311 |   }
312 | });
313 | 
314 | function wrappedNDArrayCtor(data, shape, stride, offset) {
315 |   if(data === undefined) {
316 |     var ctor = CACHED_CONSTRUCTORS.array[0]
317 |     return ctor([])
318 |   } else if(typeof data === "number") {
319 |     data = [data]
320 |   }
321 |   if(shape === undefined) {
322 |     shape = [ data.length ]
323 |   }
324 |   var d = shape.length
325 |   if(stride === undefined) {
326 |     stride = new Array(d)
327 |     for(var i=d-1, sz=1; i>=0; --i) {
328 |       stride[i] = sz
329 |       sz *= shape[i]
330 |     }
331 |   }
332 |   if(offset === undefined) {
333 |     offset = 0
334 |     for(var i=0; i<d; ++i) {
335 |       if(stride[i] < 0) {
336 |         offset -= (shape[i]-1)*stride[i]
337 |       }
338 |     }
339 |   }
340 |   var dtype = arrayDType(data)
341 |   var ctor_list = CACHED_CONSTRUCTORS[dtype]
342 |   while(ctor_list.length <= d+1) {
343 |     ctor_list.push(compileConstructor(dtype, ctor_list.length-1))
344 |   }
345 |   var ctor = ctor_list[d+1]
346 |   return ctor(data, shape, stride, offset)
347 | }
348 | 
349 | module.exports = wrappedNDArrayCtor
350 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ndarray",
 3 |   "version": "1.0.19",
 4 |   "description": "Multidimensional Arrays",
 5 |   "main": "ndarray.js",
 6 |   "directories": {
 7 |     "test": "test"
 8 |   },
 9 |   "dependencies": {
10 |     "iota-array": "^1.0.0",
11 |     "is-buffer": "^1.0.2"
12 |   },
13 |   "devDependencies": {
14 |     "permutation-rank": "^1.0.0",
15 |     "dup": "^1.0.0",
16 |     "invert-permutation": "^1.0.0",
17 |     "tape": "^2.12.3"
18 |   },
19 |   "scripts": {
20 |     "test": "tape test/*.js"
21 |   },
22 |   "repository": {
23 |     "type": "git",
24 |     "url": "git://github.com/mikolalysenko/ndarray.git"
25 |   },
26 |   "keywords": [
27 |     "ndarray",
28 |     "array",
29 |     "multi",
30 |     "multidimensional",
31 |     "dimension",
32 |     "higher",
33 |     "image",
34 |     "volume",
35 |     "webgl",
36 |     "tensor",
37 |     "matrix",
38 |     "linear",
39 |     "algebra",
40 |     "science",
41 |     "numerical",
42 |     "computing",
43 |     "stride",
44 |     "shape"
45 |   ],
46 |   "author": "Mikola Lysenko",
47 |   "license": "MIT",
48 |   "readmeFilename": "README.md",
49 |   "gitHead": "a85785ca7a7e12c3fc29671a4f7c214bebc4ddc7",
50 |   "testling": {
51 |     "files": "test/*.js",
52 |     "browsers": [
53 |       "ie/10..latest",
54 |       "firefox/17..latest",
55 |       "firefox/nightly",
56 |       "chrome/22..latest",
57 |       "chrome/canary",
58 |       "opera/12..latest",
59 |       "opera/next",
60 |       "safari/6.0..latest",
61 |       "ipad/6.0..latest",
62 |       "iphone/6.0..latest",
63 |       "android-browser/4.2..latest"
64 |     ]
65 |   }
66 | }
67 | 


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
  1 | var test = require("tape")
  2 | var perm = require("permutation-rank")
  3 | var invPerm = require("invert-permutation")
  4 | var dup = require("dup")
  5 | var ndarray = require("../ndarray.js")
  6 | 
  7 | test("ndarray", function(t) {
  8 | 
  9 |   var p = ndarray(new Float32Array([1,2,3,4]), [2,2])
 10 | 
 11 |   t.equals(p.dtype, "float32")
 12 |   t.equals(p.shape.length, 2)
 13 |   t.equals(p.shape[0], 2)
 14 |   t.equals(p.shape[1], 2)
 15 |   t.equals(p.stride[0], 2)
 16 |   t.equals(p.stride[1], 1)
 17 |   
 18 |   t.end()
 19 | })
 20 | 
 21 | test("index", function(t) {
 22 | 
 23 |   var p = ndarray(new Float32Array([1,2,3,4]), [2,2])
 24 | 
 25 |   t.equals(p.index(0,0), 0)
 26 |   t.equals(p.index(0,1), 1)
 27 |   t.equals(p.index(1,0), 2)
 28 |   t.equals(p.index(1,1), 3)
 29 |   t.end()
 30 | })
 31 | 
 32 | test("scalars", function(t) {
 33 |   var p = ndarray(new Float32Array([1,2,3,4]))
 34 |   var c = p.pick(0)
 35 |   t.equals(c.get(), 1)
 36 |   t.equals(c.set(10), 10)
 37 |   t.equals(p.get(0), 10)
 38 |   c = p.pick(3)
 39 |   t.equals(c.index(), 3)
 40 |   t.same(c.shape, [])
 41 |   t.same(c.order, [])
 42 |   t.same(c.stride, [])
 43 |   t.equals(c.get(), 4)
 44 |   t.same(c.lo(), c)
 45 |   t.equals(c + 1, 5)
 46 |   //Test trivial array
 47 |   t.equals(c.pick().dimension, -1)
 48 |   t.end()
 49 | })
 50 | 
 51 | if((typeof Uint8ClampedArray) !== "undefined")
 52 | test("uint8clamped", function(t) {
 53 |   var p = ndarray(new Uint8ClampedArray([1,2,3,4]), [4])
 54 |   t.equals(p.dtype, "uint8_clamped")
 55 |   t.equals(p.get(0), 1)
 56 |   t.equals(p.get(1), 2)
 57 |   t.equals(p.get(2), 3)
 58 |   t.equals(p.get(3), 4)
 59 |   p.set(0, 1000)
 60 |   t.equals(p.get(0), 255)
 61 |   p.set(1, -1000)
 62 |   t.equals(p.get(1), 0)
 63 |   t.end()
 64 | })
 65 | 
 66 | if((typeof BigInt64Array) !== "undefined")
 67 | test("bigint64", function(t) {
 68 |   var p = ndarray(new BigInt64Array([1,2,3,4].map(BigInt)), [4])
 69 |   t.equals(p.dtype, "bigint64")
 70 |   t.equals(p.get(0), BigInt(1))
 71 |   t.equals(p.get(1), BigInt(2))
 72 |   t.equals(p.get(2), BigInt(3))
 73 |   t.equals(p.get(3), BigInt(4))
 74 |   t.end()
 75 | })
 76 | 
 77 | test("buffer", function(t) {
 78 |   var p = ndarray(new Buffer(5))
 79 |   t.equals(p.dtype, "buffer")
 80 |   p.set(0, 1)
 81 |   p.set(1, 2)
 82 |   p.set(2, 3)
 83 |   p.set(3, 4)
 84 |   t.equals(p.get(0), 1)
 85 |   t.equals(p.get(1), 2)
 86 |   t.equals(p.get(2), 3)
 87 |   t.equals(p.get(3), 4)
 88 |   t.end()
 89 | })
 90 | 
 91 | test("dtypes", function(t) {
 92 |   t.equals(ndarray(new Uint8Array(5)).dtype, "uint8")
 93 |   t.equals(ndarray(new Uint16Array(5)).dtype, "uint16")
 94 |   t.equals(ndarray(new Uint32Array(5)).dtype, "uint32")
 95 |   t.equals(ndarray(new Int8Array(5)).dtype, "int8")
 96 |   t.equals(ndarray(new Int16Array(5)).dtype, "int16")
 97 |   t.equals(ndarray(new Int32Array(5)).dtype, "int32")
 98 |   t.equals(ndarray(new Float32Array(5)).dtype, "float32")
 99 |   t.equals(ndarray(new Float64Array(5)).dtype, "float64")
100 |   t.equals(ndarray([1,2,3]).dtype, "array")
101 |   t.end()
102 | })
103 | 
104 | test("shape/stride", function(t) {
105 | 
106 |   var p = ndarray(new Float32Array(100), [3,3,3], [3,2,1])
107 |   
108 |   t.equals(p.dtype, "float32")
109 |   t.equals(p.shape[0], 3)
110 |   p.shape[0] = 1
111 |   t.equals(p.shape[0], 1)
112 |   t.equals(p.shape[1], 3)
113 |   t.equals(p.shape[2], 3)
114 |   
115 |   t.end()
116 | })
117 | 
118 | test("order", function(t) {
119 |   t.same(ndarray([0]).pick(0).order, [])
120 |   var f = 1
121 |   for(var d=1; d<=5; ++d) {
122 |     f *= d
123 |     for(var r=0; r<f; ++r) {
124 |       var p = perm.unrank(d, r)
125 |       var x = ndarray([1], dup(d), p)
126 |       t.same(x.order, invPerm(p.slice(0)), x.stride.join(","))
127 |     }
128 |   }
129 |   t.end()
130 | })
131 | 
132 | test("pick", function(t) {
133 | 
134 |   var x = ndarray(new Float32Array(25), [5, 5])
135 |   
136 |   x.set(0, 0, 1)
137 |   x.set(4, 0, 5)
138 |   x.set(0, 4, 10)
139 |   
140 |   var y = x.pick(0)
141 |   t.equals(y.get(0), 1)
142 |   t.equals(y.get(1), 0)
143 |   t.equals(y.get(2), 0)
144 |   t.equals(y.get(3), 0)
145 |   t.equals(y.get(4), 10)
146 |   t.equals(y.shape.join(","), "5")
147 | 
148 |   y = x.pick(-1, 0)
149 |   t.equals(y.get(0), 1)
150 |   t.equals(y.get(1), 0)
151 |   t.equals(y.get(2), 0)
152 |   t.equals(y.get(3), 0)
153 |   t.equals(y.get(4), 5)
154 |   t.equals(y.shape.join(","), "5")
155 |   
156 |   y = x.pick(undefined, 0)
157 |   t.equals(y.get(0), 1)
158 |   t.equals(y.get(1), 0)
159 |   t.equals(y.get(2), 0)
160 |   t.equals(y.get(3), 0)
161 |   t.equals(y.get(4), 5)
162 |   t.equals(y.shape.join(","), "5")
163 | 
164 |   y = x.pick(null, 0)
165 |   t.equals(y.get(0), 1)
166 |   t.equals(y.get(1), 0)
167 |   t.equals(y.get(2), 0)
168 |   t.equals(y.get(3), 0)
169 |   t.equals(y.get(4), 5)
170 |   t.equals(y.shape.join(","), "5")
171 |   
172 |   t.end()
173 | })
174 | 
175 | 
176 | test("accessor", function(t) {
177 |   for(var d=1; d<5; ++d) {
178 |     var shape = new Array(d)
179 |     for(var i=0; i<d; ++i) {
180 |       shape[i] = 3
181 |     }
182 |     var x = ndarray(new Float32Array(1000), shape)
183 |     x.set(1,1,1,1,1,1,1,1,1)
184 |     t.equals(x.get(1,1,1,1,1,1,1), 1, "get/set array d=" + d)
185 |     
186 |     var array1D = ndarray(new Int8Array(1000))
187 |     var x = ndarray(array1D, shape)
188 |     x.set(1,1,1,1,1,1,1,1,1)
189 |     t.equals(x.get(1,1,1,1,1,1,1), 1, "get/set generic d=" + d)
190 |   }
191 | 
192 |   t.end()
193 | })
194 | 
195 | test("size", function(t) {
196 |   var x = ndarray(new Float32Array(100), [2, 3, 5])
197 |   t.equals(x.size, 2*3*5)
198 |   t.equals(x.pick(0,0,0).size, 1)
199 |   for(var d=1; d<5; ++d) {
200 |     var x = ndarray(new Float32Array(256), dup(d,2))
201 |     t.equals(x.size, 1<<d, "size d="+d)
202 |   }
203 |   t.end()
204 | })
205 | 
206 | test("lo", function(t) {
207 | 
208 |   var x = ndarray(new Float32Array(9), [3, 3])
209 |     , y = x.lo(1, 2)
210 |   t.equals(y.shape.join(","), "2,1")
211 |   t.equals(y.stride.join(","), x.stride.join(","))
212 |   t.equals(y.offset, 3+2)
213 |   
214 |   y.set(0, 0, 1)
215 |   t.equals(x.get(1, 2), 1)
216 | 
217 |   t.end()
218 | })
219 | 
220 | test("hi", function(t) {
221 |   var x = ndarray(new Float32Array(9), [3, 3])
222 |     , y = x.hi(1, 2)
223 |   t.equals(y.shape.join(","), "1,2")
224 |   t.equals(y.stride.join(","), x.stride.join(","))
225 |   t.equals(y.offset, 0)
226 | 
227 |   y.set(0, 1, 1)
228 |   t.equals(x.get(0, 1), 1)
229 | 
230 |   t.equals(x.hi(undefined, 2).shape.join(","), "3,2")
231 | 
232 |   t.end()
233 | })
234 | 
235 | 
236 | test("step", function(t) {
237 |   var x = ndarray(new Float32Array(10))
238 |   for(var i=0; i<10; ++i) {
239 |     x.set(i, i)
240 |   }
241 |   
242 |   var y = x.step(-1)
243 |   for(var i=0; i<10; ++i) {
244 |     t.equals(y.get(i), (9-i))
245 |   }
246 |   
247 |   var z = y.step(-1)
248 |   for(var i=0; i<10; ++i) {
249 |     t.equals(z.get(i), i)
250 |   }
251 |   
252 |   var w = x.step(2)
253 |   t.equals(w.shape[0], 5)
254 |   for(var i=0; i<5; ++i) {
255 |     t.equals(w.get(i), 2*i)
256 |   }
257 |   
258 |   var a = w.step(-1), b = y.step(2)
259 |   t.same(a.shape.toString(), b.shape.toString())
260 |   for(var i=0; i<5; ++i) {
261 |     t.equals(a.get(i)+1, b.get(i))
262 |   }
263 | 
264 |   t.end()
265 | })
266 | 
267 | test("transpose", function(t) {
268 |   var x = ndarray(new Array(6), [2,3])
269 |   var y = x.transpose(1, 0)
270 |   t.equals(x.shape[0], y.shape[1])
271 |   t.equals(x.shape[1], y.shape[0])
272 |   t.equals(x.stride[0], y.stride[1])
273 |   t.equals(x.stride[1], y.stride[0])
274 |   
275 |   var f = 1
276 |   var shape = []
277 |   for(var d=1; d<=5; ++d) {
278 |     shape.push(d)
279 |     f *= d
280 |     var x = ndarray(new Array(f), shape, shape)
281 |     for(var r=0; r<f; ++r) {
282 |       var p = perm.unrank(d, r)
283 |       var xt = x.transpose.apply(x, p)
284 |       var xord = xt.order
285 |       var pinv = invPerm(p.slice(0))
286 |       t.same(xord, pinv)
287 |       for(var i=0; i<d; ++i) {
288 |         t.equals(xt.shape[i], x.shape[p[i]])
289 |         t.equals(xt.stride[i], x.stride[p[i]])
290 |       }
291 |     }
292 |   }
293 |   
294 |   t.end()
295 | })
296 | 
297 | test("toJSON", function(t) {
298 | 
299 |   var x = ndarray(new Float32Array(10))
300 |   
301 |   t.same(JSON.stringify(x.shape), "[10]")
302 |   
303 |   t.end()
304 | })
305 | 
306 | test("generic", function(t) {
307 |   var hash = {}
308 |   var hashStore = {
309 |     get: function(i) {
310 |       return +hash[i]
311 |     },
312 |     set: function(i,v) {
313 |       return hash[i]=v
314 |     },
315 |     length: Infinity
316 |   }
317 |   var array = ndarray(hashStore, [1000,1000,1000])
318 | 
319 |   t.equals(array.dtype, "generic")
320 |   t.same(array.shape.slice(), [1000,1000,1000])
321 | 
322 |   array.set(10,10,10, 1)
323 |   t.equals(array.get(10,10,10), 1)
324 |   t.equals(array.pick(10).dtype, "generic")
325 |   t.equals(+array.pick(10).pick(10).pick(10), 1)
326 |   
327 |   t.end()
328 | })


--------------------------------------------------------------------------------