Is there a best practice for creating constants in core for precise algorithms (e.g. a Pi constant)?

Ari_BirthdaySurprise

In designing high precision algorithms in core, is there anything relevant regarding difference in precision among different constant types/configurations?

Example constant types/configurations:

• const
• quickconst on a math module input (e.g. +/*/|x|/etc.)
• quickconst on macro input / output
• primary constant connected to core cell input
• and any of the above constant types sent to a quickbus or distribution bus

Anyone know of any quirks in Reaktor that should lean me toward avoiding or favoring an approach?

Alternatively, is there a better unlisted way for developing a high precision constant? If so, how would you go about creating a Pi constant, for example?

colB

Kinda surprised that someone who knows that they need that level of precision can't just test it for themselves ;)

Here I did some random arithmetic in Windows calculator:

Then I copied that value and pasted it into a constant in a 64bit core cell, it was truncated by Reaktor (or rounded?.. need to test that) to 64bit aka a 'double' (you need to look in the properties pane for the constant to see the full value).

I then did the same calculation in a 64bit core cell, and the tool tip shows the resulting value to be 0

Then I deleted that '3' from the end of the constant, and the tool tip now shows the error

What is fascinating though is that if I replace the constant with a 'quick' constant and paste in the value copied directly from the calculator, I get the correct answer - 0. However, if I copy and paste the value from the properties pane of the correct value constant, I get an error of -4.44089E-16. That's a miniscule error, but does suggest that what Reaktor is showing us in the properties pane might not be what it's using in the background?

Not to worry though, if you need the kind of precision where an error of -4.44089E-16 is a problem, then Reaktor is entirely the wrong environment for you :)