create array methods deasyncifyed

unbornchikken · unbornchikken · commit 560897f1aeea · 2015-06-18T22:08:57.000+02:00
diff --git a/documentation/docs/create.md b/documentation/docs/create.md
@@ -19,15 +19,13 @@
 
 ## randu()
 
-asynchronous, counterparts: `randuAsync()`, `randuSync()`
-
 Create a random array sampled from uniform distribution.
 
-- `randu(dim0, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#gab3e2105aec551cb0bbcf104d437c0481)
-- `randu(dim0, dim1, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#ga9a08025609da7db72c3a22493f85a171)
-- `randu(dim0, dim1, dim2, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#gae0d335466e5f5a1cb821dc241804923b)
-- `randu(dim0, dim1, dim2, dim3, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#gac05c5b2de1cfc2d763b7d2943e9deee3)
-- `randu(dims, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#ga15a5110a447509cab9589b2ad56c5e55)
+- `randu(dim0, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#gab3e2105aec551cb0bbcf104d437c0481)
+- `randu(dim0, dim1, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#ga9a08025609da7db72c3a22493f85a171)
+- `randu(dim0, dim1, dim2, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#gae0d335466e5f5a1cb821dc241804923b)
+- `randu(dim0, dim1, dim2, dim3, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#gac05c5b2de1cfc2d763b7d2943e9deee3)
+- `randu(dims, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randu.htm#ga15a5110a447509cab9589b2ad56c5e55)
 
 **Arguments:**
 
@@ -43,15 +41,13 @@ alias of [randu()](#randu)
 
 ## randn()
 
-asynchronous, counterparts: `randnAsync()`, `randnSync()`
-
 Create a random array sampled from normal distribution.
 
-- `randn(dim0, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#ga5d7b55d3d0f34d71f30a70ed7a2d928d)
-- `randn(dim0, dim1, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#ga5fe422f8cf2acc3c6f782f9148360f6c)
-- `randn(dim0, dim1, dim2, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#ga150fb95ddda0e37e8961254ca7afc8e5)
-- `randn(dim0, dim1, dim2, dim3, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#ga9bc154f0bf07116ad208b2da4b71c3d8)
-- `randn(dims, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#gae8aa1f5ec310aeb9e4cbd19d63998349)
+- `randn(dim0, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#ga5d7b55d3d0f34d71f30a70ed7a2d928d)
+- `randn(dim0, dim1, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#ga5fe422f8cf2acc3c6f782f9148360f6c)
+- `randn(dim0, dim1, dim2, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#ga150fb95ddda0e37e8961254ca7afc8e5)
+- `randn(dim0, dim1, dim2, dim3, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#ga9bc154f0bf07116ad208b2da4b71c3d8)
+- `randn(dims, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__randn.htm#gae8aa1f5ec310aeb9e4cbd19d63998349)
 
 **Arguments:**
 
@@ -67,15 +63,13 @@ alias of [randn()](#randn)
 
 ## identity()
 
-asynchronous, counterparts: `identityAsync()`, `identitySync()`
-
 Create an identity matrix (array with diagonal values 1).
 
-- `identity(dim0, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#ga3f69c0a0ab7ba0c8c1ee3223772234b8)
-- `identity(dim0, dim1, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#gaff9da6e4b83772359d748a4df66ec571)
-- `identity(dim0, dim1, dim2, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#ga405b89c8f04901d58287fd6a8f5612c3)
-- `identity(dim0, dim1, dim2, dim3, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#ga8e6605d76748c5fff365830e1a153132)
-- `identity(dims, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#gafd8247e22fdb50218926d5d9391fa678)
+- `identity(dim0, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#ga3f69c0a0ab7ba0c8c1ee3223772234b8)
+- `identity(dim0, dim1, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#gaff9da6e4b83772359d748a4df66ec571)
+- `identity(dim0, dim1, dim2, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#ga405b89c8f04901d58287fd6a8f5612c3)
+- `identity(dim0, dim1, dim2, dim3, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#ga8e6605d76748c5fff365830e1a153132)
+- `identity(dims, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__identity.htm#gafd8247e22fdb50218926d5d9391fa678)
 
 **Arguments:**
 
@@ -87,15 +81,13 @@ Create an identity matrix (array with diagonal values 1).
 
 ## range()
 
-asynchronous, counterparts: `rangeAsync()`, `rangeSync()`
-
 Creates an array with [0, n] values along the seqDim which is tiled across other dimensions.
 
-- `range(dim0, seqDim, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga1e2ae1f90d99f42854a19877261ac455)
-- `range(dim0, dim1, seqDim, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga1e2ae1f90d99f42854a19877261ac455)
-- `range(dim0, dim1, dim2, seqDim, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga1e2ae1f90d99f42854a19877261ac455)
-- `range(dim0, dim1, dim2, dim3, seqDim, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga1e2ae1f90d99f42854a19877261ac455)
-- `range(dims, seqDim, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga3789475e962b4c31e07c1c3bdab8498b)
+- `range(dim0, seqDim, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga1e2ae1f90d99f42854a19877261ac455)
+- `range(dim0, dim1, seqDim, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga1e2ae1f90d99f42854a19877261ac455)
+- `range(dim0, dim1, dim2, seqDim, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga1e2ae1f90d99f42854a19877261ac455)
+- `range(dim0, dim1, dim2, dim3, seqDim, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga1e2ae1f90d99f42854a19877261ac455)
+- `range(dims, seqDim, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__range.htm#ga3789475e962b4c31e07c1c3bdab8498b)
 
 **Arguments:**
 
@@ -108,11 +100,9 @@ Creates an array with [0, n] values along the seqDim which is tiled across other
 
 ## iota()
 
-asynchronous, counterparts: `iotaAsync()`, `iotaSync()`
-
 Create an sequence [0, dims.elements - 1] and modify to specified dimensions dims and then tile it according to tileDims.
 
-- `iota(dims, tileDims, type, callback)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__iota.htm#ga8f7c55a54d1f93e55340f59b61662f29)
+- `iota(dims, tileDims, type)`: [-> ArrayFire Documentation](http://www.arrayfire.com/docs/group__data__func__iota.htm#ga8f7c55a54d1f93e55340f59b61662f29)
 
 **Arguments:**
 
@@ -124,8 +114,6 @@ Create an sequence [0, dims.elements - 1] and modify to specified dimensions dim
 
 ## diag()
 
-asynchronous, counterparts: `diagAsync()`, `diagSync()`
-
 Extract diagonal from a matrix when `extract` is set to `true`. 
 
 Create a diagonal marix from input array when `extract` is set to `false`.
@@ -140,15 +128,13 @@ Create a diagonal marix from input array when `extract` is set to `false`.
 
 ## constant()
 
-asynchronous, counterparts: `constantAsync()`, `constantSync()`
-
 Create an array filled with the specified value.
 
-- `constant(value, dim0, type, callback)`
-- `constant(value, dim0, dim1, type, callback)`
-- `constant(value, dim0, dim1, dim2, type, callback)`
-- `constant(value, dim0, dim1, dim2, dim3, type, callback)`
-- `constant(value, dims, type, callback)`
+- `constant(value, dim0, type)`
+- `constant(value, dim0, dim1, type)`
+- `constant(value, dim0, dim1, dim2, type)`
+- `constant(value, dim0, dim1, dim2, dim3, type)`
+- `constant(value, dims, type)`
 
 **Arguments:**
 
diff --git a/examples/es6/bechmarks/pi.js b/examples/es6/bechmarks/pi.js
@@ -14,11 +14,11 @@ let pi = async(function*(fire, deviceInfo) {
     common.printDeviceInfo(deviceInfo);
     console.log("");
 
-    let x = yield fire.randuAsync(numberOfPoints, fire.types.dtype.f32);
-    let y = yield fire.randuAsync(numberOfPoints, fire.types.dtype.f32);
+    let x = fire.randu(numberOfPoints, fire.types.dtype.f32);
+    let y = fire.randu(numberOfPoints, fire.types.dtype.f32);
     let dist = yield fire.sqrtAsync((x.mul(x)).add(y.mul(y)));
-    let num_inside = yield fire.sumAsync(dist.lt(1));
-    let piVal = (4.0 *  num_inside) / numberOfPoints;
+    let numInside = yield fire.sumAsync(dist.lt(1));
+    let piVal = (4.0 *  numInside) / numberOfPoints;
 
     console.log(`PI = ${piVal}`);
 });
diff --git a/src/createarray.cpp b/src/createarray.cpp
@@ -33,8 +33,10 @@ NAN_METHOD(RandU)
 
     try
     {
+        ARGS_LEN(2);
         auto dimAndType = ParseDimAndTypeArgs(args);
-        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::randu(dimAndType.first, dimAndType.second))); });
+        Guard();
+        NanReturnValue(ArrayWrapper::New(af::randu(dimAndType.first, dimAndType.second)));
     }
     FIRE_CATCH
 }
@@ -45,10 +47,13 @@ NAN_METHOD(RandN)
 
     try
     {
+        ARGS_LEN(2);
         auto dimAndType = ParseDimAndTypeArgs(args);
         if (dimAndType.second == f32 || dimAndType.second == f64)
         {
-            return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::randn(dimAndType.first, dimAndType.second))); });
+            Guard();
+            NanReturnValue(ArrayWrapper::New(af::randn(dimAndType.first, dimAndType.second)));
+            return;
         }
         return NAN_THROW_INVALID_DTYPE();
     }
@@ -61,8 +66,10 @@ NAN_METHOD(Identity)
 
     try
     {
+        ARGS_LEN(2);
         auto dimAndType = ParseDimAndTypeArgs(args);
-        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::identity(dimAndType.first, dimAndType.second))); });
+        Guard();
+        NanReturnValue(ArrayWrapper::New(af::identity(dimAndType.first, dimAndType.second)));
     }
     FIRE_CATCH
 }
@@ -73,10 +80,11 @@ NAN_METHOD(Range)
 
     try
     {
-        ARGS_LEN(4);
+        ARGS_LEN(3);
         auto dimAndType = ParseDimAndTypeArgs(args, -1, 1);
-        af_dtype seqDim = (af_dtype)args[args.Length() - 3]->Uint32Value();
-        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::range(dimAndType.first, seqDim, dimAndType.second))); });
+        af_dtype seqDim = (af_dtype)args[args.Length() - 2]->Uint32Value();
+        Guard();
+        NanReturnValue(ArrayWrapper::New(af::range(dimAndType.first, seqDim, dimAndType.second)));
     }
     FIRE_CATCH
 }
@@ -87,11 +95,12 @@ NAN_METHOD(Iota)
 
     try
     {
-        ARGS_LEN(4);
+        ARGS_LEN(3);
         auto dims = ToDim4(args[0]);
         auto titleDims = ToDim4(args[1]);
         auto type = GetDTypeInfo(args[3]->Uint32Value());
-        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::iota(dims, titleDims, type.first))); });
+        Guard();
+        NanReturnValue(ArrayWrapper::New(af::iota(dims, titleDims, type.first)));
     }
     FIRE_CATCH
 }
@@ -114,8 +123,8 @@ NAN_METHOD(Diag)
         {
             extract = args[2]->BooleanValue();
         }
-        af::array array(*pArray);
-        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::diag(array, num, extract))); });
+        Guard();
+        NanReturnValue(ArrayWrapper::New(af::diag(*pArray, num, extract)));
     }
     FIRE_CATCH
 }
@@ -131,23 +140,30 @@ NAN_METHOD(Constant)
         ARGS_LEN(3);
         auto dimAndType = ParseDimAndTypeArgs(args, -1, 0, 1);
         auto value = args[0];
+        Guard();
         if (value->IsNumber())
         {
             double v = value->NumberValue();
             switch (dimAndType.second)
             {
                 case f32:
-                    return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<float>(v, dimAndType.first, dimAndType.second))); });
+                    NanReturnValue(ArrayWrapper::New(af::constant<float>(v, dimAndType.first, dimAndType.second)));
+                    return;
                 case f64:
-                    return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<double>(v, dimAndType.first, dimAndType.second))); });
+                    NanReturnValue(ArrayWrapper::New(af::constant<double>(v, dimAndType.first, dimAndType.second)));
+                    return;
                 case s32:
-                    return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<int>(v, dimAndType.first, dimAndType.second))); });
+                    NanReturnValue(ArrayWrapper::New(af::constant<int>(v, dimAndType.first, dimAndType.second)));
+                    return;
                 case u32:
-                    return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<unsigned>(v, dimAndType.first, dimAndType.second))); });
+                    NanReturnValue(ArrayWrapper::New(af::constant<unsigned>(v, dimAndType.first, dimAndType.second)));
+                    return;
                 case u8:
-                    return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<unsigned char>(v, dimAndType.first, dimAndType.second))); });
+                    NanReturnValue(ArrayWrapper::New(af::constant<unsigned char>(v, dimAndType.first, dimAndType.second)));
+                    return;
                 case b8:
-                    return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<char>(v, dimAndType.first, dimAndType.second))); });
+                    NanReturnValue(ArrayWrapper::New(af::constant<char>(v, dimAndType.first, dimAndType.second)));
+                    return;
                 default:
                     break;
             }
@@ -159,12 +175,14 @@ NAN_METHOD(Constant)
                 case c32:
                     {
                         auto cv = ToFComplex(value.As<Object>());
-                        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<af::cfloat>(cv, dimAndType.first, dimAndType.second))); });
+                        NanReturnValue(ArrayWrapper::New(af::constant<af::cfloat>(cv, dimAndType.first, dimAndType.second)));
+                        return;
                     }
                 case c64:
                     {
                         auto cv = ToDComplex(value.As<Object>());
-                        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<af::cdouble>(cv, dimAndType.first, dimAndType.second))); });
+                        NanReturnValue(ArrayWrapper::New(af::constant<af::cdouble>(cv, dimAndType.first, dimAndType.second)));
+                        return;
                     }
                 default:
                     break;
@@ -178,22 +196,24 @@ NAN_METHOD(Constant)
                 case s64:
                     {
                         long long val = strtoll(*str, nullptr, 10);
-                        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<long long>(val, dimAndType.first, dimAndType.second))); });
+                        NanReturnValue(ArrayWrapper::New(af::constant<long long>(val, dimAndType.first, dimAndType.second)));
+                        return;
                     }
                 case u64:
                     {
                         unsigned long long val = strtoll(*str, nullptr, 10);
-                        return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<unsigned long long>(val, dimAndType.first, dimAndType.second))); });
+                        NanReturnValue(ArrayWrapper::New(af::constant<unsigned long long>(val, dimAndType.first, dimAndType.second)));
+                        return;
                     }
                 default:
                     break;
             }
         }
         else
         {
-            throw new logic_error("Argument at position 0 is not a constant.");
+            FIRE_THROW("Argument at position 0 is not a constant.");
         }
-        throw new logic_error("Type is unknown.");
+        FIRE_THROW("Type is unknown.");
     }
     FIRE_CATCH
 }
diff --git a/src/helpers.h b/src/helpers.h
@@ -253,7 +253,7 @@ NAN_METHOD(F)\
         ARGS_LEN(2);\
         \
         auto array = *ArrayWrapper::GetArrayAt(args, 0);\
-        if (af::isDoubleAvailable(af::getDevice()))\
+        if (NeedsDouble(array))\
         {\
             typedef std::pair<double, unsigned> PairT;\
             typedef Worker<PairT> WorkerT;\
diff --git a/tests/es6/createArrayFunctionTests.js b/tests/es6/createArrayFunctionTests.js

Original file line number	Diff line number	Diff line change
`@@ -33,8 +33,10 @@ NAN_METHOD(RandU)`
`33`	`33`
`34`	`34`	`try`
`35`	`35`	`{`
	`36`	`+ ARGS_LEN(2);`
`36`	`37`	`auto dimAndType = ParseDimAndTypeArgs(args);`
`37`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::randu(dimAndType.first, dimAndType.second))); });`
	`38`	`+ Guard();`
	`39`	`+ NanReturnValue(ArrayWrapper::New(af::randu(dimAndType.first, dimAndType.second)));`
`38`	`40`	`}`
`39`	`41`	`FIRE_CATCH`
`40`	`42`	`}`
`@@ -45,10 +47,13 @@ NAN_METHOD(RandN)`
`45`	`47`
`46`	`48`	`try`
`47`	`49`	`{`
	`50`	`+ ARGS_LEN(2);`
`48`	`51`	`auto dimAndType = ParseDimAndTypeArgs(args);`
`49`	`52`	`if (dimAndType.second == f32 \|\| dimAndType.second == f64)`
`50`	`53`	`{`
`51`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::randn(dimAndType.first, dimAndType.second))); });`
	`54`	`+ Guard();`
	`55`	`+ NanReturnValue(ArrayWrapper::New(af::randn(dimAndType.first, dimAndType.second)));`
	`56`	`+ return;`
`52`	`57`	`}`
`53`	`58`	`return NAN_THROW_INVALID_DTYPE();`
`54`	`59`	`}`
`@@ -61,8 +66,10 @@ NAN_METHOD(Identity)`
`61`	`66`
`62`	`67`	`try`
`63`	`68`	`{`
	`69`	`+ ARGS_LEN(2);`
`64`	`70`	`auto dimAndType = ParseDimAndTypeArgs(args);`
`65`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::identity(dimAndType.first, dimAndType.second))); });`
	`71`	`+ Guard();`
	`72`	`+ NanReturnValue(ArrayWrapper::New(af::identity(dimAndType.first, dimAndType.second)));`
`66`	`73`	`}`
`67`	`74`	`FIRE_CATCH`
`68`	`75`	`}`
`@@ -73,10 +80,11 @@ NAN_METHOD(Range)`
`73`	`80`
`74`	`81`	`try`
`75`	`82`	`{`
`76`		`- ARGS_LEN(4);`
	`83`	`+ ARGS_LEN(3);`
`77`	`84`	`auto dimAndType = ParseDimAndTypeArgs(args, -1, 1);`
`78`		`- af_dtype seqDim = (af_dtype)args[args.Length() - 3]->Uint32Value();`
`79`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::range(dimAndType.first, seqDim, dimAndType.second))); });`
	`85`	`+ af_dtype seqDim = (af_dtype)args[args.Length() - 2]->Uint32Value();`
	`86`	`+ Guard();`
	`87`	`+ NanReturnValue(ArrayWrapper::New(af::range(dimAndType.first, seqDim, dimAndType.second)));`
`80`	`88`	`}`
`81`	`89`	`FIRE_CATCH`
`82`	`90`	`}`
`@@ -87,11 +95,12 @@ NAN_METHOD(Iota)`
`87`	`95`
`88`	`96`	`try`
`89`	`97`	`{`
`90`		`- ARGS_LEN(4);`
	`98`	`+ ARGS_LEN(3);`
`91`	`99`	`auto dims = ToDim4(args[0]);`
`92`	`100`	`auto titleDims = ToDim4(args[1]);`
`93`	`101`	`auto type = GetDTypeInfo(args[3]->Uint32Value());`
`94`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::iota(dims, titleDims, type.first))); });`
	`102`	`+ Guard();`
	`103`	`+ NanReturnValue(ArrayWrapper::New(af::iota(dims, titleDims, type.first)));`
`95`	`104`	`}`
`96`	`105`	`FIRE_CATCH`
`97`	`106`	`}`
`@@ -114,8 +123,8 @@ NAN_METHOD(Diag)`
`114`	`123`	`{`
`115`	`124`	`extract = args[2]->BooleanValue();`
`116`	`125`	`}`
`117`		`- af::array array(*pArray);`
`118`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::diag(array, num, extract))); });`
	`126`	`+ Guard();`
	`127`	`+ NanReturnValue(ArrayWrapper::New(af::diag(*pArray, num, extract)));`
`119`	`128`	`}`
`120`	`129`	`FIRE_CATCH`
`121`	`130`	`}`
`@@ -131,23 +140,30 @@ NAN_METHOD(Constant)`
`131`	`140`	`ARGS_LEN(3);`
`132`	`141`	`auto dimAndType = ParseDimAndTypeArgs(args, -1, 0, 1);`
`133`	`142`	`auto value = args[0];`
	`143`	`+ Guard();`
`134`	`144`	`if (value->IsNumber())`
`135`	`145`	`{`
`136`	`146`	`double v = value->NumberValue();`
`137`	`147`	`switch (dimAndType.second)`
`138`	`148`	`{`
`139`	`149`	`case f32:`
`140`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<float>(v, dimAndType.first, dimAndType.second))); });`
	`150`	`+ NanReturnValue(ArrayWrapper::New(af::constant<float>(v, dimAndType.first, dimAndType.second)));`
	`151`	`+ return;`
`141`	`152`	`case f64:`
`142`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<double>(v, dimAndType.first, dimAndType.second))); });`
	`153`	`+ NanReturnValue(ArrayWrapper::New(af::constant<double>(v, dimAndType.first, dimAndType.second)));`
	`154`	`+ return;`
`143`	`155`	`case s32:`
`144`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<int>(v, dimAndType.first, dimAndType.second))); });`
	`156`	`+ NanReturnValue(ArrayWrapper::New(af::constant<int>(v, dimAndType.first, dimAndType.second)));`
	`157`	`+ return;`
`145`	`158`	`case u32:`
`146`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<unsigned>(v, dimAndType.first, dimAndType.second))); });`
	`159`	`+ NanReturnValue(ArrayWrapper::New(af::constant<unsigned>(v, dimAndType.first, dimAndType.second)));`
	`160`	`+ return;`
`147`	`161`	`case u8:`
`148`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<unsigned char>(v, dimAndType.first, dimAndType.second))); });`
	`162`	`+ NanReturnValue(ArrayWrapper::New(af::constant<unsigned char>(v, dimAndType.first, dimAndType.second)));`
	`163`	`+ return;`
