HelpSource/Classes/SimpleNumber.schelp

   1 CLASS:: SimpleNumber
   2 summary:: one-dimensional value
   3 categories:: Math
   4 related::Classes/Polar, Classes/Complex, Classes/Float, Classes/Integer, Classes/UnaryOpUGen, Classes/BinaryOpUGen
   5
   6 DESCRIPTION::
   7 Base class for numbers which can be represented by a single one dimensional value.
   8
   9 Most of the Unary and Binary operations are also implemented by link::Classes/UnaryOpUGen:: and link::Classes/BinaryOpUGen::, so you can get more examples by looking at the help for those.
  10
  11 CLASSMETHODS::
  12
  13 method:: new
  14 allocates a new SimpleNumber.
  15
  16 INSTANCEMETHODS::
  17
  18 private:: prSimpleNumberSeries
  19
  20 subsection:: math support
  21
  22 method:: +
  23 Addition
  24
  25
  26 method:: -
  27 Subtraction
  28
  29 method:: *
  30 Multiplication
  31
  32 method:: /
  33 Division
  34
  35 method:: %
  36 Modulo
  37
  38 method:: mod
  39 Modulo
  40
  41 method:: div
  42 Integer Division
  43
  44 method:: **
  45 Exponentiation
  46
  47 method:: !=
  48 Is not
  49
  50 method:: >
  51 greater than
  52
  53 method:: <
  54 greater than
  55
  56 method:: >=
  57 greater or equal than
  58
  59 method:: <=
  60 smaller or equal than
  61
  62 method:: lcm
  63 Least common multiple
  64
  65 method:: gcd
  66 Greatest common divisor
  67
  68 method:: round
  69 Round to multiple of aNumber
  70 method:: roundUp
  71 round up to a multiply of aNumber
  72
  73 method:: thresh
  74
  75 method:: min
  76 Minimum
  77
  78 method:: max
  79 Maximum
  80
  81 method:: wrap2
  82
  83 method:: trunc
  84 Truncate to multiple of aNumber
  85
  86 method:: atan2
  87 Arctangent of (this/aNumber)
  88
  89 method:: hypot
  90 Square root of the sum of the squares.
  91
  92
  93 method:: log
  94 returns:: Base e logarithm.
  95
  96 method:: log2
  97 returns:: Base 2 logarithm.
  98
  99 method:: log10
 100 returns:: Base 10 logarithm.
 101
 102 method:: neg
 103 returns:: negation
 104
 105 method:: abs
 106 returns:: absolute value.
 107
 108 method:: sign
 109 returns:: Answer -1 if negative, +1 if positive or 0 if zero.
 110
 111 method:: ceil
 112 returns:: next larger integer.
 113
 114 method:: floor
 115 returns:: next smaller integer
 116
 117 method:: sin
 118 Sine
 119
 120 method:: cos
 121 Cosine
 122
 123 method:: tan
 124 Tangent
 125
 126 method:: asin
 127 Arcsine
 128
 129 method:: acos
 130 Arccosine
 131
 132 method:: atan
 133 Arctangent
 134
 135 method:: sinh
 136 Hyperbolic sine
 137
 138 method:: cosh
 139 Hyperbolic cosine
 140
 141 method:: tanh
 142 Hyperbolic tangent
 143
 144 method:: frac
 145 fractional part
 146
 147 method:: squared
 148 the square of the number
 149
 150 method:: cubed
 151 the cube of the number
 152
 153 method:: sqrt
 154 the square root of the number.
 155
 156 method:: exp
 157 e to the power of the receiver.
 158
 159 method:: reciprocal
 160 1 / this
 161
 162 method:: pow
 163 this to the power of aNumber
 164
 165 method:: fold2
 166 the folded value, a bitwise or with aNumber
 167
 168 method:: previousPowerOf
 169 the number relative to this that is the previous power of aNumber
 170
 171 method:: nextPowerOf
 172 the next power of aNumber
 173
 174 method:: nextPowerOfTwo
 175 returns:: the number relative to this that is the next power of 2
 176
 177 method:: nextPowerOfThree
 178 the next power of three
 179
 180 method:: hash
 181 returns:: a hash value
 182
 183 method:: <!
 184 returns:: the receiver. aNumber is ignored.
 185
 186 method:: &
 187 Bitwise And
 188
 189 method::|
 190 Bitwise Or
 191
 192 method:: bitXor
 193 Bitwise Exclusive Or
 194
 195 method:: bitHammingDistance
 196 Binary Hamming distance: the count of bits that are not the same in the two numbers
 197
 198 method:: bitTest
 199 returns:: true if bit at index aNumber is set.
 200
 201 method:: bitNot
 202 returns:: ones complement
 203
 204 method:: <<
 205 Binary shift left.
 206
 207 method:: >>
 208 Binary shift right.
 209
 210 method:: +>>
 211 Unsigned binary shift right.
 212
 213 method:: rightShift
 214 returns:: performs a binary right shift
 215
 216 method:: unsignedRightShift
 217 returns:: performs an unsigned right shift
 218
 219 method:: leftShift
 220 returns:: performs a binary left shift
 221
 222 method:: bitOr
 223 returns:: performs a bitwise or with aNumber
 224
 225 method:: bitAnd
 226 returns:: performs a bitwise and with aNumber
 227
 228 method:: ring1
 229 (a * b) + a
 230
 231 method:: ring2
 232 ((a*b) + a + b)
 233
 234 method:: ring3
 235 (a * a *b)
 236
 237 method:: ring4
 238 ((a*a *b) - (a*b*b))
 239
 240 method:: difsqr
 241 (a*a) - (b*b)
 242
 243 method:: sumsqr
 244 (a*a) + (b*b)
 245
 246 method:: sqrdif
 247 (a - b) ** 2
 248
 249 method:: sqrsum
 250 (a + b) ** 2
 251
 252 method:: absdif
 253 (a - b).abs
 254
 255 method:: amclip
 256 0  when  b <= 0,  a*b  when  b > 0
 257
 258 method:: scaleneg
 259 a * b when a < 0, otherwise a.
 260
 261 method:: clip2
 262 clips receiver to +/- aNumber
 263
 264 method:: excess
 265 Returns the difference of the receiver and its clipped form.
 266 discussion::
 267 code::
 268 (a - clip2(a,b))
 269 ::
 270
 271 method:: madd
 272 code::
 273 this * a + b
 274 ::
 275
 276 subsection:: testing
 277 method:: isPositive
 278 Answer if the number is >= 0.
 279
 280 method:: isNegative
 281 Answer if the number is < 0.
 282
 283 method:: isStrictlyPositive
 284 Answer if the number is > 0.
 285
 286 method:: booleanValue
 287 returns:: true, if strictly positive ( > 0), otherwise false (see link::Classes/Boolean::)
 288
 289 method:: isNaN
 290 method:: ==
 291
 292 subsection:: conversion
 293
 294 method:: asFraction
 295 argument::denominator
 296 argument::fasterBetter
 297 if true, asFraction may find a much closer approximation and do it faster.
 298 returns:: an array of denominator and divisor of the nearest and smallest fraction
 299
 300 method:: asAudioRateInput
 301 Converts this into an audiorate input.
 302
 303 method:: asTimeString
 304 Compile a time string.
 305 argument:: precision
 306 how accurate
 307 argument::maxDays
 308 the maximum number of days
 309 argument::dropDaysIfPossible
 310 a link::Classes/Boolean::
 311 returns:: a string corresponding to the hours:minutes:seconds based on the receiver as number of seconds
 312 discussion::
 313 code::
 314 (
 315 var start;
 316 start = Main.elapsedTime;
 317 { loop({(Main.elapsedTime - start).asTimeString.postln; 0.05.wait}) }.fork;
 318 )
 319 ::
 320
 321 method:: asPoint
 322 returns:: this as link::Classes/Point::. x = y = this.
 323
 324 method:: asComplex
 325 returns:: this as link::Classes/Point::. x = y = this.
 326
 327 method:: asWarp
 328 argument::spec
 329 a link::Classes/ControlSpec::
 330 returns:: this as link::Classes/CurveWarp:: according to spec.
 331
 332 method:: asFloat
 333 returns:: this as link::Classes/Float::
 334
 335 method:: asRect
 336 returns:: a link::Classes/Rect:: with x = y = w = h = this.
 337
 338 method:: asBoolean
 339 returns:: this as a link::Classes/Boolean::.  this > 0
 340
 341 method:: asQuant
 342 returns:: the values as link::Classes/Quant::
 343
 344 method:: asInteger
 345 returns:: this as link::Classes/Integer::
 346
 347 subsection:: timing
 348
 349 method::wait
 350 within a routine, yield the number so that the clock can wait for this many beats. Outside a Routine, this trows an error (see also Routine for details).
 351
 352 discussion::
 353 Create a routine by a function fork
 354 code::
 355 (
 356 fork {
 357         1.wait;
 358         "I did wait".postln;
 359         1.0.rand.wait;
 360         "No you didn't".postln;
 361         2.wait;
 362         (1..).do { |i|
 363                 "yes I did".postln;
 364                 i.asFloat.rand.wait;
 365                 "no you didn't".postln;
 366                 i.wait
 367         }
 368 }
 369 )
 370 ::
 371
 372 method:: waitUntil
 373 like wait, only specify a time (measured in beats of the current thread's clock). Outside a Routine, this trows an error (see also Routine for details).
 374
 375 method:: sleep
 376 make the current thread sleep, until woken up by re-scheduling. Outside a Routine, this trows an error (see also Routine for details).
 377
 378 method:: nextTimeOnGrid
 379 argument::clock
 380 returns:: the next possible multiple of the clock's beats.
 381
 382 method:: schedBundleArrayOnClock
 383
 384
 385
 386 subsection:: series and arrays
 387
 388 method:: nearestInList
 389 returns:: the value in the list closest to this
 390
 391 discussion::
 392 code::
 393 (
 394 l = [0, 0.5, 0.9, 1];
 395 (0, 0.05..1).collect { |i| i.nearestInList(l) }
 396 )
 397 ::
 398
 399 method:: nearestInScale
 400 argument:: scale
 401 an array of SimpleNumbers each treated as a step in the octave.
 402 argument:: stepsPerOctave
 403 12 by default
 404 returns:: the value in the collection closest to this, assuming an octave repeating table of note values.
 405
 406 discussion::
 407 code::
 408 (
 409 l = [0, 1, 5, 9, 11]; // pentatonic scale
 410 (60, 61..76).collect { |i| i.nearestInScale(l, 12) }
 411 )
 412 ::
 413
 414 method:: series
 415 return an artithmetic series from this over second to last.
 416 discussion::
 417 This is used in the shortcuts:
 418 code::
 419 (0..100);
 420 (1, 3 .. 17)
 421 ::
 422 If second is nil, it is one magnitude step towards last (1 or -1).
 423 Examples:
 424 code::
 425 series(5, 7, 10);
 426 series(5, nil, 10);
 427 (5, 7 .. 10)
 428 ::
 429
 430 method:: seriesIter
 431 returns:: a Routine that iterates over the numbers from this to last.
 432
 433 discussion::
 434 Since this is a lazy operation, last may be inf, generating an endless series
 435 (see also link::Guides/ListComprehensions::)
 436 code::
 437 r = seriesIter(0, 5);
 438 r.nextN(8);
 439 r.nextN(8);
 440 ::
 441
 442
 443 subsection:: windowing
 444
 445 method:: rectWindow
 446 returns:: a value for a rectangular window function between 0 and 1.
 447
 448 method:: hanWindow
 449 returns:: a value for a hanning window function between 0 and 1.
 450
 451 method:: welWindow
 452 returns:: a value for a welsh window function between 0 and 1.
 453
 454 method:: triWindow
 455 returns:: a value for a triangle window function between 0 and 1.
 456
 457 subsection:: mapping
 458
 459 method:: distort
 460 a nonlinear distortion function.
 461
 462 method:: softclip
 463 Distortion with a perfectly linear region from -0.5 to +0.5
 464
 465 method:: scurve
 466 Map receiver in the onto an S-curve.
 467 discussion::
 468 code::
 469 ((0..100) / 100 ).collect(_.scurve).plot
 470 ::
 471
 472 method:: ramp
 473 Map receiver onto a ramp starting at 0.
 474 discussion::
 475 code::
 476 ((-100..100) / 100 ).collect(_.ramp).plot
 477 ::
 478
 479 method::magnitude
 480 returns:: abolute value (see link::Classes/Polar::, link::Classes/Complex::)
 481
 482 method::angle
 483 returns:: angle of receiver conceived as link::Classes/Polar:: or link::Classes/Complex:: number.
 484
 485
 486 method:: degreeToKey
 487 argument:: scale
 488 an array of SimpleNumbers each treated as a step in the octave.
 489 argument:: stepsPerOctave
 490 12 is the standard chromatic scale.
 491 discussion::
 492 the value is truncated to an integer and used as an index into an octave repeating table of note values. Indices wrap around the table and shift octaves as they do.
 493
 494 code::
 495 (
 496 l = [0, 1, 5, 9, 11]; // pentatonic scale
 497 (1, 2..15).collect{|i|
 498         i.degreeToKey(l, 12)
 499 };
 500 )
 501 ::
 502
 503 method:: keyToDegree
 504 inverse of degreeToKey.
 505 argument:: scale
 506 an array of SimpleNumbers each treated as a step in the octave.
 507 argument:: stepsPerOctave
 508 12 is the standard chromatic scale.
 509 discussion::
 510 code::
 511 (
 512 l = [0, 1, 5, 9, 11]; // pentatonic scale
 513 (60, 61..75).collect { |i| i.keyToDegree(l, 12) }
 514 )
 515 ::
 516 code::
 517 (
 518 l = [0, 1, 5, 9, 11]; // pentatonic scale
 519 (60, 61..75).postln.collect { |i| i.keyToDegree(l, 12).degreeToKey(l) }
 520 )
 521 ::
 522
 523
 524
 525 method::gaussCurve
 526 map the receiver onto a gauss function.
 527
 528 discussion::
 529 Uses the formula:
 530 code::
 531 a * (exp(squared(this - b) / (-2.0 * squared(c)))) Defalt values: a = 1; b = 0; c = 1
 532 ::
 533 Example code
 534 code::
 535 (0..1000).normalize(-10, 10).collect { |num| num.gaussCurve }.plot;
 536 ::
 537
 538
 539 method:: equalWithPrecision
 540 returns:: true if receiver is closer to that than precision.
 541
 542 discussion::
 543 code::
 544 3.1.equalWithPrecision(3.0, 0.05); // false
 545 3.1.equalWithPrecision(3.0, 0.1); // false
 546 3.1.equalWithPrecision(3.0, 0.11); // true
 547 ::
 548
 549 method:: quantize
 550 round the receiver to the quantum.
 551 argument::quantum
 552 amount.
 553 argument::tolerance
 554 allowed tolerance.
 555 argument::strength
 556 Determines how much the value is allowed to differ in the tolerance range.
 557 discussion::
 558 code::
 559 ((0..10) / 10).collect { |num| num.quantize(1, 0.3, 0.5) }.postcs.plot;
 560 ((0..10) / 10).collect { |num| num.quantize(1, 0.6, 0.5) }.postcs.plot;
 561 ((0..10) / 10).collect { |num| num.quantize(1, 1.0, 0.5) }.postcs.plot;
 562 ::
 563
 564 method:: linlin
 565 map the receiver from an assumed linear input range to a linear output range. If the input exceeds the assumed input range, the behaviour is specified by the clip argument.
 566 argument::inMin
 567 assumed input minimum
 568 argument::inMax
 569 assumed input maximum
 570 argument::outMin
 571 output minimum
 572 argument::outMax
 573 output maximum
 574 argument::clip
 575 nil (don't clip)
 576 \max (clip ceiling)
 577 \min (clip floor)
 578 \minmax (clip both - this is default).
 579
 580 discussion::
 581 code::
 582 (0..10).collect { |num| num.linlin(0, 10, -4.3, 100) };
 583 (0..10).linlin(0, 10, -4.3, 100); // equivalent.
 584 ::
 585
 586 method::linexp
 587 map the receiver from an assumed linear input range (inMin..inMax) to an exponential output range (outMin..outMax). The output range must not include zero. If the input exceeds the input range, the following behaviours are specified by the clip argument.
 588 argument::inMin
 589 assumed input minimum
 590 argument::inMax
 591 assumed input maximum
 592 argument::outMin
 593 output minimum
 594 argument::outMax
 595 output maximum
 596 argument::clip
 597 nil (don't clip)
 598 \max (clip ceiling)
 599 \min (clip floor)
 600 \minmax (clip both - this is default).
 601 discussion::
 602 code::
 603 (0..10).collect { |num| num.linexp(0, 10, 4.3, 100) };
 604 (0..10).linexp(0, 10, 4.3, 100); // equivalent.
 605 ::
 606
 607 method::explin
 608 map the receiver from an assumed exponential input range (inMin..inMax) to a linear output range (outMin..outMax). If the input exceeds the assumed input range. The input range must not include zero.
 609 If the input exceeds the input range, the following behaviours are specified by the clip argument.
 610 argument::inMin
 611 assumed input minimum
 612 argument::inMax
 613 assumed input maximum
 614 argument::outMin
 615 output minimum
 616 argument::outMax
 617 output maximum
 618 argument::clip
 619 nil (don't clip)
 620 \max (clip ceiling)
 621 \min (clip floor)
 622 \minmax (clip both - this is default).
 623 discussion::
 624 code::
 625 (1..10).collect { |num| num.explin(0.1, 10, -4.3, 100) };
 626 (1..10).explin(0.1, 10, -4.3, 100); // equivalent.
 627 ::
 628
 629 method::expexp
 630 map the receiver from an assumed exponential input range (inMin..inMax) to an exponential output range (outMin..outMax). If the input exceeds the assumed input range. Both input range and output range must not include zero.
 631 If the input exceeds the input range, the following behaviours are specified by the clip argument.
 632 argument::inMin
 633 assumed input minimum
 634 argument::inMax
 635 assumed input maximum
 636 argument::outMin
 637 output minimum
 638 argument::outMax
 639 output maximum
 640 argument::clip
 641 nil (don't clip)
 642 \max (clip ceiling)
 643 \min (clip floor)
 644 \minmax (clip both - this is default).
 645 discussion::
 646 code::
 647 (1..10).collect { |num| num.expexp(0.1, 10, 4.3, 100) };
 648 (1..10).expexp(0.1, 10, 4.3, 100); // equivalent.
 649 ::
 650
 651 method::lincurve
 652 map the receiver from an assumed linear input range (inMin..inMax) to an exponential curve output range (outMin..outMax). A curve is like the curve parameter in Env. Unlike with linexp, the output range may include zero.
 653 If the input exceeds the input range, the following behaviours are specified by the clip argument.
 654 argument::inMin
 655 assumed input minimum
 656 argument::inMax
 657 assumed input maximum
 658 argument::outMin
 659 output minimum
 660 argument::outMax
 661 output maximum
 662 argument::curve
 663 0 (linear) <0 (concave, negatively curved) >0 (convex, positively curved)
 664 argument::clip
 665 nil (don't clip)
 666 \max (clip ceiling)
 667 \min (clip floor)
 668 \minmax (clip both - this is default).
 669 discussion::
 670 code::
 671 (0..10).collect { |num| num.lincurve(0, 10, -4.3, 100, -3) };
 672 (0..10).lincurve(0, 10, -4.3, 100, -3); // equivalent.
 673 ::
 674 code::
 675 // different curves:
 676 (-4..4).do { |val|
 677         (0..100).collect(_.lincurve(0, 100, 0, 1, val)).plot
 678 }
 679 ::
 680
 681 method::curvelin
 682 map the receiver from an assumed curve-exponential input range (inMin..inMax) to a linear output range (outMin..outMax). If the input exceeds the assumed input range. A curve is like the curve parameter in Env. Unlike with explin, the input range may include zero. If the input exceeds the input range, the following behaviours are specified by the clip argument.
 683 argument::inMin
 684 assumed input minimum
 685 argument::inMax
 686 assumed input maximum
 687 argument::outMin
 688 output minimum
 689 argument::outMax
 690 output maximum
 691 argument::curve
 692 0 (linear) <0 (concave, negatively curved) >0 (convex, positively curved)
 693 argument::clip
 694 nil (don't clip)
 695 \max (clip ceiling)
 696 \min (clip floor)
 697 \minmax (clip both - this is default).
 698
 699 discussion::
 700 code::
 701 (1..10).collect { |num| num.curvelin(0, 10, -4.3, 100, -3) };
 702 (1..10).curvelin(0, 10, -4.3, 100, -3); // equivalent.
 703 ::
 704 code::
 705 // different curves:
 706 (-4..4).do { |val|
 707         (0..100).collect(_.curvelin(0, 100, 0, 1, val)).plot
 708 }
 709 ::
 710
 711 method::bilin
 712 map the receiver from two assumed linear input ranges (inMin..inCenter) and (inCenter..inMax) to two linear output ranges (outMin..outCenter) and (outCenter..outMax). If the input exceeds the input range, the following behaviours are specified by the clip argument.
 713 argument::inCenter
 714 argument::inMin
 715 assumed input minimum
 716 argument::inMax
 717 assumed input maximum
 718 argument::outCenter
 719 argument::outMin
 720 output minimum
 721 argument::outMax
 722 output maximum
 723 argument::clip
 724 nil (don't clip)
 725 \max (clip ceiling)
 726 \min (clip floor)
 727 \minmax (clip both - this is default).
 728 discussion::
 729 code::
 730 var center = 0.5, ctlCenter;
 731 w = Window("bilin", Rect(100, 100, 200, 100)).front;
 732 a = Slider(w, Rect(20, 20, 150, 20)).value_(0.5);
 733 b = Slider(w, Rect(20, 45, 150, 20)).value_(0.5);
 734 b.action = { center = b.value };
 735 a.mouseDownAction = { ctlCenter = a.value };
 736 a.action = {
 737         b.value = a.value.bilin(ctlCenter, 0, 1, center, 0, 1);
 738 };
 739 ::
 740
 741
 742 method::biexp
 743 map the receiver from two assumed exponential input ranges (inMin..inCenter) and (inCenter..inMax) to two linear output ranges (outMin..outCenter) and (outCenter..outMax). The input range must not include zero. If the input exceeds the input range, the following behaviours are specified by the clip argument.
 744 argument::inCenter
 745 argument::inMin
 746 assumed input minimum
 747 argument::inMax
 748 assumed input maximum
 749 argument::outCenter
 750 argument::outMin
 751 output minimum
 752 argument::outMax
 753 output maximum
 754 argument::clip
 755 nil (don't clip)
 756 \max (clip ceiling)
 757 \min (clip floor)
 758 \minmax (clip both - this is default).
 759
 760 discussion::
 761 code::
 762 // doesn't properly work yet.
 763 (
 764 var center = 0.5, ctlCenter;
 765 w = Window("biexp", Rect(100, 100, 200, 100)).front;
 766 a = Slider(w, Rect(20, 20, 150, 20)).value_(0.5);
 767 b = Slider(w, Rect(20, 45, 150, 20)).value_(0.5);
 768 b.action = { center = b.value };
 769 a.mouseDownAction = { ctlCenter = a.value + 0.05 };
 770 a.action = {
 771         b.value = (a.value + 0.1).biexp(ctlCenter, 0.1, 1.1, center, 0, 1);
 772 };
 773 )
 774 ::
 775
 776 method::lcurve
 777 map the receiver onto an L-curve.
 778
 779 discussion::
 780 Uses the formula
 781 code::
 782 a * (m * exp(x) * rTau + 1) / (n * exp(x) * rTau + 1)
 783 ::
 784 This is used for smoothing values and limiting them to a range.
 785 code::
 786 (0..1000).normalize(-10, 10).collect { |num| num.lcurve }.plot;
 787 ::
 788
 789
 790 method:: degrad
 791 returns:: converts degree to radian
 792
 793 method:: raddeg
 794 returns:: converts radian to degree
 795
 796 method:: midicps
 797 Convert MIDI note to cycles per second
 798 returns:: cycles per second
 799
 800 method:: cpsmidi
 801 Convert cycles per second to MIDI note.
 802 returns:: midi note
 803
 804
 805 method:: midiratio
 806 Convert an interval in semitones to a ratio.
 807 returns:: a ratio
 808
 809 method:: ratiomidi
 810 Convert a ratio to an interval in semitones.
 811 returns:: an interval in semitones
 812
 813 method:: ampdb
 814 Convert a linear amplitude to decibels.
 815
 816
 817 method:: dbamp
 818 Convert a decibels to a linear amplitude.
 819
 820 method:: octcps
 821 Convert decimal octaves to cycles per second.
 822
 823 method:: cpsoct
 824 Convert cycles per second to decimal octaves.
 825
 826
 827 subsection:: streams
 828
 829 method:: storeOn
 830 stores this on the given stream
 831 method:: printOn
 832 printrs this on the given stream
 833
 834 subsection:: random
 835
 836 method:: coin
 837 Answers a Boolean which is the result of a random test whose probability of success in a range from zero to one is this.
 838
 839 method:: rand
 840 returns:: Random number from zero up to the receiver, exclusive.
 841
 842 method:: rand2
 843 returns:: a random number from -this to +this.
 844
 845 method:: rrand
 846 argument::aNumber
 847 the upper limit
 848 argument::adverb
 849 returns:: a random number in the interval ]a, b[.
 850 discussion::
 851 If both a and b are link::Classes/Integer:: then the result will be an link::Classes/Integer::.
 852
 853 method:: linrand
 854 returns:: a linearly distributed random number from zero to this.
 855
 856 method:: bilinrand
 857 returns:: Bilateral linearly distributed random number from -this to +this.
 858
 859 method:: sum3rand
 860 This was suggested by Larry Polansky as a poor man's gaussian.
 861 returns:: A random number from -this to +this that is the result of summing three uniform random generators to yield a bell-like distribution.
 862
 863 method:: exprand
 864 an exponentially distributed random number in the interval ]a, b[. This is always a link::Classes/Float::.
 865 argument::aNumber
 866 the upper limit
 867 argument::adverb
 868
 869 method:: gauss
 870 a gaussian distributed random number.
 871 argument::standardDeviation
 872 the upper limit
 873 discussion::
 874 Always returns a link::Classes/Float::.
 875 code::
 876 (0..1000).collect { |num| gauss(0.0, num) }.plot;
 877 ::
 878
 879 method:: partition
 880 randomly partition a number into parts of at least min size.
 881 argument:: parts
 882 number of parts
 883 argument:: min
 884 the minimum size
 885
 886 discussion::
 887 code::
 888 75.partition(8, 3);
 889 75.partition(75, 1);
 890 ::
 891
 892
 893 subsection:: UGen Compatibility Methods
 894
 895 Some methods to ease the development of generic ugen code.
 896
 897 method:: lag, lag2, lag3, lagud, lag2ud, lag3ud, slew, varlag
 898
 899 returns:: code::this::
 900
 901
 902 subsection:: misc
 903
 904 method:: isValidUGenInput
 905 returns:: false if receiver cannot be used in UGen.
 906