Shorter code via `arr.at(-1)` instead of `arr[arr.length - 1]` etc.

[kungfooman]

GAmphetamine.js/src/GAmphetamine.js

Line 118 in ea3f330

var el = contract(x.slice(1)+options.basis[options.basis.length-1].slice(1));

GAmphetamine.js/src/GAmphetamine.js

Line 326 in ea3f330

if (vals.length === 1 && ${x.layout.length} !== 1) vals = [...Array(${x.layout.length})].map((y,i)=>[${x.fixed??''}][i]||(vals[0]+(i+(${options.startIndex||0}))+({"{":"}","[":"]","(":")"}[vals[0][vals[0].length-1]]||'')));

GAmphetamine.js/src/GAmphetamine.js

Line 490 in ea3f330

if (x[x.length-1] == 0) return [x];

GAmphetamine.js/src/GAmphetamine.js

Line 1238 in ea3f330

if (args[args.length-1] instanceof Function) return Element.inline(args[args.length-1]).apply(Element);

Also slices support negative indexing too:

GAmphetamine.js/src/GAmphetamine.js

Line 498 in ea3f330

var R = S.slice(0,S.length-1).map((Si,i)=>{

... and more

Example:

- var el  = contract(x.slice(1)+options.basis[options.basis.length-1].slice(1)); 
+  var el  = contract(x.slice(1)+options.basis.at(-1).slice(1)); 

[lokiofmute]

it might be shorter.. but it also might be slower.
(too lazy to check, but just deducing by reasoning. apologies for the lazyness ;-)

basis[basis.length - 1] is a property access and a subtract, to access the collection fetch

whereas

basis.at(-1) is a function call which has to find out the negative indexing
(so at least an 'if' branch, even if the function gets 'inlined' ; otherwise two)
then fetches the length and does the subtraction, to also access the collection fetch

...which is akin to what basis[basis.length - 1] actually does,
but on the inside of .at(-1) with some overhead
(lazily deduced by means of old fashioned caveman thinking)

so it depends on what the founder of the code favours: 'modern' shorter readability versus a small speed gain.
meh.

Did you check the speed, when making the pull request, btw?
What are your findings on speed? Would be interesting to learn, actually.

(maybe the jit compiler wipes it all away by optimization! He who measures, knows.)

cheers!

[lokiofmute]

out of sheer curiosity (but maintaining the lazy stance)
I asked an AI to cook up a benchmark comparison.

depending on your mileage and machine, it reaches these scores when run a gazillion times with warm-up amortization, etc.

Bracket Notation: basis[basis.length - 1]: ~55 ms
Method: basis.at(-1): ~140 ms

interesting.
now we only need to figure out if the AI was lying or not ;-)

cheers!

[kungfooman]

Good point, just this morning I created a gazillion dual blade lookup tables and those 100ms are still haunting me. ;-) Anyway, maintaining the lazy stance, ask your AI about premature optimization.

[lokiofmute]

yes, that's the everlasting discussion, true.

Matters of taste, efficiency, readability, to code or not to code, that's what it's all about ;-)

I'm still not 100% certain what is best.
as usual, I think: 'it depends'.
-> probably on the fact if it gets called a gazillion times or not,
and if the code is actually meant to be read a lot.
the usual discriminators.

I am honestly curious what the verdict will be!

cheers