/*JSON{
"type" : "staticmethod",
"ifndef" : "SAVE_ON_FLASH",
"class" : "E",
"name" : "convolve",
"generate" : "jswrap_espruino_convolve",
"params" : [
["arr1","JsVar","An array to convolve"],
["arr2","JsVar","An array to convolve"],
["offset","int32","The mean value of the array"]
],
"return" : ["float","The variance of the given buffer"]
}
Convolve arr1 with arr2. This is equivalent to `v=0;for (i in arr1) v+=arr1[i] * arr2[(i+offset) % arr2.length]`
*/
JsVarFloat jswrap_espruino_convolve(JsVar *arr1, JsVar *arr2, int offset) {
if (!(jsvIsIterable(arr1)) ||
!(jsvIsIterable(arr2))) {
jsExceptionHere(JSET_ERROR, "Expecting first 2 arguments to be iterable, not %t and %t", arr1, arr2);
return NAN;
}
JsVarFloat conv = 0;
JsvIterator it1;
jsvIteratorNew(&it1, arr1);
JsvIterator it2;
jsvIteratorNew(&it2, arr2);
// get iterator2 at the correct offset
int l = (int)jsvGetLength(arr2);
offset = offset % l;
if (offset<0) offset += l;
while (offset-->0)
jsvIteratorNext(&it2);
while (jsvIteratorHasElement(&it1)) {
conv += jsvIteratorGetFloatValue(&it1) * jsvIteratorGetFloatValue(&it2);
jsvIteratorNext(&it1);
jsvIteratorNext(&it2);
// restart iterator if it hit the end
if (!jsvIteratorHasElement(&it2)) {
jsvIteratorFree(&it2);
jsvIteratorNew(&it2, arr2);
}
}
jsvIteratorFree(&it1);
jsvIteratorFree(&it2);
return conv;
}
/*JSON{
"type" : "staticmethod",
"ifndef" : "SAVE_ON_FLASH",
"class" : "E",
"name" : "sum",
"generate" : "jswrap_espruino_sum",
"params" : [
["arr","JsVar","The array to sum"]
],
"return" : ["float","The sum of the given buffer"]
}
Sum the contents of the given Array, String or ArrayBuffer and return the result
*/
JsVarFloat jswrap_espruino_sum(JsVar *arr) {
if (!(jsvIsString(arr) || jsvIsArray(arr) || jsvIsArrayBuffer(arr))) {
jsExceptionHere(JSET_ERROR, "Expecting first argument to be an array, not %t", arr);
return NAN;
}
JsVarFloat sum = 0;
JsvIterator itsrc;
jsvIteratorNew(&itsrc, arr);
while (jsvIteratorHasElement(&itsrc)) {
sum += jsvIteratorGetFloatValue(&itsrc);
jsvIteratorNext(&itsrc);
}
jsvIteratorFree(&itsrc);
return sum;
}
/*JSON{
"type" : "staticmethod",
"ifndef" : "SAVE_ON_FLASH",
"class" : "E",
"name" : "variance",
"generate" : "jswrap_espruino_variance",
"params" : [
["arr","JsVar","The array to work out the variance for"],
["mean","float","The mean value of the array"]
],
"return" : ["float","The variance of the given buffer"]
}
Work out the variance of the contents of the given Array, String or ArrayBuffer and return the result. This is equivalent to `v=0;for (i in arr) v+=Math.pow(mean-arr[i],2)`
*/
JsVarFloat jswrap_espruino_variance(JsVar *arr, JsVarFloat mean) {
if (!(jsvIsIterable(arr))) {
jsExceptionHere(JSET_ERROR, "Expecting first argument to be iterable, not %t", arr);
return NAN;
}
JsVarFloat variance = 0;
JsvIterator itsrc;
jsvIteratorNew(&itsrc, arr);
while (jsvIteratorHasElement(&itsrc)) {
JsVarFloat val = jsvIteratorGetFloatValue(&itsrc);
val -= mean;
variance += val*val;
jsvIteratorNext(&itsrc);
}
jsvIteratorFree(&itsrc);
return variance;
}
/*JSON{
"type" : "function",
"name" : "digitalPulse",
"generate" : "jswrap_io_digitalPulse",
"params" : [
["pin","pin","The pin to use"],
["value","bool","Whether to pulse high (true) or low (false)"],
["time","JsVar","A time in milliseconds, or an array of times (in which case a square wave will be output starting with a pulse of 'value')"]
]
}
Pulse the pin with the value for the given time in milliseconds. It uses a hardware timer to produce accurate pulses, and returns immediately (before the pulse has finished). Use `digitalPulse(A0,1,0)` to wait until a previous pulse has finished.
eg. `digitalPulse(A0,1,5);` pulses A0 high for 5ms. `digitalPulse(A0,1,[5,2,4]);` pulses A0 high for 5ms, low for 2ms, and high for 4ms
**Note:** if you didn't call `pinMode` beforehand then this function will also reset pin's state to `"output"`
digitalPulse is for SHORT pulses that need to be very accurate. If you're doing anything over a few milliseconds, use setTimeout instead.
*/
void jswrap_io_digitalPulse(Pin pin, bool value, JsVar *times) {
if (jsvIsNumeric(times)) {
JsVarFloat time = jsvGetFloat(times);
if (time<0 || isnan(time)) {
jsExceptionHere(JSET_ERROR, "Pulse Time given for digitalPulse is less than 0, or not a number");
} else {
jshPinPulse(pin, value, time);
}
} else if (jsvIsIterable(times)) {
// iterable, so output a square wave
JsvIterator it;
jsvIteratorNew(&it, times);
while (jsvIteratorHasElement(&it)) {
JsVarFloat time = jsvIteratorGetFloatValue(&it);
if (time>=0 && !isnan(time))
jshPinPulse(pin, value, time);
value = !value;
jsvIteratorNext(&it);
}
jsvIteratorFree(&it);
} else {
jsExceptionHere(JSET_ERROR, "Expecting a number or array, got %t", times);
}
}
/*JSON{
"type" : "staticmethod",
"ifndef" : "SAVE_ON_FLASH",
"class" : "E",
"name" : "FFT",
"generate" : "jswrap_espruino_FFT",
"params" : [
["arrReal","JsVar","An array of real values"],
["arrImage","JsVar","An array of imaginary values (or if undefined, all values will be taken to be 0)"],
["inverse","bool","Set this to true if you want an inverse FFT - otherwise leave as 0"]
]
}
Performs a Fast Fourier Transform (fft) on the supplied data and writes it back into the original arrays. Note that if only one array is supplied, the data written back is the modulus of the complex result `sqrt(r*r+i*i)`.
*/
void jswrap_espruino_FFT(JsVar *arrReal, JsVar *arrImag, bool inverse) {
if (!(jsvIsIterable(arrReal)) ||
!(jsvIsUndefined(arrImag) || jsvIsIterable(arrImag))) {
jsExceptionHere(JSET_ERROR, "Expecting first 2 arguments to be iterable or undefined, not %t and %t", arrReal, arrImag);
return;
}
// get length and work out power of 2
size_t l = (size_t)jsvGetLength(arrReal);
size_t pow2 = 1;
int order = 0;
while (pow2 < l) {
pow2 <<= 1;
order++;
}
if (jsuGetFreeStack() < 100+sizeof(double)*pow2*2) {
jsExceptionHere(JSET_ERROR, "Insufficient stack for computing FFT");
return;
}
double *vReal = (double*)alloca(sizeof(double)*pow2);
double *vImag = (double*)alloca(sizeof(double)*pow2);
unsigned int i;
for (i=0;i<pow2;i++) {
vReal[i]=0;
vImag[i]=0;
}
// load data
JsvIterator it;
jsvIteratorNew(&it, arrReal);
i=0;
while (jsvIteratorHasElement(&it)) {
vReal[i++] = jsvIteratorGetFloatValue(&it);
jsvIteratorNext(&it);
}
jsvIteratorFree(&it);
if (jsvIsIterable(arrImag)) {
jsvIteratorNew(&it, arrImag);
i=0;
while (i<pow2 && jsvIteratorHasElement(&it)) {
vImag[i++] = jsvIteratorGetFloatValue(&it);
jsvIteratorNext(&it);
}
jsvIteratorFree(&it);
}
// do FFT
FFT(inverse ? -1 : 1, order, vReal, vImag);
// Put the results back
bool useModulus = jsvIsIterable(arrImag);
jsvIteratorNew(&it, arrReal);
i=0;
while (jsvIteratorHasElement(&it)) {
JsVarFloat f;
if (useModulus)
f = jswrap_math_sqrt(vReal[i]*vReal[i] + vImag[i]*vImag[i]);
else
f = vReal[i];
jsvUnLock(jsvIteratorSetValue(&it, jsvNewFromFloat(f)));
i++;
jsvIteratorNext(&it);
}
jsvIteratorFree(&it);
if (jsvIsIterable(arrImag)) {
jsvIteratorNew(&it, arrImag);
i=0;
while (jsvIteratorHasElement(&it)) {
jsvUnLock(jsvIteratorSetValue(&it, jsvNewFromFloat(vImag[i++])));
jsvIteratorNext(&it);
}
jsvIteratorFree(&it);
}
}