please help i really need 6 more

6? I don't know if anyone could do 6...maybe 1 or 2... 3-4 at most.

give what you can

All I can think of is a block where you give 2 or more numbers, state the operation you want to use (mathematical), and then it calculates.

so a calculator?

Kinda like a calculator, but it's more than just +, -, x, /, & ^.

i dont see a point

The math blocks only have those operations, so this would be like those blocks but also more.

Oh!

Blocks to convert Snap*!* angles two/from Maths angles!

wym

Snap*!* puts 0° as straight up, and 90° as the right. Maths puts 0° as right, and 90° as straight up.

does that work

Snap*!* rotations go clockwise, while math rotations go counterclockwise, so it should be [scratchblocks](((90)-(i))mod(360)[/scratchblocks]

Also, you should make blocks for converting radians and degrees (360 degrees = 2*π radians)

thats simple

Why 6?

How complicated do you want them to be? People have been suggesting pretty easy ones. Here's a really hard one:

(The following description is based on Scheme. You can ignore the part about `(define foo ...)`

and just write REGROUP that reports a reporter. You can then use SET FOO TO (REGROUP ...) to save the result, and CALL FOO... to use it.)

```
;;; This program generates procedures to rearrange the elements in a list
;;; according to a pattern. Sample usage:
;;;
;;; (define pairup (regroup '((1 2) (3 4) ...)))
;;;
;;; (Yes you really type "..."!) The argument to REGROUP is the result that
;;; you want your procedure to generate, supposing that its argument is the
;;; list (1 2 3 4 5 6 7 ...)
;;;
;;; > (pairup '(the rain in spain stays mainly on the plain))
;;; ((the rain) (in spain) (stays mainly) (on the))
;;;
;;; Note that PAIRUP handles odd-length argument lists appropriately.
;;; More examples of patterns that REGROUP can handle:
;;;
;;; (define overlap (regroup '((1 2) (2 3) ...)))
;;; > (overlap '(the rain in spain stays mainly on the plain))
;;; ((the rain) (rain in) (in spain) (spain stays) (stays mainly)
;;; (mainly on) (on the) (the plain))
;;;
;;; (define tails (regroup '((1 2 ...) (2 3 ...) ...)))
;;; > (tails '(the rain in spain stays mainly on the plain))
;;; ((the rain in spain stays mainly on the plain)
;;; (rain in spain stays mainly on the plain)
;;; (in spain stays mainly on the plain)
;;; (spain stays mainly on the plain)
;;; (stays mainly on the plain)
;;; (mainly on the plain)
;;; (on the plain)
;;; (the plain)
;;; (plain))
;;;
;;; (define swap (regroup '(2 1 4 3 ...)))
;;; > (swap '(the rain in spain stays mainly on the plain))
;;; (rain the spain in mainly stays the on)
;;;
;;; (define split (regroup '((1 3 ...) (2 4 ...))))
;;; > (split '(the rain in spain stays mainly on the plain))
;;; ((the in stays on plain) (rain spain mainly the))
;;;
;;;
;;; If you only give one example before an ellipsis, the recursion will
;;; cdr past the number of elements required to make one instance
;;; of the exemplified pattern. If you give two examples, the recursion will
;;; cdr past the number of elements equal to the difference between
;;; the first numbers of the two examples. (That's how OVERLAP works.)
;;; For example,
;;; (define tails (regroup '((1 ...) ...)))
;;; is equivalent to the earlier version of TAILS.
;;; If you use more than two examples, the differences must agree, or
;;; else your several examples will be taken as one big example that
;;; perhaps uses some list elements more than once.
```

let me work on it

Yes, just like the JS math library. Not MathJS, another library, but the official math library, with constants like `Math.E`

and `Math.LN10`

, or methods like `Math.clz32()`

and `Math.expm1()`

.

Bet 10 cents you haven't heard some of these.

I'll start working on it as $$\colorbox{#60c95d}{\color{#60c95d}!}$$ **Math+**!

Is that LaTeX? (Edit: Thanks, Lego Batman!)