SCClassLibrary/Common/Math/SimpleNumber.sc

   1 SimpleNumber : Number {
   2
   3         *new { ^this.shouldNotImplement(thisMethod) }
   4
   5         isValidUGenInput { ^this.isNaN.not }
   6         numChannels { ^1 }
   7
   8         magnitude { ^this.abs }
   9         angle { if (this >= 0, {^0.0}, {^pi} ) }
  10
  11
  12         neg { _Neg; ^this.primitiveFailed }
  13         bitNot { _BitNot; ^this.primitiveFailed }
  14         abs { _Abs; ^this.primitiveFailed }
  15         ceil { _Ceil; ^this.primitiveFailed }
  16         floor { _Floor; ^this.primitiveFailed }
  17         frac { _Frac; ^this.primitiveFailed }
  18         sign { _Sign; ^this.primitiveFailed }
  19         squared { _Squared; ^this.primitiveFailed }
  20         cubed { _Cubed; ^this.primitiveFailed }
  21         sqrt { _Sqrt; ^this.primitiveFailed }
  22         exp { _Exp; ^this.primitiveFailed }
  23         reciprocal { _Recip; ^this.primitiveFailed }
  24         midicps { _MIDICPS; ^this.primitiveFailed }
  25         cpsmidi { _CPSMIDI; ^this.primitiveFailed }
  26         midiratio { _MIDIRatio; ^this.primitiveFailed }
  27         ratiomidi { _RatioMIDI; ^this.primitiveFailed }
  28         ampdb { _AmpDb; ^this.primitiveFailed }
  29         dbamp { _DbAmp; ^this.primitiveFailed }
  30         octcps { _OctCPS; ^this.primitiveFailed }
  31         cpsoct { _CPSOct; ^this.primitiveFailed }
  32         log { _Log; ^this.primitiveFailed }
  33         log2 { _Log2; ^this.primitiveFailed }
  34         log10 { _Log10; ^this.primitiveFailed }
  35         sin { _Sin; ^this.primitiveFailed }
  36         cos { _Cos; ^this.primitiveFailed }
  37         tan { _Tan; ^this.primitiveFailed }
  38         asin { _ArcSin; ^this.primitiveFailed }
  39         acos { _ArcCos; ^this.primitiveFailed }
  40         atan { _ArcTan; ^this.primitiveFailed }
  41         sinh { _SinH; ^this.primitiveFailed }
  42         cosh { _CosH; ^this.primitiveFailed }
  43         tanh { _TanH; ^this.primitiveFailed }
  44         rand { _Rand; ^this.primitiveFailed }
  45         rand2 { _Rand2; ^this.primitiveFailed }
  46         linrand { _LinRand; ^this.primitiveFailed }
  47         bilinrand { _BiLinRand; ^this.primitiveFailed }
  48         sum3rand { _Sum3Rand; ^this.primitiveFailed }
  49
  50         distort { _Distort; ^this.primitiveFailed }
  51         softclip { _SoftClip; ^this.primitiveFailed }
  52         coin { _Coin; ^this.primitiveFailed }
  53         isPositive { ^this >= 0 }
  54         isNegative { ^this < 0 }
  55         isStrictlyPositive { ^this > 0 }
  56         isNaN { ^(this >= 0 or: { this <= 0 }).not }
  57         asBoolean    { ^this > 0 }
  58         booleanValue { ^this > 0 } // TODO in the long-run, deprecate for asBoolean
  59         binaryValue { ^this.sign.max(0) } // TODO in the long-run, deprecate for asInteger
  60
  61         rectWindow { _RectWindow; ^this.primitiveFailed }
  62         hanWindow { _HanWindow; ^this.primitiveFailed }
  63         welWindow { _WelchWindow; ^this.primitiveFailed }
  64         triWindow { _TriWindow; ^this.primitiveFailed }
  65
  66         scurve { _SCurve; ^this.primitiveFailed }
  67         ramp { _Ramp; ^this.primitiveFailed }
  68
  69         + { arg aNumber, adverb; _Add; ^aNumber.performBinaryOpOnSimpleNumber('+', this, adverb) }
  70         - { arg aNumber, adverb; _Sub; ^aNumber.performBinaryOpOnSimpleNumber('-', this, adverb) }
  71         * { arg aNumber, adverb; _Mul; ^aNumber.performBinaryOpOnSimpleNumber('*', this, adverb) }
  72         / { arg aNumber, adverb; _FDiv; ^aNumber.performBinaryOpOnSimpleNumber('/', this, adverb) }
  73         mod { arg aNumber, adverb; _Mod; ^aNumber.performBinaryOpOnSimpleNumber('mod', this, adverb) }
  74         div { arg aNumber, adverb; _IDiv; ^aNumber.performBinaryOpOnSimpleNumber('div', this, adverb) }
  75         pow { arg aNumber, adverb; _Pow; ^aNumber.performBinaryOpOnSimpleNumber('pow', this, adverb) }
  76         min { arg aNumber, adverb; _Min; ^aNumber.performBinaryOpOnSimpleNumber('min', this, adverb) }
  77         max { arg aNumber=0.0, adverb; _Max; ^aNumber.performBinaryOpOnSimpleNumber('max', this, adverb) }
  78         bitAnd { arg aNumber, adverb; _BitAnd; ^aNumber.performBinaryOpOnSimpleNumber('bitAnd', this, adverb) }
  79         bitOr { arg aNumber, adverb; _BitOr; ^aNumber.performBinaryOpOnSimpleNumber('bitOr', this, adverb) }
  80         bitXor { arg aNumber, adverb; _BitXor; ^aNumber.performBinaryOpOnSimpleNumber('bitXor', this, adverb) }
  81         bitHammingDistance { arg aNumber, adverb; _HammingDistance  ^aNumber.performBinaryOpOnSimpleNumber('hammingDistance', this, adverb) }
  82         bitTest { arg bit; ^( (this & 1.leftShift(bit)) != 0) }
  83         lcm { arg aNumber, adverb; _LCM; ^aNumber.performBinaryOpOnSimpleNumber('lcm', this, adverb) }
  84         gcd { arg aNumber, adverb; _GCD; ^aNumber.performBinaryOpOnSimpleNumber('gcd', this, adverb) }
  85         round { arg aNumber=1.0, adverb; _Round; ^aNumber.performBinaryOpOnSimpleNumber('round', this, adverb) }
  86         roundUp { arg aNumber=1.0, adverb; _RoundUp; ^aNumber.performBinaryOpOnSimpleNumber('roundUp', this, adverb) }
  87         trunc { arg aNumber=1.0, adverb; _Trunc; ^aNumber.performBinaryOpOnSimpleNumber('trunc', this, adverb) }
  88         atan2 { arg aNumber, adverb; _Atan2; ^aNumber.performBinaryOpOnSimpleNumber('atan2', this, adverb) }
  89         hypot { arg aNumber, adverb; _Hypot; ^aNumber.performBinaryOpOnSimpleNumber('hypot', this, adverb) }
  90         hypotApx { arg aNumber, adverb; _HypotApx; ^aNumber.performBinaryOpOnSimpleNumber('hypotApx', this, adverb) }
  91         leftShift { arg aNumber=1, adverb; _ShiftLeft; ^aNumber.performBinaryOpOnSimpleNumber('leftShift', this, adverb) }
  92         rightShift { arg aNumber=1, adverb; _ShiftRight; ^aNumber.performBinaryOpOnSimpleNumber('rightShift', this, adverb) }
  93         unsignedRightShift { arg aNumber, adverb; _UnsignedShift; ^aNumber.performBinaryOpOnSimpleNumber('unsignedRightShift', this, adverb) }
  94         ring1 { arg aNumber, adverb; _Ring1; ^aNumber.performBinaryOpOnSimpleNumber('ring1', this, adverb) }
  95         ring2 { arg aNumber, adverb; _Ring2; ^aNumber.performBinaryOpOnSimpleNumber('ring2', this, adverb) }
  96         ring3 { arg aNumber, adverb; _Ring3; ^aNumber.performBinaryOpOnSimpleNumber('ring3', this, adverb) }
  97         ring4 { arg aNumber, adverb; _Ring4; ^aNumber.performBinaryOpOnSimpleNumber('ring4', this, adverb) }
  98         difsqr { arg aNumber, adverb; _DifSqr; ^aNumber.performBinaryOpOnSimpleNumber('difsqr', this, adverb) }
  99         sumsqr { arg aNumber, adverb; _SumSqr; ^aNumber.performBinaryOpOnSimpleNumber('sumsqr', this, adverb) }
 100         sqrsum { arg aNumber, adverb; _SqrSum; ^aNumber.performBinaryOpOnSimpleNumber('sqrsum', this, adverb) }
 101         sqrdif { arg aNumber, adverb; _SqrDif; ^aNumber.performBinaryOpOnSimpleNumber('sqrdif', this, adverb) }
 102         absdif { arg aNumber, adverb; _AbsDif; ^aNumber.performBinaryOpOnSimpleNumber('absdif', this, adverb) }
 103         thresh { arg aNumber, adverb; _Thresh; ^aNumber.performBinaryOpOnSimpleNumber('thresh', this, adverb) }
 104         amclip { arg aNumber, adverb; _AMClip; ^aNumber.performBinaryOpOnSimpleNumber('amclip', this, adverb) }
 105         scaleneg { arg aNumber, adverb; _ScaleNeg; ^aNumber.performBinaryOpOnSimpleNumber('scaleneg', this, adverb) }
 106         clip2 { arg aNumber, adverb; _Clip2; ^aNumber.performBinaryOpOnSimpleNumber('clip2', this, adverb) }
 107         fold2 { arg aNumber, adverb; _Fold2; ^aNumber.performBinaryOpOnSimpleNumber('fold2', this, adverb) }
 108         wrap2 { arg aNumber, adverb; _Wrap2; ^aNumber.performBinaryOpOnSimpleNumber('wrap2', this, adverb) }
 109
 110         excess { arg aNumber, adverb; _Excess; ^aNumber.performBinaryOpOnSimpleNumber('excess', this, adverb) }
 111         firstArg { arg aNumber, adverb; _FirstArg; ^aNumber.performBinaryOpOnSimpleNumber('firstArg', this, adverb) }
 112         rrand { arg aNumber, adverb; _RandRange; ^aNumber.performBinaryOpOnSimpleNumber('rrand', this, adverb) }
 113         exprand { arg aNumber, adverb; _ExpRandRange; ^aNumber.performBinaryOpOnSimpleNumber('exprand', this, adverb) }
 114
 115         == { arg aNumber, adverb; _EQ; ^aNumber.perform('==', this, adverb) }
 116         != { arg aNumber, adverb; _NE; ^aNumber.perform('!=', this, adverb) }
 117         < { arg aNumber, adverb; _LT; ^aNumber.performBinaryOpOnSimpleNumber('<', this, adverb) }
 118         > { arg aNumber, adverb; _GT; ^aNumber.performBinaryOpOnSimpleNumber('>', this, adverb) }
 119         <= { arg aNumber, adverb; _LE; ^aNumber.performBinaryOpOnSimpleNumber('<=', this, adverb) }
 120         >= { arg aNumber, adverb; _GE; ^aNumber.performBinaryOpOnSimpleNumber('>=', this, adverb) }
 121
 122         equalWithPrecision { arg that, precision=0.0001;
 123                 ^absdif(this, that) < precision
 124         }
 125
 126         hash { _ObjectHash; ^this.primitiveFailed }
 127
 128         asInteger { _AsInt; ^this.primitiveFailed }
 129         asFloat { _AsFloat; ^this.primitiveFailed }
 130         asComplex { ^Complex.new(this, 0.0) }
 131         asRect { ^Rect(this, this, this, this) }
 132
 133         degrad { ^this*pi/180 }
 134         raddeg { ^this*180/pi }
 135
 136         performBinaryOpOnSimpleNumber { arg aSelector, aNumber, adverb;
 137                  BinaryOpFailureError(this, aSelector, [aNumber, adverb]).throw;
 138         }
 139         performBinaryOpOnComplex { arg aSelector, aComplex, adverb; ^aComplex.perform(aSelector, this.asComplex, adverb) }
 140         performBinaryOpOnSignal { arg aSelector, aSignal, adverb;
 141                 BinaryOpFailureError(this, aSelector, [aSignal, adverb]).throw;
 142         }
 143
 144         nextPowerOfTwo { ^this.nextPowerOf(2) }
 145         nextPowerOf { arg base; ^pow(base, ceil(log(this) / log(base))) }
 146         nextPowerOfThree { ^pow(3, ceil(log(this) / log(3))) }
 147         previousPowerOf { arg base; ^pow(base, ceil(log(this) / log(base)) - 1) }
 148
 149         quantize { arg quantum = 1.0, tolerance = 0.05, strength = 1.0;
 150                 var round = round(this, quantum);
 151                 var diff = round - this;
 152                 if (abs(diff) < tolerance) {
 153                         ^this + (strength * diff)
 154                 }{
 155                         ^this
 156                 }
 157         }
 158
 159
 160         linlin { arg inMin, inMax, outMin, outMax, clip=\minmax;
 161                 // linear to linear mapping
 162                 switch(clip,
 163                         \minmax, {
 164                                 if (this <= inMin, { ^outMin });
 165                                 if (this >= inMax, { ^outMax });
 166                         },
 167                         \min, {
 168                                 if (this <= inMin, { ^outMin });
 169                         },
 170                         \max, {
 171                                 if (this >= inMax, { ^outMax });
 172                         }
 173                 );
 174                 ^(this-inMin)/(inMax-inMin) * (outMax-outMin) + outMin;
 175         }
 176
 177         linexp { arg inMin, inMax, outMin, outMax, clip=\minmax;
 178                 // linear to exponential mapping
 179                 switch(clip,
 180                         \minmax, {
 181                                 if (this <= inMin, { ^outMin });
 182                                 if (this >= inMax, { ^outMax });
 183                         },
 184                         \min, {
 185                                 if (this <= inMin, { ^outMin });
 186                         },
 187                         \max, {
 188                                 if (this >= inMax, { ^outMax });
 189                         }
 190                 );
 191                 ^pow(outMax/outMin, (this-inMin)/(inMax-inMin)) * outMin
 192         }
 193
 194         explin { arg inMin, inMax, outMin, outMax, clip=\minmax;
 195                 // exponential to linear mapping
 196                 switch(clip,
 197                         \minmax, {
 198                                 if (this <= inMin, { ^outMin });
 199                                 if (this >= inMax, { ^outMax });
 200                         },
 201                         \min, {
 202                                 if (this <= inMin, { ^outMin });
 203                         },
 204                         \max, {
 205                                 if (this >= inMax, { ^outMax });
 206                         }
 207                 );
 208                 ^(log(this/inMin)) / (log(inMax/inMin)) * (outMax-outMin) + outMin;
 209         }
 210
 211         expexp { arg inMin, inMax, outMin, outMax, clip=\minmax;
 212                 // exponential to exponential mapping
 213                 switch(clip,
 214                         \minmax, {
 215                                 if (this <= inMin, { ^outMin });
 216                                 if (this >= inMax, { ^outMax });
 217                         },
 218                         \min, {
 219                                 if (this <= inMin, { ^outMin });
 220                         },
 221                         \max, {
 222                                 if (this >= inMax, { ^outMax });
 223                         }
 224                 );
 225                 ^pow(outMax/outMin, log(this/inMin) / log(inMax/inMin)) * outMin;
 226         }
 227
 228         lincurve { arg inMin = 0, inMax = 1, outMin = 0, outMax = 1, curve = -4, clip = \minmax;
 229                 var grow, a, b, scaled;
 230                 switch(clip,
 231                         \minmax, {
 232                                 if (this <= inMin, { ^outMin });
 233                                 if (this >= inMax, { ^outMax });
 234                         },
 235                         \min, {
 236                                 if (this <= inMin, { ^outMin });
 237                         },
 238                         \max, {
 239                                 if (this >= inMax, { ^outMax });
 240                         }
 241                 );
 242                 if (abs(curve) < 0.001) { ^this.linlin(inMin, inMax, outMin, outMax) };
 243
 244                 grow = exp(curve);
 245                 a = outMax - outMin / (1.0 - grow);
 246                 b = outMin + a;
 247                 scaled = (this - inMin) / (inMax - inMin);
 248
 249                 ^b - (a * pow(grow, scaled));
 250         }
 251
 252         curvelin { arg inMin = 0, inMax = 1, outMin = 0, outMax = 1, curve = -4, clip = \minmax;
 253                 var grow, a, b, scaled;
 254                 switch(clip,
 255                         \minmax, {
 256                                 if (this <= inMin, { ^outMin });
 257                                 if (this >= inMax, { ^outMax });
 258                         },
 259                         \min, {
 260                                 if (this <= inMin, { ^outMin });
 261                         },
 262                         \max, {
 263                                 if (this >= inMax, { ^outMax });
 264                         }
 265                 );
 266                 if (abs(curve) < 0.001) { ^this.linlin(inMin, inMax, outMin, outMax) };
 267
 268                 grow = exp(curve);
 269                 a = outMax - outMin / (1.0 - grow);
 270                 b = outMin + a;
 271                 scaled = (this - inMin) / (inMax - inMin);
 272
 273                 ^log((b - scaled) / a) / curve
 274         }
 275
 276         bilin { arg inCenter, inMin, inMax, outCenter, outMin, outMax, clip=\minmax;
 277                 // triangular linear mapping
 278                 switch(clip,
 279                         \minmax, {
 280                                 if (this <= inMin, { ^outMin });
 281                                 if (this >= inMax, { ^outMax });
 282                         },
 283                         \min, {
 284                                 if (this <= inMin, { ^outMin });
 285                         },
 286                         \max, {
 287                                 if (this >= inMax, { ^outMax });
 288                         }
 289                 );
 290                 ^if (this >= inCenter) {
 291                         this.linlin(inCenter, inMax, outCenter, outMax, \none);
 292                 } {
 293                         this.linlin(inMin, inCenter, outMin, outCenter, \none);
 294                 }
 295         }
 296
 297         biexp { arg inCenter, inMin, inMax, outCenter, outMin, outMax, clip=\minmax;
 298                 // triangular exponential mapping
 299                 switch(clip,
 300                         \minmax, {
 301                                 if (this <= inMin, { ^outMin });
 302                                 if (this >= inMax, { ^outMax });
 303                         },
 304                         \min, {
 305                                 if (this <= inMin, { ^outMin });
 306                         },
 307                         \max, {
 308                                 if (this >= inMax, { ^outMax });
 309                         }
 310                 );
 311                 if (this >= inCenter) {
 312                         this.explin(inCenter, inMax, outCenter, outMax, \none);
 313                 } {
 314                         this.explin(inMin, inCenter, outMin, outCenter, \none);
 315                 }
 316         }
 317         lcurve { arg a = 1.0, m = 0.0, n = 1.0, tau = 1.0;
 318                 var rTau, x = this.neg;
 319                 ^if(tau == 1.0) {
 320                         a * (m * exp(x) + 1) / (n * exp(x) + 1)
 321                 } {
 322                         rTau = tau.reciprocal;
 323                         a * (m * exp(x) * rTau + 1) / (n * exp(x) * rTau + 1)
 324                 }
 325         }
 326         gauss { arg standardDeviation;
 327                 ^((((-2*log(1.0.rand)).sqrt * sin(2pi.rand)) * standardDeviation) + this)
 328         }
 329         gaussCurve { arg a = 1.0, b = 0.0, c = 1.0;
 330                 ^a * (exp(squared(this - b) / (-2.0 * squared(c))))
 331         }
 332
 333         asPoint { ^Point.new(this, this) }
 334
 335         asWarp { arg spec; ^CurveWarp.new(spec, this) }
 336
 337         // scheduled Routine support
 338         wait { ^this.yield }
 339         waitUntil { ^(this - thisThread.beats).max(0).yield }
 340         sleep {
 341                 var thread = thisThread;
 342                 thread.clock.sched(this, { thread.next; nil });
 343                 nil.yield;
 344         }
 345
 346         printOn { arg stream;
 347                 stream.putAll(this.asString);
 348         }
 349         storeOn { arg stream;
 350                 stream.putAll(this.asString);
 351         }
 352
 353
 354         rate { ^'scalar' } // scalarRate constant
 355         asAudioRateInput { ^if(this == 0) { Silent.ar } { DC.ar(this) } }
 356
 357         // support for writing synth defs
 358         writeInputSpec { arg file, synth;
 359                 var constIndex = synth.constants.at(this.asFloat);
 360                 if (constIndex.isNil) {
 361                         Error("SimpleNumber-writeInputSpec constant not found: " ++ this.asFloat).throw;                };
 362                 //[\inpspc, this.class.name, constIndex, this].postln;
 363                 file.putInt16(-1);
 364                 file.putInt16(constIndex);
 365         }
 366
 367         series { arg second, last;
 368                 _SimpleNumberSeries
 369                 ^this.primitiveFailed
 370                 /* var step, size;
 371                 second = second ?? { if (this < last) { this + 1 } { this - 1 } };
 372                 step = second - this;
 373                 size = floor((last - this) / step + 0.001).asInteger + 1;
 374                 ^Array.series(size, this, step) */
 375         }
 376         seriesIter { arg second, last;
 377                 var step, size;
 378                 if (second.isNil) {
 379                         last = last ? inf;
 380                         step = if (this < last, 1, -1);
 381                 }{
 382                         last ?? { last = if (second < this, -inf, inf) };
 383                         step = second - this;
 384                 };
 385                 ^if (step < 0) {
 386                         r {
 387                                 var val = this;
 388                                 while {
 389                                         val >= last;
 390                                 }{
 391                                         val.yield;
 392                                         val = val + step;
 393                                 };
 394                         }
 395                 }{
 396                         r {
 397                                 var val = this;
 398                                 while {
 399                                         val <= last;
 400                                 }{
 401                                         val.yield;
 402                                         val = val + step;
 403                                 };
 404                         }
 405                 }
 406         }
 407
 408
 409         degreeToKey { arg scale, stepsPerOctave = 12;
 410                 var scaleDegree = this.round.asInteger;
 411                 var accidental = (this - scaleDegree) * 10.0;
 412                 ^scale.performDegreeToKey(scaleDegree, stepsPerOctave, accidental)
 413         }
 414
 415         keyToDegree { arg scale, stepsPerOctave=12;
 416                 var n = this div: stepsPerOctave * scale.size;
 417                 var key = this % stepsPerOctave;
 418                 ^scale.indexInBetween(key) + n
 419         }
 420
 421         nearestInList { arg list;  // collection is sorted
 422                 ^list.performNearestInList(this);
 423         }
 424
 425         nearestInScale { arg scale, stepsPerOctave=12; // collection is sorted
 426                 ^scale.performNearestInScale(this, stepsPerOctave);
 427         }
 428
 429         partition { arg parts=2, min=1;
 430                 // randomly partition a number into parts of at least min size :
 431                 var n = this - (min - 1 * parts);
 432                 ^(1..n-1).scramble.keep(parts-1).sort.add(n).differentiate + (min - 1)
 433         }
 434
 435         nextTimeOnGrid { arg clock;
 436                 ^clock.nextTimeOnGrid(this, 0);
 437         }
 438
 439         playAndDelta {}
 440
 441         asQuant { ^Quant(this) }
 442
 443         // a clock format inspired by ISO 8601 time interval display (truncated representation)
 444         // receiver is a time in seconds, returns string "ddd:hh:mm:ss:ttt" where t is milliseconds
 445         // see String:asSecs for complement
 446
 447         asTimeString { arg precision = 0.001, maxDays = 365, dropDaysIfPossible = true;
 448                 var decimal, days, hours, minutes, seconds, mseconds;
 449                 decimal = this.asInteger;
 450                 days = decimal.div(86400).min(maxDays);
 451                 days = if(dropDaysIfPossible and: { days == 0 }) {
 452                         days = ""
 453                 } {
 454                         days.asString.padLeft(3, "0").add($:);
 455                 };
 456                 hours = (decimal.div(3600) % 24).asString.padLeft(2, "0").add($:);
 457                 minutes = (decimal.div(60) % 60).asString.padLeft(2, "0").add($:);
 458                 seconds = (decimal % 60).asString.padLeft(2, "0").add($:);
 459                 mseconds = (this.frac / precision).round(precision).asInteger.asString.padLeft(3, "0");
 460                 ^days ++ hours ++ minutes ++ seconds ++ mseconds
 461         }
 462
 463         asFraction {|denominator=100, fasterBetter=true|
 464                 _AsFraction
 465                 // asFraction will return a fraction that is the best approximation up to the given
 466                 // denominator.
 467                 // if fasterBetter is true it may find a much closer approximation and do it faster.
 468                 ^this.primitiveFailed
 469         }
 470         prSimpleNumberSeries { arg second, last;
 471                 _SimpleNumberSeries
 472                 ^this.primitiveFailed
 473         }
 474
 475         asBufWithValues {
 476                 ^this
 477         }
 478
 479         schedBundleArrayOnClock { |clock, bundleArray, lag = 0, server, latency|
 480                 clock.sched(this, {
 481                                         if (lag != 0) {
 482                                                 SystemClock.sched(lag, {
 483                                                         server.sendBundle(latency ? server.latency, *bundleArray)
 484                                                 })
 485                                         } {
 486                                                 server.sendBundle(latency ? server.latency, *bundleArray)
 487                                         }
 488                 })
 489         }
 490 }