Could we please have an exponents block? ( ) ^ ( )

IndexErrorException

HelloJelloPeople wrote:
Guys, I have discovered a workaround.
([10^ v] of (((numerator) / (denominator)) * ([log v] of (base))))
or
([e^ v] of (((numerator) / (denominator)) * ([ln v] of (base))))
(I do still support an exponent block)

There are countless workarounds but not only are they extremely bulk and way over the heads of 95% of Scratchers, it's also slow. All those operations happening in Scratch and not in JS or C makes it slow. Faster exponents would be helpful for a lot of projects.

tetraquark

HelloJelloPeople wrote:
Guys, I have discovered a workaround.
([10^ v] of (((numerator) / (denominator)) * ([log v] of (base))))
or
([e^ v] of (((numerator) / (denominator)) * ([ln v] of (base))))
(I do still support an exponent block)

Yeah but it only works for positive numbers because of log and has a rounding error.

IndexErrorException wrote:
There are countless workarounds but not only are they extremely bulk and way over the heads of 95% of Scratchers, it's also slow. All those operations happening in Scratch and not in JS or C makes it slow. Faster exponents would be helpful for a lot of projects.

Yes, but they are still functional and easy to use by backpacking. A very good one was shown earlier in the post. https://scratch.mit.edu/projects/16871883/

jmdzti_0-0

+1, but maybe just add this?

((3) [^ v] (3)::operators)

with all the operator menus?

AHypnoman

jmdzti_0-0 wrote:
+1, but maybe just add this?
((3) [^ v] (3)::operators)
with all the operator menus?

That wouldn't fit any existing block shape. An entirely new block would be necessary for this.

jmdzti_0-0

+1. would be easior so we hadn't use the

[10 ^ v] of ([log v] of ((2) * (10))

Block I't so messy ;-;

qloakonscratch

Everybody is saying the same reason. I would like to put a new one to the table; it helps with transition to other coding languages, such as Python. Not the symbol perse, but the operations. If people get into the habit of using operations when learning using Scratch, it will stick with them during the rest of their coding experience.

medians

Bringing this topic up.

qloakonscratch wrote:
Everybody is saying the same reason. I would like to put a new one to the table; it helps with transition to other coding languages, such as Python. Not the symbol perse, but the operations. If people get into the habit of using operations when learning using Scratch, it will stick with them during the rest of their coding experience.

I feel like there's no way that this hasn't been mentioned though, and there's not much to say honestly.

tyjinw1

just use this

([10 ^ v] of ((exponent) * ([log v] of (base)))

example

([10 ^ v] of ((4) * ([log v] of (2))

is 16

RobotChickens

100% Support. It's insane to me how this hasn't been a block since the start of scratch. Is it any more difficult to implement than any of the other operations? And have we had a statement form the ST on why this hasn't been added yet? (Fear of extremely large numbers crashing projects?)

-Clickertale_2-

The fact that ST won't add this block because of “Fear of extremely large number crashing projects” is stupid since we could also do:

((-1) / (0)) // Negative Infinity
((1) / (0)) // Positive Infinity
((-1) * ([10 ^ v] of (309))) // Negative Infinity
([10 ^ v] of (309)) // Positive Infinity

and even more ways to make big numbers in regular Scratch without this block!
Edited: I am only using Infinity as an example. I know that Infinity is a special case but I didn't want to make a weird equation multiple times to make an actual large number. Even tho this block would also produce Infinity if the numbers inputted are large enough. (I knew that Infinity is a special case while making this post but I didn't feel the need to specify the fact that Infinity is a special case since Infinity is also seen as a big number that is easier to deal with).

Last edited by -Clickertale_2- (Aug. 1, 2024 09:31:25)

Blue_Hat_Wiz

+1 I didn't even know that It wasn't in here until I tried to use it, seems like such a no-brainer

RobotChickens

-Clickertale_2- wrote:
(#753)
The fact that ST won't add this block because of “Fear of extremely large number crashing projects” is stupid since we could also do:
((-1) / (0)) // Negative Infinity
((1) / (0)) // Positive Infinity
((-1) * ([10 ^ v] of (309))) // Negative Infinity
([10 ^ v] of (309)) // Positive Infinity
and even more ways to make big numbers in regular Scratch without this block!

I'm not an expert on the Scratch code backend, but I'm pretty sure extremely large numbers are harder to handle than infinity…

medians

Bringing this topic up.

julmik6478

() ^ ()::operators reporter

You can find it in scratch++. Scratch++ is a Scratch mod that is compatible with normal Scratch.

Foldy_TPOT

If you want this block

((a) ^ (v)::operators)

just do this:

[10 ^ v]of ((v) / (([log v]of (10))/([log v] of (a))))//It will not work properly for negative bases, such as trying to compute (-2)5.

Or just go here for more.

Foldy_TPOT

julmik6478 wrote:
() ^ ()::operators reporter 
You can find it in scratch++. Scratch++ is a Scratch mod that is compatible with normal Scratch.

You can also find it here!

HelloJelloPeople

AHypnoman wrote:
(#747)
jmdzti_0-0 wrote:
+1, but maybe just add this?
((3) [^ v] (3)::operators)
with all the operator menus?
That wouldn't fit any existing block shape. An entirely new block would be necessary for this.

This would fit with the

((x) mod (y))

block shape, turning it into a dropdown, seen above.

BigNate469

-Clickertale_2- wrote:
The fact that ST won't add this block because of “Fear of extremely large number crashing projects” is stupid since we could also do:
((-1) / (0)) // Negative Infinity
((1) / (0)) // Positive Infinity
((-1) * ([10 ^ v] of (309))) // Negative Infinity
([10 ^ v] of (309)) // Positive Infinity
and even more ways to make big numbers in regular Scratch without this block!

Scratch turns equations that evaluate to infinity into the string “infinity”- meaning that it's actually far easier for JavaScript to handle it on the backend than something like 9999999999999999999999999999999999999999999999999999, even if it's converted to a bigint.

medians

AHypnoman wrote:
jmdzti_0-0 wrote:
+1, but maybe just add this?
((3) [^ v] (3)::operators)
with all the operator menus?
That wouldn't fit any existing block shape. An entirely new block would be necessary for this.

What are you talking about??
Anyways (to the person that you quoted), that would make scripts longer. I think block switching should just be reimplemented, and () ^ () could be one of the options

RobotChickens

BigNate469 wrote:
(#761)
-Clickertale_2- wrote:
The fact that ST won't add this block because of “Fear of extremely large number crashing projects” is stupid since we could also do:
((-1) / (0)) // Negative Infinity
((1) / (0)) // Positive Infinity
((-1) * ([10 ^ v] of (309))) // Negative Infinity
([10 ^ v] of (309)) // Positive Infinity
and even more ways to make big numbers in regular Scratch without this block!
Scratch turns equations that evaluate to infinity into the string “infinity”- meaning that it's actually far easier for JavaScript to handle it on the backend than something like 9999999999999999999999999999999999999999999999999999, even if it's converted to a bigint.

Again, I'm talking about extremely large numbers that aren't large enough to be recognized as infinity!

Discuss Scratch