List of triple factorization without repetition of a whole number

That is to create the set of rectangular prisms with the same volume.

They are the whole partitions of the volume in width, length and height.

At least I have an idea that it can be solved with the two DivisorsList command

and two Sequence command nested, Sort command and Unique command.

https://wiki.geogebra.org/e...

n=1,000

l1=DivisorsList(n);

========================

RemoveUndefined(Sequence(Sequence(Sort({Element(l1, i),

Element(ListDivisors(Element(l1, a - i + 1)),j),

n / (Element(l1, i) * Element(ListDivisors(Element(l1, a - i + 1)),j))}),

j,1,Length(ListDivisors(Element(l1, a - i + 1)))), i, 1, a))

Something similar to this but it gives me an error.

Lexical error at line 1, column 30. Encountered "[" (91), after: ""

As I would love to create these nested command using KeepIf, Join, Zip, Sort, DivisorsList nest.

Powerful commands and super commands.

Generating a list all divisor combinations and trimming the list only at the end is quite inefficient.

If I do this with a = 504 on my old computer, it takes 5-10 seconds to compute. The intermediate list contains 13824 triples, shortened to 2600 after "unique", then trimmed to the final 32 triples. Way too much overhead.

If I try this with 2520, Geogebra tries for half a minute or so, then stops with an error message. (The intermediate list would contain 110592 triples, which Geogebra seems to have problems with.)

Here's a much more efficient version that generates only the final triples without all the intermediate overhead:

Join(Zip(Zip({p, q, a / (p q)}, q, KeepIf(t ≥ p ∧ t² p ≤ a ∧ Mod(a, p t) ≟ 0, t, DivisorsList(a))), p, KeepIf(t³ ≤ a, t, DivisorsList(a))))

Feasible for high numbers with many divisors, but also becomes quite slow for numbers with ~100 divisors and eventually also gives up.

Hm....better use

Join(Zip(Zip({p, q, a / (p q)}, q, KeepIf(t ≥ p ∧ t² p ≤ a+0.5 ∧ Mod(a+0.4, p t) <= 0.6, t, DivisorsList(a))), p, KeepIf(t³ ≤ a+0.5, t, DivisorsList(a))))

to make it floating point error proof (at least up to 2^51). I hadn't actually expected floating point issues here (at least not if t^3 is replaced by t*t*t etc. to hopefully avoid calling power functions), but there is some issue with a "less or equal" condition in KeepIf, which I will address in a separate topic.

I also made a javascript version in hopes that it would be faster. Well, the actual computation in javascript is done practically immediately, but I couldn't find an efficient way to get an array of triples from javascript to a Geogebra list. For big lists (a few hundred triples) this step can take over a minute, but at least Geogebra doesn't throw any errors even for large lists this way. File is attached if anyone cares.