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         fontID { ^this }
 137
 138         performBinaryOpOnSimpleNumber { arg aSelector, aNumber; ^error("Math operation failed.\n") }
 139         performBinaryOpOnComplex { arg aSelector, aComplex, adverb; ^aComplex.perform(aSelector, this.asComplex, adverb) }
 140         performBinaryOpOnSignal { arg aSelector, aSignal; ^error("Math operation failed.\n") }
 141
 142         nextPowerOfTwo { ^this.nextPowerOf(2) }
 143         nextPowerOf { arg base; ^pow(base, ceil(log(this) / log(base))) }
 144         nextPowerOfThree { ^pow(3, ceil(log(this) / log(3))) }
 145         previousPowerOf { arg base; ^pow(base, ceil(log(this) / log(base)) - 1) }
 146
 147         quantize { arg quantum = 1.0, tolerance = 0.05, strength = 1.0;
 148                 var round = round(this, quantum);
 149                 var diff = round - this;
 150                 if (abs(diff) < tolerance) {
 151                         ^this + (strength * diff)
 152                 }{
 153                         ^this
 154                 }
 155         }
 156
 157
 158         linlin { arg inMin, inMax, outMin, outMax, clip=\minmax;
 159                 // linear to linear mapping
 160                 switch(clip,
 161                         \minmax, {
 162                                 if (this <= inMin, { ^outMin });
 163                                 if (this >= inMax, { ^outMax });
 164                         },
 165                         \min, {
 166                                 if (this <= inMin, { ^outMin });
 167                         },
 168                         \max, {
 169                                 if (this >= inMax, { ^outMax });
 170                         }
 171                 );
 172                 ^(this-inMin)/(inMax-inMin) * (outMax-outMin) + outMin;
 173         }
 174
 175         linexp { arg inMin, inMax, outMin, outMax, clip=\minmax;
 176                 // linear to exponential mapping
 177                 switch(clip,
 178                         \minmax, {
 179                                 if (this <= inMin, { ^outMin });
 180                                 if (this >= inMax, { ^outMax });
 181                         },
 182                         \min, {
 183                                 if (this <= inMin, { ^outMin });
 184                         },
 185                         \max, {
 186                                 if (this >= inMax, { ^outMax });
 187                         }
 188                 );
 189                 ^pow(outMax/outMin, (this-inMin)/(inMax-inMin)) * outMin
 190         }
 191
 192         explin { arg inMin, inMax, outMin, outMax, clip=\minmax;
 193                 // exponential to linear mapping
 194                 switch(clip,
 195                         \minmax, {
 196                                 if (this <= inMin, { ^outMin });
 197                                 if (this >= inMax, { ^outMax });
 198                         },
 199                         \min, {
 200                                 if (this <= inMin, { ^outMin });
 201                         },
 202                         \max, {
 203                                 if (this >= inMax, { ^outMax });
 204                         }
 205                 );
 206                 ^(log(this/inMin)) / (log(inMax/inMin)) * (outMax-outMin) + outMin;
 207         }
 208
 209         expexp { arg inMin, inMax, outMin, outMax, clip=\minmax;
 210                 // exponential to exponential mapping
 211                 switch(clip,
 212                         \minmax, {
 213                                 if (this <= inMin, { ^outMin });
 214                                 if (this >= inMax, { ^outMax });
 215                         },
 216                         \min, {
 217                                 if (this <= inMin, { ^outMin });
 218                         },
 219                         \max, {
 220                                 if (this >= inMax, { ^outMax });
 221                         }
 222                 );
 223                 ^pow(outMax/outMin, log(this/inMin) / log(inMax/inMin)) * outMin;
 224         }
 225
 226         lincurve { arg inMin = 0, inMax = 1, outMin = 0, outMax = 1, curve = -4, clip = \minmax;
 227                 var grow, a, b, scaled;
 228                 switch(clip,
 229                         \minmax, {
 230                                 if (this <= inMin, { ^outMin });
 231                                 if (this >= inMax, { ^outMax });
 232                         },
 233                         \min, {
 234                                 if (this <= inMin, { ^outMin });
 235                         },
 236                         \max, {
 237                                 if (this >= inMax, { ^outMax });
 238                         }
 239                 );
 240                 if (abs(curve) < 0.001) { ^this.linlin(inMin, inMax, outMin, outMax) };
 241
 242                 grow = exp(curve);
 243                 a = outMax - outMin / (1.0 - grow);
 244                 b = outMin + a;
 245                 scaled = (this - inMin) / (inMax - inMin);
 246
 247                 ^b - (a * pow(grow, scaled));
 248         }
 249
 250         curvelin { arg inMin = 0, inMax = 1, outMin = 0, outMax = 1, curve = -4, clip = \minmax;
 251                 var grow, a, b, scaled;
 252                 switch(clip,
 253                         \minmax, {
 254                                 if (this <= inMin, { ^outMin });
 255                                 if (this >= inMax, { ^outMax });
 256                         },
 257                         \min, {
 258                                 if (this <= inMin, { ^outMin });
 259                         },
 260                         \max, {
 261                                 if (this >= inMax, { ^outMax });
 262                         }
 263                 );
 264                 if (abs(curve) < 0.001) { ^this.linlin(inMin, inMax, outMin, outMax) };
 265
 266                 grow = exp(curve);
 267                 a = outMax - outMin / (1.0 - grow);
 268                 b = outMin + a;
 269                 scaled = (this - inMin) / (inMax - inMin);
 270
 271                 ^log((b - scaled) / a) / curve
 272         }
 273
 274         bilin { arg inCenter, inMin, inMax, outCenter, outMin, outMax, clip=\minmax;
 275                 // triangular linear mapping
 276                 switch(clip,
 277                         \minmax, {
 278                                 if (this <= inMin, { ^outMin });
 279                                 if (this >= inMax, { ^outMax });
 280                         },
 281                         \min, {
 282                                 if (this <= inMin, { ^outMin });
 283                         },
 284                         \max, {
 285                                 if (this >= inMax, { ^outMax });
 286                         }
 287                 );
 288                 ^if (this >= inCenter) {
 289                         this.linlin(inCenter, inMax, outCenter, outMax, \none);
 290                 } {
 291                         this.linlin(inMin, inCenter, outMin, outCenter, \none);
 292                 }
 293         }
 294
 295         biexp { arg inCenter, inMin, inMax, outCenter, outMin, outMax, clip=\minmax;
 296                 // triangular exponential mapping
 297                 switch(clip,
 298                         \minmax, {
 299                                 if (this <= inMin, { ^outMin });
 300                                 if (this >= inMax, { ^outMax });
 301                         },
 302                         \min, {
 303                                 if (this <= inMin, { ^outMin });
 304                         },
 305                         \max, {
 306                                 if (this >= inMax, { ^outMax });
 307                         }
 308                 );
 309                 if (this >= inCenter) {
 310                         this.explin(inCenter, inMax, outCenter, outMax, \none);
 311                 } {
 312                         this.explin(inMin, inCenter, outMin, outCenter, \none);
 313                 }
 314         }
 315         lcurve { arg a = 1.0, m = 0.0, n = 1.0, tau = 1.0;
 316                 var rTau, x = this.neg;
 317                 ^if(tau == 1.0) {
 318                         a * (m * exp(x) + 1) / (n * exp(x) + 1)
 319                 } {
 320                         rTau = tau.reciprocal;
 321                         a * (m * exp(x) * rTau + 1) / (n * exp(x) * rTau + 1)
 322                 }
 323         }
 324         gauss { arg standardDeviation;
 325                 ^((((-2*log(1.0.rand)).sqrt * sin(2pi.rand)) * standardDeviation) + this)
 326         }
 327         gaussCurve { arg a = 1.0, b = 0.0, c = 1.0;
 328                 ^a * (exp(squared(this - b) / (-2.0 * squared(c))))
 329         }
 330
 331         asPoint { ^Point.new(this, this) }
 332
 333         asWarp { arg spec; ^CurveWarp.new(spec, this) }
 334
 335         // scheduled Routine support
 336         wait { ^this.yield }
 337         waitUntil { ^(this - thisThread.beats).max(0).yield }
 338         sleep {
 339                 var thread = thisThread;
 340                 thread.clock.sched(this, { thread.next; nil });
 341                 nil.yield;
 342         }
 343
 344         printOn { arg stream;
 345                 stream.putAll(this.asString);
 346         }
 347         storeOn { arg stream;
 348                 stream.putAll(this.asString);
 349         }
 350
 351
 352         rate { ^'scalar' } // scalarRate constant
 353         asAudioRateInput { ^if(this == 0) { Silent.ar } { DC.ar(this) } }
 354
 355         // support for writing synth defs
 356         writeInputSpec { arg file, synth;
 357                 var constIndex = synth.constants.at(this.asFloat);
 358                 if (constIndex.isNil) {
 359                         Error("SimpleNumber-writeInputSpec constant not found: " ++ this.asFloat).throw;                };
 360                 //[\inpspc, this.class.name, constIndex, this].postln;
 361                 file.putInt16(-1);
 362                 file.putInt16(constIndex);
 363         }
 364
 365         series { arg second, last;
 366                 _SimpleNumberSeries
 367                 ^this.primitiveFailed
 368                 /* var step, size;
 369                 second = second ?? { if (this < last) { this + 1 } { this - 1 } };
 370                 step = second - this;
 371                 size = floor((last - this) / step + 0.001).asInteger + 1;
 372                 ^Array.series(size, this, step) */
 373         }
 374         seriesIter { arg second, last;
 375                 var step, size;
 376                 if (second.isNil) {
 377                         last = last ? inf;
 378                         step = if (this < last, 1, -1);
 379                 }{
 380                         last ?? { last = if (second < this, -inf, inf) };
 381                         step = second - this;
 382                 };
 383                 ^if (step < 0) {
 384                         r {
 385                                 var val = this;
 386                                 while {
 387                                         val >= last;
 388                                 }{
 389                                         val.yield;
 390                                         val = val + step;
 391                                 };
 392                         }
 393                 }{
 394                         r {
 395                                 var val = this;
 396                                 while {
 397                                         val <= last;
 398                                 }{
 399                                         val.yield;
 400                                         val = val + step;
 401                                 };
 402                         }
 403                 }
 404         }
 405
 406
 407         degreeToKey { arg scale, stepsPerOctave = 12;
 408                 var scaleDegree = this.round.asInteger;
 409                 var accidental = (this - scaleDegree) * 10.0;
 410                 ^scale.performDegreeToKey(scaleDegree, stepsPerOctave, accidental)
 411         }
 412
 413         keyToDegree { arg scale, stepsPerOctave=12;
 414                 var n = this div: stepsPerOctave * scale.size;
 415                 var key = this % stepsPerOctave;
 416                 ^scale.indexInBetween(key) + n
 417         }
 418
 419         nearestInList { arg list;  // collection is sorted
 420                 ^list.performNearestInList(this);
 421         }
 422
 423         nearestInScale { arg scale, stepsPerOctave=12; // collection is sorted
 424                 ^scale.performNearestInScale(this, stepsPerOctave);
 425         }
 426
 427         partition { arg parts=2, min=1;
 428                 // randomly partition a number into parts of at least min size :
 429                 var n = this - (min - 1 * parts);
 430                 ^(1..n-1).scramble.keep(parts-1).sort.add(n).differentiate + (min - 1)
 431         }
 432
 433         nextTimeOnGrid { arg clock;
 434                 ^clock.nextTimeOnGrid(this, 0);
 435         }
 436
 437         playAndDelta {}
 438
 439         asQuant { ^Quant(this) }
 440
 441         // a clock format inspired by ISO 8601 time interval display (truncated representation)
 442         // receiver is a time in seconds, returns string "ddd:hh:mm:ss:ttt" where t is milliseconds
 443         // see String:asSecs for complement
 444
 445         asTimeString { arg precision = 0.001, maxDays = 365, dropDaysIfPossible = true;
 446                 var decimal, days, hours, minutes, seconds, mseconds;
 447                 decimal = this.asInteger;
 448                 days = decimal.div(86400).min(maxDays);
 449                 days = if(dropDaysIfPossible and: { days == 0 }) {
 450                         days = ""
 451                 } {
 452                         days.asString.padLeft(3, "0").add($:);
 453                 };
 454                 hours = (decimal.div(3600) % 24).asString.padLeft(2, "0").add($:);
 455                 minutes = (decimal.div(60) % 60).asString.padLeft(2, "0").add($:);
 456                 seconds = (decimal % 60).asString.padLeft(2, "0").add($:);
 457                 mseconds = (this.frac / precision).round(precision).asInteger.asString.padLeft(3, "0");
 458                 ^days ++ hours ++ minutes ++ seconds ++ mseconds
 459         }
 460
 461         asFraction {|denominator=100, fasterBetter=true|
 462                 _AsFraction
 463                 // asFraction will return a fraction that is the best approximation up to the given
 464                 // denominator.
 465                 // if fasterBetter is true it may find a much closer approximation and do it faster.
 466                 ^this.primitiveFailed
 467         }
 468         prSimpleNumberSeries { arg second, last;
 469                 _SimpleNumberSeries
 470                 ^this.primitiveFailed
 471         }
 472
 473         asBufWithValues {
 474                 ^this
 475         }
 476
 477         schedBundleArrayOnClock { |clock, bundleArray, lag = 0, server, latency|
 478                 clock.sched(this, {
 479                                         if (lag != 0) {
 480                                                 SystemClock.sched(lag, {
 481                                                         server.sendBundle(latency ? server.latency, *bundleArray)
 482                                                 })
 483                                         } {
 484                                                 server.sendBundle(latency ? server.latency, *bundleArray)
 485                                         }
 486                 })
 487         }
 488 }