`149`	`164`	`case b8:`
`150`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<char>(v, dimAndType.first, dimAndType.second))); });`
	`165`	`+ NanReturnValue(ArrayWrapper::New(af::constant<char>(v, dimAndType.first, dimAndType.second)));`
	`166`	`+ return;`
`151`	`167`	`default:`
`152`	`168`	`break;`
`153`	`169`	`}`
`@@ -159,12 +175,14 @@ NAN_METHOD(Constant)`
`159`	`175`	`case c32:`
`160`	`176`	`{`
`161`	`177`	`auto cv = ToFComplex(value.As<Object>());`
`162`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<af::cfloat>(cv, dimAndType.first, dimAndType.second))); });`
	`178`	`+ NanReturnValue(ArrayWrapper::New(af::constant<af::cfloat>(cv, dimAndType.first, dimAndType.second)));`
	`179`	`+ return;`
`163`	`180`	`}`
`164`	`181`	`case c64:`
`165`	`182`	`{`
`166`	`183`	`auto cv = ToDComplex(value.As<Object>());`
`167`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<af::cdouble>(cv, dimAndType.first, dimAndType.second))); });`
	`184`	`+ NanReturnValue(ArrayWrapper::New(af::constant<af::cdouble>(cv, dimAndType.first, dimAndType.second)));`
	`185`	`+ return;`
`168`	`186`	`}`
`169`	`187`	`default:`
`170`	`188`	`break;`
`@@ -178,22 +196,24 @@ NAN_METHOD(Constant)`
`178`	`196`	`case s64:`
`179`	`197`	`{`
`180`	`198`	`long long val = strtoll(*str, nullptr, 10);`
`181`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<long long>(val, dimAndType.first, dimAndType.second))); });`
	`199`	`+ NanReturnValue(ArrayWrapper::New(af::constant<long long>(val, dimAndType.first, dimAndType.second)));`
	`200`	`+ return;`
`182`	`201`	`}`
`183`	`202`	`case u64:`
`184`	`203`	`{`
`185`	`204`	`unsigned long long val = strtoll(*str, nullptr, 10);`
`186`		`- return ArrayWrapper::NewAsync(args, [=]() { Guard(); return new af::array(move(af::constant<unsigned long long>(val, dimAndType.first, dimAndType.second))); });`
	`205`	`+ NanReturnValue(ArrayWrapper::New(af::constant<unsigned long long>(val, dimAndType.first, dimAndType.second)));`
	`206`	`+ return;`
`187`	`207`	`}`
`188`	`208`	`default:`
`189`	`209`	`break;`
`190`	`210`	`}`
`191`	`211`	`}`
`192`	`212`	`else`
`193`	`213`	`{`
`194`		`- throw new logic_error("Argument at position 0 is not a constant.");`
	`214`	`+ FIRE_THROW("Argument at position 0 is not a constant.");`
`195`	`215`	`}`
`196`		`- throw new logic_error("Type is unknown.");`
	`216`	`+ FIRE_THROW("Type is unknown.");`
`197`	`217`	`}`
`198`	`218`	`FIRE_CATCH`
`199`	`219`	`}`
Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,7 @@ NAN_METHOD(F)\`
`253`	`253`	`ARGS_LEN(2);\`
`254`	`254`	`\`
`255`	`255`	`auto array = *ArrayWrapper::GetArrayAt(args, 0);\`
`256`		`- if (af::isDoubleAvailable(af::getDevice()))\`
	`256`	`+ if (NeedsDouble(array))\`
`257`	`257`	`{\`
`258`	`258`	`typedef std::pair<double, unsigned> PairT;\`
`259`	`259`	`typedef Worker<PairT> WorkerT;\`