info
Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss
Re: -- GRUMBLE prototype progress update 27 April 2020: TOWARDS REASON AND ASSAYING MEMEBRAIN PRINCIPLES AS CRITERIA
1 view
Skip to first unread message
dolf
Apr 26, 2020, 9:49:18 PM4/26/20
to
I ought to fore-warn you that with respects to *faint*-*hearted* entry
strongs: "G3642", "xlit" : "oligópsychos" and its metalogic derived
categories which we are intentioned to then spatially overlay for time
of day / day of year watch events and interleave by telos hierarchy that
we can apply to your speech by such we shall know your *FEAR*
YOUTUBE: "Nineteen Eighty Four Hate Week Rally"
<https://www.youtube.com/watch?v=oD_Bdq1MLWg>
In then by intersecting such with our temporal heuristic ask at the most
probable and opportune time:
ARE YOU FRIGHTENED?
---------
One more informal observation on the *faint*-*hearted* entry strongs:
"G3642", "xlit" : "oligópsychos" that is it has a #321 - *PRO* *DOMO*
ONTIC grounding of @150 + @171 = #321 and has an interesting *synaptic*
condition of:
{@7: Sup: 68 - DIMMING: MENG (#312); Ego: 76 - AGGRAVATION: CHU (#311)}
Of #68 - *RIGHTS* #312 - *CONTRADICTION* associated to KANT'S
PROLEGOMENA mapping of #27 - *DUTIES* as idea #311. And the discovery
of these would be beneficial for RULE SET conditions ...
That the METALOGIC (AUTONOMOUS DELIMITER) panel then provides the
meta-descriptor criteria to determine the condition:
NATURE: (EGO) ⦿
70 76 3 149
52 10 62 211 159
38 33 30 101 312 153
NURTURE: (SUPERNAL)
4 9 19 32
42 68 20 130 162 52
32 29 21 82 244 124
SYNCRETIC: (AMALGAM)
70 76 3 149
20 21 4 45 194 153
19 10 9 38 232 58
︖ METALOGIC (AUTONOMOUS DELIMITER) ⦿
#ONE: #149 as #68 - DIMMING (MENG)
#TWO: #62 as #62 - DOUBT (YI)
#THREE: #101 as #20 - ADVANCE (CHIN)
#FOUR: #211 as #49 - FLIGHT (T'AO)
#FIVE: #312 as #69 - EXHAUSTION (CH'IUNG)
#SIX: #159 as #78 - ON THE VERGE (CHIANG)
#SEVEN: #153 as #72 - HARDNESS (CHIEN)
#EIGHT:
And you can perhaps see the immense wealth of intellectual property
which we want to later deploy in our development to animate as active
functions in a viable emulation of the thinking process itself which
might be considered to be minimally bound by the variable conditions
that are relative to the INTELLECTUS AS GENITIVE VOLUNTĀTIS and as being
a grapple 'from' and 'to' against which values are then assayed to any
given IDEA as impetus.
----------
I’ll be spending the next couple of days offline in self educating on
the existential problem associated with the search process that has to
be as optimal as possible.
And courtesy of StackOverflow.com we've found some purposed and
favourable goal driven dialog which will provide the semantcial basis
which suits our purpose:
var myObject = { 'a': 1, 'b': 2, 'c': 3 };
var newObject = {};
function lexiconMap(obj, mapper) {
var result = {};
Object.keys(obj).forEach(function (key) {
result[key] = mapper(obj[key], key);
});
return result;
}
newObject = lexiconMap(myObject, function(x) { return x * x; });
console.log(myObject);
// => { 'a': 1, 'b': 2, 'c': 3 }
console.log(newObject);
// => { 'a': 2, 'b': 4, 'c': 6 }
That can enable us to transmogrify and search the umbra / gematria
entries for 14,298 record dataset:
{
"derivation" : "from G3641 (ὀλίγος) and G5590 (\u03c8\u03c5\u03c7\u03ae);",
"kjv_def" : "feebleminded",
"lemma" : "ὀλιγόψυχος",
"frequency" : 1,
"strongs_def" : " little-spirited, i.e. faint-hearted",
"outline" : {
"@1" : "fainthearted"
},
"strongs" : "G3642",
"xlit" : "oligópsychos",
"umbra" : {
"2153" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 200]
},
"gematria" : {
"2153" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 200], "2553" : [70,
30, 10, 3, 70, 700, 400, 600, 70, 400, 200]
}
}
For example if we consider the lexicon gematria entry:
"2553" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 400, 200]
We'll readily observe that it is has a #321 - *PRO* *DOMO* ONTIC
grounding of @150 + @171 = #321 and has an interesting *synaptic*
condition of:
{@7: Sup: 68 - DIMMING: MENG (#312); Ego: 76 - AGGRAVATION: CHU (#311)}
Of #68 - *RIGHTS* #312 - *CONTRADICTION* associated to KANT'S
PROLEGOMENA mapping of #27 - *DUTIES* as idea #311. And the discovery
of these would be beneficial for RULE SET conditions:
[70, {@1: Sup: 70 - SEVERANCE: KE (#70); Ego: 70 - SEVERANCE: KE (#70)}
30, {@2: Sup: 19 - FOLLOWING: TS'UNG (#89); Ego: 30 - BOLD RESOLUTION:
YI (#100)}
10, {@3: Sup: 29 - DECISIVENESS: TUAN (#118); Ego: 10 - DEFECTIVENESS,
DISTORTION: HSIEN (#110)}
3, {@4: Sup: 32 - LEGION: CHUANG (#150 - I INDULGE NOT IN ANGER {%28});
Ego: 3 - MIRED: HSIEN (#113)}
70, {@5: Sup: 21 - RELEASE: SHIH (#171 - I AM NOT UNCHASTE WITH ANY ONE
{%20}); Ego: 70 - SEVERANCE: KE (#183)}
700, {@6: Sup: 73 - ALREADY FORDING, COMPLETION: CH'ENG (#244); Ego: 52
- MEASURE: TU (#235)}
400, {@7: Sup: 68 - DIMMING: MENG (#312); Ego: 76 - AGGRAVATION: CHU (#311)}
600, {@8: Sup: 20 - ADVANCE: CHIN (#332); Ego: 33 - CLOSENESS: MI (#344)}
70, {@9: Sup: 9 - BRANCHING OUT: SHU (#341); Ego: 70 - SEVERANCE: KE (#414)}
400, {@10: Sup: 4 - BARRIER: HSIEN (#345); Ego: 76 - AGGRAVATION: CHU
(#490)}
200] {@11: Sup: 42 - GOING TO MEET: YING (#387); Ego: 38 - FULLNESS:
SHENG (#528)}
MALE: @150 + @171 = #321
ONTIC CHECKSUM TOTAL: #321
On 26/4/20 12:15, dolf wrote:
> As our concluding task for the day, we've implemented a
> COINRULES.memeBrain based search() rule set which is entirely reliant
> upon a setTimeout() operation which deploys a context {} object and
> hence the grappleCoinSearch() scheduler action is no longer required.
>
> Within this coding derivation the WIDGET click initiates the context
> within the setTimeout() as the scheduler...
>
> if (/WIDGET-(\d{1,})/.test(d3.select(this).property('id'))) {
>
> vEVENT[RegExp.$1].search = {
> data: function () {
> return ((typeof (LEXICON) != "undefined") ? LEXICON :
> "undefined");
> },
> action: "search",
> results: "results",
> event: null,
> query: _memeBrain.searchSimpleFormulate({
> syllogism: vEVENT[RegExp.$1].syllogism,
> metalogic: vEVENT[RegExp.$1].metalogic
> })
> }
>
> setTimeout(function() {
>
> var context = vEVENT[RegExp.$1].search;
>
> context.context = {
> loop: true,
> event: RegExp.$1,
> record: 1
> }
>
> return (dockJSFileTimerProc({
> load: void(0),
> src: "scripts/Strongs_max.js",
> viable: function () { return (typeof(LEXICON)); },
> retry: 1000,
> eject: void(0),
> queue: void(0),
> action: "search",
> event: RegExp.$1,
> context: context
> }));
> });
>
> }
>
> AND THE ACTUAL SEARCH OPERATION DEPLOYS A CONTEXT FOR EACH INSTANCE OF
> THE setTimeout() process. We've done preliminary tests and have
> identified no difficulties scheduling multiple search sequences.
>
> search: function (obj) {
>
> obj.context.loop = true;
> obj.context.task = {
> event: void(0),
> data: void(0),
> count: void(0),
> result: void(0)
> }
>
> determine:
>
> do {
>
> switch ("undefined") {
> case (typeof obj.context.task.data) :
> obj.context.task.data = (obj.data() != "undefined") ?
> obj.data() : null;
> if (!obj.context.task.data)
> return;
> continue determine;
>
> case (typeof obj.context.task.count) :
> obj.context.task.count = true;
> if (obj.context.record == obj.context.task.data.length)
> return;
> continue determine;
>
> case (typeof obj.context.task.result) :
> obj.context.task.result = true;
> vEVENT[obj.context.event].record = ++obj.context.record;
> continue;
>
> default:
> obj.context.loop = false;
>
> }
>
> } while (obj.context.loop);
>
> setTimeout(function() {
> return (COINRULES.memeBrain.search(obj));
> });
>
> },
>
> ----------
>
> Thusly in support of the goal as to the avoidance of perturbance being
> an essential design principle within any setTimeout() operation, we've
> implemented a context {} object within the dockJSFileTimerProc() and
> bootLoader () processes
>
> setTimeout(function() {
> return (bootLoader ({
> ruleset: "memeBrain",
> reason: "reason",
> params: {
> action: "loaded"
> },
> loadRules: void(0),
> cls: void(0),
> viableRules: function () { return (typeof(_memeBrain)); },
> retry: 1000,
> loadForms: void(0),
> form: "memeBrain",
> forms: "forms",
> viableForms: function () { return (typeof(FORMS.memeBrain)); },
> start: void (0),
> context: {
> reader: new FileReader(), <-- *Added* here
> loop: true
> }
> }));
> });
>
> Whilst it is immaterial to the specific coding example, we're simply
> implementing a best practice design / coding process since we're aware
> that a significant number of setTimeout() operations might be spawned
> within other coding segments and we consider that "the avoidance of
> perturbance is an essential principle" of its intrinsic nature.
> Whereupon what was previously considered as local variable declarations
> are now referenced within the context of passed obj:
>
> var bootLoader = function (obj) {
>
> obj.context.loop = true;
>
> determine:
>
> do {
>
> switch ("undefined") {
> case (typeof obj.loadRules) :
> obj.loadRules = true;
>
> obj.context.reader.onload = function() {
> eval(["COINRULES['", obj.ruleset, "'] = ",
> obj.context.reader.result].join(''));
> }
>
> if (obj.viableRules() == "undefined") {
>
> d3.blob([stub, obj.reason, '/', obj.ruleset,
> '.json'].join(''), {type : "application/json"})
> .then(function (data) {
>
> if (typeof(data) == "object") {
> obj.context.reader.readAsText(data);
> } else {
> throw 404;
> }
>
> })
> .catch((error) => {
>
> readTextFile(stub, [obj.reason, '/', obj.ruleset,
> '.json'].join(''), function(data){
> eval(["COINRULES['", obj.ruleset, "'] = ",
> data].join(''));
> })
>
> })
> }
> continue determine;
>
> case (typeof obj.cls) :
> obj.cls = true;
> var body = d3.select("body")
> body.html("");
> body.append("div").attr("id", "memeSelector");
> body.append("div").attr("id", "IO");
> body.append("div").attr("id", "memeIO");
> body.append("div").attr("id", "memeNarrative");
> continue determine;
>
> case (obj.viableRules()) :
> if (--obj.retry)
> setTimeout(function() {
> return (bootLoader(obj));
> });
> obj.context.loop = false;
> break;
>
> case (typeof obj.loadForms) :
> obj.loadForms = true;
> obj.retry = 1000;
>
> obj.context.reader.onload = function() {
> eval(["FORMS['", obj.form, "'] = ",
> obj.context.reader.result].join(''));
> }
>
> d3.blob([stub + 'forms/', obj.form, '.json'].join(''),
> {type : "application/json"})
> .then(function (data) {
>
> obj.context.reader.readAsText(data);
>
> }) .catch((error) => {
>
> readTextFile(stub, [obj.forms, '/', obj.form,
> '.json'].join(''), function(data){
> eval(["FORMS['", obj.form, "'] = ", data].join(''));
> })
>
> })
> continue determine;
>
> case (obj.viableForms()) :
> if (--obj.retry)
> setTimeout(function() {
> return (bootLoader(obj));
> });
> obj.context.loop = false;
> break;
>
> case (typeof obj.start) :
> obj.start = true;
> startup();
>
> default:
> obj.context.loop = false;
>
> }
>
> } while (obj.context.loop);
>
> }
>
> ----------
>
> Thus in the circumstance where we have broadly articulated an ontic
> grounding as necessity to the epistemological premise being some
> physical law of which we do not know all its properties and potentiality.
>
> As a provisional propostion, could not the ontological condition of
> disease itself being
>
> "a disorder of structure or function in a human" or
>
> "a particular quality or disposition regarded as adversely affecting a
> person or group of people"
>
> be a consideration as to the use of a specific #328 - TRANSFORMATIVE
> PROTOTYPE which applies the #369 - REVERSE TRANSCRIPTASE INHIBITOR
> within such a determined manner so as to place any perturbance of
> disease into a hypostasis that is then subject to the #287 - SEPTET
> BONDING (MANIFESTING NORM).
>
> ----------
>
> This comment has gotten me thinking: "preserve each rule set context so
> that the setTimeout() can operate without any perturbance."
>
> And whilst we have identified certain ONTIC properties of #CENTRE which
> might fall into the category of "operate without any perturbance" one of
> our goals for transmogrifying of the lexicon array 123: [100, 20, 3]
> into its object IDEA form, is that we want to consider whether the ONTIC
> framing itself: #41 x 7 + #41 x 2 of the #369 - DISCRIMINATING NORM (ie.
> it is a cosmological view) is able to naturally arbitrate perturbance
> within causality:
>
> #41 - PRINCIPLE OF EMANATION
> #82 - PRINCIPLE OF CONTINUITY
> #123 - JUDGMENT SENSIBILITY
> #164 - PRINCIPLE OF MATERIALITY
> #205 - PRINCIPLE OF PERSISTENT SUBSTANCE (DISCRIMINATING NORM)
> #246 - NORMA OBLIGANS (OBLIGATING NORM)
> #287 - BONDING (MANIFESTING NORM)
>
> According to wikipedia that the perturbed solution actually satisfies
> closer to the formula in the original problem: #164 + #205 = #369 -
> DISCRIMINATING NORM and typically, the "conditions" that represent
> reality are a formula (or several) that specifically express some
> physical law.
>
> <https://en.wikipedia.org/wiki/Perturbation_theory>
>
> So as a first step towards such a goal as to the avoidance of pertubance
> being an essential design principle within any setTimeout() operation,
> we're going to explore placing each of the local function variables
> deployed by our embryonic grappleCoinSearch({event: obj.event, record:
> 0}) and bootLoader() processes such as:
>
> var reader = new FileReader();
> var loop = true;
>
> And place those within each initiating object:
>
> bootLoader ({
> ruleset: "memeBrain",
> reason: "reason",
> params: {
> action: "loaded"
> },
> loadRules: void(0),
> cls: void(0),
> viableRules: function () { return (typeof(_memeBrain)); },
> retry: 1000,
> loadForms: void(0),
> form: "memeBrain",
> forms: "forms",
> viableForms: function () { return (typeof(FORMS.memeBrain)); },
> start: void (0)
> })
>
> - dolf
>
> On 26/4/20 05:51, dolf wrote:
>> I’ll probably spend the next couple of days offline in self educating on
>> the existential problem associated with the search process that has to be
>> as optimal as possible.
>>
>> The first anomaly which we have to consider is the exception of final
>> form
>> letters within the Hebrew lexicon.
>>
>> And I found online a kernel of an idea which will allow us to
>> transmogrify
>> the lexicon object array 123: [100, 20, 3] into its object IDEA form
>> and we
>> may use the same technique for the search itself:
>>
>> {sup: nn, stelos: nn, ego: nn, etelos: nn}
>>
>> This is an immense wealth of intellectual property which we want to later
>> deploy in our development to animate as active functions in a viable
>> emulation of the thinking process itself which might be considered to be
>> minimally bound by the variable conditions that are relative to the
>> INTELLECTUS AS GENITIVE VOLUNTĀTIS and as being a grapple 'from' and 'to'
>> against which values are then assayed to any given IDEA as impetus.
>>
>> But suffice to say we’re going to explore some JavaScript semantical
>> forms
>> which we have never used:
>>
>> var myObject = { 'a': 1, 'b': 2, 'c': 3 };
>>
>> // returns a new object with the values at each key mapped using
>> mapFn(value)
>> function lexiconMap(object, mapFn) {
>> return Object.keys(object).map(function(result, key) {
>> result[key] = mapFn(object[key])
>> return result
>> }, {})
>> }
>>
>> var newObject = lexiconMap(myObject, function(value) {
>> return value * 2
>> })
>>
>> console.log(newObject);
>> // => { 'a': 2, 'b': 4, 'c': 6 }
>>
>> console.log(myObject);
>> // => { 'a': 1, 'b': 2, 'c': 3 }
>>
>> dolf <dolf...@hotmail.com> wrote:
>>> Today we are going to work further on the framing of our simple query
>>> for the LEXICON search process...
>>>
>>> And this will involve a pairing made by a determination of the
>>> criterion.metalogic.metaChecks[] array...
>>>
>>> That the rule coding to undertake such action is as follows:
>>>
>>> case (typeof task.links) :
>>> if (task.links = checked[s]) {
>>> for (var i = 1; i < 8; i++) {
>>> if (criterion.metalogic.metaLinks[s][i] > 0)
>>> links[links.length] = {
>>> sup: (criterion.metalogic.delimiters[s][i] % 81) ?
>>> criterion.metalogic.delimiters[s][i] % 81 : 81,
>>> stelos: criterion.metalogic.delimiters[s][i],
>>> ego:
>>> (criterion.metalogic.delimiters[s][criterion.metalogic.metaLinks[s][i]]
>>> % 81) ?
>>> criterion.metalogic.delimiters[s][criterion.metalogic.metaLinks[s][i]] %
>>> 81 : 81,
>>> etelos:
>>> criterion.metalogic.delimiters[s][criterion.metalogic.metaLinks[s][i]]
>>> }
>>> }
>>> }
>>> continue determine;
>>>
>>> And since the pairing links are stored within an array it is a simpler
>>> process of storeing the result within the query.links element before
>>> returning the object as the framed query:
>>>
>>> if (links.length)
>>> query.links = new Object(links);
>>>
>>> And so tomorrow we'll consider our best approach to the search algorithm
>>> which will be reliant upon a setTimeout() where there is a real
>>> possibility of multiple searches being undertaken simultaneously.
>>>
>>> So we have we might have to utilise the vEVENT id so to preserve each
>>> rule set context so that the setTimeout() can operate without any
>>> perturbance.
>>>
>>> One thing we did note, that the task rules ought to be declared to their
>>> void(0) condition so that they are triggered correctly since for some
>>> unknown reason assigning task = {} did not trigger the case (typeof
>>> task.ontic) : rule. And since run
>>> nested within a loop, this state of operation should be reset:
>>>
>>> task = {
>>> ontic: void(0),
>>> telos: void(0),
>>> links: void(0)
>>> };
>>> loop = true;
>>>
>>> However given the context is passed by the setTimeout() I don't think
>>> this will be an issue...
>>>
>>> ----------
>>> However since our search criterion is going to produce search results,
>>> we also need to give some consideration to the displaying of any
>>> results.
>>>
>>> And the approach to this will be to first load a REPORTS form via our
>>> bootLoader() process, and whilst emulating the functionality of our
>>> SPIRAL SELECTOR@{...} mechanism, it capable of being anchored as an
>>> inline character ...
>>>
>>> On 23/4/20 13:55, dolf wrote:
>>>> And don't forget that the items are needed to be considered to be
>>>> Number() and not a string sequence:
>>>>
>>>> query.telos[i] = Number(items[i][0]);
>>>>
>>>> Thusly to get back to the framing of our query parameters for the
>>>> simple
>>>> search process within the searchSimpleFormulate() function we've
>>>> completed two rules so far:
>>>>
>>>> case (typeof task.ontic) :
>>>> if (task.ontic = checked[s]) {
>>>> for (var i = 1; i < 8; i++)
>>>> if (criterion.metalogic.metaChecks[s][i] &&
>>>> isOntic(criterion.metalogic.delimiters[s][i]))
>>>> ontic[criterion.metalogic.delimiters[s][i]] = true;
>>>> }
>>>> continue determine;
>>>>
>>>> case (typeof task.telos) :
>>>> if (task.telos = checked[s]) {
>>>> for (var i = 1; i < 8; i++)
>>>> if (criterion.metalogic.metaChecks[s][i] && !
>>>> ontic[criterion.metalogic.delimiters[s][i]])
>>>> telos[criterion.metalogic.delimiters[s][i]] = true;
>>>> }
>>>> continue determine;
>>>>
>>>> And we then derive an array of the entries from the telos {} data set
>>>> and push them onto the query.telos [] element before returning the
>>>> object as the framed query:
>>>>
>>>> items = Object.entries(telos);
>>>> if (items.length) {
>>>> query.telos = [];
>>>> for (var i = 0; i < items.length; i++)
>>>> query.telos[i] = Number(items[i][0]);
>>>> }
>>>>
>>>> Our next process task is to determine each of the metaChecks
>>>> correspondences and then formulate their pairings into an object:
>>>>
>>>> {sup: nn, stelos: nn, ego: nn, etelos: nn}
>>>>
>>>> If for instance the dropdown list is option 4 to the #ONE metalogic
>>>> autonomous delimiter, it means that the #ONE entry comprising the telos
>>>> / tetra (as and / or condition) is as SUPERNAL constrauct then paired
>>>> with the #FOUR entry and so forth...
>>>>
>>>> But we shall accomplish that tomorrow...
>>>>
>>>> On 23/4/20 05:53, dolf wrote:
>>>>> Before we return to the framing of our query parameters for the simple
>>>>> search process, let me just comment on the additional favourable
>>>>> outcome to our self-education as informal research into
>>>>> setTimeout(function() {}) which resulted in the best approach being
>>>>> parameters passed by the function as a complete inversion of our
>>>>> initial approach.
>>>>>
>>>>> Such technique has enabled us to update the initialisation as startup
>>>>> RULESET sequence by means of a bootloader:
>>>>>
>>>>> setTimeout(function() {
>>>>> return (bootLoader ({
>>>>> ruleset: "memeBrain",
>>>>> reason: "reason",
>>>>> params: {
>>>>> action: "loaded"
>>>>> },
>>>>> loadRules: void(0),
>>>>> cls: void(0),
>>>>> viableRules: function () { return (typeof(_memeBrain)); },
>>>>> retry: 1000,
>>>>> loadForms: void(0),
>>>>> form: "memeBrain",
>>>>> viableForms: function () { return
>>>>> (typeof(FORMS.memeBrain)); },
>>>>> start: void (0)
>>>>> }));
>>>>> });
>>>>>
>>>>> Which facilitates a similar appraoch to NOW wrap the d3 PROMISE
>>>>> command within a viable setTimeout condition that will retry a
>>>>> viability test until the retrieval has been completed... As greatly
>>>>> improving the efficiency and reliability of our crtical process that
>>>>> heretofore was brutish as promulgating needless read requests ...
>>>>>
>>>>> var bootLoader = function (obj) {
>>>>>
>>>>> var reader = new FileReader();
>>>>> var loop = true;
>>>>>
>>>>> determine:
>>>>>
>>>>> do {
>>>>>
>>>>> switch ("undefined") {
>>>>> case (typeof obj.loadRules) :
>>>>> obj.loadRules = true;
>>>>>
>>>>> reader.onload = function() {
>>>>> eval(["COINRULES['", obj.ruleset, "'] = ",
>>>>> reader.result].join(''));
>>>>> }
>>>>>
>>>>> if (obj.viableRules() == "undefined") {
>>>>>
>>>>> d3.blob([stub, obj.reason, '/', obj.ruleset,
>>>>> '.json'].join(''))
>>>>> .then(function (data) {
>>>>>
>>>>> if (typeof(data) == "object") {
>>>>> reader.readAsText(data);
>>>>> } else {
>>>>> throw 404;
>>>>> }
>>>>>
>>>>> })
>>>>> .catch((error) => {
>>>>>
>>>>> readTextFile(stub, [obj.reason, '/',
>>>>> obj.ruleset,
>>>>> '.json'].join(''), function(data){
>>>>> eval(["COINRULES['", obj.ruleset, "'] = ",
>>>>> data].join(''));
>>>>> })
>>>>>
>>>>> })
>>>>> }
>>>>> continue determine;
>>>>>
>>>>> case (typeof obj.cls) :
>>>>> obj.cls = true;
>>>>> var body = d3.select("body")
>>>>> body.append("div").attr("id", "memeSelector");
>>>>> body.append("div").attr("id", "IO");
>>>>> body.append("div").attr("id", "memeIO");
>>>>> body.append("div").attr("id", "memeNarrative");
>>>>> continue determine;
>>>>>
>>>>> case (obj.viableRules()) :
>>>>> if (--obj.retry)
>>>>> setTimeout(function() {
>>>>> return (bootLoader(obj));
>>>>> });
>>>>> loop = false;
>>>>> break;
>>>>>
>>>>> case (typeof obj.loadForms) :
>>>>> obj.loadForms = true;
>>>>> obj.retry = 1000;
>>>>>
>>>>> �� reader.onload = function() {
>>>>> eval(["FORMS['", obj.form, "'] = ",
>>>>> reader.result].join(''));
>>>>> }
>>>>>
>>>>> d3.blob([stub + 'forms/', obj.form, '.json'].join(''),
>>>>> {type : "application/json"})
>>>>> .then(function (data) {
>>>>>
>>>>> reader.readAsText(data);
>>>>>
>>>>> }) .catch((error) => {
>>>>>
>>>>> readTextFile(stub, ['forms/', obj.form,
>>>>> '.json'].join(''), function(data){
>>>>> eval(["FORMS['", obj.form, "'] = ",
>>>>> data].join(''));
>>>>> })
>>>>>
>>>>> })
>>>>> continue determine;
>>>>>
>>>>> case (obj.viableForms()) :
>>>>> if (--obj.retry)
>>>>> setTimeout(function() {
>>>>> return (bootLoader(obj));
>>>>> });
>>>>> loop = false;
>>>>> break;
>>>>>
>>>>> case (typeof obj.start) :
>>>>> obj.start = true;
>>>>> startup();
>>>>>
>>>>> default:
>>>>> loop = false;
>>>>>
>>>>> }
>>>>>
>>>>> } while (loop);
>>>>>
>>>>> }
>>>>>
>>>>> On 22/4/20 16:01, dolf wrote:
>>>>>> And our final comment on this relates to the non-necessity of the
>>>>>> clearTimeout() for the transit search process and hence no need to
>>>>>> store it in the vEVENT[id].
>>>>>>
>>>>>> However it would be prudent to store the setTimeout() handle given
>>>>>> our provisional consideration as to a viable emulation of the
>>>>>> thinking process itself which might be considered to be minimally
>>>>>> bound by the variable conditions that are relative to the INTELLECTUS
>>>>>> AS GENITIVE VOLUNTĀTIS and as being a grapple 'from' and 'to' against
>>>>>> which values are then assayed to any given an IDEA as impetus:
>>>>>>
>>>>>> {
>>>>>> from: [1, 2, 3, 4, 5, 6, 7, 8, 9],
>>>>>> to: [9, 8, 7, 6, 5, 4, 3, 2, 1]
>>>>>> }
>>>>>>
>>>>>> If one firstly anchors the setTimeout() handle to a timer[] array
>>>>>> within the from grapple and then retain the last timer.length within
>>>>>> the action, its relativity is an increment offset+1 for the purpose
>>>>>> of *determination* *of* *the* *sequential* *nature* *of* *the*
>>>>>> *thinking* *action*.
>>>>>>
>>>>>> Once the timer[n] array entry is nulled, no further reference is made
>>>>>> and a garbage() collection function ought to periodically trim nulled
>>>>>> timer[] arrays and return it to timer = [];
>>>>>>
>>>>>> That's what we are working towards as our design goal...
>>>>>>
>>>>>> And its very likely that we'll update the initialisation of the
>>>>>> COINRULES at startup to adopt a similar _FILELOADTIMER perspective
>>>>>> relative to the FORMS as to check viability of the COINRULE {} before
>>>>>> invoking any FORM process which might be reliant upon such ...
>>>>>>
>>>>>> So that's the favourable outcome to our setTimeout() self education.
>>>>>>
>>>>>> ---------
>>>>>>
>>>>>> We've thought to investigate the feasibility of the following
>>>>>> processes by utilizing only a setTimeout() with parameters redacted
>>>>>> to comply with the JSON.stringify() function and that required us to
>>>>>> deploy non void(0) conditions within our determine / loop ruleset:
>>>>>>
>>>>>> 1) DOCKING with JS file (if required)
>>>>>> 2) DETERMINE resource viability
>>>>>> 3) RELEASE JS file
>>>>>> 4) INITIATE traversal
>>>>>>
>>>>>> We have then considered the possibility of a setTimeout(function()
>>>>>> {}) and therefore further modified our Grumble prototype to support
>>>>>> this later method because it enables us to deploy more complex
>>>>>> variable types but have retained our existing dock ruleset within the
>>>>>> memeBrain {} COINRULES object:
>>>>>>
>>>>>> THUSLY the process will work with the following process which will
>>>>>> invoke the grappleCoinSearch() action at the conclusion:
>>>>>>
>>>>>> if (_FILELOADTIMER == null)
>>>>>> _FILELOADTIMER = setTimeout(function() {
>>>>>>
>>>>>> return (dockJSFileTimerProc({
>>>>>> load: void(0),
>>>>>> src: "scripts/Strongs_max.js",
>>>>>> viable: function () { return (typeof(LEXICON)); },
>>>>>> retry: 1000,
>>>>>> eject: void(0),
>>>>>> queue: void(0),
>>>>>> action: "grappleCoinSearch",
>>>>>> event: RegExp.$1
>>>>>> }));
>>>>>> });
>>>>>>
>>>>>> }
>>>>>>
>>>>>> grappleCoinSearchQueue: <-- Redacted as no longer necessary
>>>>>>
>>>>>> var _FILELOADTIMER = null;
>>>>>>
>>>>>> var dockJSFileTimerProc = function (obj) {
>>>>>>
>>>>>> window.clearTimeout(_FILELOADTIMER);
>>>>>> _FILELOADTIMER = null;
>>>>>>
>>>>>> var loop = true;
>>>>>>
>>>>>> determine:
>>>>>>
>>>>>> do {
>>>>>>
>>>>>> switch ("undefined") {
>>>>>> case (typeof obj.load) :
>>>>>>
>>>>>> obj.load = true;
>>>>>> if (obj.viable() == "undefined") {
>>>>>>
>>>>>> d3.select("head")
>>>>>> .append("script")
>>>>>> .attr("type", "text/javascript")
>>>>>> .attr("src", obj.src);
>>>>>>
>>>>>> _FILELOADTIMER = setTimeout(function() {
>>>>>> return (dockJSFileTimerProc(obj));
>>>>>> });
>>>>>>
>>>>>> } else {
>>>>>> obj.eject = false;
>>>>>> continue determine;
>>>>>> }
>>>>>> loop = false;
>>>>>> break;
>>>>>>
>>>>>> case (obj.viable()) :
>>>>>> if (--obj.retry)
>>>>>> _FILELOADTIMER = setTimeout(function() {
>>>>>> return (dockJSFileTimerProc(obj));
>>>>>> });
>>>>>> loop = false;
>>>>>> break;
>>>>>>
>>>>>> case (typeof obj.eject) :
>>>>>> d3.selectAll('script')
>>>>>> .each(function () {
>>>>>> if
>>>>>> (d3.select(this).property("src").indexOf(obj.src) != -1)
>>>>>> d3.select(this).remove();
>>>>>> });
>>>>>>
>>>>>> obj.eject = true;
>>>>>> continue determine;
>>>>>>
>>>>>> case (typeof obj.queue) :
>>>>>> vEVENT[obj.event].COINSEARCH = setTimeout(function() {
>>>>>> return (window[obj.action]({
>>>>>> event: obj.event,
>>>>>> record: 0
>>>>>> }));
>>>>>> });
>>>>>>
>>>>>> default:
>>>>>> loop = false;
>>>>>>
>>>>>> }
>>>>>>
>>>>>> } while (loop);
>>>>>>
>>>>>> }
>>>>>>
>>>>>> On 22/4/20 06:40, dolf wrote:
>>>>>>> We'll make one more comment this morning before we return to the
>>>>>>> programming task at hand. Since we're aware that the setTimeout()
>>>>>>> function is capable of passing variables:
>>>>>>>
>>>>>>> vEVENT[next.event].COINSEARCH = setTimeout(
>>>>>>> ["grappleCoinSearch({event: '", next.event, "', record: ",
>>>>>>> next.record, "})"].join(''));
>>>>>>>
>>>>>>> We would consider it a worthwhile activity to determine if our
>>>>>>> initial prototype javascript docking process could be modified
>>>>>>> further to accommodate a semantical form which no longer relied upon
>>>>>>> the COINQUEUE[] approach.
>>>>>>>
>>>>>>> It would be meritorious as a self-education process to investigate
>>>>>>> the potential of the following functions to accomplish this:
>>>>>>>
>>>>>>> JSON.stringify() <-- converts an object in Javascript to a string
>>>>>>>
>>>>>>> JSON.parse() <-- interpret the data into a JavaScript object
>>>>>>>
>>>>>>>>> if (/WIDGET-(\d{1,})/.test(d3.select(this).property('id'))) {
>>>>>>>>>>>
>>>>>>>>> COINQUEUE[COINQUEUE.length] = {
>>>>>>>>> dataType: "COIN_request",
>>>>>>>>> format: "reason",
>>>>>>>>> ruleset: "memeBrain",
>>>>>>>>> params: {
>>>>>>>>> action: "dock",
>>>>>>>>> load: void(0),
>>>>>>>>> src: "scripts/Strongs_max.js",
>>>>>>>>> viable: function () {
>>>>>>>>> return (typeof(LEXICON));
>>>>>>>>> },
>>>>>>>>> retry: 1000,
>>>>>>>>> eject: void(0),
>>>>>>>>> queue: void(0),
>>>>>>>>> watch: function () {
>>>>>>>>> return (
>>>>>>>>> {
>>>>>>>>> record: 0,
>>>>>>>>> results: []
>>>>>>>>> }
>>>>>>>>> )
>>>>>>>>> },
>>>>>>>>> event: RegExp.$1
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> if (_COINTIMER == null)
>>>>>>>>> _COINTIMER = setTimeout('grappleCoinProc(false)');
>>>>>>>>>
>>>>>>>>> }
>>>>>>>
>>>>>>> ----------
>>>>>>>
>>>>>>> Just a quick progress update on the formulation of our simple search
>>>>>>> query and we start with a caveat that I'm engaged in self education,
>>>>>>> I'm neither a computer systems engineer nor a professional
>>>>>>> programmer but I have a respect for their sapient expertise and the
>>>>>>> faculty knowledge of others.
>>>>>>>
>>>>>>> That all we are doing is here facilitating dialog by means of our
>>>>>>> prototype (ie. the labours of 24 years) which we contribute to the
>>>>>>> vast universe of discourse.
>>>>>>>
>>>>>>> And in that regard, much of yesterday was taken up with thinking
>>>>>>> (ie. such is usually a phonetic apprehension which may not be an
>>>>>>> optimal nor a viable reality but we spend time doing so) about the
>>>>>>> best approach to undertake this task and considered that what was
>>>>>>> requisite for the query formulation process was to pass both the
>>>>>>> syllogism and metalogic {} data sets:
>>>>>>>
>>>>>>> vEVENT[RegExp.$1].search = {
>>>>>>> data: function () {
>>>>>>> return ((typeof (LEXICON) != "undefined") ? LEXICON :
>>>>>>> "undefined");
>>>>>>> },
>>>>>>> action: "search",
>>>>>>> type: "simple",
>>>>>>> results: "results",
>>>>>>> event: null,
>>>>>>> query: _memeBrain.searchSimpleFormulate({
>>>>>>> syllogism: vEVENT[RegExp.$1].syllogism,
>>>>>>> metalogic: vEVENT[RegExp.$1].metalogic
>>>>>>> })
>>>>>>> }
>>>>>>>
>>>>>>> And to then commence the process by breaking it up in a top / down
>>>>>>> approach where we commence with the most important consideration
>>>>>>> which is whether the syllogism criteria has been checked:
>>>>>>> natureCheck, nurtureCheck or syncreticCheck and then to determine
>>>>>>> any ONTIC condition (ie. the red background checkbox) by the
>>>>>>> task.ontic as our first rule and we store the result in the ontic{}
>>>>>>> dataset so that any duplicates are eliminated:
>>>>>>>
>>>>>>> case (typeof task.ontic) :
>>>>>>> if (task.ontic = checked[s]) {
>>>>>>> for (var i = 1; i < 8; i++)
>>>>>>> if (criterion.metalogic.metaChecks[s][i] &&
>>>>>>> isOntic(criterion.metalogic.delimiters[s][i]))
>>>>>>> ontic[criterion.metalogic.delimiters[s][i]] =
>>>>>>> true;
>>>>>>> }
>>>>>>> continue determine;
>>>>>>>
>>>>>>> At the conclusion of our determine cycle / do .. while (loop) which
>>>>>>> is nested in the syllogism criteria checked for {} process we then
>>>>>>> derive an array of the entries from the ontic {} data set and push
>>>>>>> them onto the query.ontic [] element before returning the object as
>>>>>>> the framed query.
>>>>>>>
>>>>>>> var items = Object.entries(ontic);
>>>>>>> if (items.length) {
>>>>>>> query.ontic = [];
>>>>>>> for (var i = 0; i < items.length; i++)
>>>>>>> query.ontic[i] = items[i][0];
>>>>>>> }
>>>>>>>
>>>>>>> return (query);
>>>>>>>
>>>>>>> <http://www.grapple369.com/Grumble/reason/memeBrain.json>
>>>>>>>
>>>>>>> Our next rule step as task.telos is to determine any telos criteria
>>>>>>> and we'll need to access the intermediate ontic{} data set so as to
>>>>>>> avoid any duplicates.
>>>>>>>
>>>>>>> And so we'll continue that programming task as at leisurely pace ...
>>>>>>>
>>>>>>> On 20/4/20 09:52, dolf wrote:
>>>>>>>> We've made a further optimization to our search traversal process,
>>>>>>>> since the resultant condition of the memeBrain COINRULES search
>>>>>>>> returned either a TRUE or FALSE state, we considered that the TRUE
>>>>>>>> condition could more easily accommodate the RECORD count which is
>>>>>>>> then passed as an object {event: "12345678", record: nnn} by the
>>>>>>>> setTimeout() process itself...
>>>>>>>>
>>>>>>>> So therefore the initial queuing sets the initial record count to
>>>>>>>> zero. And we're only storing the coin.record in the
>>>>>>>> vEVENT[coin.event].record only for the temporary purposes of visual
>>>>>>>> reporting.
>>>>>>>>
>>>>>>>> vEVENT[obj.event].COINSEARCH =
>>>>>>>> setTimeout(["grappleCoinSearch({event: '", obj.event, "', record:
>>>>>>>> ", 0, "})"].join(''));
>>>>>>>>
>>>>>>>> We've sought to differentiate this notion by the rule task.count
>>>>>>>> instead of task.record which is now omitted. But for now we'll keep
>>>>>>>> the results designate because we might want to compare multiple
>>>>>>>> instances, but that could change.
>>>>>>>>
>>>>>>>> Thusly the code (and I did promise not to publish any more of it)
>>>>>>>> is redacted as follows:
>>>>>>>>
>>>>>>>> var search = {
>>>>>>>> data: function () {
>>>>>>>> return ((typeof (LEXICON) != "undefined") ? LEXICON :
>>>>>>>> "undefined");
>>>>>>>> },
>>>>>>>> action: "search",
>>>>>>>> type: "simple",
>>>>>>>> results: "results",
>>>>>>>> event: null,
>>>>>>>> query: {}
>>>>>>>> }
>>>>>>>>
>>>>>>>> search: function (obj) {
>>>>>>>>
>>>>>>>> var result = void(0);
>>>>>>>> var loop = true;
>>>>>>>> var task = {}
>>>>>>>>
>>>>>>>> determine:
>>>>>>>>
>>>>>>>> do {
>>>>>>>>
>>>>>>>> switch ("undefined") {
>>>>>>>> case (typeof task.data) :
>>>>>>>> task.data = (obj.data() != "undefined") ?
>>>>>>>> obj.data() :
>>>>>>>> null;
>>>>>>>> if (!task.data) {
>>>>>>>> loop = false;
>>>>>>>> break;
>>>>>>>> }
>>>>>>>> continue determine;
>>>>>>>>
>>>>>>>> case (typeof task.count) :
>>>>>>>> task.count = obj.count;
>>>>>>>> if (task.count == task.data.length) {
>>>>>>>> loop = false;
>>>>>>>> break;
>>>>>>>> }
>>>>>>>> continue determine;
>>>>>>>>
>>>>>>>> case (typeof result) :
>>>>>>>> result = ++task.count;
>>>>>>>> return(result);
>>>>>>>>
>>>>>>>> default:
>>>>>>>> loop = false;
>>>>>>>>
>>>>>>>> }
>>>>>>>>
>>>>>>>> } while (loop);
>>>>>>>>
>>>>>>>> return (false);
>>>>>>>>
>>>>>>>> },
>>>>>>>>
>>>>>>>> function grappleCoinSearch (coin) {
>>>>>>>>
>>>>>>>> function nextCoinSearchProcess (next) {
>>>>>>>>
>>>>>>>> if (vEVENT[next.event].COINSEARCH == null)
>>>>>>>> vEVENT[next.event].COINSEARCH =
>>>>>>>> setTimeout(["grappleCoinSearch({event: '", next.event, "', record:
>>>>>>>> ", next.record, "})"].join(''));
>>>>>>>>
>>>>>>>> }
>>>>>>>>
>>>>>>>> var event = void(0);
>>>>>>>> var task = void(0);
>>>>>>>> var loop = true;
>>>>>>>>
>>>>>>>> determine:
>>>>>>>>
>>>>>>>> do {
>>>>>>>>
>>>>>>>> switch ("undefined") {
>>>>>>>> case (typeof event) :
>>>>>>>> event = vEVENT[coin.event];
>>>>>>>> if (typeof (event) == "undefined") {
>>>>>>>> loop = false;
>>>>>>>> break;
>>>>>>>> }
>>>>>>>>
>>>>>>>> window.clearTimeout(vEVENT[coin.event].COINSEARCH);
>>>>>>>> vEVENT[coin.event].COINSEARCH = null;
>>>>>>>> continue determine;
>>>>>>>>
>>>>>>>> case (typeof task) :
>>>>>>>> task = vEVENT[coin.event].search;
>>>>>>>> task.event = coin.event;
>>>>>>>> task.count = coin.record;
>>>>>>>>
>>>>>>>> switch (true) {
>>>>>>>> case (task.action == "search") :
>>>>>>>> if (coin.record =
>>>>>>>> COINRULES.memeBrain.search(task)) {
>>>>>>>> vEVENT[coin.event].record = coin.record;
>>>>>>>> nextCoinSearchProcess(coin);
>>>>>>>> }
>>>>>>>> break;
>>>>>>>> }
>>>>>>>> continue determine;
>>>>>>>>
>>>>>>>> default :
>>>>>>>> loop = false;
>>>>>>>> }
>>>>>>>>
>>>>>>>> } while (loop);
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> -----------
>>>>>>>>
>>>>>>>> Our task today will be to move from the INITIATE traversal phase to
>>>>>>>> actually facilitate the query{} and provide some preliminary
>>>>>>>> deduction search method using the options displayed within the
>>>>>>>> example of our earlier POEM which is conveyed on our expanded
>>>>>>>> SPIRAL SELECTOR@{LOGICAL SYLLOGISM} / METALOGIC (AUTONOMOUS
>>>>>>>> DELIMITER) panels
>>>>>>>>
>>>>>>>> — CATHOLIC ANGER AT MURDOCH'S PAPAL KNIGHTHOOD —
>>>>>>>>
>>>>>>>> “OH RUPERT CAN YOU NOW SEE.
>>>>>>>> TWAS IMPOSSIBILITY TO SAY.
>>>>>>>> YOUR SOUL LONG LOST NOR FREE.
>>>>>>>> SOLD TO SATAN {#351} COME WHAT MAY.
>>>>>>>>
>>>>>>>> DOES *MISHPOCHA* ANY COMFORT BRING?
>>>>>>>> WHILST YOU OUR NATION BETRAY.
>>>>>>>> CAN ANY WIPE SUCH TROUBLING
>>>>>>>> UNREDEEMABLE BY PHILANTHROPY.
>>>>>>>>
>>>>>>>> YOUR NOT A SON OF THIS FAIR LAND.
>>>>>>>> AS A KNIGHT OF ANOTHER REALM.
>>>>>>>> TRAFFICKING LUSTS OF CONTRABAND,
>>>>>>>> PLYING DECEIT EVER SO CALM.”
>>>>>>>>
>>>>>>>> And here we are concerned with the #273 - SYNCRETIC progression:
>>>>>>>>
>>>>>>>> SYNCRETIC: (AMALGAM)
>>>>>>>> 8 15 33 56
>>>>>>>> 37 38 44 119 175 100
>>>>>>>> 24 14 5 43 218 80
>>>>>>>>
>>>>>>>> ︖ METALOGIC (AUTONOMOUS DELIMITER) ⦿
>>>>>>>>
>>>>>>>> #ONE: #56 as #56 - CLOSED MOUTH (CHIN)
>>>>>>>>
>>>>>>>> #TWO: #119 as #38 - FULLNESS (SHENG)
>>>>>>>>
>>>>>>>> #THREE: #43 as #43 - ENCOUNTERS (YU)
>>>>>>>>
>>>>>>>> #FOUR: #175 as #13 - INCREASE (TSENG)
>>>>>>>>
>>>>>>>> #FIVE: #218 as #56 - CLOSED MOUTH (CHIN)
>>>>>>>>
>>>>>>>> #SIX: #100 as #19 - FOLLOWING (TS'UNG)
>>>>>>>>
>>>>>>>> #SEVEN: #80 as #80 - LABOURING (CH'IN)
>>>>>>>>
>>>>>>>> #EIGHT: #38 as #38 - FULLNESS (SHENG)
>>>>>>>>
>>>>>>>> As an optimization there is one change that we can make to the
>>>>>>>> function grappleCoinSearch (coin) routine given the
>>>>>>>> COINRULES.memeBrain.know(task) simply calls the search(task) after
>>>>>>>> needlessly generating a temporal HANDLE and otherwise which we
>>>>>>>> already have we can call the COINRULES.memeBrain.search(task)
>>>>>>>> process directly:
>>>>>>>>
>>>>>>>> switch (true) {
>>>>>>>> case (task.action == "search") :
>>>>>>>> if (COINRULES.memeBrain.search(task))
>>>>>>>> nextCoinSearchProcess(coin.event);
>>>>>>>> break;
>>>>>>>>
>>>>>>>> ----------
>>>>>>>>
>>>>>>>> I ought to point out that since the event ID is the elapsed
>>>>>>>> milliseconds from midnight it ought to be passed as a STRING
>>>>>>>> context so as to preserve any leading zeros which will otherwise be
>>>>>>>> truncated and no longer correctly
>>>>>>>> reference the vEVENT
>>>>>>>>
>>>>>>>> vEVENT[obj.event].COINSEARCH =
>>>>>>>> setTimeout(['grappleCoinSearch({event: “',
>>>>>>>> obj.event, '”})'].join(''));
>>>>>>>>
>>>>>>>> I apologise for not earlier detecting the cause for such nihilistic
>>>>>>>> consequence...
>>>>>>>>
>>>>>>>> dolf <dolf...@hotmail.com> wrote:
>>>>>>>>> Just an update, we found that when multiple vEVENT{} searches were
>>>>>>>>> initiated on seperate SPIRAL SELECTOR@{LOGICAL SYLLOGISM} /
>>>>>>>>> METALOGIC (AUTONOMOUS DELIMITER) panel instances, that a *clash*
>>>>>>>>> did occur with the assignment of the setTimeout() handle made to
>>>>>>>>> the single COINSEARCH variable and accordingly this variable is
>>>>>>>>> now moved to the vEVENT[obj.event] object.
>>>>>>>>>
>>>>>>>>> Currently the COINRULES process has a design goal of abstracting
>>>>>>>>> the data{}, vEVENT[obj.event].record count and the intended
>>>>>>>>> vEVENT[obj.event].results by the cycling determine steps:
>>>>>>>>>
>>>>>>>>> task.data <-- pointer to the dataset
>>>>>>>>>
>>>>>>>>> task.record <-- string reference to the vEVENT[obj.event] record
>>>>>>>>> count
>>>>>>>>>
>>>>>>>>> task.bounds <-- vEVENT[obj.event][task.record] < task.data.length
>>>>>>>>>
>>>>>>>>> task.increment <-- set to true on record increment
>>>>>>>>>
>>>>>>>>> It's unlikely that we'll publish further coding ... but there you
>>>>>>>>> have the demonstrable feasibility of #473 - GENESIS tasks by these
>>>>>>>>> COINRULES timer processes:
>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 1) DOCKING with JS file (if required)
>>>>>>>>>>> 2) DETERMINE resource viability
>>>>>>>>>>> 3) RELEASE JS file
>>>>>>>>>>> 4) INITIATE traversal
>>>>>>>>>
>>>>>>>>> And we're able to demonstrate a multiple traversal of the 14,298
>>>>>>>>> records...
>>>>>>>>>
>>>>>>>>> search: function (obj) {
>>>>>>>>>
>>>>>>>>> var result = false;
>>>>>>>>> var loop = true;
>>>>>>>>> var task = {}
>>>>>>>>>
>>>>>>>>> determine:
>>>>>>>>>
>>>>>>>>> do {
>>>>>>>>>
>>>>>>>>> switch ("undefined") {
>>>>>>>>> case (typeof task.data) :
>>>>>>>>> task.data = (obj.data() != "undefined") ?
>>>>>>>>> obj.data() :
>>>>>>>>> null;
>>>>>>>>> if (!task.data) {
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof task.record) :
>>>>>>>>> task.record = (typeof (obj.record) == "string") ?
>>>>>>>>> obj.record : null;
>>>>>>>>> if (!task.record) {
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof task.bounds) :
>>>>>>>>> task.bounds = vEVENT[obj.event][task.record] <
>>>>>>>>> task.data.length;
>>>>>>>>> if (!task.bounds) {
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof task.increment) :
>>>>>>>>> vEVENT[obj.event][task.record]++;
>>>>>>>>> task.increment = true;
>>>>>>>>> result = true;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> default:
>>>>>>>>> loop = false;
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> } while (loop);
>>>>>>>>>
>>>>>>>>> return (result);
>>>>>>>>>
>>>>>>>>> },
>>>>>>>>>
>>>>>>>>> ----------
>>>>>>>>>
>>>>>>>>> You've probably realised that since reasoning is predominantly a
>>>>>>>>> sequential process that this queuing / timer mechanism is a key
>>>>>>>>> component.
>>>>>>>>>
>>>>>>>>> We've thus far completed three of our #473 - GENESIS tasks as
>>>>>>>>> COINRULES timer processes:
>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 1) DOCKING with JS file (if required)
>>>>>>>>>>> 2) DETERMINE resource viability
>>>>>>>>>>> 3) RELEASE JS file
>>>>>>>>>>> 4) INITIATE traversal
>>>>>>>>>
>>>>>>>>> However our task today as to the framing of the enquiry {} object
>>>>>>>>> that will initiate the traversal timer process which is INSTEAD
>>>>>>>>> reliant upon a EVENT centric perspective, and my propositional
>>>>>>>>> view is that a hybrid parameter to the setTimeout() will suit our
>>>>>>>>> purpose by the passing of an obj{} with the event id reference to
>>>>>>>>> the actual vEVENT{} object which then conveys the context
>>>>>>>>> traversal point and the framed enquiry {} object itself:
>>>>>>>>>
>>>>>>>>> _COINSEARCH = setTimeout(['grappleCoinSearch({event: ', obj.event,
>>>>>>>>> '})'].join(''))
>>>>>>>>>
>>>>>>>>> Given the dataset contains 14,298 records, we want to explore the
>>>>>>>>> possibility of the setTimeout() process being able to handle
>>>>>>>>> multiple search contexts.
>>>>>>>>>
>>>>>>>>> But since we presently don't know whether the setTimeout() process
>>>>>>>>> will result in any scheduling *clashes*, there is inserted an
>>>>>>>>> alert() within the code to convey any such eventuality...
>>>>>>>>>
>>>>>>>>> If such should occur, it will be necessary to place an equivalent
>>>>>>>>> of the _COINSEARCH parameter within the vEVENT{} object...
>>>>>>>>>
>>>>>>>>> In order to get the mechanics of the traversal timer process
>>>>>>>>> working we've added some additional elements to the COINQUEUE[]
>>>>>>>>> dock determine tasks which will trigger the queue rule and setup
>>>>>>>>> any watch variables within the relevant vEVENT itself, and the
>>>>>>>>> process uses a wrapper function() as a means to abstract the data
>>>>>>>>> so that the operation is generalised (ie. we are self-educating
>>>>>>>>> here and such approaches may change):
>>>>>>>>>
>>>>>>>>> queue: void(0),
>>>>>>>>> watch: function () {
>>>>>>>>> return (
>>>>>>>>> {lexicon: 0}
>>>>>>>>> )
>>>>>>>>> },
>>>>>>>>>
>>>>>>>>> It's then necessary to make some minor adjustments to the dock
>>>>>>>>> determine ruleset so as to accommodate the circumstances of
>>>>>>>>> present obj.viable() or obj.load instances:
>>>>>>>>>
>>>>>>>>> case (typeof obj.queue) :
>>>>>>>>> var watch = (obj.watch()) ? obj.watch() : null;
>>>>>>>>>
>>>>>>>>> if (typeof (vEVENT[obj.event]) != "undefined") {
>>>>>>>>> for (var is in watch)
>>>>>>>>> vEVENT[obj.event][is] = watch[is];
>>>>>>>>>
>>>>>>>>> vEVENT[obj.event].COINSEARCH =
>>>>>>>>> setTimeout(['grappleCoinSearch({event: ', obj.event,
>>>>>>>>> '})'].join(''));
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> obj.queue = false;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> At the present time the grappleCoinSearch() is a SIMPLE function
>>>>>>>>> that only generates an alert() and we've purposely done this so as
>>>>>>>>> to determine the efficiency of our design and coding processes.
>>>>>>>>>
>>>>>>>>> This will be our Sunday task ....
>>>>>>>>>
>>>>>>>>> PS. my mind is still asleep @ 0645 hours
>>>>>>>>>
>>>>>>>>> function grappleCoinSearch (coin) {
>>>>>>>>>
>>>>>>>>> function nextCoinSearchProcess (event) {
>>>>>>>>>
>>>>>>>>> if (vEVENT[event].COINSEARCH == null)
>>>>>>>>> vEVENT[event].COINSEARCH =
>>>>>>>>> setTimeout(['grappleCoinSearch({event: "', event,
>>>>>>>>> '"})'].join(''));
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> var event = void(0);
>>>>>>>>> var task = void(0);
>>>>>>>>> var loop = true;
>>>>>>>>>
>>>>>>>>> determine:
>>>>>>>>>
>>>>>>>>> do {
>>>>>>>>>
>>>>>>>>> switch ("undefined") {
>>>>>>>>> case (typeof event) :
>>>>>>>>> event = vEVENT[coin.event];
>>>>>>>>> if (typeof (event) == "undefined") {
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> window.clearTimeout(vEVENT[coin.event].COINSEARCH);
>>>>>>>>> vEVENT[coin.event].COINSEARCH = null;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof task) :
>>>>>>>>> task = vEVENT[coin.event].search;
>>>>>>>>> task.event = coin.event;
>>>>>>>>>
>>>>>>>>> switch (true) {
>>>>>>>>> case (task.action == "search") :
>>>>>>>>> if (COINRULES.memeBrain.know(task))
>>>>>>>>> nextCoinSearchProcess(coin.event);
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> default :
>>>>>>>>> loop = false;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> } while (loop);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> ------
>>>>>>>>>
>>>>>>>>> We've now implemented a javascript file docking process within our
>>>>>>>>> memeBrain{} COIN ruleset which is accessible by the COINQUEUE[]
>>>>>>>>> and then invoked with a _COINTIMER =
>>>>>>>>> setTimeout('grappleCoinProc(false)')...
>>>>>>>>>
>>>>>>>>> metalogicSearchButton() process:
>>>>>>>>>
>>>>>>>>> /*
>>>>>>>>> Frame enquiry {} object
>>>>>>>>>
>>>>>>>>> */
>>>>>>>>>
>>>>>>>>> var search = {
>>>>>>>>> data: function () {
>>>>>>>>> return ((typeof (LEXICON) != "undefined") ? LEXICON :
>>>>>>>>> "undefined");
>>>>>>>>> },
>>>>>>>>> action: "search",
>>>>>>>>> type: "simple",
>>>>>>>>> record: "record",
>>>>>>>>> results: "results",
>>>>>>>>> event: null,
>>>>>>>>> query: {}
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> if (/WIDGET-(\d{1,})/.test(d3.select(this).property('id'))) {
>>>>>>>>>
>>>>>>>>> vEVENT[RegExp.$1].search = new Object(search);
>>>>>>>>>
>>>>>>>>> COINQUEUE[COINQUEUE.length] = {
>>>>>>>>> dataType: "COIN_request",
>>>>>>>>> format: "reason",
>>>>>>>>> ruleset: "memeBrain",
>>>>>>>>> params: {
>>>>>>>>> action: "dock",
>>>>>>>>> load: void(0),
>>>>>>>>> src: "scripts/Strongs_max.js",
>>>>>>>>> viable: function () {
>>>>>>>>> return (typeof(LEXICON));
>>>>>>>>> },
>>>>>>>>> retry: 1000,
>>>>>>>>> eject: void(0),
>>>>>>>>> queue: void(0),
>>>>>>>>> watch: function () {
>>>>>>>>> return (
>>>>>>>>> {
>>>>>>>>> record: 0,
>>>>>>>>> results: []
>>>>>>>>> }
>>>>>>>>> )
>>>>>>>>> },
>>>>>>>>> event: RegExp.$1
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> if (_COINTIMER == null)
>>>>>>>>> _COINTIMER = setTimeout('grappleCoinProc(false)');
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> The dock() ruleset here directly access the COINQUEUE[] request
>>>>>>>>> variables: obj.load, obj.viable(), obj.eject and then simply
>>>>>>>>> pushes the request back onto the COINQUEUE[] until either the
>>>>>>>>> obj.viable() condition is met or the obj.retry threshold is
>>>>>>>>> exceeded.
>>>>>>>>>
>>>>>>>>> dock: function (obj) {
>>>>>>>>>
>>>>>>>>> var loop = true;
>>>>>>>>>
>>>>>>>>> determine:
>>>>>>>>>
>>>>>>>>> do {
>>>>>>>>>
>>>>>>>>> switch ("undefined") {
>>>>>>>>> case (typeof obj.load) :
>>>>>>>>>
>>>>>>>>> obj.load = true;
>>>>>>>>>
>>>>>>>>> if (obj.viable() == "undefined") {
>>>>>>>>>
>>>>>>>>> d3.select("head")
>>>>>>>>> .append("script")
>>>>>>>>> .attr("type", "text/javascript")
>>>>>>>>> .attr("src", obj.src);
>>>>>>>>>
>>>>>>>>> COINQUEUE[COINQUEUE.length] = {
>>>>>>>>> dataType: "COIN_request",
>>>>>>>>> format: "reason",
>>>>>>>>> ruleset: 'memeBrain',
>>>>>>>>> params: new Object(obj)
>>>>>>>>> }
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>>
>>>>>>>>> } else {
>>>>>>>>> obj.eject = false;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (obj.viable()) :
>>>>>>>>> if (--obj.retry)
>>>>>>>>> COINQUEUE[COINQUEUE.length] = {
>>>>>>>>> dataType: "COIN_request",
>>>>>>>>> format: "reason",
>>>>>>>>> ruleset: 'memeBrain',
>>>>>>>>> params: new Object(obj)
>>>>>>>>> }
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>>
>>>>>>>>> case (typeof obj.eject) :
>>>>>>>>> d3.selectAll('script')
>>>>>>>>> .each(function () {
>>>>>>>>> if
>>>>>>>>> (d3.select(this).property("src").indexOf(obj.src) != -1)
>>>>>>>>> d3.select(this).remove();
>>>>>>>>> });
>>>>>>>>>
>>>>>>>>> obj.eject = true;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof obj.queue) :
>>>>>>>>> var watch = (obj.watch()) ? obj.watch() : null;
>>>>>>>>>
>>>>>>>>> if (typeof (vEVENT[obj.event]) != "undefined") {
>>>>>>>>> for (var is in watch)
>>>>>>>>> vEVENT[obj.event][is] = watch[is];
>>>>>>>>>
>>>>>>>>> if (_COINSEARCH == null)
>>>>>>>>> _COINSEARCH =
>>>>>>>>> setTimeout(['grappleCoinSearch({event: ', obj.event,
>>>>>>>>> '})'].join(''));
>>>>>>>>> else
>>>>>>>>> alert("grappleCoinSearch() process timer
>>>>>>>>> scheduling problem...");
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> obj.queue = false;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> default:
>>>>>>>>> loop = false;
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> } while (loop);
>>>>>>>>>
>>>>>>>>> },
>>>>>>>>>
>>>>>>>>> The variable in this instance is named LEXICON and contains 14,298
>>>>>>>>> entries...
>>>>>>>>>
>>>>>>>>> Tomorrow's task will be to the Frame enquiry {} object and then
>>>>>>>>> initiate the traversal timer process...
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> On 18/4/20 05:36, dolf wrote:
>>>>>>>>>> One ought to readily intuit that the INTELLECTUS AS GENITIVE
>>>>>>>>>> VOLUNTĀTIS is with the provision of an ONTIC EPISTEMOLOGICAL
>>>>>>>>>> premise and LANGUAGE INDEPENDENT METALOGIC REDACTION is then a
>>>>>>>>>> suitable proposition for a SAPIENT KNOWLEDGE / COGNITIVE ECONOMY
>>>>>>>>>> with its own as inherent actuality and vitality ...
>>>>>>>>>>
>>>>>>>>>> That any economic stimulus beyond technological innovation is
>>>>>>>>>> then more properly an accelerant ...
>>>>>>>>>>
>>>>>>>>>> But I am reliant upon the faculty knowledge and expertise of
>>>>>>>>>> others to properly articulate such.
>>>>>>>>>>
>>>>>>>>>> So we'll continue our informal research into:
>>>>>>>>>>
>>>>>>>>>>> COINRULES timer processes
>>>>>>>>>>>
>>>>>>>>>>> 1) DOCKING with JS file (if required)
>>>>>>>>>>> 2) DETERMINE resource viability
>>>>>>>>>>> 3) RELEASE JS file
>>>>>>>>>>> 4) INITIATE traversal
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> On 17/4/20 17:36, dolf wrote:
>>>>>>>>>>> In order to get the METALOGIC (AUTONOMOUS DELIMITER)
>>>>>>>>>>> multi-segment panels operating correctly (ie. it changes the
>>>>>>>>>>> start and ending row boundary) we've moved the initialise()
>>>>>>>>>>> function to the d3GrappleFORM checkFormBounds() function.
>>>>>>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>
>>
>>
>
--
YOUTUBE: "The Meerkat Circus"
<https://www.youtube.com/watch?v=H-7OuqWi4vQ>
SEE ALSO AS RELATIONSHIP: *INVALIDATING* {Perennial philosophy (HETEROS
{#390 - ROBBERS} v’s HOMOIOS {#391 - STEWARDS OF GOD’S HOUSE} THEORY OF
NUMBER) as universal of right and wrong...} *THE* *ORTHODOX* *AND*
*ROMAN* *CATHOLIC* *CHURCH'S* *CLAIM* {#390 as 1, #100, #80, #1, #3, #5,
#200 as harpax (G727): {#11 as #242} 1) rapacious, ravenous; 2) a
extortioner, a robber} *TO* *JUBILEE2000* *AS* *BEING* *DELUSIONAL*
*AND* *FRAUDULENT*
Private Street on the edge of the Central Business District dated 16th
May, 2000 - This report is prepared in response to a TP00/55 as a Notice
of an Application for Planning Permit
<http://www.grapple369.com/jubilee2000.html>
SEE ALSO: HYPOSTASIS AS DAO OF NATURE (Chinese: ZIRAN) / COURSE (Greek:
TROCHOS) OF NATURE (Greek: GENESIS) [James 3:6]
Chinese HAN Dynasty (206 BCE - 220CE) Hexagon Trigrams to Tetragram
assignments proposed by Yang Hsiung (53BCE - 18CE) which by 4BCE
(translation published within English as first European language in
1993), first appeared in draft form as a meta-thesis titled T'AI HSUAN
CHING {ie. Canon of Supreme Mystery} on Natural Divination associated
with the theory of number, annual seasonal chronology and astrology
reliant upon the seven visible planets as cosmological mother image and
the zodiac.
It shows the ZIRAN as the DAO of NATURE / COURSE-trochos OF
NATURE-genesis [James 3:6] as HYPOSTASIS comprising #81 trinomial
tetragrammaton x 4.5 day = #364.5 day / year as HOMOIOS THEORY OF NUMBER
which is an amalgam of the 64 hexagrams as binomial trigrams / 81 as
trinomial tetragrammaton rather than its encapsulated contrived use as
the microcosm to redefine the macrocosm as the quintessence of the
Pythagorean [Babylonian] as binomial canon of transposition as HETEROS
THEORY OF NUMBER.
<http://www.grapple369.com/nature.html>
The Charter of Human Rights and Responsibilities No. 43 of Act 2006
defines a "PERSON MEANS A HUMAN BEING” and the question is, if it is
permissible to extend this definition to be a "PERSON MEANS A HUMAN
BEING AS A CONSCIOUS REALITY OF HOMO[iOS] SAPIEN[T] WHO IS INSTANTIATED
WITHIN THE TEMPORAL REALITY AS THEN THE CAUSE FOR REASONING AND
RATIONALITY."
That my mathematical theoretical noumenon defines the meta-descriptor
prototypes which are prerequisite to the BEING of HOMO[iOS] SAPIEN[T] as
EXISTENCE / *OUSIA*.
<http://www.grapple369.com/Grumble.zip> (Download resources)
After all the ENNEAD of THOTH and not the Roman Catholic Eucharist,
expresses an Anthropic Cosmological Principle which appears within its
geometric conception as being equivalent to the Pythagorean
TETRAD/TETRACTYS.
strongs: "G3642", "xlit" : "oligópsychos" and its metalogic derived
categories which we are intentioned to then spatially overlay for time
of day / day of year watch events and interleave by telos hierarchy that
we can apply to your speech by such we shall know your *FEAR*
YOUTUBE: "Nineteen Eighty Four Hate Week Rally"
<https://www.youtube.com/watch?v=oD_Bdq1MLWg>
In then by intersecting such with our temporal heuristic ask at the most
probable and opportune time:
ARE YOU FRIGHTENED?
---------
One more informal observation on the *faint*-*hearted* entry strongs:
"G3642", "xlit" : "oligópsychos" that is it has a #321 - *PRO* *DOMO*
ONTIC grounding of @150 + @171 = #321 and has an interesting *synaptic*
condition of:
{@7: Sup: 68 - DIMMING: MENG (#312); Ego: 76 - AGGRAVATION: CHU (#311)}
Of #68 - *RIGHTS* #312 - *CONTRADICTION* associated to KANT'S
PROLEGOMENA mapping of #27 - *DUTIES* as idea #311. And the discovery
of these would be beneficial for RULE SET conditions ...
That the METALOGIC (AUTONOMOUS DELIMITER) panel then provides the
meta-descriptor criteria to determine the condition:
NATURE: (EGO) ⦿
70 76 3 149
52 10 62 211 159
38 33 30 101 312 153
NURTURE: (SUPERNAL)
4 9 19 32
42 68 20 130 162 52
32 29 21 82 244 124
SYNCRETIC: (AMALGAM)
70 76 3 149
20 21 4 45 194 153
19 10 9 38 232 58
︖ METALOGIC (AUTONOMOUS DELIMITER) ⦿
#ONE: #149 as #68 - DIMMING (MENG)
#TWO: #62 as #62 - DOUBT (YI)
#THREE: #101 as #20 - ADVANCE (CHIN)
#FOUR: #211 as #49 - FLIGHT (T'AO)
#FIVE: #312 as #69 - EXHAUSTION (CH'IUNG)
#SIX: #159 as #78 - ON THE VERGE (CHIANG)
#SEVEN: #153 as #72 - HARDNESS (CHIEN)
#EIGHT:
And you can perhaps see the immense wealth of intellectual property
which we want to later deploy in our development to animate as active
functions in a viable emulation of the thinking process itself which
might be considered to be minimally bound by the variable conditions
that are relative to the INTELLECTUS AS GENITIVE VOLUNTĀTIS and as being
a grapple 'from' and 'to' against which values are then assayed to any
given IDEA as impetus.
----------
I’ll be spending the next couple of days offline in self educating on
the existential problem associated with the search process that has to
be as optimal as possible.
And courtesy of StackOverflow.com we've found some purposed and
favourable goal driven dialog which will provide the semantcial basis
which suits our purpose:
var myObject = { 'a': 1, 'b': 2, 'c': 3 };
var newObject = {};
function lexiconMap(obj, mapper) {
var result = {};
Object.keys(obj).forEach(function (key) {
result[key] = mapper(obj[key], key);
});
return result;
}
newObject = lexiconMap(myObject, function(x) { return x * x; });
console.log(myObject);
// => { 'a': 1, 'b': 2, 'c': 3 }
console.log(newObject);
// => { 'a': 2, 'b': 4, 'c': 6 }
That can enable us to transmogrify and search the umbra / gematria
entries for 14,298 record dataset:
{
"derivation" : "from G3641 (ὀλίγος) and G5590 (\u03c8\u03c5\u03c7\u03ae);",
"kjv_def" : "feebleminded",
"lemma" : "ὀλιγόψυχος",
"frequency" : 1,
"strongs_def" : " little-spirited, i.e. faint-hearted",
"outline" : {
"@1" : "fainthearted"
},
"strongs" : "G3642",
"xlit" : "oligópsychos",
"umbra" : {
"2153" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 200]
},
"gematria" : {
"2153" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 200], "2553" : [70,
30, 10, 3, 70, 700, 400, 600, 70, 400, 200]
}
}
For example if we consider the lexicon gematria entry:
"2553" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 400, 200]
We'll readily observe that it is has a #321 - *PRO* *DOMO* ONTIC
grounding of @150 + @171 = #321 and has an interesting *synaptic*
condition of:
{@7: Sup: 68 - DIMMING: MENG (#312); Ego: 76 - AGGRAVATION: CHU (#311)}
Of #68 - *RIGHTS* #312 - *CONTRADICTION* associated to KANT'S
PROLEGOMENA mapping of #27 - *DUTIES* as idea #311. And the discovery
of these would be beneficial for RULE SET conditions:
[70, {@1: Sup: 70 - SEVERANCE: KE (#70); Ego: 70 - SEVERANCE: KE (#70)}
30, {@2: Sup: 19 - FOLLOWING: TS'UNG (#89); Ego: 30 - BOLD RESOLUTION:
YI (#100)}
10, {@3: Sup: 29 - DECISIVENESS: TUAN (#118); Ego: 10 - DEFECTIVENESS,
DISTORTION: HSIEN (#110)}
3, {@4: Sup: 32 - LEGION: CHUANG (#150 - I INDULGE NOT IN ANGER {%28});
Ego: 3 - MIRED: HSIEN (#113)}
70, {@5: Sup: 21 - RELEASE: SHIH (#171 - I AM NOT UNCHASTE WITH ANY ONE
{%20}); Ego: 70 - SEVERANCE: KE (#183)}
700, {@6: Sup: 73 - ALREADY FORDING, COMPLETION: CH'ENG (#244); Ego: 52
- MEASURE: TU (#235)}
400, {@7: Sup: 68 - DIMMING: MENG (#312); Ego: 76 - AGGRAVATION: CHU (#311)}
600, {@8: Sup: 20 - ADVANCE: CHIN (#332); Ego: 33 - CLOSENESS: MI (#344)}
70, {@9: Sup: 9 - BRANCHING OUT: SHU (#341); Ego: 70 - SEVERANCE: KE (#414)}
400, {@10: Sup: 4 - BARRIER: HSIEN (#345); Ego: 76 - AGGRAVATION: CHU
(#490)}
200] {@11: Sup: 42 - GOING TO MEET: YING (#387); Ego: 38 - FULLNESS:
SHENG (#528)}
MALE: @150 + @171 = #321
ONTIC CHECKSUM TOTAL: #321
On 26/4/20 12:15, dolf wrote:
> As our concluding task for the day, we've implemented a
> COINRULES.memeBrain based search() rule set which is entirely reliant
> upon a setTimeout() operation which deploys a context {} object and
> hence the grappleCoinSearch() scheduler action is no longer required.
>
> Within this coding derivation the WIDGET click initiates the context
> within the setTimeout() as the scheduler...
>
> if (/WIDGET-(\d{1,})/.test(d3.select(this).property('id'))) {
>
> vEVENT[RegExp.$1].search = {
> data: function () {
> return ((typeof (LEXICON) != "undefined") ? LEXICON :
> "undefined");
> },
> action: "search",
> results: "results",
> event: null,
> query: _memeBrain.searchSimpleFormulate({
> syllogism: vEVENT[RegExp.$1].syllogism,
> metalogic: vEVENT[RegExp.$1].metalogic
> })
> }
>
> setTimeout(function() {
>
> var context = vEVENT[RegExp.$1].search;
>
> context.context = {
> loop: true,
> event: RegExp.$1,
> record: 1
> }
>
> return (dockJSFileTimerProc({
> load: void(0),
> src: "scripts/Strongs_max.js",
> viable: function () { return (typeof(LEXICON)); },
> retry: 1000,
> eject: void(0),
> queue: void(0),
> action: "search",
> event: RegExp.$1,
> context: context
> }));
> });
>
> }
>
> AND THE ACTUAL SEARCH OPERATION DEPLOYS A CONTEXT FOR EACH INSTANCE OF
> THE setTimeout() process. We've done preliminary tests and have
> identified no difficulties scheduling multiple search sequences.
>
> search: function (obj) {
>
> obj.context.loop = true;
> obj.context.task = {
> event: void(0),
> data: void(0),
> count: void(0),
> result: void(0)
> }
>
> determine:
>
> do {
>
> switch ("undefined") {
> case (typeof obj.context.task.data) :
> obj.context.task.data = (obj.data() != "undefined") ?
> obj.data() : null;
> if (!obj.context.task.data)
> return;
> continue determine;
>
> case (typeof obj.context.task.count) :
> obj.context.task.count = true;
> if (obj.context.record == obj.context.task.data.length)
> return;
> continue determine;
>
> case (typeof obj.context.task.result) :
> obj.context.task.result = true;
> vEVENT[obj.context.event].record = ++obj.context.record;
> continue;
>
> default:
> obj.context.loop = false;
>
> }
>
> } while (obj.context.loop);
>
> setTimeout(function() {
> return (COINRULES.memeBrain.search(obj));
> });
>
> },
>
> ----------
>
> Thusly in support of the goal as to the avoidance of perturbance being
> an essential design principle within any setTimeout() operation, we've
> implemented a context {} object within the dockJSFileTimerProc() and
> bootLoader () processes
>
> setTimeout(function() {
> return (bootLoader ({
> ruleset: "memeBrain",
> reason: "reason",
> params: {
> action: "loaded"
> },
> loadRules: void(0),
> cls: void(0),
> viableRules: function () { return (typeof(_memeBrain)); },
> retry: 1000,
> loadForms: void(0),
> form: "memeBrain",
> forms: "forms",
> viableForms: function () { return (typeof(FORMS.memeBrain)); },
> start: void (0),
> context: {
> reader: new FileReader(), <-- *Added* here
> loop: true
> }
> }));
> });
>
> Whilst it is immaterial to the specific coding example, we're simply
> implementing a best practice design / coding process since we're aware
> that a significant number of setTimeout() operations might be spawned
> within other coding segments and we consider that "the avoidance of
> perturbance is an essential principle" of its intrinsic nature.
> Whereupon what was previously considered as local variable declarations
> are now referenced within the context of passed obj:
>
> var bootLoader = function (obj) {
>
> obj.context.loop = true;
>
> determine:
>
> do {
>
> switch ("undefined") {
> case (typeof obj.loadRules) :
> obj.loadRules = true;
>
> obj.context.reader.onload = function() {
> eval(["COINRULES['", obj.ruleset, "'] = ",
> obj.context.reader.result].join(''));
> }
>
> if (obj.viableRules() == "undefined") {
>
> d3.blob([stub, obj.reason, '/', obj.ruleset,
> '.json'].join(''), {type : "application/json"})
> .then(function (data) {
>
> if (typeof(data) == "object") {
> obj.context.reader.readAsText(data);
> } else {
> throw 404;
> }
>
> })
> .catch((error) => {
>
> readTextFile(stub, [obj.reason, '/', obj.ruleset,
> '.json'].join(''), function(data){
> eval(["COINRULES['", obj.ruleset, "'] = ",
> data].join(''));
> })
>
> })
> }
> continue determine;
>
> case (typeof obj.cls) :
> obj.cls = true;
> var body = d3.select("body")
> body.html("");
> body.append("div").attr("id", "memeSelector");
> body.append("div").attr("id", "IO");
> body.append("div").attr("id", "memeIO");
> body.append("div").attr("id", "memeNarrative");
> continue determine;
>
> case (obj.viableRules()) :
> if (--obj.retry)
> setTimeout(function() {
> return (bootLoader(obj));
> });
> obj.context.loop = false;
> break;
>
> case (typeof obj.loadForms) :
> obj.loadForms = true;
> obj.retry = 1000;
>
> obj.context.reader.onload = function() {
> eval(["FORMS['", obj.form, "'] = ",
> obj.context.reader.result].join(''));
> }
>
> d3.blob([stub + 'forms/', obj.form, '.json'].join(''),
> {type : "application/json"})
> .then(function (data) {
>
> obj.context.reader.readAsText(data);
>
> }) .catch((error) => {
>
> readTextFile(stub, [obj.forms, '/', obj.form,
> '.json'].join(''), function(data){
> eval(["FORMS['", obj.form, "'] = ", data].join(''));
> })
>
> })
> continue determine;
>
> case (obj.viableForms()) :
> if (--obj.retry)
> setTimeout(function() {
> return (bootLoader(obj));
> });
> obj.context.loop = false;
> break;
>
> case (typeof obj.start) :
> obj.start = true;
> startup();
>
> default:
> obj.context.loop = false;
>
> }
>
> } while (obj.context.loop);
>
> }
>
> ----------
>
> Thus in the circumstance where we have broadly articulated an ontic
> grounding as necessity to the epistemological premise being some
> physical law of which we do not know all its properties and potentiality.
>
> As a provisional propostion, could not the ontological condition of
> disease itself being
>
> "a disorder of structure or function in a human" or
>
> "a particular quality or disposition regarded as adversely affecting a
> person or group of people"
>
> be a consideration as to the use of a specific #328 - TRANSFORMATIVE
> PROTOTYPE which applies the #369 - REVERSE TRANSCRIPTASE INHIBITOR
> within such a determined manner so as to place any perturbance of
> disease into a hypostasis that is then subject to the #287 - SEPTET
> BONDING (MANIFESTING NORM).
>
> ----------
>
> This comment has gotten me thinking: "preserve each rule set context so
> that the setTimeout() can operate without any perturbance."
>
> And whilst we have identified certain ONTIC properties of #CENTRE which
> might fall into the category of "operate without any perturbance" one of
> our goals for transmogrifying of the lexicon array 123: [100, 20, 3]
> into its object IDEA form, is that we want to consider whether the ONTIC
> framing itself: #41 x 7 + #41 x 2 of the #369 - DISCRIMINATING NORM (ie.
> it is a cosmological view) is able to naturally arbitrate perturbance
> within causality:
>
> #41 - PRINCIPLE OF EMANATION
> #82 - PRINCIPLE OF CONTINUITY
> #123 - JUDGMENT SENSIBILITY
> #164 - PRINCIPLE OF MATERIALITY
> #205 - PRINCIPLE OF PERSISTENT SUBSTANCE (DISCRIMINATING NORM)
> #246 - NORMA OBLIGANS (OBLIGATING NORM)
> #287 - BONDING (MANIFESTING NORM)
>
> According to wikipedia that the perturbed solution actually satisfies
> closer to the formula in the original problem: #164 + #205 = #369 -
> DISCRIMINATING NORM and typically, the "conditions" that represent
> reality are a formula (or several) that specifically express some
> physical law.
>
> <https://en.wikipedia.org/wiki/Perturbation_theory>
>
> So as a first step towards such a goal as to the avoidance of pertubance
> being an essential design principle within any setTimeout() operation,
> we're going to explore placing each of the local function variables
> deployed by our embryonic grappleCoinSearch({event: obj.event, record:
> 0}) and bootLoader() processes such as:
>
> var reader = new FileReader();
> var loop = true;
>
> And place those within each initiating object:
>
> bootLoader ({
> ruleset: "memeBrain",
> reason: "reason",
> params: {
> action: "loaded"
> },
> loadRules: void(0),
> cls: void(0),
> viableRules: function () { return (typeof(_memeBrain)); },
> retry: 1000,
> loadForms: void(0),
> form: "memeBrain",
> forms: "forms",
> viableForms: function () { return (typeof(FORMS.memeBrain)); },
> start: void (0)
> })
>
> - dolf
>
> On 26/4/20 05:51, dolf wrote:
>> I’ll probably spend the next couple of days offline in self educating on
>> the existential problem associated with the search process that has to be
>> as optimal as possible.
>>
>> The first anomaly which we have to consider is the exception of final
>> form
>> letters within the Hebrew lexicon.
>>
>> And I found online a kernel of an idea which will allow us to
>> transmogrify
>> the lexicon object array 123: [100, 20, 3] into its object IDEA form
>> and we
>> may use the same technique for the search itself:
>>
>> {sup: nn, stelos: nn, ego: nn, etelos: nn}
>>
>> This is an immense wealth of intellectual property which we want to later
>> deploy in our development to animate as active functions in a viable
>> emulation of the thinking process itself which might be considered to be
>> minimally bound by the variable conditions that are relative to the
>> INTELLECTUS AS GENITIVE VOLUNTĀTIS and as being a grapple 'from' and 'to'
>> against which values are then assayed to any given IDEA as impetus.
>>
>> But suffice to say we’re going to explore some JavaScript semantical
>> forms
>> which we have never used:
>>
>> var myObject = { 'a': 1, 'b': 2, 'c': 3 };
>>
>> // returns a new object with the values at each key mapped using
>> mapFn(value)
>> function lexiconMap(object, mapFn) {
>> return Object.keys(object).map(function(result, key) {
>> result[key] = mapFn(object[key])
>> return result
>> }, {})
>> }
>>
>> var newObject = lexiconMap(myObject, function(value) {
>> return value * 2
>> })
>>
>> console.log(newObject);
>> // => { 'a': 2, 'b': 4, 'c': 6 }
>>
>> console.log(myObject);
>> // => { 'a': 1, 'b': 2, 'c': 3 }
>>
>> dolf <dolf...@hotmail.com> wrote:
>>> Today we are going to work further on the framing of our simple query
>>> for the LEXICON search process...
>>>
>>> And this will involve a pairing made by a determination of the
>>> criterion.metalogic.metaChecks[] array...
>>>
>>> That the rule coding to undertake such action is as follows:
>>>
>>> case (typeof task.links) :
>>> if (task.links = checked[s]) {
>>> for (var i = 1; i < 8; i++) {
>>> if (criterion.metalogic.metaLinks[s][i] > 0)
>>> links[links.length] = {
>>> sup: (criterion.metalogic.delimiters[s][i] % 81) ?
>>> criterion.metalogic.delimiters[s][i] % 81 : 81,
>>> stelos: criterion.metalogic.delimiters[s][i],
>>> ego:
>>> (criterion.metalogic.delimiters[s][criterion.metalogic.metaLinks[s][i]]
>>> % 81) ?
>>> criterion.metalogic.delimiters[s][criterion.metalogic.metaLinks[s][i]] %
>>> 81 : 81,
>>> etelos:
>>> criterion.metalogic.delimiters[s][criterion.metalogic.metaLinks[s][i]]
>>> }
>>> }
>>> }
>>> continue determine;
>>>
>>> And since the pairing links are stored within an array it is a simpler
>>> process of storeing the result within the query.links element before
>>> returning the object as the framed query:
>>>
>>> if (links.length)
>>> query.links = new Object(links);
>>>
>>> And so tomorrow we'll consider our best approach to the search algorithm
>>> which will be reliant upon a setTimeout() where there is a real
>>> possibility of multiple searches being undertaken simultaneously.
>>>
>>> So we have we might have to utilise the vEVENT id so to preserve each
>>> rule set context so that the setTimeout() can operate without any
>>> perturbance.
>>>
>>> One thing we did note, that the task rules ought to be declared to their
>>> void(0) condition so that they are triggered correctly since for some
>>> unknown reason assigning task = {} did not trigger the case (typeof
>>> task.ontic) : rule. And since run
>>> nested within a loop, this state of operation should be reset:
>>>
>>> task = {
>>> ontic: void(0),
>>> telos: void(0),
>>> links: void(0)
>>> };
>>> loop = true;
>>>
>>> However given the context is passed by the setTimeout() I don't think
>>> this will be an issue...
>>>
>>> ----------
>>> However since our search criterion is going to produce search results,
>>> we also need to give some consideration to the displaying of any
>>> results.
>>>
>>> And the approach to this will be to first load a REPORTS form via our
>>> bootLoader() process, and whilst emulating the functionality of our
>>> SPIRAL SELECTOR@{...} mechanism, it capable of being anchored as an
>>> inline character ...
>>>
>>> On 23/4/20 13:55, dolf wrote:
>>>> And don't forget that the items are needed to be considered to be
>>>> Number() and not a string sequence:
>>>>
>>>> query.telos[i] = Number(items[i][0]);
>>>>
>>>> Thusly to get back to the framing of our query parameters for the
>>>> simple
>>>> search process within the searchSimpleFormulate() function we've
>>>> completed two rules so far:
>>>>
>>>> case (typeof task.ontic) :
>>>> if (task.ontic = checked[s]) {
>>>> for (var i = 1; i < 8; i++)
>>>> if (criterion.metalogic.metaChecks[s][i] &&
>>>> isOntic(criterion.metalogic.delimiters[s][i]))
>>>> ontic[criterion.metalogic.delimiters[s][i]] = true;
>>>> }
>>>> continue determine;
>>>>
>>>> case (typeof task.telos) :
>>>> if (task.telos = checked[s]) {
>>>> for (var i = 1; i < 8; i++)
>>>> if (criterion.metalogic.metaChecks[s][i] && !
>>>> ontic[criterion.metalogic.delimiters[s][i]])
>>>> telos[criterion.metalogic.delimiters[s][i]] = true;
>>>> }
>>>> continue determine;
>>>>
>>>> And we then derive an array of the entries from the telos {} data set
>>>> and push them onto the query.telos [] element before returning the
>>>> object as the framed query:
>>>>
>>>> items = Object.entries(telos);
>>>> if (items.length) {
>>>> query.telos = [];
>>>> for (var i = 0; i < items.length; i++)
>>>> query.telos[i] = Number(items[i][0]);
>>>> }
>>>>
>>>> Our next process task is to determine each of the metaChecks
>>>> correspondences and then formulate their pairings into an object:
>>>>
>>>> {sup: nn, stelos: nn, ego: nn, etelos: nn}
>>>>
>>>> If for instance the dropdown list is option 4 to the #ONE metalogic
>>>> autonomous delimiter, it means that the #ONE entry comprising the telos
>>>> / tetra (as and / or condition) is as SUPERNAL constrauct then paired
>>>> with the #FOUR entry and so forth...
>>>>
>>>> But we shall accomplish that tomorrow...
>>>>
>>>> On 23/4/20 05:53, dolf wrote:
>>>>> Before we return to the framing of our query parameters for the simple
>>>>> search process, let me just comment on the additional favourable
>>>>> outcome to our self-education as informal research into
>>>>> setTimeout(function() {}) which resulted in the best approach being
>>>>> parameters passed by the function as a complete inversion of our
>>>>> initial approach.
>>>>>
>>>>> Such technique has enabled us to update the initialisation as startup
>>>>> RULESET sequence by means of a bootloader:
>>>>>
>>>>> setTimeout(function() {
>>>>> return (bootLoader ({
>>>>> ruleset: "memeBrain",
>>>>> reason: "reason",
>>>>> params: {
>>>>> action: "loaded"
>>>>> },
>>>>> loadRules: void(0),
>>>>> cls: void(0),
>>>>> viableRules: function () { return (typeof(_memeBrain)); },
>>>>> retry: 1000,
>>>>> loadForms: void(0),
>>>>> form: "memeBrain",
>>>>> viableForms: function () { return
>>>>> (typeof(FORMS.memeBrain)); },
>>>>> start: void (0)
>>>>> }));
>>>>> });
>>>>>
>>>>> Which facilitates a similar appraoch to NOW wrap the d3 PROMISE
>>>>> command within a viable setTimeout condition that will retry a
>>>>> viability test until the retrieval has been completed... As greatly
>>>>> improving the efficiency and reliability of our crtical process that
>>>>> heretofore was brutish as promulgating needless read requests ...
>>>>>
>>>>> var bootLoader = function (obj) {
>>>>>
>>>>> var reader = new FileReader();
>>>>> var loop = true;
>>>>>
>>>>> determine:
>>>>>
>>>>> do {
>>>>>
>>>>> switch ("undefined") {
>>>>> case (typeof obj.loadRules) :
>>>>> obj.loadRules = true;
>>>>>
>>>>> reader.onload = function() {
>>>>> eval(["COINRULES['", obj.ruleset, "'] = ",
>>>>> reader.result].join(''));
>>>>> }
>>>>>
>>>>> if (obj.viableRules() == "undefined") {
>>>>>
>>>>> d3.blob([stub, obj.reason, '/', obj.ruleset,
>>>>> '.json'].join(''))
>>>>> .then(function (data) {
>>>>>
>>>>> if (typeof(data) == "object") {
>>>>> reader.readAsText(data);
>>>>> } else {
>>>>> throw 404;
>>>>> }
>>>>>
>>>>> })
>>>>> .catch((error) => {
>>>>>
>>>>> readTextFile(stub, [obj.reason, '/',
>>>>> obj.ruleset,
>>>>> '.json'].join(''), function(data){
>>>>> eval(["COINRULES['", obj.ruleset, "'] = ",
>>>>> data].join(''));
>>>>> })
>>>>>
>>>>> })
>>>>> }
>>>>> continue determine;
>>>>>
>>>>> case (typeof obj.cls) :
>>>>> obj.cls = true;
>>>>> var body = d3.select("body")
>>>>> body.append("div").attr("id", "memeSelector");
>>>>> body.append("div").attr("id", "IO");
>>>>> body.append("div").attr("id", "memeIO");
>>>>> body.append("div").attr("id", "memeNarrative");
>>>>> continue determine;
>>>>>
>>>>> case (obj.viableRules()) :
>>>>> if (--obj.retry)
>>>>> setTimeout(function() {
>>>>> return (bootLoader(obj));
>>>>> });
>>>>> loop = false;
>>>>> break;
>>>>>
>>>>> case (typeof obj.loadForms) :
>>>>> obj.loadForms = true;
>>>>> obj.retry = 1000;
>>>>>
>>>>> �� reader.onload = function() {
>>>>> eval(["FORMS['", obj.form, "'] = ",
>>>>> reader.result].join(''));
>>>>> }
>>>>>
>>>>> d3.blob([stub + 'forms/', obj.form, '.json'].join(''),
>>>>> {type : "application/json"})
>>>>> .then(function (data) {
>>>>>
>>>>> reader.readAsText(data);
>>>>>
>>>>> }) .catch((error) => {
>>>>>
>>>>> readTextFile(stub, ['forms/', obj.form,
>>>>> '.json'].join(''), function(data){
>>>>> eval(["FORMS['", obj.form, "'] = ",
>>>>> data].join(''));
>>>>> })
>>>>>
>>>>> })
>>>>> continue determine;
>>>>>
>>>>> case (obj.viableForms()) :
>>>>> if (--obj.retry)
>>>>> setTimeout(function() {
>>>>> return (bootLoader(obj));
>>>>> });
>>>>> loop = false;
>>>>> break;
>>>>>
>>>>> case (typeof obj.start) :
>>>>> obj.start = true;
>>>>> startup();
>>>>>
>>>>> default:
>>>>> loop = false;
>>>>>
>>>>> }
>>>>>
>>>>> } while (loop);
>>>>>
>>>>> }
>>>>>
>>>>> On 22/4/20 16:01, dolf wrote:
>>>>>> And our final comment on this relates to the non-necessity of the
>>>>>> clearTimeout() for the transit search process and hence no need to
>>>>>> store it in the vEVENT[id].
>>>>>>
>>>>>> However it would be prudent to store the setTimeout() handle given
>>>>>> our provisional consideration as to a viable emulation of the
>>>>>> thinking process itself which might be considered to be minimally
>>>>>> bound by the variable conditions that are relative to the INTELLECTUS
>>>>>> AS GENITIVE VOLUNTĀTIS and as being a grapple 'from' and 'to' against
>>>>>> which values are then assayed to any given an IDEA as impetus:
>>>>>>
>>>>>> {
>>>>>> from: [1, 2, 3, 4, 5, 6, 7, 8, 9],
>>>>>> to: [9, 8, 7, 6, 5, 4, 3, 2, 1]
>>>>>> }
>>>>>>
>>>>>> If one firstly anchors the setTimeout() handle to a timer[] array
>>>>>> within the from grapple and then retain the last timer.length within
>>>>>> the action, its relativity is an increment offset+1 for the purpose
>>>>>> of *determination* *of* *the* *sequential* *nature* *of* *the*
>>>>>> *thinking* *action*.
>>>>>>
>>>>>> Once the timer[n] array entry is nulled, no further reference is made
>>>>>> and a garbage() collection function ought to periodically trim nulled
>>>>>> timer[] arrays and return it to timer = [];
>>>>>>
>>>>>> That's what we are working towards as our design goal...
>>>>>>
>>>>>> And its very likely that we'll update the initialisation of the
>>>>>> COINRULES at startup to adopt a similar _FILELOADTIMER perspective
>>>>>> relative to the FORMS as to check viability of the COINRULE {} before
>>>>>> invoking any FORM process which might be reliant upon such ...
>>>>>>
>>>>>> So that's the favourable outcome to our setTimeout() self education.
>>>>>>
>>>>>> ---------
>>>>>>
>>>>>> We've thought to investigate the feasibility of the following
>>>>>> processes by utilizing only a setTimeout() with parameters redacted
>>>>>> to comply with the JSON.stringify() function and that required us to
>>>>>> deploy non void(0) conditions within our determine / loop ruleset:
>>>>>>
>>>>>> 1) DOCKING with JS file (if required)
>>>>>> 2) DETERMINE resource viability
>>>>>> 3) RELEASE JS file
>>>>>> 4) INITIATE traversal
>>>>>>
>>>>>> We have then considered the possibility of a setTimeout(function()
>>>>>> {}) and therefore further modified our Grumble prototype to support
>>>>>> this later method because it enables us to deploy more complex
>>>>>> variable types but have retained our existing dock ruleset within the
>>>>>> memeBrain {} COINRULES object:
>>>>>>
>>>>>> THUSLY the process will work with the following process which will
>>>>>> invoke the grappleCoinSearch() action at the conclusion:
>>>>>>
>>>>>> if (_FILELOADTIMER == null)
>>>>>> _FILELOADTIMER = setTimeout(function() {
>>>>>>
>>>>>> return (dockJSFileTimerProc({
>>>>>> load: void(0),
>>>>>> src: "scripts/Strongs_max.js",
>>>>>> viable: function () { return (typeof(LEXICON)); },
>>>>>> retry: 1000,
>>>>>> eject: void(0),
>>>>>> queue: void(0),
>>>>>> action: "grappleCoinSearch",
>>>>>> event: RegExp.$1
>>>>>> }));
>>>>>> });
>>>>>>
>>>>>> }
>>>>>>
>>>>>> grappleCoinSearchQueue: <-- Redacted as no longer necessary
>>>>>>
>>>>>> var _FILELOADTIMER = null;
>>>>>>
>>>>>> var dockJSFileTimerProc = function (obj) {
>>>>>>
>>>>>> window.clearTimeout(_FILELOADTIMER);
>>>>>> _FILELOADTIMER = null;
>>>>>>
>>>>>> var loop = true;
>>>>>>
>>>>>> determine:
>>>>>>
>>>>>> do {
>>>>>>
>>>>>> switch ("undefined") {
>>>>>> case (typeof obj.load) :
>>>>>>
>>>>>> obj.load = true;
>>>>>> if (obj.viable() == "undefined") {
>>>>>>
>>>>>> d3.select("head")
>>>>>> .append("script")
>>>>>> .attr("type", "text/javascript")
>>>>>> .attr("src", obj.src);
>>>>>>
>>>>>> _FILELOADTIMER = setTimeout(function() {
>>>>>> return (dockJSFileTimerProc(obj));
>>>>>> });
>>>>>>
>>>>>> } else {
>>>>>> obj.eject = false;
>>>>>> continue determine;
>>>>>> }
>>>>>> loop = false;
>>>>>> break;
>>>>>>
>>>>>> case (obj.viable()) :
>>>>>> if (--obj.retry)
>>>>>> _FILELOADTIMER = setTimeout(function() {
>>>>>> return (dockJSFileTimerProc(obj));
>>>>>> });
>>>>>> loop = false;
>>>>>> break;
>>>>>>
>>>>>> case (typeof obj.eject) :
>>>>>> d3.selectAll('script')
>>>>>> .each(function () {
>>>>>> if
>>>>>> (d3.select(this).property("src").indexOf(obj.src) != -1)
>>>>>> d3.select(this).remove();
>>>>>> });
>>>>>>
>>>>>> obj.eject = true;
>>>>>> continue determine;
>>>>>>
>>>>>> case (typeof obj.queue) :
>>>>>> vEVENT[obj.event].COINSEARCH = setTimeout(function() {
>>>>>> return (window[obj.action]({
>>>>>> event: obj.event,
>>>>>> record: 0
>>>>>> }));
>>>>>> });
>>>>>>
>>>>>> default:
>>>>>> loop = false;
>>>>>>
>>>>>> }
>>>>>>
>>>>>> } while (loop);
>>>>>>
>>>>>> }
>>>>>>
>>>>>> On 22/4/20 06:40, dolf wrote:
>>>>>>> We'll make one more comment this morning before we return to the
>>>>>>> programming task at hand. Since we're aware that the setTimeout()
>>>>>>> function is capable of passing variables:
>>>>>>>
>>>>>>> vEVENT[next.event].COINSEARCH = setTimeout(
>>>>>>> ["grappleCoinSearch({event: '", next.event, "', record: ",
>>>>>>> next.record, "})"].join(''));
>>>>>>>
>>>>>>> We would consider it a worthwhile activity to determine if our
>>>>>>> initial prototype javascript docking process could be modified
>>>>>>> further to accommodate a semantical form which no longer relied upon
>>>>>>> the COINQUEUE[] approach.
>>>>>>>
>>>>>>> It would be meritorious as a self-education process to investigate
>>>>>>> the potential of the following functions to accomplish this:
>>>>>>>
>>>>>>> JSON.stringify() <-- converts an object in Javascript to a string
>>>>>>>
>>>>>>> JSON.parse() <-- interpret the data into a JavaScript object
>>>>>>>
>>>>>>>>> if (/WIDGET-(\d{1,})/.test(d3.select(this).property('id'))) {
>>>>>>>>>>>
>>>>>>>>> COINQUEUE[COINQUEUE.length] = {
>>>>>>>>> dataType: "COIN_request",
>>>>>>>>> format: "reason",
>>>>>>>>> ruleset: "memeBrain",
>>>>>>>>> params: {
>>>>>>>>> action: "dock",
>>>>>>>>> load: void(0),
>>>>>>>>> src: "scripts/Strongs_max.js",
>>>>>>>>> viable: function () {
>>>>>>>>> return (typeof(LEXICON));
>>>>>>>>> },
>>>>>>>>> retry: 1000,
>>>>>>>>> eject: void(0),
>>>>>>>>> queue: void(0),
>>>>>>>>> watch: function () {
>>>>>>>>> return (
>>>>>>>>> {
>>>>>>>>> record: 0,
>>>>>>>>> results: []
>>>>>>>>> }
>>>>>>>>> )
>>>>>>>>> },
>>>>>>>>> event: RegExp.$1
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> if (_COINTIMER == null)
>>>>>>>>> _COINTIMER = setTimeout('grappleCoinProc(false)');
>>>>>>>>>
>>>>>>>>> }
>>>>>>>
>>>>>>> ----------
>>>>>>>
>>>>>>> Just a quick progress update on the formulation of our simple search
>>>>>>> query and we start with a caveat that I'm engaged in self education,
>>>>>>> I'm neither a computer systems engineer nor a professional
>>>>>>> programmer but I have a respect for their sapient expertise and the
>>>>>>> faculty knowledge of others.
>>>>>>>
>>>>>>> That all we are doing is here facilitating dialog by means of our
>>>>>>> prototype (ie. the labours of 24 years) which we contribute to the
>>>>>>> vast universe of discourse.
>>>>>>>
>>>>>>> And in that regard, much of yesterday was taken up with thinking
>>>>>>> (ie. such is usually a phonetic apprehension which may not be an
>>>>>>> optimal nor a viable reality but we spend time doing so) about the
>>>>>>> best approach to undertake this task and considered that what was
>>>>>>> requisite for the query formulation process was to pass both the
>>>>>>> syllogism and metalogic {} data sets:
>>>>>>>
>>>>>>> vEVENT[RegExp.$1].search = {
>>>>>>> data: function () {
>>>>>>> return ((typeof (LEXICON) != "undefined") ? LEXICON :
>>>>>>> "undefined");
>>>>>>> },
>>>>>>> action: "search",
>>>>>>> type: "simple",
>>>>>>> results: "results",
>>>>>>> event: null,
>>>>>>> query: _memeBrain.searchSimpleFormulate({
>>>>>>> syllogism: vEVENT[RegExp.$1].syllogism,
>>>>>>> metalogic: vEVENT[RegExp.$1].metalogic
>>>>>>> })
>>>>>>> }
>>>>>>>
>>>>>>> And to then commence the process by breaking it up in a top / down
>>>>>>> approach where we commence with the most important consideration
>>>>>>> which is whether the syllogism criteria has been checked:
>>>>>>> natureCheck, nurtureCheck or syncreticCheck and then to determine
>>>>>>> any ONTIC condition (ie. the red background checkbox) by the
>>>>>>> task.ontic as our first rule and we store the result in the ontic{}
>>>>>>> dataset so that any duplicates are eliminated:
>>>>>>>
>>>>>>> case (typeof task.ontic) :
>>>>>>> if (task.ontic = checked[s]) {
>>>>>>> for (var i = 1; i < 8; i++)
>>>>>>> if (criterion.metalogic.metaChecks[s][i] &&
>>>>>>> isOntic(criterion.metalogic.delimiters[s][i]))
>>>>>>> ontic[criterion.metalogic.delimiters[s][i]] =
>>>>>>> true;
>>>>>>> }
>>>>>>> continue determine;
>>>>>>>
>>>>>>> At the conclusion of our determine cycle / do .. while (loop) which
>>>>>>> is nested in the syllogism criteria checked for {} process we then
>>>>>>> derive an array of the entries from the ontic {} data set and push
>>>>>>> them onto the query.ontic [] element before returning the object as
>>>>>>> the framed query.
>>>>>>>
>>>>>>> var items = Object.entries(ontic);
>>>>>>> if (items.length) {
>>>>>>> query.ontic = [];
>>>>>>> for (var i = 0; i < items.length; i++)
>>>>>>> query.ontic[i] = items[i][0];
>>>>>>> }
>>>>>>>
>>>>>>> return (query);
>>>>>>>
>>>>>>> <http://www.grapple369.com/Grumble/reason/memeBrain.json>
>>>>>>>
>>>>>>> Our next rule step as task.telos is to determine any telos criteria
>>>>>>> and we'll need to access the intermediate ontic{} data set so as to
>>>>>>> avoid any duplicates.
>>>>>>>
>>>>>>> And so we'll continue that programming task as at leisurely pace ...
>>>>>>>
>>>>>>> On 20/4/20 09:52, dolf wrote:
>>>>>>>> We've made a further optimization to our search traversal process,
>>>>>>>> since the resultant condition of the memeBrain COINRULES search
>>>>>>>> returned either a TRUE or FALSE state, we considered that the TRUE
>>>>>>>> condition could more easily accommodate the RECORD count which is
>>>>>>>> then passed as an object {event: "12345678", record: nnn} by the
>>>>>>>> setTimeout() process itself...
>>>>>>>>
>>>>>>>> So therefore the initial queuing sets the initial record count to
>>>>>>>> zero. And we're only storing the coin.record in the
>>>>>>>> vEVENT[coin.event].record only for the temporary purposes of visual
>>>>>>>> reporting.
>>>>>>>>
>>>>>>>> vEVENT[obj.event].COINSEARCH =
>>>>>>>> setTimeout(["grappleCoinSearch({event: '", obj.event, "', record:
>>>>>>>> ", 0, "})"].join(''));
>>>>>>>>
>>>>>>>> We've sought to differentiate this notion by the rule task.count
>>>>>>>> instead of task.record which is now omitted. But for now we'll keep
>>>>>>>> the results designate because we might want to compare multiple
>>>>>>>> instances, but that could change.
>>>>>>>>
>>>>>>>> Thusly the code (and I did promise not to publish any more of it)
>>>>>>>> is redacted as follows:
>>>>>>>>
>>>>>>>> var search = {
>>>>>>>> data: function () {
>>>>>>>> return ((typeof (LEXICON) != "undefined") ? LEXICON :
>>>>>>>> "undefined");
>>>>>>>> },
>>>>>>>> action: "search",
>>>>>>>> type: "simple",
>>>>>>>> results: "results",
>>>>>>>> event: null,
>>>>>>>> query: {}
>>>>>>>> }
>>>>>>>>
>>>>>>>> search: function (obj) {
>>>>>>>>
>>>>>>>> var result = void(0);
>>>>>>>> var loop = true;
>>>>>>>> var task = {}
>>>>>>>>
>>>>>>>> determine:
>>>>>>>>
>>>>>>>> do {
>>>>>>>>
>>>>>>>> switch ("undefined") {
>>>>>>>> case (typeof task.data) :
>>>>>>>> task.data = (obj.data() != "undefined") ?
>>>>>>>> obj.data() :
>>>>>>>> null;
>>>>>>>> if (!task.data) {
>>>>>>>> loop = false;
>>>>>>>> break;
>>>>>>>> }
>>>>>>>> continue determine;
>>>>>>>>
>>>>>>>> case (typeof task.count) :
>>>>>>>> task.count = obj.count;
>>>>>>>> if (task.count == task.data.length) {
>>>>>>>> loop = false;
>>>>>>>> break;
>>>>>>>> }
>>>>>>>> continue determine;
>>>>>>>>
>>>>>>>> case (typeof result) :
>>>>>>>> result = ++task.count;
>>>>>>>> return(result);
>>>>>>>>
>>>>>>>> default:
>>>>>>>> loop = false;
>>>>>>>>
>>>>>>>> }
>>>>>>>>
>>>>>>>> } while (loop);
>>>>>>>>
>>>>>>>> return (false);
>>>>>>>>
>>>>>>>> },
>>>>>>>>
>>>>>>>> function grappleCoinSearch (coin) {
>>>>>>>>
>>>>>>>> function nextCoinSearchProcess (next) {
>>>>>>>>
>>>>>>>> if (vEVENT[next.event].COINSEARCH == null)
>>>>>>>> vEVENT[next.event].COINSEARCH =
>>>>>>>> setTimeout(["grappleCoinSearch({event: '", next.event, "', record:
>>>>>>>> ", next.record, "})"].join(''));
>>>>>>>>
>>>>>>>> }
>>>>>>>>
>>>>>>>> var event = void(0);
>>>>>>>> var task = void(0);
>>>>>>>> var loop = true;
>>>>>>>>
>>>>>>>> determine:
>>>>>>>>
>>>>>>>> do {
>>>>>>>>
>>>>>>>> switch ("undefined") {
>>>>>>>> case (typeof event) :
>>>>>>>> event = vEVENT[coin.event];
>>>>>>>> if (typeof (event) == "undefined") {
>>>>>>>> loop = false;
>>>>>>>> break;
>>>>>>>> }
>>>>>>>>
>>>>>>>> window.clearTimeout(vEVENT[coin.event].COINSEARCH);
>>>>>>>> vEVENT[coin.event].COINSEARCH = null;
>>>>>>>> continue determine;
>>>>>>>>
>>>>>>>> case (typeof task) :
>>>>>>>> task = vEVENT[coin.event].search;
>>>>>>>> task.event = coin.event;
>>>>>>>> task.count = coin.record;
>>>>>>>>
>>>>>>>> switch (true) {
>>>>>>>> case (task.action == "search") :
>>>>>>>> if (coin.record =
>>>>>>>> COINRULES.memeBrain.search(task)) {
>>>>>>>> vEVENT[coin.event].record = coin.record;
>>>>>>>> nextCoinSearchProcess(coin);
>>>>>>>> }
>>>>>>>> break;
>>>>>>>> }
>>>>>>>> continue determine;
>>>>>>>>
>>>>>>>> default :
>>>>>>>> loop = false;
>>>>>>>> }
>>>>>>>>
>>>>>>>> } while (loop);
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> -----------
>>>>>>>>
>>>>>>>> Our task today will be to move from the INITIATE traversal phase to
>>>>>>>> actually facilitate the query{} and provide some preliminary
>>>>>>>> deduction search method using the options displayed within the
>>>>>>>> example of our earlier POEM which is conveyed on our expanded
>>>>>>>> SPIRAL SELECTOR@{LOGICAL SYLLOGISM} / METALOGIC (AUTONOMOUS
>>>>>>>> DELIMITER) panels
>>>>>>>>
>>>>>>>> — CATHOLIC ANGER AT MURDOCH'S PAPAL KNIGHTHOOD —
>>>>>>>>
>>>>>>>> “OH RUPERT CAN YOU NOW SEE.
>>>>>>>> TWAS IMPOSSIBILITY TO SAY.
>>>>>>>> YOUR SOUL LONG LOST NOR FREE.
>>>>>>>> SOLD TO SATAN {#351} COME WHAT MAY.
>>>>>>>>
>>>>>>>> DOES *MISHPOCHA* ANY COMFORT BRING?
>>>>>>>> WHILST YOU OUR NATION BETRAY.
>>>>>>>> CAN ANY WIPE SUCH TROUBLING
>>>>>>>> UNREDEEMABLE BY PHILANTHROPY.
>>>>>>>>
>>>>>>>> YOUR NOT A SON OF THIS FAIR LAND.
>>>>>>>> AS A KNIGHT OF ANOTHER REALM.
>>>>>>>> TRAFFICKING LUSTS OF CONTRABAND,
>>>>>>>> PLYING DECEIT EVER SO CALM.”
>>>>>>>>
>>>>>>>> And here we are concerned with the #273 - SYNCRETIC progression:
>>>>>>>>
>>>>>>>> SYNCRETIC: (AMALGAM)
>>>>>>>> 8 15 33 56
>>>>>>>> 37 38 44 119 175 100
>>>>>>>> 24 14 5 43 218 80
>>>>>>>>
>>>>>>>> ︖ METALOGIC (AUTONOMOUS DELIMITER) ⦿
>>>>>>>>
>>>>>>>> #ONE: #56 as #56 - CLOSED MOUTH (CHIN)
>>>>>>>>
>>>>>>>> #TWO: #119 as #38 - FULLNESS (SHENG)
>>>>>>>>
>>>>>>>> #THREE: #43 as #43 - ENCOUNTERS (YU)
>>>>>>>>
>>>>>>>> #FOUR: #175 as #13 - INCREASE (TSENG)
>>>>>>>>
>>>>>>>> #FIVE: #218 as #56 - CLOSED MOUTH (CHIN)
>>>>>>>>
>>>>>>>> #SIX: #100 as #19 - FOLLOWING (TS'UNG)
>>>>>>>>
>>>>>>>> #SEVEN: #80 as #80 - LABOURING (CH'IN)
>>>>>>>>
>>>>>>>> #EIGHT: #38 as #38 - FULLNESS (SHENG)
>>>>>>>>
>>>>>>>> As an optimization there is one change that we can make to the
>>>>>>>> function grappleCoinSearch (coin) routine given the
>>>>>>>> COINRULES.memeBrain.know(task) simply calls the search(task) after
>>>>>>>> needlessly generating a temporal HANDLE and otherwise which we
>>>>>>>> already have we can call the COINRULES.memeBrain.search(task)
>>>>>>>> process directly:
>>>>>>>>
>>>>>>>> switch (true) {
>>>>>>>> case (task.action == "search") :
>>>>>>>> if (COINRULES.memeBrain.search(task))
>>>>>>>> nextCoinSearchProcess(coin.event);
>>>>>>>> break;
>>>>>>>>
>>>>>>>> ----------
>>>>>>>>
>>>>>>>> I ought to point out that since the event ID is the elapsed
>>>>>>>> milliseconds from midnight it ought to be passed as a STRING
>>>>>>>> context so as to preserve any leading zeros which will otherwise be
>>>>>>>> truncated and no longer correctly
>>>>>>>> reference the vEVENT
>>>>>>>>
>>>>>>>> vEVENT[obj.event].COINSEARCH =
>>>>>>>> setTimeout(['grappleCoinSearch({event: “',
>>>>>>>> obj.event, '”})'].join(''));
>>>>>>>>
>>>>>>>> I apologise for not earlier detecting the cause for such nihilistic
>>>>>>>> consequence...
>>>>>>>>
>>>>>>>> dolf <dolf...@hotmail.com> wrote:
>>>>>>>>> Just an update, we found that when multiple vEVENT{} searches were
>>>>>>>>> initiated on seperate SPIRAL SELECTOR@{LOGICAL SYLLOGISM} /
>>>>>>>>> METALOGIC (AUTONOMOUS DELIMITER) panel instances, that a *clash*
>>>>>>>>> did occur with the assignment of the setTimeout() handle made to
>>>>>>>>> the single COINSEARCH variable and accordingly this variable is
>>>>>>>>> now moved to the vEVENT[obj.event] object.
>>>>>>>>>
>>>>>>>>> Currently the COINRULES process has a design goal of abstracting
>>>>>>>>> the data{}, vEVENT[obj.event].record count and the intended
>>>>>>>>> vEVENT[obj.event].results by the cycling determine steps:
>>>>>>>>>
>>>>>>>>> task.data <-- pointer to the dataset
>>>>>>>>>
>>>>>>>>> task.record <-- string reference to the vEVENT[obj.event] record
>>>>>>>>> count
>>>>>>>>>
>>>>>>>>> task.bounds <-- vEVENT[obj.event][task.record] < task.data.length
>>>>>>>>>
>>>>>>>>> task.increment <-- set to true on record increment
>>>>>>>>>
>>>>>>>>> It's unlikely that we'll publish further coding ... but there you
>>>>>>>>> have the demonstrable feasibility of #473 - GENESIS tasks by these
>>>>>>>>> COINRULES timer processes:
>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 1) DOCKING with JS file (if required)
>>>>>>>>>>> 2) DETERMINE resource viability
>>>>>>>>>>> 3) RELEASE JS file
>>>>>>>>>>> 4) INITIATE traversal
>>>>>>>>>
>>>>>>>>> And we're able to demonstrate a multiple traversal of the 14,298
>>>>>>>>> records...
>>>>>>>>>
>>>>>>>>> search: function (obj) {
>>>>>>>>>
>>>>>>>>> var result = false;
>>>>>>>>> var loop = true;
>>>>>>>>> var task = {}
>>>>>>>>>
>>>>>>>>> determine:
>>>>>>>>>
>>>>>>>>> do {
>>>>>>>>>
>>>>>>>>> switch ("undefined") {
>>>>>>>>> case (typeof task.data) :
>>>>>>>>> task.data = (obj.data() != "undefined") ?
>>>>>>>>> obj.data() :
>>>>>>>>> null;
>>>>>>>>> if (!task.data) {
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof task.record) :
>>>>>>>>> task.record = (typeof (obj.record) == "string") ?
>>>>>>>>> obj.record : null;
>>>>>>>>> if (!task.record) {
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof task.bounds) :
>>>>>>>>> task.bounds = vEVENT[obj.event][task.record] <
>>>>>>>>> task.data.length;
>>>>>>>>> if (!task.bounds) {
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof task.increment) :
>>>>>>>>> vEVENT[obj.event][task.record]++;
>>>>>>>>> task.increment = true;
>>>>>>>>> result = true;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> default:
>>>>>>>>> loop = false;
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> } while (loop);
>>>>>>>>>
>>>>>>>>> return (result);
>>>>>>>>>
>>>>>>>>> },
>>>>>>>>>
>>>>>>>>> ----------
>>>>>>>>>
>>>>>>>>> You've probably realised that since reasoning is predominantly a
>>>>>>>>> sequential process that this queuing / timer mechanism is a key
>>>>>>>>> component.
>>>>>>>>>
>>>>>>>>> We've thus far completed three of our #473 - GENESIS tasks as
>>>>>>>>> COINRULES timer processes:
>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 1) DOCKING with JS file (if required)
>>>>>>>>>>> 2) DETERMINE resource viability
>>>>>>>>>>> 3) RELEASE JS file
>>>>>>>>>>> 4) INITIATE traversal
>>>>>>>>>
>>>>>>>>> However our task today as to the framing of the enquiry {} object
>>>>>>>>> that will initiate the traversal timer process which is INSTEAD
>>>>>>>>> reliant upon a EVENT centric perspective, and my propositional
>>>>>>>>> view is that a hybrid parameter to the setTimeout() will suit our
>>>>>>>>> purpose by the passing of an obj{} with the event id reference to
>>>>>>>>> the actual vEVENT{} object which then conveys the context
>>>>>>>>> traversal point and the framed enquiry {} object itself:
>>>>>>>>>
>>>>>>>>> _COINSEARCH = setTimeout(['grappleCoinSearch({event: ', obj.event,
>>>>>>>>> '})'].join(''))
>>>>>>>>>
>>>>>>>>> Given the dataset contains 14,298 records, we want to explore the
>>>>>>>>> possibility of the setTimeout() process being able to handle
>>>>>>>>> multiple search contexts.
>>>>>>>>>
>>>>>>>>> But since we presently don't know whether the setTimeout() process
>>>>>>>>> will result in any scheduling *clashes*, there is inserted an
>>>>>>>>> alert() within the code to convey any such eventuality...
>>>>>>>>>
>>>>>>>>> If such should occur, it will be necessary to place an equivalent
>>>>>>>>> of the _COINSEARCH parameter within the vEVENT{} object...
>>>>>>>>>
>>>>>>>>> In order to get the mechanics of the traversal timer process
>>>>>>>>> working we've added some additional elements to the COINQUEUE[]
>>>>>>>>> dock determine tasks which will trigger the queue rule and setup
>>>>>>>>> any watch variables within the relevant vEVENT itself, and the
>>>>>>>>> process uses a wrapper function() as a means to abstract the data
>>>>>>>>> so that the operation is generalised (ie. we are self-educating
>>>>>>>>> here and such approaches may change):
>>>>>>>>>
>>>>>>>>> queue: void(0),
>>>>>>>>> watch: function () {
>>>>>>>>> return (
>>>>>>>>> {lexicon: 0}
>>>>>>>>> )
>>>>>>>>> },
>>>>>>>>>
>>>>>>>>> It's then necessary to make some minor adjustments to the dock
>>>>>>>>> determine ruleset so as to accommodate the circumstances of
>>>>>>>>> present obj.viable() or obj.load instances:
>>>>>>>>>
>>>>>>>>> case (typeof obj.queue) :
>>>>>>>>> var watch = (obj.watch()) ? obj.watch() : null;
>>>>>>>>>
>>>>>>>>> if (typeof (vEVENT[obj.event]) != "undefined") {
>>>>>>>>> for (var is in watch)
>>>>>>>>> vEVENT[obj.event][is] = watch[is];
>>>>>>>>>
>>>>>>>>> vEVENT[obj.event].COINSEARCH =
>>>>>>>>> setTimeout(['grappleCoinSearch({event: ', obj.event,
>>>>>>>>> '})'].join(''));
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> obj.queue = false;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> At the present time the grappleCoinSearch() is a SIMPLE function
>>>>>>>>> that only generates an alert() and we've purposely done this so as
>>>>>>>>> to determine the efficiency of our design and coding processes.
>>>>>>>>>
>>>>>>>>> This will be our Sunday task ....
>>>>>>>>>
>>>>>>>>> PS. my mind is still asleep @ 0645 hours
>>>>>>>>>
>>>>>>>>> function grappleCoinSearch (coin) {
>>>>>>>>>
>>>>>>>>> function nextCoinSearchProcess (event) {
>>>>>>>>>
>>>>>>>>> if (vEVENT[event].COINSEARCH == null)
>>>>>>>>> vEVENT[event].COINSEARCH =
>>>>>>>>> setTimeout(['grappleCoinSearch({event: "', event,
>>>>>>>>> '"})'].join(''));
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> var event = void(0);
>>>>>>>>> var task = void(0);
>>>>>>>>> var loop = true;
>>>>>>>>>
>>>>>>>>> determine:
>>>>>>>>>
>>>>>>>>> do {
>>>>>>>>>
>>>>>>>>> switch ("undefined") {
>>>>>>>>> case (typeof event) :
>>>>>>>>> event = vEVENT[coin.event];
>>>>>>>>> if (typeof (event) == "undefined") {
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> window.clearTimeout(vEVENT[coin.event].COINSEARCH);
>>>>>>>>> vEVENT[coin.event].COINSEARCH = null;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof task) :
>>>>>>>>> task = vEVENT[coin.event].search;
>>>>>>>>> task.event = coin.event;
>>>>>>>>>
>>>>>>>>> switch (true) {
>>>>>>>>> case (task.action == "search") :
>>>>>>>>> if (COINRULES.memeBrain.know(task))
>>>>>>>>> nextCoinSearchProcess(coin.event);
>>>>>>>>> break;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> default :
>>>>>>>>> loop = false;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> } while (loop);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> ------
>>>>>>>>>
>>>>>>>>> We've now implemented a javascript file docking process within our
>>>>>>>>> memeBrain{} COIN ruleset which is accessible by the COINQUEUE[]
>>>>>>>>> and then invoked with a _COINTIMER =
>>>>>>>>> setTimeout('grappleCoinProc(false)')...
>>>>>>>>>
>>>>>>>>> metalogicSearchButton() process:
>>>>>>>>>
>>>>>>>>> /*
>>>>>>>>> Frame enquiry {} object
>>>>>>>>>
>>>>>>>>> */
>>>>>>>>>
>>>>>>>>> var search = {
>>>>>>>>> data: function () {
>>>>>>>>> return ((typeof (LEXICON) != "undefined") ? LEXICON :
>>>>>>>>> "undefined");
>>>>>>>>> },
>>>>>>>>> action: "search",
>>>>>>>>> type: "simple",
>>>>>>>>> record: "record",
>>>>>>>>> results: "results",
>>>>>>>>> event: null,
>>>>>>>>> query: {}
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> if (/WIDGET-(\d{1,})/.test(d3.select(this).property('id'))) {
>>>>>>>>>
>>>>>>>>> vEVENT[RegExp.$1].search = new Object(search);
>>>>>>>>>
>>>>>>>>> COINQUEUE[COINQUEUE.length] = {
>>>>>>>>> dataType: "COIN_request",
>>>>>>>>> format: "reason",
>>>>>>>>> ruleset: "memeBrain",
>>>>>>>>> params: {
>>>>>>>>> action: "dock",
>>>>>>>>> load: void(0),
>>>>>>>>> src: "scripts/Strongs_max.js",
>>>>>>>>> viable: function () {
>>>>>>>>> return (typeof(LEXICON));
>>>>>>>>> },
>>>>>>>>> retry: 1000,
>>>>>>>>> eject: void(0),
>>>>>>>>> queue: void(0),
>>>>>>>>> watch: function () {
>>>>>>>>> return (
>>>>>>>>> {
>>>>>>>>> record: 0,
>>>>>>>>> results: []
>>>>>>>>> }
>>>>>>>>> )
>>>>>>>>> },
>>>>>>>>> event: RegExp.$1
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> if (_COINTIMER == null)
>>>>>>>>> _COINTIMER = setTimeout('grappleCoinProc(false)');
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> The dock() ruleset here directly access the COINQUEUE[] request
>>>>>>>>> variables: obj.load, obj.viable(), obj.eject and then simply
>>>>>>>>> pushes the request back onto the COINQUEUE[] until either the
>>>>>>>>> obj.viable() condition is met or the obj.retry threshold is
>>>>>>>>> exceeded.
>>>>>>>>>
>>>>>>>>> dock: function (obj) {
>>>>>>>>>
>>>>>>>>> var loop = true;
>>>>>>>>>
>>>>>>>>> determine:
>>>>>>>>>
>>>>>>>>> do {
>>>>>>>>>
>>>>>>>>> switch ("undefined") {
>>>>>>>>> case (typeof obj.load) :
>>>>>>>>>
>>>>>>>>> obj.load = true;
>>>>>>>>>
>>>>>>>>> if (obj.viable() == "undefined") {
>>>>>>>>>
>>>>>>>>> d3.select("head")
>>>>>>>>> .append("script")
>>>>>>>>> .attr("type", "text/javascript")
>>>>>>>>> .attr("src", obj.src);
>>>>>>>>>
>>>>>>>>> COINQUEUE[COINQUEUE.length] = {
>>>>>>>>> dataType: "COIN_request",
>>>>>>>>> format: "reason",
>>>>>>>>> ruleset: 'memeBrain',
>>>>>>>>> params: new Object(obj)
>>>>>>>>> }
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>>
>>>>>>>>> } else {
>>>>>>>>> obj.eject = false;
>>>>>>>>> }
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (obj.viable()) :
>>>>>>>>> if (--obj.retry)
>>>>>>>>> COINQUEUE[COINQUEUE.length] = {
>>>>>>>>> dataType: "COIN_request",
>>>>>>>>> format: "reason",
>>>>>>>>> ruleset: 'memeBrain',
>>>>>>>>> params: new Object(obj)
>>>>>>>>> }
>>>>>>>>> loop = false;
>>>>>>>>> break;
>>>>>>>>>
>>>>>>>>> case (typeof obj.eject) :
>>>>>>>>> d3.selectAll('script')
>>>>>>>>> .each(function () {
>>>>>>>>> if
>>>>>>>>> (d3.select(this).property("src").indexOf(obj.src) != -1)
>>>>>>>>> d3.select(this).remove();
>>>>>>>>> });
>>>>>>>>>
>>>>>>>>> obj.eject = true;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> case (typeof obj.queue) :
>>>>>>>>> var watch = (obj.watch()) ? obj.watch() : null;
>>>>>>>>>
>>>>>>>>> if (typeof (vEVENT[obj.event]) != "undefined") {
>>>>>>>>> for (var is in watch)
>>>>>>>>> vEVENT[obj.event][is] = watch[is];
>>>>>>>>>
>>>>>>>>> if (_COINSEARCH == null)
>>>>>>>>> _COINSEARCH =
>>>>>>>>> setTimeout(['grappleCoinSearch({event: ', obj.event,
>>>>>>>>> '})'].join(''));
>>>>>>>>> else
>>>>>>>>> alert("grappleCoinSearch() process timer
>>>>>>>>> scheduling problem...");
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> obj.queue = false;
>>>>>>>>> continue determine;
>>>>>>>>>
>>>>>>>>> default:
>>>>>>>>> loop = false;
>>>>>>>>>
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> } while (loop);
>>>>>>>>>
>>>>>>>>> },
>>>>>>>>>
>>>>>>>>> The variable in this instance is named LEXICON and contains 14,298
>>>>>>>>> entries...
>>>>>>>>>
>>>>>>>>> Tomorrow's task will be to the Frame enquiry {} object and then
>>>>>>>>> initiate the traversal timer process...
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> On 18/4/20 05:36, dolf wrote:
>>>>>>>>>> One ought to readily intuit that the INTELLECTUS AS GENITIVE
>>>>>>>>>> VOLUNTĀTIS is with the provision of an ONTIC EPISTEMOLOGICAL
>>>>>>>>>> premise and LANGUAGE INDEPENDENT METALOGIC REDACTION is then a
>>>>>>>>>> suitable proposition for a SAPIENT KNOWLEDGE / COGNITIVE ECONOMY
>>>>>>>>>> with its own as inherent actuality and vitality ...
>>>>>>>>>>
>>>>>>>>>> That any economic stimulus beyond technological innovation is
>>>>>>>>>> then more properly an accelerant ...
>>>>>>>>>>
>>>>>>>>>> But I am reliant upon the faculty knowledge and expertise of
>>>>>>>>>> others to properly articulate such.
>>>>>>>>>>
>>>>>>>>>> So we'll continue our informal research into:
>>>>>>>>>>
>>>>>>>>>>> COINRULES timer processes
>>>>>>>>>>>
>>>>>>>>>>> 1) DOCKING with JS file (if required)
>>>>>>>>>>> 2) DETERMINE resource viability
>>>>>>>>>>> 3) RELEASE JS file
>>>>>>>>>>> 4) INITIATE traversal
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> On 17/4/20 17:36, dolf wrote:
>>>>>>>>>>> In order to get the METALOGIC (AUTONOMOUS DELIMITER)
>>>>>>>>>>> multi-segment panels operating correctly (ie. it changes the
>>>>>>>>>>> start and ending row boundary) we've moved the initialise()
>>>>>>>>>>> function to the d3GrappleFORM checkFormBounds() function.
>>>>>>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>
>>
>>
>
--
YOUTUBE: "The Meerkat Circus"
<https://www.youtube.com/watch?v=H-7OuqWi4vQ>
SEE ALSO AS RELATIONSHIP: *INVALIDATING* {Perennial philosophy (HETEROS
{#390 - ROBBERS} v’s HOMOIOS {#391 - STEWARDS OF GOD’S HOUSE} THEORY OF
NUMBER) as universal of right and wrong...} *THE* *ORTHODOX* *AND*
*ROMAN* *CATHOLIC* *CHURCH'S* *CLAIM* {#390 as 1, #100, #80, #1, #3, #5,
#200 as harpax (G727): {#11 as #242} 1) rapacious, ravenous; 2) a
extortioner, a robber} *TO* *JUBILEE2000* *AS* *BEING* *DELUSIONAL*
*AND* *FRAUDULENT*
Private Street on the edge of the Central Business District dated 16th
May, 2000 - This report is prepared in response to a TP00/55 as a Notice
of an Application for Planning Permit
<http://www.grapple369.com/jubilee2000.html>
SEE ALSO: HYPOSTASIS AS DAO OF NATURE (Chinese: ZIRAN) / COURSE (Greek:
TROCHOS) OF NATURE (Greek: GENESIS) [James 3:6]
Chinese HAN Dynasty (206 BCE - 220CE) Hexagon Trigrams to Tetragram
assignments proposed by Yang Hsiung (53BCE - 18CE) which by 4BCE
(translation published within English as first European language in
1993), first appeared in draft form as a meta-thesis titled T'AI HSUAN
CHING {ie. Canon of Supreme Mystery} on Natural Divination associated
with the theory of number, annual seasonal chronology and astrology
reliant upon the seven visible planets as cosmological mother image and
the zodiac.
It shows the ZIRAN as the DAO of NATURE / COURSE-trochos OF
NATURE-genesis [James 3:6] as HYPOSTASIS comprising #81 trinomial
tetragrammaton x 4.5 day = #364.5 day / year as HOMOIOS THEORY OF NUMBER
which is an amalgam of the 64 hexagrams as binomial trigrams / 81 as
trinomial tetragrammaton rather than its encapsulated contrived use as
the microcosm to redefine the macrocosm as the quintessence of the
Pythagorean [Babylonian] as binomial canon of transposition as HETEROS
THEORY OF NUMBER.
<http://www.grapple369.com/nature.html>
The Charter of Human Rights and Responsibilities No. 43 of Act 2006
defines a "PERSON MEANS A HUMAN BEING” and the question is, if it is
permissible to extend this definition to be a "PERSON MEANS A HUMAN
BEING AS A CONSCIOUS REALITY OF HOMO[iOS] SAPIEN[T] WHO IS INSTANTIATED
WITHIN THE TEMPORAL REALITY AS THEN THE CAUSE FOR REASONING AND
RATIONALITY."
That my mathematical theoretical noumenon defines the meta-descriptor
prototypes which are prerequisite to the BEING of HOMO[iOS] SAPIEN[T] as
EXISTENCE / *OUSIA*.
<http://www.grapple369.com/Grumble.zip> (Download resources)
After all the ENNEAD of THOTH and not the Roman Catholic Eucharist,
expresses an Anthropic Cosmological Principle which appears within its
geometric conception as being equivalent to the Pythagorean
TETRAD/TETRACTYS.
dolf
Apr 26, 2020, 11:06:07 PM4/26/20
to
We have the basic concept of the coding completed:
var lexicon1 = {
"derivation" : "from H3559 (כּוּן);",
"pron" : "kee-yoon'",
"outline" : {
"@0" : "Chiun = 'an image' or 'pillar'",
"@1" : "probably a statue of the Assyrian-Babylonian god of the planet
Saturn and used to symbolise Israelite apostasy",
"@2" : "perhaps corresponding to Priapus or Baal-peor"
},
"kjv_def" : "Chiun.",
"lemma" : "כִּיּוּן",
"frequency" : 1,
"strongs_def" : "properly, a statue, i.e. idol; but used (by euphemism)
forsome heathen deity (perhaps corresponding to Priapus or Baal-peor)",
"xlit" : "Kîyûwn",
"strongs" : "H3594",
"umbra" : {
"86" : [20, 10, 6, 700]
},
"gematria" : {
"86" : {
"0" : [20, 10, 6, 50], "1" : [20, 10, 6, 700]
}, "736" : [20, 10, 6, 700]
}
}
function lexiconMap(obj, mapper) {
function keyMapper(ideas) {
var result = {}
Object.keys(ideas).forEach (function (key) {
if (ideas[key] == "[object Object]")
result[key] = keyMapper(ideas[key]);
else
result[key] = mapper(key, ideas[key]);
});
return result;
}
var umbra = keyMapper(obj.umbra);
var gematria = keyMapper(obj.gematria);
return ({
umbra: umbra,
gematria: gematria
});
}
function test1 (idea, milesian) {
var matrix = [];
milesian.forEach (function (o, i) {
var ego = (o % 81) ? o % 81 : 81;
var x = (i) ? matrix[i-1].sup + ego : ego;
var sup = (x % 81) ? x % 81 : 81;
matrix[i] = {
sup: sup, stelos: (i) ? matrix[i-1].stelos + sup : sup,
ego: ego, etelos: (i) ? matrix[i-1].etelos + ego : ego
}
});
return matrix;
}
var impetus1 = lexiconMap(lexicon1, test1);
var impetus2 = lexiconMap(lexicon2, test1);
console.log(impetus1);
console.log(impetus2);
And I think the best approach to facilitate any search condition is to
perhaps first build a truth{} matrix which contains all possible
instances and their relations:
For instance given:
1 = ego
2 = etolos
3 = sup
4 = stelos
5 = ontic
6 = norms {n x #41}
7 = coin {ie. specific interest}
THEN:
truth: {
1: [1, 2]
}
Would mean that nous: #1 has an occurrence of both an ego / etelos
instance ...
---------
var lexicon1 = {
"derivation" : "from G3641 (ὀλίγος) and G5590 (\u03c8\u03c5\u03c7\u03ae);",
"kjv_def" : "feebleminded",
"lemma" : "ὀλιγόψυχος",
"frequency" : 1,
"strongs_def" : " little-spirited, i.e. faint-hearted",
"outline" : {
"@1" : "fainthearted"
},
"strongs" : "G3642",
"xlit" : "oligópsychos",
"umbra" : {
"2153" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 200]
},
"gematria" : {
"2153" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 200], "2553" : [70,
30, 10, 3, 70, 700, 400, 600, 70, 400, 200]
}
}
var lexicon2 = {
"kjv_def" : "feebleminded",
"lemma" : "ὀλιγόψυχος",
"frequency" : 1,
"strongs_def" : " little-spirited, i.e. faint-hearted",
"outline" : {
"@1" : "fainthearted"
},
"strongs" : "G3642",
"xlit" : "oligópsychos",
"umbra" : {
"2153" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 200]
},
"gematria" : {
"2153" : [70, 30, 10, 3, 70, 700, 400, 600, 70, 200], "2553" : [70,
30, 10, 3, 70, 700, 400, 600, 70, 400, 200]
}
}
"derivation" : "from H3559 (כּוּן);",
"pron" : "kee-yoon'",
"outline" : {
"@0" : "Chiun = 'an image' or 'pillar'",
"@1" : "probably a statue of the Assyrian-Babylonian god of the planet
Saturn and used to symbolise Israelite apostasy",
"@2" : "perhaps corresponding to Priapus or Baal-peor"
},
"kjv_def" : "Chiun.",
"lemma" : "כִּיּוּן",
"frequency" : 1,
"strongs_def" : "properly, a statue, i.e. idol; but used (by euphemism)
forsome heathen deity (perhaps corresponding to Priapus or Baal-peor)",
"xlit" : "Kîyûwn",
"strongs" : "H3594",
"umbra" : {
"86" : [20, 10, 6, 700]
},
"gematria" : {
"86" : {
"0" : [20, 10, 6, 50], "1" : [20, 10, 6, 700]
}, "736" : [20, 10, 6, 700]
}
}
function lexiconMap(obj, mapper) {
function keyMapper(ideas) {
var result = {}
Object.keys(ideas).forEach (function (key) {
if (ideas[key] == "[object Object]")
result[key] = keyMapper(ideas[key]);
else
result[key] = mapper(key, ideas[key]);
});
return result;
}
var umbra = keyMapper(obj.umbra);
var gematria = keyMapper(obj.gematria);
return ({
umbra: umbra,
gematria: gematria
});
}
function test1 (idea, milesian) {
var matrix = [];
milesian.forEach (function (o, i) {
var ego = (o % 81) ? o % 81 : 81;
var x = (i) ? matrix[i-1].sup + ego : ego;
var sup = (x % 81) ? x % 81 : 81;
matrix[i] = {
sup: sup, stelos: (i) ? matrix[i-1].stelos + sup : sup,
ego: ego, etelos: (i) ? matrix[i-1].etelos + ego : ego
}
});
return matrix;
}
var impetus1 = lexiconMap(lexicon1, test1);
var impetus2 = lexiconMap(lexicon2, test1);
console.log(impetus1);
console.log(impetus2);
And I think the best approach to facilitate any search condition is to
perhaps first build a truth{} matrix which contains all possible
instances and their relations:
For instance given:
1 = ego
2 = etolos
3 = sup
4 = stelos
5 = ontic
6 = norms {n x #41}
7 = coin {ie. specific interest}
THEN:
truth: {
1: [1, 2]
}
Would mean that nous: #1 has an occurrence of both an ego / etelos
instance ...
---------
0 new messages