unnor wrote:

JamesTheScratcherBoy wrote:

I've heard people say it would be too advanced for Scratch, but Scratch already has sin, cos, tan, log, and more.

Anyways, support. We need this.

I don't understand why a CHILDREN's website would have such complicated mathematics.

([tan v] of ()::operators)

([10^ v] of ()::operators)

CuddlyGrouse wrote:

Yeah, ^ is very simple, It is repeated multiplication, And can be quite useful. Also, it is quite silly of Scratch not to add it, because recreating it with

([tan v] of ()::operators)

and

([10^ v] of ()::operators)

can return slightly incorrect values.

unnor wrote:

JamesTheScratcherBoy wrote:

I've heard people say it would be too advanced for Scratch, but Scratch already has sin, cos, tan, log, and more.

Anyways, support. We need this.

I don't understand why a CHILDREN's website would have such complicated mathematics.

unnor wrote:

CuddlyGrouse wrote:

Yeah, ^ is very simple, It is repeated multiplication, And can be quite useful. Also, it is quite silly of Scratch not to add it, because recreating it with

([tan v] of ()::operators)

and

([10^ v] of ()::operators)

can return slightly incorrect values.

6^-2.125 =

(() ^ () ::operators)

([e ^ v] of ())

([10 ^ v] of ())

