([e^ v] of (([ln v] of ()) * ())::operators)//this is the current workaround

scratchisthebest wrote:

by this logic, we can remove “move (10) steps”

why not just use

go to x: ((x position) + ([cos v] of ((direction)*(amt)))) y ((x position) + ([sin v] of ((direction)*(amt))))

i mean jeez so simple

scienceexplorer1 wrote:

scratchisthebest wrote:

by this logic, we can remove “move (10) steps”

why not just use

go to x: ((x position) + ([cos v] of ((direction)*(amt)))) y ((x position) + ([sin v] of ((direction)*(amt))))

i mean jeez so simple

How is that simple???

Greg8128 wrote:

Some people say that

([e ^ v] of (([ln v] of (base))*(exponent))

is a workaround but it really isn't because:
1. It often fails to return an integer result when it should: e.g. “3^2” will return “8.99999999998”
2. It is unable to take a negative base to a positive integer exponent because ln(x) is only defined for x > 0



Fully capturing the proper behavior of an exponent block requires the user to make a large block, such as:

([e ^ v] of (([ln v] of ([abs v] of (base)))*(exponent))*(magicexpr))
//magicexpr returns NaN if base is negative and exponent is not whole, 
// -1 if base is negative and exponent is odd, and 1 otherwise. You should be able to make this expression from blocks but it will be large
// and I am too lazy to make it right now

This becomes extremely clumsy, especially if you need several exponents in one expression (for example to calculate a polynomial)

round ([e ^ v] of (([ln v] of (base))*(exponent))

ssvbxx2 wrote:

You could do

round ([e ^ v] of (([ln v] of (base))*(exponent))

dimayajonelcid wrote:

ssvbxx2 wrote:

You could do

round ([e ^ v] of (([ln v] of (base))*(exponent))

I don't think that would work with non-whole (negative/non-integer) powers. Sure, there could be floating point errors, but what if you wanted to calculate something around the lines of an irrational number? Such as square-root 2?

if <not <((base) mod (1)) = [0]>> then 
set [exponent v] to ([e ^ v] of (([ln v] of (base))*(exponent)
else
set [exponent v] to (round ([e ^ v] of (([ln v] of (base))*(exponent))
end

((base) mod (1))

ssvbxx2 wrote:

Then you would remove the round block. Here is what I did in my exponent project:

if <not <((base) mod (1)) = [0]>> then 
set [exponent v] to ([e ^ v] of (([ln v] of (base))*(exponent)
else
set [exponent v] to (round ([e ^ v] of (([ln v] of (base))*(exponent))
end

This works because

((base) mod (1))

returns a non-zero value for non-integer values of the base.

dimayajonelcid wrote:

Bump after 1 month and 2 weeks of silence. Oof

Futurebot5 wrote:

Bump