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 subsection:: testing
 272 method:: isPositive
 273 Answer if the number is >= 0.
 274
 275 method:: isNegative
 276 Answer if the number is < 0.
 277
 278 method:: isStrictlyPositive
 279 Answer if the number is > 0.
 280
 281 method:: booleanValue
 282 returns:: true, if strictly positive ( > 0), otherwise false (see link::Classes/Boolean::)
 283
 284 method:: isNaN
 285 method:: ==
 286
 287 subsection:: conversion
 288
 289 method:: asFraction
 290 argument::denominator
 291 argument::fasterBetter
 292 if true, asFraction may find a much closer approximation and do it faster.
 293 returns:: an array of denominator and divisor of the nearest and smallest fraction
 294
 295 method:: asAudioRateInput
 296 Converts this into an audiorate input.
 297
 298 method:: asTimeString
 299 Compile a time string.
 300 argument:: precision
 301 0.1 by default
 302 returns:: a string corresponding to the hours:minutes:seconds based on the receiver as number of seconds
 303 discussion::
 304 code::
 305 (
 306 var start;
 307 start = Main.elapsedTime;
 308 { loop({(Main.elapsedTime - start).asTimeString.postln; 0.05.wait}) }.fork;
 309 )
 310 ::
 311
 312 method:: asPoint
 313 returns:: this as link::Classes/Point::. x = y = this.
 314
 315 method:: asComplex
 316 returns:: this as link::Classes/Point::. x = y = this.
 317
 318 method:: asWarp
 319 argument::spec a link::Classes/ControlSpec::
 320 returns:: this as link::Classes/CurveWarp:: according to spec.
 321
 322 method:: asFloat
 323 returns:: this as link::Classes/Float::
 324
 325 method:: asRect
 326 returns:: a link::Classes/Rect:: with x = y = w = h = this.
 327
 328 method:: asBoolean
 329 returns:: this as a link::Classes/Boolean::.  this > 0
 330
 331 method:: asQuant
 332 returns:: the values as link::Classes/Quant::
 333
 334 method:: asInteger
 335 returns:: this as link::Classes/Integer::
 336
 337 subsection:: timing
 338
 339 method::wait
 340 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).
 341
 342 discussion::
 343 Create a routine by a function fork
 344 code::
 345 (
 346 fork {
 347         1.wait;
 348         "I did wait".postln;
 349         1.0.rand.wait;
 350         "No you didn't".postln;
 351         2.wait;
 352         (1..).do { |i|
 353                 "yes I did".postln;
 354                 i.asFloat.rand.wait;
 355                 "no you didn't".postln;
 356                 i.wait
 357         }
 358 }
 359 )
 360 ::
 361
 362 method:: waitUntil
 363 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).
 364
 365 method:: sleep
 366 make the current thread sleep, until woken up by re-scheduling. Outside a Routine, this trows an error (see also Routine for details).
 367
 368 method:: nextTimeOnGrid
 369 argument::clock
 370 returns:: the next possible multiple of the clock's beats.
 371
 372 method:: schedBundleArrayOnClock
 373
 374
 375
 376 subsection:: series and arrays
 377
 378 method:: nearestInList
 379 returns:: the value in the list closest to this
 380
 381 discussion::
 382 code::
 383 (
 384 l = [0, 0.5, 0.9, 1];
 385 (0, 0.05..1).collect { |i| i.nearestInList(l) }
 386 )
 387 ::
 388
 389 method:: nearestInScale
 390 argument:: scale
 391 an array of SimpleNumbers each treated as a step in the octave.
 392 argument:: stepsPerOctave
 393 12 by default
 394 returns:: the value in the collection closest to this, assuming an octave repeating table of note values.
 395
 396 discussion::
 397 code::
 398 (
 399 l = [0, 1, 5, 9, 11]; // pentatonic scale
 400 (60, 61..76).collect { |i| i.nearestInScale(l, 12) }
 401 )
 402 ::
 403
 404 method:: series
 405 return an artithmetic series from this over second to last.
 406 discussion::
 407 This is used in the shortcuts:
 408 code::
 409 (0..100);
 410 (1, 3 .. 17)
 411 ::
 412 If second is nil, it is one magnitude step towards last (1 or -1).
 413 Examples:
 414 code::
 415 series(5, 7, 10);
 416 series(5, nil, 10);
 417 (5, 7 .. 10)
 418 ::
 419
 420 method:: seriesIter
 421 returns:: a Routine that iterates over the numbers from this to last.
 422
 423 discussion::
 424 Since this is a lazy operation, last may be inf, generating an endless series
 425 (see also link::Guides/ListComprehensions::)
 426 code::
 427 r = seriesIter(0, 5);
 428 r.nextN(8);
 429 r.nextN(8);
 430 ::
 431
 432
 433 subsection:: windowing
 434
 435 method:: rectWindow
 436 returns:: a value for a rectangular window function between 0 and 1.
 437
 438 method:: hanWindow
 439 returns:: a value for a hanning window function between 0 and 1.
 440
 441 method:: welWindow
 442 returns:: a value for a welsh window function between 0 and 1.
 443
 444 method:: triWindow
 445 returns:: a value for a triangle window function between 0 and 1.
 446
 447 subsection:: mapping
 448
 449 method:: distort
 450 a nonlinear distortion function.
 451
 452 method:: softclip
 453 Distortion with a perfectly linear region from -0.5 to +0.5
 454
 455 method:: scurve
 456 Map receiver in the onto an S-curve.
 457 discussion::
 458 code::
 459 ((0..100) / 100 ).collect(_.scurve).plot
 460 ::
 461
 462 method:: ramp
 463 Map receiver onto a ramp starting at 0.
 464 discussion::
 465 code::
 466 ((-100..100) / 100 ).collect(_.ramp).plot
 467 ::
 468
 469 method::magnitude
 470 returns:: abolute value (see link::Classes/Polar::, link::Classes/Complex::)
 471
 472 method::angle
 473 returns:: angle of receiver conceived as link::Classes/Polar:: or link::Classes/Complex:: number.
 474
 475
 476 method:: degreeToKey
 477 argument:: scale
 478 an array of SimpleNumbers each treated as a step in the octave.
 479
 480 discussion::
 481 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.
 482
 483 code::
 484 (
 485 l = [0, 1, 5, 9, 11]; // pentatonic scale
 486 (1, 2..15).collect{|i|
 487         i.degreeToKey(l, 12)
 488 };
 489 )
 490 ::
 491
 492 method:: keyToDegree
 493 inverse of degreeToKey.
 494 argument:: scale
 495 an array of SimpleNumbers each treated as a step in the octave.
 496
 497
 498 discussion::
 499 code::
 500 (
 501 l = [0, 1, 5, 9, 11]; // pentatonic scale
 502 (60, 61..75).collect { |i| i.keyToDegree(l, 12) }
 503 )
 504 ::
 505 code::
 506 (
 507 l = [0, 1, 5, 9, 11]; // pentatonic scale
 508 (60, 61..75).postln.collect { |i| i.keyToDegree(l, 12).degreeToKey(l) }
 509 )
 510 ::
 511
 512
 513
 514 method::gaussCurve
 515 map the receiver onto a gauss function.
 516
 517 discussion::
 518 Uses the formula:
 519 code::
 520 a * (exp(squared(this - b) / (-2.0 * squared(c)))) Defalt values: a = 1; b = 0; c = 1
 521 ::
 522 Example code
 523 code::
 524 (0..1000).normalize(-10, 10).collect { |num| num.gaussCurve }.plot;
 525 ::
 526
 527
 528 method:: equalWithPrecision
 529 returns:: true if receiver is closer to that than precision.
 530
 531 discussion::
 532 code::
 533 3.1.equalWithPrecision(3.0, 0.05); // false
 534 3.1.equalWithPrecision(3.0, 0.1); // false
 535 3.1.equalWithPrecision(3.0, 0.11); // true
 536 ::
 537
 538 method:: quantize
 539 round the receiver to the quantum.
 540 argument::tolerance
 541 allowed tolerance.
 542 argument::strength
 543 Determines how much the value is allowed to differ in the tolerance range.
 544 discussion::
 545 code::
 546 ((0..10) / 10).collect { |num| num.quantize(1, 0.3, 0.5) }.postcs.plot;
 547 ((0..10) / 10).collect { |num| num.quantize(1, 0.6, 0.5) }.postcs.plot;
 548 ((0..10) / 10).collect { |num| num.quantize(1, 1.0, 0.5) }.postcs.plot;
 549 ::
 550
 551 method:: linlin
 552 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.
 553 argument::inMin
 554 assumed input minimum
 555 argument::inMax
 556 assumed input maximum
 557 argument::outMin
 558 output minimum
 559 argument::outMax
 560 output maximum
 561 argument::clip
 562 nil (don't clip)
 563 \max (clip ceiling)
 564 \min (clip floor)
 565 \minmax (clip both - this is default).
 566
 567 discussion::
 568 code::
 569 (0..10).collect { |num| num.linlin(0, 10, -4.3, 100) };
 570 (0..10).linlin(0, 10, -4.3, 100); // equivalent.
 571 ::
 572
 573 method::linexp
 574 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.
 575 argument::inMin
 576 assumed input minimum
 577 argument::inMax
 578 assumed input maximum
 579 argument::outMin
 580 output minimum
 581 argument::outMax
 582 output maximum
 583 argument::clip
 584 nil (don't clip)
 585 \max (clip ceiling)
 586 \min (clip floor)
 587 \minmax (clip both - this is default).
 588 discussion::
 589 code::
 590 (0..10).collect { |num| num.linexp(0, 10, 4.3, 100) };
 591 (0..10).linexp(0, 10, 4.3, 100); // equivalent.
 592 ::
 593
 594 method::explin
 595 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.
 596 If the input exceeds the input range, the following behaviours are specified by the clip argument.
 597 argument::inMin
 598 assumed input minimum
 599 argument::inMax
 600 assumed input maximum
 601 argument::outMin
 602 output minimum
 603 argument::outMax
 604 output maximum
 605 argument::clip
 606 nil (don't clip)
 607 \max (clip ceiling)
 608 \min (clip floor)
 609 \minmax (clip both - this is default).
 610 discussion::
 611 code::
 612 (1..10).collect { |num| num.explin(0.1, 10, -4.3, 100) };
 613 (1..10).explin(0.1, 10, -4.3, 100); // equivalent.
 614 ::
 615
 616 method::expexp
 617 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.
 618 If the input exceeds the input range, the following behaviours are specified by the clip argument.
 619 argument::inMin
 620 assumed input minimum
 621 argument::inMax
 622 assumed input maximum
 623 argument::outMin
 624 output minimum
 625 argument::outMax
 626 output maximum
 627 argument::clip
 628 nil (don't clip)
 629 \max (clip ceiling)
 630 \min (clip floor)
 631 \minmax (clip both - this is default).
 632 discussion::
 633 code::
 634 (1..10).collect { |num| num.expexp(0.1, 10, 4.3, 100) };
 635 (1..10).expexp(0.1, 10, 4.3, 100); // equivalent.
 636 ::
 637
 638 method::lincurve
 639 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.
 640 If the input exceeds the input range, the following behaviours are specified by the clip argument.
 641 argument::inMin
 642 assumed input minimum
 643 argument::inMax
 644 assumed input maximum
 645 argument::outMin
 646 output minimum
 647 argument::outMax
 648 output maximum
 649 argument::curve
 650 0 (linear) <0 (concave, negatively curved) >0 (convex, positively curved)
 651 argument::clip
 652 nil (don't clip)
 653 \max (clip ceiling)
 654 \min (clip floor)
 655 \minmax (clip both - this is default).
 656 discussion::
 657 code::
 658 (0..10).collect { |num| num.lincurve(0, 10, -4.3, 100, -3) };
 659 (0..10).lincurve(0, 10, -4.3, 100, -3); // equivalent.
 660 ::
 661 code::
 662 // different curves:
 663 (-4..4).do { |val|
 664         (0..100).collect(_.lincurve(0, 100, 0, 1, val)).plot
 665 }
 666 ::
 667
 668 method::curvelin
 669 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.
 670 argument::inMin
 671 assumed input minimum
 672 argument::inMax
 673 assumed input maximum
 674 argument::outMin
 675 output minimum
 676 argument::outMax
 677 output maximum
 678 argument::curve
 679 0 (linear) <0 (concave, negatively curved) >0 (convex, positively curved)
 680 argument::clip
 681 nil (don't clip)
 682 \max (clip ceiling)
 683 \min (clip floor)
 684 \minmax (clip both - this is default).
 685
 686 discussion::
 687 code::
 688 (1..10).collect { |num| num.curvelin(0, 10, -4.3, 100, -3) };
 689 (1..10).curvelin(0, 10, -4.3, 100, -3); // equivalent.
 690 ::
 691 code::
 692 // different curves:
 693 (-4..4).do { |val|
 694         (0..100).collect(_.curvelin(0, 100, 0, 1, val)).plot
 695 }
 696 ::
 697
 698 method::bilin
 699 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.
 700 argument::inCenter
 701 argument::inMin
 702 assumed input minimum
 703 argument::inMax
 704 assumed input maximum
 705 argument::outCenter
 706 argument::outMin
 707 output minimum
 708 argument::outMax
 709 output maximum
 710 argument::clip
 711 nil (don't clip)
 712 \max (clip ceiling)
 713 \min (clip floor)
 714 \minmax (clip both - this is default).
 715 discussion::
 716 code::
 717 var center = 0.5, ctlCenter;
 718 w = Window("bilin", Rect(100, 100, 200, 100)).front;
 719 a = Slider(w, Rect(20, 20, 150, 20)).value_(0.5);
 720 b = Slider(w, Rect(20, 45, 150, 20)).value_(0.5);
 721 b.action = { center = b.value };
 722 a.mouseDownAction = { ctlCenter = a.value };
 723 a.action = {
 724         b.value = a.value.bilin(ctlCenter, 0, 1, center, 0, 1);
 725 };
 726 ::
 727
 728
 729 method::biexp
 730 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.
 731 argument::inCenter
 732 argument::inMin
 733 assumed input minimum
 734 argument::inMax
 735 assumed input maximum
 736 argument::outCenter
 737 argument::outMin
 738 output minimum
 739 argument::outMax
 740 output maximum
 741 argument::clip
 742 nil (don't clip)
 743 \max (clip ceiling)
 744 \min (clip floor)
 745 \minmax (clip both - this is default).
 746
 747 discussion::
 748 code::
 749 // doesn't properly work yet.
 750 (
 751 var center = 0.5, ctlCenter;
 752 w = Window("biexp", Rect(100, 100, 200, 100)).front;
 753 a = Slider(w, Rect(20, 20, 150, 20)).value_(0.5);
 754 b = Slider(w, Rect(20, 45, 150, 20)).value_(0.5);
 755 b.action = { center = b.value };
 756 a.mouseDownAction = { ctlCenter = a.value + 0.05 };
 757 a.action = {
 758         b.value = (a.value + 0.1).biexp(ctlCenter, 0.1, 1.1, center, 0, 1);
 759 };
 760 )
 761 ::
 762
 763 method::lcurve
 764 map the receiver onto an L-curve.
 765
 766 discussion::
 767 Uses the formula
 768 code::
 769 a * (m * exp(x) * rTau + 1) / (n * exp(x) * rTau + 1)
 770 ::
 771 This is used for smoothing values and limiting them to a range.
 772 code::
 773 (0..1000).normalize(-10, 10).collect { |num| num.lcurve }.plot;
 774 ::
 775
 776
 777 method:: degrad
 778 returns:: converts degree to radian
 779
 780 method:: raddeg
 781 returns:: converts radian to degree
 782
 783 method:: midicps
 784 Convert MIDI note to cycles per second
 785 returns:: cycles per second
 786
 787 method:: cpsmidi
 788 Convert cycles per second to MIDI note.
 789 returns:: midi note
 790
 791
 792 method:: midiratio
 793 Convert an interval in semitones to a ratio.
 794 returns:: a ratio
 795
 796 method:: ratiomidi
 797 Convert a ratio to an interval in semitones.
 798 returns:: an interval in semitones
 799
 800 method:: ampdb
 801 Convert a linear amplitude to decibels.
 802
 803
 804 method:: dbamp
 805 Convert a decibels to a linear amplitude.
 806
 807 method:: octcps
 808 Convert decimal octaves to cycles per second.
 809
 810 method:: cpsoct
 811 Convert cycles per second to decimal octaves.
 812
 813
 814 subsection:: streams
 815
 816 method:: storeOn
 817 stores this on the given stream
 818 method:: printOn
 819 printrs this on the given stream
 820
 821 subsection:: random
 822
 823 method:: coin
 824 Answers a Boolean which is the result of a random test whose probability of success in a range from zero to one is this.
 825
 826 method:: rand
 827 returns:: Random number from zero up to the receiver, exclusive.
 828
 829 method:: rand2
 830 returns:: a random number from -this to +this.
 831
 832 method:: rrand
 833 returns:: a random number in the interval ]a, b[.
 834 argument::aNumber
 835 the upper limit
 836 discussion::
 837 If both a and b are link::Classes/Integer:: then the result will be an link::Classes/Integer::.
 838
 839 method:: linrand
 840 returns:: a linearly distributed random number from zero to this.
 841
 842 method:: bilinrand
 843 returns:: Bilateral linearly distributed random number from -this to +this.
 844
 845 method:: sum3rand
 846 This was suggested by Larry Polansky as a poor man's gaussian.
 847 returns:: A random number from -this to +this that is the result of summing three uniform random generators to yield a bell-like distribution.
 848
 849 method:: exprand
 850 an exponentially distributed random number in the interval ]a, b[. This is always a link::Classes/Float::.
 851 argument::aNumber
 852 the upper limit
 853
 854 method:: gauss
 855 a gaussian distributed random number.
 856 argument::aNumber
 857 the upper limit
 858 discussion::
 859 Always returns a link::Classes/Float::.
 860 code::
 861 (0..1000).collect { |num| gauss(0.0, num) }.plot;
 862 ::
 863
 864 method:: partition
 865 randomly partition a number into parts of at least min size.
 866 argument:: parts
 867 number of parts
 868 argument:: min
 869 the minimum size
 870
 871 discussion::
 872 code::
 873 75.partition(8, 3);
 874 75.partition(75, 1);
 875 ::
 876
 877
 878 subsection:: misc
 879
 880 method:: rate
 881 method::isValidUGenInput
 882 returns:: false if receiver cannot be used in UGen.
 883 method:: performBinaryOpOnSignal (aSelector, aSignal)
 884 method:: performBinaryOpOnComplex
 885
 886 method:: performBinaryOpOnSimpleNumber
 887 method:: hypotApx
 888 method:: playAndDelta
 889 method:: numChannels
 890 method:: asBufWithValues
 891 method:: firstArg
 892
 893
 894
 895
 896
 897
 898
 899