(([e v] of (([ln v]of(base))*([abs v] of (exponent)))::operators)*((1)-((2)*((([floor v] of (exponent))mod(2))*<(base)<(0)>)))

bitmap_caketin wrote:

If you need negative numbers, use:

(([e v] of (([ln v]of(base))*([abs v] of (exponent)))::operators)*((1)-((2)*((([floor v] of (exponent))mod(2))*<(base)<(0)>)))

• they're not obvious at the skill level where the exponent block would start to be helpful (that is probably clumsily stated)
  
• the errors show even for small numbers (2 ^ 3 should be eight but the workaround gives 7.999999999999998)
  

ixvizikil wrote:

unnor wrote:

snippity snip snip

The principle is simple.
Of course, some equations are difficult to calculate, which is why we need it in the first place.

If you could just do
repeat pow:
set result to ((result)*(base)),
We wouldn't need so much this block.

Assycot243 wrote:

bitmap_caketin wrote:

If you need negative numbers, use:

(([e v] of (([ln v]of(base))*([abs v] of (exponent)))::operators)*((1)-((2)*((([floor v] of (exponent))mod(2))*<(base)<(0)>)))

these workarounds have two problems:

• they're not obvious at the skill level where the exponent block would start to be helpful (that is probably clumsily stated)
  
• the errors show even for small numbers (2 ^ 3 should be eight but the workaround gives 7.999999999999998)
  

bitmap_caketin wrote:

Assycot243 wrote:

bitmap_caketin wrote:

If you need negative numbers, use:

(([e v] of (([ln v]of(base))*([abs v] of (exponent)))::operators)*((1)-((2)*((([floor v] of (exponent))mod(2))*<(base)<(0)>)))

these workarounds have two problems:

• they're not obvious at the skill level where the exponent block would start to be helpful (that is probably clumsily stated)
  
• the errors show even for small numbers (2 ^ 3 should be eight but the workaround gives 7.999999999999998)
  

I expect OP could've done it a bit faster than waiting thirteen years and counting.
Also, the floating-point error is unavoidable in the maths system that scratch uses

Mimi-EEEEE wrote:

bitmap_caketin wrote:

Assycot243 wrote:

bitmap_caketin wrote:

If you need negative numbers, use:

(([e v] of (([ln v]of(base))*([abs v] of (exponent)))::operators)*((1)-((2)*((([floor v] of (exponent))mod(2))*<(base)<(0)>)))

these workarounds have two problems:

• they're not obvious at the skill level where the exponent block would start to be helpful (that is probably clumsily stated)
  
• the errors show even for small numbers (2 ^ 3 should be eight but the workaround gives 7.999999999999998)
  

I expect OP could've done it a bit faster than waiting thirteen years and counting.
Also, the floating-point error is unavoidable in the maths system that scratch uses

Eh IDK. Some Scratch mods have exponent blocks, and they dont have too many of those errors.

((0) - ((0) * (0)))

((0) * (() - (0)))

Assycot243 wrote:

bitmap_caketin wrote:

If you need negative numbers, use:

(([e v] of (([ln v]of(base))*([abs v] of (exponent)))::operators)*((1)-((2)*((([floor v] of (exponent))mod(2))*<(base)<(0)>)))

these workarounds have two problems:

• they're not obvious at the skill level where the exponent block would start to be helpful (that is probably clumsily stated)
  
• the errors show even for small numbers (2 ^ 3 should be eight but the workaround gives 7.999999999999998)
  

scratchy_boy106 wrote:

Assycot243 wrote:

bitmap_caketin wrote:

If you need negative numbers, use:

(([e v] of (([ln v]of(base))*([abs v] of (exponent)))::operators)*((1)-((2)*((([floor v] of (exponent))mod(2))*<(base)<(0)>)))

these workarounds have two problems:

• they're not obvious at the skill level where the exponent block would start to be helpful (that is probably clumsily stated)
  
• the errors show even for small numbers (2 ^ 3 should be eight but the workaround gives 7.999999999999998)
  

To make it output 8, just pop a round block somewhere.

TheRealAL2009 wrote:

Yeah, but suppose it was:

3.2 ^ 5
= 3.2 * 3.2 * 3.2 * 3.2 * 3.2
= 335.54432 (exactly that, it's not rounded)

While scratch's e^5ln(3.2) workaround might give something like 335.5443199999…

You would have to do something more complex to find which decimal places are just floating point error. Maybe if you multiply it by ten, various numbers of times, then round it and check the difference to see how close the decimal part is to 0 / 1.

But that's a bit of a hassle.

hotcrystal wrote:

TheRealAL2009 wrote:

Yeah, but suppose it was:

3.2 ^ 5
= 3.2 * 3.2 * 3.2 * 3.2 * 3.2
= 335.54432 (exactly that, it's not rounded)

While scratch's e^5ln(3.2) workaround might give something like 335.5443199999…

You would have to do something more complex to find which decimal places are just floating point error. Maybe if you multiply it by ten, various numbers of times, then round it and check the difference to see how close the decimal part is to 0 / 1.

But that's a bit of a hassle.

It's called floating point imprecision, and unfortunately, there is no solution to that.

hotcrystal wrote:

TheRealAL2009 wrote:

Yeah, but suppose it was:

3.2 ^ 5
= 3.2 * 3.2 * 3.2 * 3.2 * 3.2
= 335.54432 (exactly that, it's not rounded)

While scratch's e^5ln(3.2) workaround might give something like 335.5443199999…

You would have to do something more complex to find which decimal places are just floating point error. Maybe if you multiply it by ten, various numbers of times, then round it and check the difference to see how close the decimal part is to 0 / 1.

But that's a bit of a hassle.

It's called floating point imprecision, and unfortunately, there is no solution to that.

ixvizikil wrote:

hotcrystal wrote:

TheRealAL2009 wrote:

Yeah, but suppose it was:

3.2 ^ 5
= 3.2 * 3.2 * 3.2 * 3.2 * 3.2
= 335.54432 (exactly that, it's not rounded)

While scratch's e^5ln(3.2) workaround might give something like 335.5443199999…

You would have to do something more complex to find which decimal places are just floating point error. Maybe if you multiply it by ten, various numbers of times, then round it and check the difference to see how close the decimal part is to 0 / 1.

But that's a bit of a hassle.

It's called floating point imprecision, and unfortunately, there is no solution to that.

I think the problem is not that we have imprecision (I don't know if ST could even avoid them by using complex code),
but that it's complex to build (I don't know anything about log, so I wouldn't be able to code the workaround myself).