31:T5c1,{ const log = []; const sigList = []; const signals = {}; function initSignal(code, sigFun) { const s = {outputKey: code}; sigFun.apply(s); log.push("Init "+code+" fun:" + sigFun.evaluateSignal); sigList.push(s); signals[code] = s; } //======================================= // Start of wrapper for signalA initSignal("A", function() { // Start of signalA evalscript const twoVal = 2; function evaluateSignal(signalResults, samples) { return twoVal * samples * samples; } //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this.eval = evaluateSignal; }); //======================================= // Start of wrapper for signalB initSignal("B", function() { // Start of signalB evalscript function evaluateSignal(signalResults, samples) { return 2 * signalResults.A / 32; // <-- Use the result of signalA } // End of signalB evalscript this.eval = evaluateSignal; }); //================================================== // Aggregation code - glue together all the wrappers function evaluate(param) { const ret = {}; sigList.forEach(s => { log.push("Calling " + s.outputKey +" with " + param + ", " +JSON.stringify(ret)); ret[s.outputKey] = s.eval(ret, param); log.push("Signal " + s.outputKey +" computed " + ret[s.outputKey]); }); ret.log = log; return ret; } return evaluate(4); }32:T656,{ const log = []; function evaluate(param) { //======================================= // Start of wrapper for signalA const signals = {}; { //------------------------------------- // Start of signalA evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV function evaluate(param) { log.push("Eval A called"); const ret = 2 * doStuff(param); log.push("Computed A"); return ret; } function doStuff(param) { return param*param; } //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalA evalscript //------------------------------------- signals.signalA = evaluate(param); }; //======================================= // Start of wrapper for signalB { //------------------------------------- // Start of signalB evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV function evaluate(param) { log.push("Eval B called"); const ret = doStuff(signals.signalA); log.push("Computed B"); return ret; } function doStuff(param) { return 2 * param/32; } //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalB evalscript //-------------------------------------- signals.signalB = evaluate(param); } //================================================== // Aggregation code - glue together all the wrappers return ({ signalB: signals.signalB, signalA: signals.signalA, log: log }) } return evaluate(4); }33:T861,{ const log = []; //======================================= // Start of wrapper for signalA const signalA = { outputKey : "A", init : function() { //------------------------------------- // Start of signalA evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV this.evaluate = function(param) { log.push("Eval A called"); const ret = signalB.twoVal * param * param; // <-- Use a constant or utility function from another signal log.push("Computed A"); return ret; } //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalA evalscript //------------------------------------- if (this.evaluate === undefined) { this.evaluate = evaluate; } } }; //======================================= // Start of wrapper for signalB const signalB = { outputKey : "B", init : function() { //------------------------------------- // Start of signalB evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV this.twoVal = 2; function evaluate(param) { log.push("Eval B called"); const ret = this.twoVal * signalA.result / 32; // <-- Use the result of signalA log.push("Computed B"); return ret; } //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalB evalscript //------------------------------------- if (!this.evaluate) { this.evaluate = evaluate } // capture 'evaluate' function so we can reference it } }; //================================================== // Aggregation code - glue together all the wrappers function evaluate(param) { const ret = {}; const signals = [signalA, signalB]; //list signals in correct order here signals.forEach(s => s.init()); signals.forEach(s => { s.result = s.evaluate(param) ret[s.outputKey] = s.result; }); ret.log = log; return ret; } return evaluate(4); }34:T7a9,{ const log = []; const sigList = []; const signals = {}; function initSignal(code, sigFun) { const s = {outputKey: code}; sigFun.apply(s); sigList.push(s); signals[code] = s; } //======================================= // Start of wrapper for signalA initSignal("A", function() { //------------------------------------- // Start of signalA evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV this.twoVal = 2; function evaluate(signalResults, samples/*, ...*/) { log.push("Eval A called"); const ret = this.twoVal * samples * samples; // <-- Use a constant or utility function from another signal log.push("Computed A"); return ret; } //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalA evalscript //------------------------------------- this.evaluate = evaluate; // capture 'evaluate' function so we can reference it }); //======================================= // Start of wrapper for signalB initSignal("B", function() { //------------------------------------- // Start of signalB evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV this.evaluate = function(param, results) { log.push("Eval B called signalA.twoVal:"+signals.A.twoVal+ " results.A:"+results.A); const ret = signals.A.twoVal * results.A / 32; // <-- Use the result of signalA log.push("Computed B"); return ret; } //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalB evalscript //------------------------------------- }); //================================================== // Aggregation code - glue together all the wrappers function evaluate(param) { const ret = {}; sigList.forEach(s => { ret[s.outputKey] = s.evaluate(param, ret); }); ret.log = log; return ret; } return evaluate(4); }35:T5da,{ const log = []; const signalsList = []; const signals = {}; function initSignal(code, sigFun) { const s = {outputKey: code}; try { sigFun.apply(s); } catch (err) { log.push("ERR @ "+code+":"+err); } // handle the version of script with just `return` if (s.evaluate === undefined) { s.evaluate = sigFun; } signalsList.push(s); signals[code] = s; } //======================================= // Start of wrapper for signalA initSignal("A", function(param, results) { //vvvvvv user script start this.twoVal = 2; return this.twoVal * param.B01 * param.B01; // <-- Use a constant or utility function from another signal //^^^^^^ user script end }); //======================================= // Start of wrapper for signalB initSignal("B", function(param, results) { //vvvvvv user script start this.evaluate = function(param, results) { return signals.A.twoVal * results.A / 32; // <-- Use the result of signalA } //^^^^^^ user script end }); //================================================== // Aggregation code - glue together all the wrappers function evaluateAll(param) { const ret = {}; signalsList.forEach(s => { ret[s.outputKey] = s.evaluate(param, ret); }); ret.log = log; return ret; } //try { return evaluateAll({B01: 4}); //} catch (err) { //return {log, err}; //} }36:T70b,{ const log = []; //======================================= // Start of wrapper for signalA const signalA = { outputKey : "A", evaluate : function(param) { //------------------------------------- // Start of signalA evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV this.twoVal = 2; log.push("Eval A called"); const ret = this.twoVal * param * param; log.push("Computed A"); return ret; //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalA evalscript //------------------------------------- } }; //======================================= // Start of wrapper for signalB const signalB = { outputKey : "B", evaluate: function(param) { //------------------------------------- // Start of signalB evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV log.push("Eval B called"); const ret = signalA.twoVal * signalA.result / 32; // <-- Use the result of signalA // <-- Use a constant or utility function from another signal log.push("Computed B"); return ret; //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalB evalscript //------------------------------------- } }; //================================================== // Aggregation code - glue together all the wrappers function evaluate(param) { const ret = {}; const signals = [signalA, signalB]; //list signals in correct order here signals.forEach(s => { s.result = s.evaluate(param) ret[s.outputKey] = s.result; }); ret.log = log; return ret; } return evaluate(4); }37:T961,{ const log = []; const getResultForSignal = function(signalObject, param) { // lazy compute and cache result, to avoid having to call signals in order if (signalObject.result === undefined) { signalObject.result = signalObject.evaluate(param); signalObject.resultParam = param; } if (signalObject.resultParam === param) { return signalObject.result; } log.push("Eval called with different params"); return signalObject.evaluate(param); }; //======================================= // Start of wrapper for signalB const signalB = (param) => getResultForSignal(signalB, param); signalB.init = function() { //------------------------------------- // Start of signalB evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV this.twoVal = 2; function evaluate(param) { log.push("Eval B called"); const ret = this.twoVal * signalA(param) / 32; // <-- Use the result of signalA log.push("Computed B"); return ret; }; //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalB evalscript //------------------------------------- if (!this.evaluate) { this.evaluate = evaluate; } }; signalB.init(); //======================================= // Start of wrapper for signalA const signalA = (param) => getResultForSignal(signalA, param); signalA.init = function() { //------------------------------------- // Start of signalA evalscript //VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV this.evaluate = function(param) { log.push("Eval A called"); const ret = signalB.twoVal * param * param; // <-- Use a constant or utility function from another signal log.push("Computed A"); return ret; }; //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // End of signalA evalscript //------------------------------------- if (this.evaluate === undefined) { this.evaluate = evaluate; } }; signalA.init(); //================================================== // Aggregation code - glue together all the wrappers function evaluate(param) { //cleanup results signalA.result = undefined; signalB.result = undefined; return ({ signalB: signalB(param), signalA: signalA(param), log: log }) } return evaluate(4); }38:[] 2f:{"title":"Composing signal evalscripts","cells":[{"id":32,"value":"md`# Composing signal evalscripts`","pinned":false,"hidden":false,"mode":"ojs"},{"id":320,"value":"md`\nCurrent proposal:\n- Anonymous function for initialization.\n- No \\`init\\` for each signal - the initialization function does all the work\n- Dependencies passed via parameter \\`signalResults\\` instead of assuming global access.\n- Per-signal evalscript defines \\`function evaluateSignal(signalResults, ...)\\`\n- Order defined at initialization of each signal (no need to list all signals in an array)\n- Wrapper code is constant, the necessary signals-dependent transformations happen at run-time (either at initialization or evaluation)\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":325,"value":"$31","pinned":true,"hidden":false,"mode":"ojs"},{"id":321,"value":"md`---`","pinned":false,"hidden":false,"mode":"ojs"},{"id":109,"value":"md`With a block:`","pinned":false,"hidden":false,"mode":"ojs"},{"id":101,"value":"$32","pinned":true,"hidden":false,"mode":"ojs"},{"id":177,"value":"md`With a function outside the aggregator's \\`evaluate\\`. Requires correct order of execution.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":179,"value":"$33","pinned":true,"hidden":false,"mode":"ojs"},{"id":264,"value":"md`\nCurrent proposal:\n- Anonymous function for initialization.\n- No \\`init\\` for each signal - the initialization function does all the work\n- Dependencies passed via parameter \\`signalResults\\` instead of assuming global access.\n- Per-signal evalscript defines \\`function evaluateSignal(signalResults, ...)\\`\n- Order defined at initialization of each signal (no need to list all signals in an array)\n- Wrapper code is constant, the necessary signals-dependent transformations happen at run-time (either at initialization or evaluation)\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":250,"value":"$34","pinned":true,"hidden":false,"mode":"ojs"},{"id":273,"value":"md`Anonymous function for initialization. Order defined at initialization. Dependencies passed via parameter instead of assuming global access. Allowing just \\`return\\` in signal evalscript.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":276,"value":"$35","pinned":true,"hidden":false,"mode":"ojs"},{"id":240,"value":"md`With all code inside signal's \\`evaluate\\`. No \\`init\\`. Requires correct order of execution.\n\nThe drawback is that the evalscript is written as the body of \\`evaluate\\` which would make complex evalscripts a bit messier IMO.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":242,"value":"$36","pinned":true,"hidden":false,"mode":"ojs"},{"id":112,"value":"md`With a function outside the aggregator's \\`evaluate\\`, and caching of results which supports implementation in which execution order doesn't really matter:`","pinned":false,"hidden":false,"mode":"ojs"},{"id":0,"value":"$37","pinned":true,"hidden":false,"mode":"ojs"},{"id":221,"value":"testExtractParams = {\n const eob_params = ({a: 13});\n\n const evalscript = `//VERSION=3\n const eob_params = (${JSON.stringify(eob_params)});\n // ...the script: setup, evaluatePixel and other functions\n `;\n\n const extracted_params = eval('(() => {'+evalscript +' return eob_params;})()');\n return extracted_params;\n}","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W38","stdlib":"1","titling":"auto"}