(Redirected from () × () (block))

 () * () `(() * ())` Category Operators Type Reporter

The () * () block is an Operators Block and a Reporter Block. The block multiplies the two values and reports the result. In Snap!, it will be shown as () × ().

The numbers can be typed directly into the block, or Reporter blocks can be used instead.

This block can be stacked inside itself - this can be used to fit more numbers in or calculate exponents.

## Example Uses

In many projects, numbers must be multiplied; this block will do the job.

Some common uses for the () * () block:

• Scripts in calculator simulations
```set [result v] to ((a) * (b))
```
• Multiplying lists of numbers
```set [result v] to (1)
set [item v] to (1)
repeat (length of [numbers v])
set [result v] to ((result) *  (item (item) of [numbers v]))
change [item v] by (1)
end
```
• Math formulas
```([sqrt v] of ((((y1) - (y2)) * ((y1) - (y2))) + (((x1) - (x2)) * ((x1) - (x2))))) //Pythagorean Theorem
```
• Score multipliers
```set [score v] to ((score) * (2))
```
```when gf clicked
set [velocity v] to [0]
forever
if <key [space v] pressed?> then
change [velocity v] by (2)
set [velocity v] to ((velocity) * (0.87)) //simulates friction slowdown
```
• 3D Projects

## Scientific Notation

In Scratch 1.4 and previous versions, it sometimes converts very large numbers into scientific notation to save space. Scientific notation is simply the number in the form a*10b. These can be converted to a normal number by performing any mathematical function on it, such as adding. So if a variable named "number" has a value of 3*103 and you want to display it as a normal number, you can change it by:

`((number) + (0))`

It will then report "3000".

## Workaround

Main article: List of Block Workarounds

With natural numbers, this block can be replicated with the following code, assuming a is the first number and b is the second number:

```set [product v] to [0]
repeat (b)
change [product v] by (a)
```

The following code works for all cases (with the conditional). It divides by the reciprocal, the equivalent of multiplying.

```if <(b) = (0)> then
set [product v] to [0]
else
set [product v] to ((a) / ((1) / (b)))
end
```

The following code accepts negative numbers with decimals:

```delete all of [num1 numbers v] //setup
delete all of [num2 numbers v]
delete all of [product digits v]
set [product v] to [0]
set [dec pos 1 v] to [0]
set [dec pos 2 v] to [0]
set [count v] to [1]
set [no 1 negative v] to [y]
else
set [count v] to [0]
set [no 1 negative v] to [n]
end
change [count v] by (1)
if <not <(letter (count) of (answer)) = [.]>> then
else
set [dec pos 1 v] to ((length of (answer)) - (count))
end
end
set [count v] to [1]
set [no 2 negative v] to [y]
else
set [count v] to [0]
set [no 2 negative v] to [n]
end
change [count v] by (1)
if <not <(letter (count) of (answer)) = [.]>> then
else
set [dec pos 2 v] to ((length of (answer)) - (count))
end
end
set [num1 v] to (num1 numbers)
set [num2 v] to (num2 numbers)
repeat (num1) //start
change [product v] by (num2)
end
set [decimal position v] to ((dec pos 1) + (dec pos 2))
set [count v] to [0]
repeat (length of (product))
change [count v] by (1)
add (letter (count) of (product)) to [product digits v]
end
if <not <(decimal position) = [0]>> then
insert [.] at ((length of [product digits v]) - ((decimal position) - (1))) of [product digits v]
end
if <<<(no 1 negative) = [y]> or <(no 2 negative) = [y]>> and <not <<(no 1 negative) = [y]> and <(no 2 negative) = [y]>>>> then
insert [-] at (1 v) of [product digits v]
end
set [product v] to (product digits)
```