# I need 6 custom blocks ideas

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!

Oh, nice! Maybe @avi_shor could make a whole math library with our two ideas as part of it!

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!)