Mercurial > lasercutter

annotate src/clojure/lang/Numbers.java @ 10:ef7dbbd6452c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
added clojure source goodness
author Robert McIntyre <rlm@mit.edu>
date Sat, 21 Aug 2010 06:25:44 -0400
parents
children
rev   line source
rlm@10 1 /**
rlm@10 2 * Copyright (c) Rich Hickey. All rights reserved.
rlm@10 3 * The use and distribution terms for this software are covered by the
rlm@10 4 * Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
rlm@10 5 * which can be found in the file epl-v10.html at the root of this distribution.
rlm@10 6 * By using this software in any fashion, you are agreeing to be bound by
rlm@10 7 * the terms of this license.
rlm@10 8 * You must not remove this notice, or any other, from this software.
rlm@10 9 **/
rlm@10 10
rlm@10 11 /* rich Mar 31, 2008 */
rlm@10 12
rlm@10 13 package clojure.lang;
rlm@10 14
rlm@10 15 import java.math.BigInteger;
rlm@10 16 import java.math.BigDecimal;
rlm@10 17 import java.math.MathContext;
rlm@10 18
rlm@10 19 public class Numbers{
rlm@10 20
rlm@10 21 static interface Ops{
rlm@10 22 Ops combine(Ops y);
rlm@10 23
rlm@10 24 Ops opsWith(IntegerOps x);
rlm@10 25
rlm@10 26 Ops opsWith(LongOps x);
rlm@10 27
rlm@10 28 Ops opsWith(FloatOps x);
rlm@10 29
rlm@10 30 Ops opsWith(DoubleOps x);
rlm@10 31
rlm@10 32 Ops opsWith(RatioOps x);
rlm@10 33
rlm@10 34 Ops opsWith(BigIntegerOps x);
rlm@10 35
rlm@10 36 Ops opsWith(BigDecimalOps x);
rlm@10 37
rlm@10 38 public boolean isZero(Number x);
rlm@10 39
rlm@10 40 public boolean isPos(Number x);
rlm@10 41
rlm@10 42 public boolean isNeg(Number x);
rlm@10 43
rlm@10 44 public Number add(Number x, Number y);
rlm@10 45
rlm@10 46 public Number multiply(Number x, Number y);
rlm@10 47
rlm@10 48 public Number divide(Number x, Number y);
rlm@10 49
rlm@10 50 public Number quotient(Number x, Number y);
rlm@10 51
rlm@10 52 public Number remainder(Number x, Number y);
rlm@10 53
rlm@10 54 public boolean equiv(Number x, Number y);
rlm@10 55
rlm@10 56 public boolean lt(Number x, Number y);
rlm@10 57
rlm@10 58 public Number negate(Number x);
rlm@10 59
rlm@10 60 public Number inc(Number x);
rlm@10 61
rlm@10 62 public Number dec(Number x);
rlm@10 63 }
rlm@10 64
rlm@10 65 static interface BitOps{
rlm@10 66 BitOps combine(BitOps y);
rlm@10 67
rlm@10 68 BitOps bitOpsWith(IntegerBitOps x);
rlm@10 69
rlm@10 70 BitOps bitOpsWith(LongBitOps x);
rlm@10 71
rlm@10 72 BitOps bitOpsWith(BigIntegerBitOps x);
rlm@10 73
rlm@10 74 public Number not(Number x);
rlm@10 75
rlm@10 76 public Number and(Number x, Number y);
rlm@10 77
rlm@10 78 public Number or(Number x, Number y);
rlm@10 79
rlm@10 80 public Number xor(Number x, Number y);
rlm@10 81
rlm@10 82 public Number andNot(Number x, Number y);
rlm@10 83
rlm@10 84 public Number clearBit(Number x, int n);
rlm@10 85
rlm@10 86 public Number setBit(Number x, int n);
rlm@10 87
rlm@10 88 public Number flipBit(Number x, int n);
rlm@10 89
rlm@10 90 public boolean testBit(Number x, int n);
rlm@10 91
rlm@10 92 public Number shiftLeft(Number x, int n);
rlm@10 93
rlm@10 94 public Number shiftRight(Number x, int n);
rlm@10 95 }
rlm@10 96
rlm@10 97
rlm@10 98 static public boolean isZero(Object x){
rlm@10 99 return ops(x).isZero((Number)x);
rlm@10 100 }
rlm@10 101
rlm@10 102 static public boolean isPos(Object x){
rlm@10 103 return ops(x).isPos((Number)x);
rlm@10 104 }
rlm@10 105
rlm@10 106 static public boolean isNeg(Object x){
rlm@10 107 return ops(x).isNeg((Number)x);
rlm@10 108 }
rlm@10 109
rlm@10 110 static public Number minus(Object x){
rlm@10 111 return ops(x).negate((Number)x);
rlm@10 112 }
rlm@10 113
rlm@10 114 static public Number inc(Object x){
rlm@10 115 return ops(x).inc((Number)x);
rlm@10 116 }
rlm@10 117
rlm@10 118 static public Number dec(Object x){
rlm@10 119 return ops(x).dec((Number)x);
rlm@10 120 }
rlm@10 121
rlm@10 122 static public Number add(Object x, Object y){
rlm@10 123 return ops(x).combine(ops(y)).add((Number)x, (Number)y);
rlm@10 124 }
rlm@10 125
rlm@10 126 static public Number minus(Object x, Object y){
rlm@10 127 Ops yops = ops(y);
rlm@10 128 return ops(x).combine(yops).add((Number)x, yops.negate((Number)y));
rlm@10 129 }
rlm@10 130
rlm@10 131 static public Number multiply(Object x, Object y){
rlm@10 132 return ops(x).combine(ops(y)).multiply((Number)x, (Number)y);
rlm@10 133 }
rlm@10 134
rlm@10 135 static public Number divide(Object x, Object y){
rlm@10 136 Ops yops = ops(y);
rlm@10 137 if(yops.isZero((Number)y))
rlm@10 138 throw new ArithmeticException("Divide by zero");
rlm@10 139 return ops(x).combine(yops).divide((Number)x, (Number)y);
rlm@10 140 }
rlm@10 141
rlm@10 142 static public Number quotient(Number x, Number y){
rlm@10 143 Ops yops = ops(y);
rlm@10 144 if(yops.isZero(y))
rlm@10 145 throw new ArithmeticException("Divide by zero");
rlm@10 146 return reduce(ops(x).combine(yops).quotient(x, y));
rlm@10 147 }
rlm@10 148
rlm@10 149 static public Number remainder(Number x, Number y){
rlm@10 150 Ops yops = ops(y);
rlm@10 151 if(yops.isZero(y))
rlm@10 152 throw new ArithmeticException("Divide by zero");
rlm@10 153 return reduce(ops(x).combine(yops).remainder(x, y));
rlm@10 154 }
rlm@10 155
rlm@10 156 static Number quotient(double n, double d){
rlm@10 157 double q = n / d;
rlm@10 158 if(q <= Integer.MAX_VALUE && q >= Integer.MIN_VALUE)
rlm@10 159 {
rlm@10 160 return (int) q;
rlm@10 161 }
rlm@10 162 else
rlm@10 163 { //bigint quotient
rlm@10 164 return reduce(new BigDecimal(q).toBigInteger());
rlm@10 165 }
rlm@10 166 }
rlm@10 167
rlm@10 168 static Number remainder(double n, double d){
rlm@10 169 double q = n / d;
rlm@10 170 if(q <= Integer.MAX_VALUE && q >= Integer.MIN_VALUE)
rlm@10 171 {
rlm@10 172 return (n - ((int) q) * d);
rlm@10 173 }
rlm@10 174 else
rlm@10 175 { //bigint quotient
rlm@10 176 Number bq = reduce(new BigDecimal(q).toBigInteger());
rlm@10 177 return (n - bq.doubleValue() * d);
rlm@10 178 }
rlm@10 179 }
rlm@10 180
rlm@10 181 static public boolean equiv(Object x, Object y){
rlm@10 182 return equiv((Number) x, (Number) y);
rlm@10 183 }
rlm@10 184
rlm@10 185 static public boolean equiv(Number x, Number y){
rlm@10 186 return ops(x).combine(ops(y)).equiv(x, y);
rlm@10 187 }
rlm@10 188
rlm@10 189 static public boolean lt(Object x, Object y){
rlm@10 190 return ops(x).combine(ops(y)).lt((Number)x, (Number)y);
rlm@10 191 }
rlm@10 192
rlm@10 193 static public boolean lte(Object x, Object y){
rlm@10 194 return !ops(x).combine(ops(y)).lt((Number)y, (Number)x);
rlm@10 195 }
rlm@10 196
rlm@10 197 static public boolean gt(Object x, Object y){
rlm@10 198 return ops(x).combine(ops(y)).lt((Number)y, (Number)x);
rlm@10 199 }
rlm@10 200
rlm@10 201 static public boolean gte(Object x, Object y){
rlm@10 202 return !ops(x).combine(ops(y)).lt((Number)x, (Number)y);
rlm@10 203 }
rlm@10 204
rlm@10 205 static public int compare(Number x, Number y){
rlm@10 206 Ops ops = ops(x).combine(ops(y));
rlm@10 207 if(ops.lt(x, y))
rlm@10 208 return -1;
rlm@10 209 else if(ops.lt(y, x))
rlm@10 210 return 1;
rlm@10 211 return 0;
rlm@10 212 }
rlm@10 213
rlm@10 214 static BigInteger toBigInteger(Object x){
rlm@10 215 if(x instanceof BigInteger)
rlm@10 216 return (BigInteger) x;
rlm@10 217 else
rlm@10 218 return BigInteger.valueOf(((Number) x).longValue());
rlm@10 219 }
rlm@10 220
rlm@10 221 static BigDecimal toBigDecimal(Object x){
rlm@10 222 if(x instanceof BigDecimal)
rlm@10 223 return (BigDecimal) x;
rlm@10 224 else if(x instanceof BigInteger)
rlm@10 225 return new BigDecimal((BigInteger) x);
rlm@10 226 else
rlm@10 227 return BigDecimal.valueOf(((Number) x).longValue());
rlm@10 228 }
rlm@10 229
rlm@10 230 static Ratio toRatio(Object x){
rlm@10 231 if(x instanceof Ratio)
rlm@10 232 return (Ratio) x;
rlm@10 233 else if(x instanceof BigDecimal)
rlm@10 234 {
rlm@10 235 BigDecimal bx = (BigDecimal) x;
rlm@10 236 BigInteger bv = bx.unscaledValue();
rlm@10 237 int scale = bx.scale();
rlm@10 238 if(scale < 0)
rlm@10 239 return new Ratio(bv.multiply(BigInteger.TEN.pow(-scale)), BigInteger.ONE);
rlm@10 240 else
rlm@10 241 return new Ratio(bv, BigInteger.TEN.pow(scale));
rlm@10 242 }
rlm@10 243 return new Ratio(toBigInteger(x), BigInteger.ONE);
rlm@10 244 }
rlm@10 245
rlm@10 246 static public Number rationalize(Number x){
rlm@10 247 if(x instanceof Float || x instanceof Double)
rlm@10 248 return rationalize(BigDecimal.valueOf(x.doubleValue()));
rlm@10 249 else if(x instanceof BigDecimal)
rlm@10 250 {
rlm@10 251 BigDecimal bx = (BigDecimal) x;
rlm@10 252 BigInteger bv = bx.unscaledValue();
rlm@10 253 int scale = bx.scale();
rlm@10 254 if(scale < 0)
rlm@10 255 return bv.multiply(BigInteger.TEN.pow(-scale));
rlm@10 256 else
rlm@10 257 return divide(bv, BigInteger.TEN.pow(scale));
rlm@10 258 }
rlm@10 259 return x;
rlm@10 260 }
rlm@10 261
rlm@10 262 static public Number reduce(Number val){
rlm@10 263 if(val instanceof Long)
rlm@10 264 return reduce(val.longValue());
rlm@10 265 else if (val instanceof BigInteger)
rlm@10 266 return reduce((BigInteger) val);
rlm@10 267 return val;
rlm@10 268 }
rlm@10 269
rlm@10 270 static public Number reduce(BigInteger val){
rlm@10 271 int bitLength = val.bitLength();
rlm@10 272 if(bitLength < 32)
rlm@10 273 return val.intValue();
rlm@10 274 else if(bitLength < 64)
rlm@10 275 return val.longValue();
rlm@10 276 else
rlm@10 277 return val;
rlm@10 278 }
rlm@10 279
rlm@10 280 static public Number reduce(long val){
rlm@10 281 if(val >= Integer.MIN_VALUE && val <= Integer.MAX_VALUE)
rlm@10 282 return (int) val;
rlm@10 283 else
rlm@10 284 return val;
rlm@10 285 }
rlm@10 286
rlm@10 287 static public Number divide(BigInteger n, BigInteger d){
rlm@10 288 if(d.equals(BigInteger.ZERO))
rlm@10 289 throw new ArithmeticException("Divide by zero");
rlm@10 290 BigInteger gcd = n.gcd(d);
rlm@10 291 if(gcd.equals(BigInteger.ZERO))
rlm@10 292 return 0;
rlm@10 293 n = n.divide(gcd);
rlm@10 294 d = d.divide(gcd);
rlm@10 295 if(d.equals(BigInteger.ONE))
rlm@10 296 return reduce(n);
rlm@10 297 else if(d.equals(BigInteger.ONE.negate()))
rlm@10 298 return reduce(n.negate());
rlm@10 299 return new Ratio((d.signum() < 0 ? n.negate() : n),
rlm@10 300 (d.signum() < 0 ? d.negate() : d));
rlm@10 301 }
rlm@10 302
rlm@10 303 static public Number not(Object x){
rlm@10 304 return bitOps(x).not((Number)x);
rlm@10 305 }
rlm@10 306
rlm@10 307
rlm@10 308 static public Number and(Object x, Object y){
rlm@10 309 return bitOps(x).combine(bitOps(y)).and((Number)x, (Number)y);
rlm@10 310 }
rlm@10 311
rlm@10 312 static public Number or(Object x, Object y){
rlm@10 313 return bitOps(x).combine(bitOps(y)).or((Number)x, (Number)y);
rlm@10 314 }
rlm@10 315
rlm@10 316 static public Number xor(Object x, Object y){
rlm@10 317 return bitOps(x).combine(bitOps(y)).xor((Number)x, (Number)y);
rlm@10 318 }
rlm@10 319
rlm@10 320 static public Number andNot(Number x, Number y){
rlm@10 321 return bitOps(x).combine(bitOps(y)).andNot(x, y);
rlm@10 322 }
rlm@10 323
rlm@10 324 static public Number clearBit(Number x, int n){
rlm@10 325 if(n < 0)
rlm@10 326 throw new ArithmeticException("Negative bit index");
rlm@10 327 return bitOps(x).clearBit(x, n);
rlm@10 328 }
rlm@10 329
rlm@10 330 static public Number setBit(Number x, int n){
rlm@10 331 if(n < 0)
rlm@10 332 throw new ArithmeticException("Negative bit index");
rlm@10 333 return bitOps(x).setBit(x, n);
rlm@10 334 }
rlm@10 335
rlm@10 336 static public Number flipBit(Number x, int n){
rlm@10 337 if(n < 0)
rlm@10 338 throw new ArithmeticException("Negative bit index");
rlm@10 339 return bitOps(x).flipBit(x, n);
rlm@10 340 }
rlm@10 341
rlm@10 342 static public boolean testBit(Number x, int n){
rlm@10 343 if(n < 0)
rlm@10 344 throw new ArithmeticException("Negative bit index");
rlm@10 345 return bitOps(x).testBit(x, n);
rlm@10 346 }
rlm@10 347
rlm@10 348 static public Number shiftLeft(Object x, Object n){
rlm@10 349 return bitOps(x).shiftLeft((Number)x, ((Number)n).intValue());
rlm@10 350 }
rlm@10 351
rlm@10 352 static public int shiftLeft(int x, int n){
rlm@10 353 return x << n;
rlm@10 354 }
rlm@10 355
rlm@10 356 static public Number shiftRight(Object x, Object n){
rlm@10 357 return bitOps(x).shiftRight((Number)x, ((Number)n).intValue());
rlm@10 358 }
rlm@10 359
rlm@10 360 static public int shiftRight(int x, int n){
rlm@10 361 return x >> n;
rlm@10 362 }
rlm@10 363
rlm@10 364 final static class IntegerOps implements Ops{
rlm@10 365 public Ops combine(Ops y){
rlm@10 366 return y.opsWith(this);
rlm@10 367 }
rlm@10 368
rlm@10 369 final public Ops opsWith(IntegerOps x){
rlm@10 370 return this;
rlm@10 371 }
rlm@10 372
rlm@10 373 final public Ops opsWith(LongOps x){
rlm@10 374 return LONG_OPS;
rlm@10 375 }
rlm@10 376
rlm@10 377 final public Ops opsWith(FloatOps x){
rlm@10 378 return FLOAT_OPS;
rlm@10 379 }
rlm@10 380
rlm@10 381 final public Ops opsWith(DoubleOps x){
rlm@10 382 return DOUBLE_OPS;
rlm@10 383 }
rlm@10 384
rlm@10 385 final public Ops opsWith(RatioOps x){
rlm@10 386 return RATIO_OPS;
rlm@10 387 }
rlm@10 388
rlm@10 389 final public Ops opsWith(BigIntegerOps x){
rlm@10 390 return BIGINTEGER_OPS;
rlm@10 391 }
rlm@10 392
rlm@10 393 final public Ops opsWith(BigDecimalOps x){
rlm@10 394 return BIGDECIMAL_OPS;
rlm@10 395 }
rlm@10 396
rlm@10 397 public boolean isZero(Number x){
rlm@10 398 return x.intValue() == 0;
rlm@10 399 }
rlm@10 400
rlm@10 401 public boolean isPos(Number x){
rlm@10 402 return x.intValue() > 0;
rlm@10 403 }
rlm@10 404
rlm@10 405 public boolean isNeg(Number x){
rlm@10 406 return x.intValue() < 0;
rlm@10 407 }
rlm@10 408
rlm@10 409 final public Number add(Number x, Number y){
rlm@10 410 long ret = x.longValue() + y.longValue();
rlm@10 411 if(ret <= Integer.MAX_VALUE && ret >= Integer.MIN_VALUE)
rlm@10 412 return (int) ret;
rlm@10 413 return ret;
rlm@10 414 }
rlm@10 415
rlm@10 416 final public Number multiply(Number x, Number y){
rlm@10 417 long ret = x.longValue() * y.longValue();
rlm@10 418 if(ret <= Integer.MAX_VALUE && ret >= Integer.MIN_VALUE)
rlm@10 419 return (int) ret;
rlm@10 420 return ret;
rlm@10 421 }
rlm@10 422
rlm@10 423 static int gcd(int u, int v){
rlm@10 424 while(v != 0)
rlm@10 425 {
rlm@10 426 int r = u % v;
rlm@10 427 u = v;
rlm@10 428 v = r;
rlm@10 429 }
rlm@10 430 return u;
rlm@10 431 }
rlm@10 432
rlm@10 433 public Number divide(Number x, Number y){
rlm@10 434 int n = x.intValue();
rlm@10 435 int val = y.intValue();
rlm@10 436 int gcd = gcd(n, val);
rlm@10 437 if(gcd == 0)
rlm@10 438 return 0;
rlm@10 439
rlm@10 440 n = n / gcd;
rlm@10 441 int d = val / gcd;
rlm@10 442 if(d == 1)
rlm@10 443 return n;
rlm@10 444 if(d < 0)
rlm@10 445 {
rlm@10 446 n = -n;
rlm@10 447 d = -d;
rlm@10 448 }
rlm@10 449 return new Ratio(BigInteger.valueOf(n), BigInteger.valueOf(d));
rlm@10 450 }
rlm@10 451
rlm@10 452 public Number quotient(Number x, Number y){
rlm@10 453 return x.intValue() / y.intValue();
rlm@10 454 }
rlm@10 455
rlm@10 456 public Number remainder(Number x, Number y){
rlm@10 457 return x.intValue() % y.intValue();
rlm@10 458 }
rlm@10 459
rlm@10 460 public boolean equiv(Number x, Number y){
rlm@10 461 return x.intValue() == y.intValue();
rlm@10 462 }
rlm@10 463
rlm@10 464 public boolean lt(Number x, Number y){
rlm@10 465 return x.intValue() < y.intValue();
rlm@10 466 }
rlm@10 467
rlm@10 468 //public Number subtract(Number x, Number y);
rlm@10 469 final public Number negate(Number x){
rlm@10 470 int val = x.intValue();
rlm@10 471 if(val > Integer.MIN_VALUE)
rlm@10 472 return -val;
rlm@10 473 return -((long) val);
rlm@10 474 }
rlm@10 475
rlm@10 476 public Number inc(Number x){
rlm@10 477 int val = x.intValue();
rlm@10 478 if(val < Integer.MAX_VALUE)
rlm@10 479 return val + 1;
rlm@10 480 return (long) val + 1;
rlm@10 481 }
rlm@10 482
rlm@10 483 public Number dec(Number x){
rlm@10 484 int val = x.intValue();
rlm@10 485 if(val > Integer.MIN_VALUE)
rlm@10 486 return val - 1;
rlm@10 487 return (long) val - 1;
rlm@10 488 }
rlm@10 489 }
rlm@10 490
rlm@10 491 final static class LongOps implements Ops{
rlm@10 492 public Ops combine(Ops y){
rlm@10 493 return y.opsWith(this);
rlm@10 494 }
rlm@10 495
rlm@10 496 final public Ops opsWith(IntegerOps x){
rlm@10 497 return this;
rlm@10 498 }
rlm@10 499
rlm@10 500 final public Ops opsWith(LongOps x){
rlm@10 501 return this;
rlm@10 502 }
rlm@10 503
rlm@10 504 final public Ops opsWith(FloatOps x){
rlm@10 505 return FLOAT_OPS;
rlm@10 506 }
rlm@10 507
rlm@10 508 final public Ops opsWith(DoubleOps x){
rlm@10 509 return DOUBLE_OPS;
rlm@10 510 }
rlm@10 511
rlm@10 512 final public Ops opsWith(RatioOps x){
rlm@10 513 return RATIO_OPS;
rlm@10 514 }
rlm@10 515
rlm@10 516 final public Ops opsWith(BigIntegerOps x){
rlm@10 517 return BIGINTEGER_OPS;
rlm@10 518 }
rlm@10 519
rlm@10 520 final public Ops opsWith(BigDecimalOps x){
rlm@10 521 return BIGDECIMAL_OPS;
rlm@10 522 }
rlm@10 523
rlm@10 524 public boolean isZero(Number x){
rlm@10 525 return x.longValue() == 0;
rlm@10 526 }
rlm@10 527
rlm@10 528 public boolean isPos(Number x){
rlm@10 529 return x.longValue() > 0;
rlm@10 530 }
rlm@10 531
rlm@10 532 public boolean isNeg(Number x){
rlm@10 533 return x.longValue() < 0;
rlm@10 534 }
rlm@10 535
rlm@10 536 final public Number add(Number x, Number y){
rlm@10 537 long lx = x.longValue(), ly = y.longValue();
rlm@10 538 long ret = lx + ly;
rlm@10 539 if ((ret ^ lx) < 0 && (ret ^ ly) < 0)
rlm@10 540 return BIGINTEGER_OPS.add(x, y);
rlm@10 541 return ret;
rlm@10 542 }
rlm@10 543
rlm@10 544 final public Number multiply(Number x, Number y){
rlm@10 545 long lx = x.longValue(), ly = y.longValue();
rlm@10 546 long ret = lx * ly;
rlm@10 547 if (ly != 0 && ret/ly != lx)
rlm@10 548 return BIGINTEGER_OPS.multiply(x, y);
rlm@10 549 return ret;
rlm@10 550 }
rlm@10 551
rlm@10 552 static long gcd(long u, long v){
rlm@10 553 while(v != 0)
rlm@10 554 {
rlm@10 555 long r = u % v;
rlm@10 556 u = v;
rlm@10 557 v = r;
rlm@10 558 }
rlm@10 559 return u;
rlm@10 560 }
rlm@10 561
rlm@10 562 public Number divide(Number x, Number y){
rlm@10 563 long n = x.longValue();
rlm@10 564 long val = y.longValue();
rlm@10 565 long gcd = gcd(n, val);
rlm@10 566 if(gcd == 0)
rlm@10 567 return 0;
rlm@10 568
rlm@10 569 n = n / gcd;
rlm@10 570 long d = val / gcd;
rlm@10 571 if(d == 1)
rlm@10 572 return n;
rlm@10 573 if(d < 0)
rlm@10 574 {
rlm@10 575 n = -n;
rlm@10 576 d = -d;
rlm@10 577 }
rlm@10 578 return new Ratio(BigInteger.valueOf(n), BigInteger.valueOf(d));
rlm@10 579 }
rlm@10 580
rlm@10 581 public Number quotient(Number x, Number y){
rlm@10 582 return x.longValue() / y.longValue();
rlm@10 583 }
rlm@10 584
rlm@10 585 public Number remainder(Number x, Number y){
rlm@10 586 return x.longValue() % y.longValue();
rlm@10 587 }
rlm@10 588
rlm@10 589 public boolean equiv(Number x, Number y){
rlm@10 590 return x.longValue() == y.longValue();
rlm@10 591 }
rlm@10 592
rlm@10 593 public boolean lt(Number x, Number y){
rlm@10 594 return x.longValue() < y.longValue();
rlm@10 595 }
rlm@10 596
rlm@10 597 //public Number subtract(Number x, Number y);
rlm@10 598 final public Number negate(Number x){
rlm@10 599 long val = x.longValue();
rlm@10 600 if(val > Long.MIN_VALUE)
rlm@10 601 return -val;
rlm@10 602 return BigInteger.valueOf(val).negate();
rlm@10 603 }
rlm@10 604
rlm@10 605 public Number inc(Number x){
rlm@10 606 long val = x.longValue();
rlm@10 607 if(val < Long.MAX_VALUE)
rlm@10 608 return val + 1;
rlm@10 609 return BIGINTEGER_OPS.inc(x);
rlm@10 610 }
rlm@10 611
rlm@10 612 public Number dec(Number x){
rlm@10 613 long val = x.longValue();
rlm@10 614 if(val > Long.MIN_VALUE)
rlm@10 615 return val - 1;
rlm@10 616 return BIGINTEGER_OPS.dec(x);
rlm@10 617 }
rlm@10 618 }
rlm@10 619
rlm@10 620 final static class FloatOps implements Ops{
rlm@10 621 public Ops combine(Ops y){
rlm@10 622 return y.opsWith(this);
rlm@10 623 }
rlm@10 624
rlm@10 625 final public Ops opsWith(IntegerOps x){
rlm@10 626 return this;
rlm@10 627 }
rlm@10 628
rlm@10 629 final public Ops opsWith(LongOps x){
rlm@10 630 return this;
rlm@10 631 }
rlm@10 632
rlm@10 633 final public Ops opsWith(FloatOps x){
rlm@10 634 return this;
rlm@10 635 }
rlm@10 636
rlm@10 637 final public Ops opsWith(DoubleOps x){
rlm@10 638 return DOUBLE_OPS;
rlm@10 639 }
rlm@10 640
rlm@10 641 final public Ops opsWith(RatioOps x){
rlm@10 642 return this;
rlm@10 643 }
rlm@10 644
rlm@10 645 final public Ops opsWith(BigIntegerOps x){
rlm@10 646 return this;
rlm@10 647 }
rlm@10 648
rlm@10 649 final public Ops opsWith(BigDecimalOps x){
rlm@10 650 return this;
rlm@10 651 }
rlm@10 652
rlm@10 653 public boolean isZero(Number x){
rlm@10 654 return x.floatValue() == 0;
rlm@10 655 }
rlm@10 656
rlm@10 657 public boolean isPos(Number x){
rlm@10 658 return x.floatValue() > 0;
rlm@10 659 }
rlm@10 660
rlm@10 661 public boolean isNeg(Number x){
rlm@10 662 return x.floatValue() < 0;
rlm@10 663 }
rlm@10 664
rlm@10 665 final public Number add(Number x, Number y){
rlm@10 666 return x.floatValue() + y.floatValue();
rlm@10 667 }
rlm@10 668
rlm@10 669 final public Number multiply(Number x, Number y){
rlm@10 670 return x.floatValue() * y.floatValue();
rlm@10 671 }
rlm@10 672
rlm@10 673 public Number divide(Number x, Number y){
rlm@10 674 return x.floatValue() / y.floatValue();
rlm@10 675 }
rlm@10 676
rlm@10 677 public Number quotient(Number x, Number y){
rlm@10 678 return Numbers.quotient(x.doubleValue(), y.doubleValue());
rlm@10 679 }
rlm@10 680
rlm@10 681 public Number remainder(Number x, Number y){
rlm@10 682 return Numbers.remainder(x.doubleValue(), y.doubleValue());
rlm@10 683 }
rlm@10 684
rlm@10 685 public boolean equiv(Number x, Number y){
rlm@10 686 return x.floatValue() == y.floatValue();
rlm@10 687 }
rlm@10 688
rlm@10 689 public boolean lt(Number x, Number y){
rlm@10 690 return x.floatValue() < y.floatValue();
rlm@10 691 }
rlm@10 692
rlm@10 693 //public Number subtract(Number x, Number y);
rlm@10 694 final public Number negate(Number x){
rlm@10 695 return -x.floatValue();
rlm@10 696 }
rlm@10 697
rlm@10 698 public Number inc(Number x){
rlm@10 699 return x.floatValue() + 1;
rlm@10 700 }
rlm@10 701
rlm@10 702 public Number dec(Number x){
rlm@10 703 return x.floatValue() - 1;
rlm@10 704 }
rlm@10 705 }
rlm@10 706
rlm@10 707 final static class DoubleOps implements Ops{
rlm@10 708 public Ops combine(Ops y){
rlm@10 709 return y.opsWith(this);
rlm@10 710 }
rlm@10 711
rlm@10 712 final public Ops opsWith(IntegerOps x){
rlm@10 713 return this;
rlm@10 714 }
rlm@10 715
rlm@10 716 final public Ops opsWith(LongOps x){
rlm@10 717 return this;
rlm@10 718 }
rlm@10 719
rlm@10 720 final public Ops opsWith(FloatOps x){
rlm@10 721 return this;
rlm@10 722 }
rlm@10 723
rlm@10 724 final public Ops opsWith(DoubleOps x){
rlm@10 725 return this;
rlm@10 726 }
rlm@10 727
rlm@10 728 final public Ops opsWith(RatioOps x){
rlm@10 729 return this;
rlm@10 730 }
rlm@10 731
rlm@10 732 final public Ops opsWith(BigIntegerOps x){
rlm@10 733 return this;
rlm@10 734 }
rlm@10 735
rlm@10 736 final public Ops opsWith(BigDecimalOps x){
rlm@10 737 return this;
rlm@10 738 }
rlm@10 739
rlm@10 740 public boolean isZero(Number x){
rlm@10 741 return x.doubleValue() == 0;
rlm@10 742 }
rlm@10 743
rlm@10 744 public boolean isPos(Number x){
rlm@10 745 return x.doubleValue() > 0;
rlm@10 746 }
rlm@10 747
rlm@10 748 public boolean isNeg(Number x){
rlm@10 749 return x.doubleValue() < 0;
rlm@10 750 }
rlm@10 751
rlm@10 752 final public Number add(Number x, Number y){
rlm@10 753 return x.doubleValue() + y.doubleValue();
rlm@10 754 }
rlm@10 755
rlm@10 756 final public Number multiply(Number x, Number y){
rlm@10 757 return x.doubleValue() * y.doubleValue();
rlm@10 758 }
rlm@10 759
rlm@10 760 public Number divide(Number x, Number y){
rlm@10 761 return x.doubleValue() / y.doubleValue();
rlm@10 762 }
rlm@10 763
rlm@10 764 public Number quotient(Number x, Number y){
rlm@10 765 return Numbers.quotient(x.doubleValue(), y.doubleValue());
rlm@10 766 }
rlm@10 767
rlm@10 768 public Number remainder(Number x, Number y){
rlm@10 769 return Numbers.remainder(x.doubleValue(), y.doubleValue());
rlm@10 770 }
rlm@10 771
rlm@10 772 public boolean equiv(Number x, Number y){
rlm@10 773 return x.doubleValue() == y.doubleValue();
rlm@10 774 }
rlm@10 775
rlm@10 776 public boolean lt(Number x, Number y){
rlm@10 777 return x.doubleValue() < y.doubleValue();
rlm@10 778 }
rlm@10 779
rlm@10 780 //public Number subtract(Number x, Number y);
rlm@10 781 final public Number negate(Number x){
rlm@10 782 return -x.doubleValue();
rlm@10 783 }
rlm@10 784
rlm@10 785 public Number inc(Number x){
rlm@10 786 return x.doubleValue() + 1;
rlm@10 787 }
rlm@10 788
rlm@10 789 public Number dec(Number x){
rlm@10 790 return x.doubleValue() - 1;
rlm@10 791 }
rlm@10 792 }
rlm@10 793
rlm@10 794 final static class RatioOps implements Ops{
rlm@10 795 public Ops combine(Ops y){
rlm@10 796 return y.opsWith(this);
rlm@10 797 }
rlm@10 798
rlm@10 799 final public Ops opsWith(IntegerOps x){
rlm@10 800 return this;
rlm@10 801 }
rlm@10 802
rlm@10 803 final public Ops opsWith(LongOps x){
rlm@10 804 return this;
rlm@10 805 }
rlm@10 806
rlm@10 807 final public Ops opsWith(FloatOps x){
rlm@10 808 return FLOAT_OPS;
rlm@10 809 }
rlm@10 810
rlm@10 811 final public Ops opsWith(DoubleOps x){
rlm@10 812 return DOUBLE_OPS;
rlm@10 813 }
rlm@10 814
rlm@10 815 final public Ops opsWith(RatioOps x){
rlm@10 816 return this;
rlm@10 817 }
rlm@10 818
rlm@10 819 final public Ops opsWith(BigIntegerOps x){
rlm@10 820 return this;
rlm@10 821 }
rlm@10 822
rlm@10 823 final public Ops opsWith(BigDecimalOps x){
rlm@10 824 return this;
rlm@10 825 }
rlm@10 826
rlm@10 827 public boolean isZero(Number x){
rlm@10 828 Ratio r = (Ratio) x;
rlm@10 829 return r.numerator.signum() == 0;
rlm@10 830 }
rlm@10 831
rlm@10 832 public boolean isPos(Number x){
rlm@10 833 Ratio r = (Ratio) x;
rlm@10 834 return r.numerator.signum() > 0;
rlm@10 835 }
rlm@10 836
rlm@10 837 public boolean isNeg(Number x){
rlm@10 838 Ratio r = (Ratio) x;
rlm@10 839 return r.numerator.signum() < 0;
rlm@10 840 }
rlm@10 841
rlm@10 842 final public Number add(Number x, Number y){
rlm@10 843 Ratio rx = toRatio(x);
rlm@10 844 Ratio ry = toRatio(y);
rlm@10 845 return divide(ry.numerator.multiply(rx.denominator)
rlm@10 846 .add(rx.numerator.multiply(ry.denominator))
rlm@10 847 , ry.denominator.multiply(rx.denominator));
rlm@10 848 }
rlm@10 849
rlm@10 850 final public Number multiply(Number x, Number y){
rlm@10 851 Ratio rx = toRatio(x);
rlm@10 852 Ratio ry = toRatio(y);
rlm@10 853 return Numbers.divide(ry.numerator.multiply(rx.numerator)
rlm@10 854 , ry.denominator.multiply(rx.denominator));
rlm@10 855 }
rlm@10 856
rlm@10 857 public Number divide(Number x, Number y){
rlm@10 858 Ratio rx = toRatio(x);
rlm@10 859 Ratio ry = toRatio(y);
rlm@10 860 return Numbers.divide(ry.denominator.multiply(rx.numerator)
rlm@10 861 , ry.numerator.multiply(rx.denominator));
rlm@10 862 }
rlm@10 863
rlm@10 864 public Number quotient(Number x, Number y){
rlm@10 865 Ratio rx = toRatio(x);
rlm@10 866 Ratio ry = toRatio(y);
rlm@10 867 BigInteger q = rx.numerator.multiply(ry.denominator).divide(
rlm@10 868 rx.denominator.multiply(ry.numerator));
rlm@10 869 return reduce(q);
rlm@10 870 }
rlm@10 871
rlm@10 872 public Number remainder(Number x, Number y){
rlm@10 873 Ratio rx = toRatio(x);
rlm@10 874 Ratio ry = toRatio(y);
rlm@10 875 BigInteger q = rx.numerator.multiply(ry.denominator).divide(
rlm@10 876 rx.denominator.multiply(ry.numerator));
rlm@10 877 return Numbers.minus(x, Numbers.multiply(q, y));
rlm@10 878 }
rlm@10 879
rlm@10 880 public boolean equiv(Number x, Number y){
rlm@10 881 Ratio rx = toRatio(x);
rlm@10 882 Ratio ry = toRatio(y);
rlm@10 883 return rx.numerator.equals(ry.numerator)
rlm@10 884 && rx.denominator.equals(ry.denominator);
rlm@10 885 }
rlm@10 886
rlm@10 887 public boolean lt(Number x, Number y){
rlm@10 888 Ratio rx = toRatio(x);
rlm@10 889 Ratio ry = toRatio(y);
rlm@10 890 return Numbers.lt(rx.numerator.multiply(ry.denominator), ry.numerator.multiply(rx.denominator));
rlm@10 891 }
rlm@10 892
rlm@10 893 //public Number subtract(Number x, Number y);
rlm@10 894 final public Number negate(Number x){
rlm@10 895 Ratio r = (Ratio) x;
rlm@10 896 return new Ratio(r.numerator.negate(), r.denominator);
rlm@10 897 }
rlm@10 898
rlm@10 899 public Number inc(Number x){
rlm@10 900 return Numbers.add(x, 1);
rlm@10 901 }
rlm@10 902
rlm@10 903 public Number dec(Number x){
rlm@10 904 return Numbers.add(x, -1);
rlm@10 905 }
rlm@10 906
rlm@10 907 }
rlm@10 908
rlm@10 909 final static class BigIntegerOps implements Ops{
rlm@10 910 public Ops combine(Ops y){
rlm@10 911 return y.opsWith(this);
rlm@10 912 }
rlm@10 913
rlm@10 914 final public Ops opsWith(IntegerOps x){
rlm@10 915 return this;
rlm@10 916 }
rlm@10 917
rlm@10 918 final public Ops opsWith(LongOps x){
rlm@10 919 return this;
rlm@10 920 }
rlm@10 921
rlm@10 922 final public Ops opsWith(FloatOps x){
rlm@10 923 return FLOAT_OPS;
rlm@10 924 }
rlm@10 925
rlm@10 926 final public Ops opsWith(DoubleOps x){
rlm@10 927 return DOUBLE_OPS;
rlm@10 928 }
rlm@10 929
rlm@10 930 final public Ops opsWith(RatioOps x){
rlm@10 931 return RATIO_OPS;
rlm@10 932 }
rlm@10 933
rlm@10 934 final public Ops opsWith(BigIntegerOps x){
rlm@10 935 return this;
rlm@10 936 }
rlm@10 937
rlm@10 938 final public Ops opsWith(BigDecimalOps x){
rlm@10 939 return BIGDECIMAL_OPS;
rlm@10 940 }
rlm@10 941
rlm@10 942 public boolean isZero(Number x){
rlm@10 943 BigInteger bx = toBigInteger(x);
rlm@10 944 return bx.signum() == 0;
rlm@10 945 }
rlm@10 946
rlm@10 947 public boolean isPos(Number x){
rlm@10 948 BigInteger bx = toBigInteger(x);
rlm@10 949 return bx.signum() > 0;
rlm@10 950 }
rlm@10 951
rlm@10 952 public boolean isNeg(Number x){
rlm@10 953 BigInteger bx = toBigInteger(x);
rlm@10 954 return bx.signum() < 0;
rlm@10 955 }
rlm@10 956
rlm@10 957 final public Number add(Number x, Number y){
rlm@10 958 return reduce(toBigInteger(x).add(toBigInteger(y)));
rlm@10 959 }
rlm@10 960
rlm@10 961 final public Number multiply(Number x, Number y){
rlm@10 962 return reduce(toBigInteger(x).multiply(toBigInteger(y)));
rlm@10 963 }
rlm@10 964
rlm@10 965 public Number divide(Number x, Number y){
rlm@10 966 return Numbers.divide(toBigInteger(x), toBigInteger(y));
rlm@10 967 }
rlm@10 968
rlm@10 969 public Number quotient(Number x, Number y){
rlm@10 970 return toBigInteger(x).divide(toBigInteger(y));
rlm@10 971 }
rlm@10 972
rlm@10 973 public Number remainder(Number x, Number y){
rlm@10 974 return toBigInteger(x).remainder(toBigInteger(y));
rlm@10 975 }
rlm@10 976
rlm@10 977 public boolean equiv(Number x, Number y){
rlm@10 978 return toBigInteger(x).equals(toBigInteger(y));
rlm@10 979 }
rlm@10 980
rlm@10 981 public boolean lt(Number x, Number y){
rlm@10 982 return toBigInteger(x).compareTo(toBigInteger(y)) < 0;
rlm@10 983 }
rlm@10 984
rlm@10 985 //public Number subtract(Number x, Number y);
rlm@10 986 final public Number negate(Number x){
rlm@10 987 return toBigInteger(x).negate();
rlm@10 988 }
rlm@10 989
rlm@10 990 public Number inc(Number x){
rlm@10 991 BigInteger bx = toBigInteger(x);
rlm@10 992 return reduce(bx.add(BigInteger.ONE));
rlm@10 993 }
rlm@10 994
rlm@10 995 public Number dec(Number x){
rlm@10 996 BigInteger bx = toBigInteger(x);
rlm@10 997 return reduce(bx.subtract(BigInteger.ONE));
rlm@10 998 }
rlm@10 999 }
rlm@10 1000
rlm@10 1001 final static class BigDecimalOps implements Ops{
rlm@10 1002 final static Var MATH_CONTEXT = RT.MATH_CONTEXT;
rlm@10 1003
rlm@10 1004 public Ops combine(Ops y){
rlm@10 1005 return y.opsWith(this);
rlm@10 1006 }
rlm@10 1007
rlm@10 1008 final public Ops opsWith(IntegerOps x){
rlm@10 1009 return this;
rlm@10 1010 }
rlm@10 1011
rlm@10 1012 final public Ops opsWith(LongOps x){
rlm@10 1013 return this;
rlm@10 1014 }
rlm@10 1015
rlm@10 1016 final public Ops opsWith(FloatOps x){
rlm@10 1017 return FLOAT_OPS;
rlm@10 1018 }
rlm@10 1019
rlm@10 1020 final public Ops opsWith(DoubleOps x){
rlm@10 1021 return DOUBLE_OPS;
rlm@10 1022 }
rlm@10 1023
rlm@10 1024 final public Ops opsWith(RatioOps x){
rlm@10 1025 return RATIO_OPS;
rlm@10 1026 }
rlm@10 1027
rlm@10 1028 final public Ops opsWith(BigIntegerOps x){
rlm@10 1029 return this;
rlm@10 1030 }
rlm@10 1031
rlm@10 1032 final public Ops opsWith(BigDecimalOps x){
rlm@10 1033 return this;
rlm@10 1034 }
rlm@10 1035
rlm@10 1036 public boolean isZero(Number x){
rlm@10 1037 BigDecimal bx = (BigDecimal) x;
rlm@10 1038 return bx.signum() == 0;
rlm@10 1039 }
rlm@10 1040
rlm@10 1041 public boolean isPos(Number x){
rlm@10 1042 BigDecimal bx = (BigDecimal) x;
rlm@10 1043 return bx.signum() > 0;
rlm@10 1044 }
rlm@10 1045
rlm@10 1046 public boolean isNeg(Number x){
rlm@10 1047 BigDecimal bx = (BigDecimal) x;
rlm@10 1048 return bx.signum() < 0;
rlm@10 1049 }
rlm@10 1050
rlm@10 1051 final public Number add(Number x, Number y){
rlm@10 1052 MathContext mc = (MathContext) MATH_CONTEXT.deref();
rlm@10 1053 return mc == null
rlm@10 1054 ? toBigDecimal(x).add(toBigDecimal(y))
rlm@10 1055 : toBigDecimal(x).add(toBigDecimal(y), mc);
rlm@10 1056 }
rlm@10 1057
rlm@10 1058 final public Number multiply(Number x, Number y){
rlm@10 1059 MathContext mc = (MathContext) MATH_CONTEXT.deref();
rlm@10 1060 return mc == null
rlm@10 1061 ? toBigDecimal(x).multiply(toBigDecimal(y))
rlm@10 1062 : toBigDecimal(x).multiply(toBigDecimal(y), mc);
rlm@10 1063 }
rlm@10 1064
rlm@10 1065 public Number divide(Number x, Number y){
rlm@10 1066 MathContext mc = (MathContext) MATH_CONTEXT.deref();
rlm@10 1067 return mc == null
rlm@10 1068 ? toBigDecimal(x).divide(toBigDecimal(y))
rlm@10 1069 : toBigDecimal(x).divide(toBigDecimal(y), mc);
rlm@10 1070 }
rlm@10 1071
rlm@10 1072 public Number quotient(Number x, Number y){
rlm@10 1073 MathContext mc = (MathContext) MATH_CONTEXT.deref();
rlm@10 1074 return mc == null
rlm@10 1075 ? toBigDecimal(x).divideToIntegralValue(toBigDecimal(y))
rlm@10 1076 : toBigDecimal(x).divideToIntegralValue(toBigDecimal(y), mc);
rlm@10 1077 }
rlm@10 1078
rlm@10 1079 public Number remainder(Number x, Number y){
rlm@10 1080 MathContext mc = (MathContext) MATH_CONTEXT.deref();
rlm@10 1081 return mc == null
rlm@10 1082 ? toBigDecimal(x).remainder(toBigDecimal(y))
rlm@10 1083 : toBigDecimal(x).remainder(toBigDecimal(y), mc);
rlm@10 1084 }
rlm@10 1085
rlm@10 1086 public boolean equiv(Number x, Number y){
rlm@10 1087 return toBigDecimal(x).equals(toBigDecimal(y));
rlm@10 1088 }
rlm@10 1089
rlm@10 1090 public boolean lt(Number x, Number y){
rlm@10 1091 return toBigDecimal(x).compareTo(toBigDecimal(y)) < 0;
rlm@10 1092 }
rlm@10 1093
rlm@10 1094 //public Number subtract(Number x, Number y);
rlm@10 1095 final public Number negate(Number x){
rlm@10 1096 MathContext mc = (MathContext) MATH_CONTEXT.deref();
rlm@10 1097 return mc == null
rlm@10 1098 ? ((BigDecimal) x).negate()
rlm@10 1099 : ((BigDecimal) x).negate(mc);
rlm@10 1100 }
rlm@10 1101
rlm@10 1102 public Number inc(Number x){
rlm@10 1103 MathContext mc = (MathContext) MATH_CONTEXT.deref();
rlm@10 1104 BigDecimal bx = (BigDecimal) x;
rlm@10 1105 return mc == null
rlm@10 1106 ? bx.add(BigDecimal.ONE)
rlm@10 1107 : bx.add(BigDecimal.ONE, mc);
rlm@10 1108 }
rlm@10 1109
rlm@10 1110 public Number dec(Number x){
rlm@10 1111 MathContext mc = (MathContext) MATH_CONTEXT.deref();
rlm@10 1112 BigDecimal bx = (BigDecimal) x;
rlm@10 1113 return mc == null
rlm@10 1114 ? bx.subtract(BigDecimal.ONE)
rlm@10 1115 : bx.subtract(BigDecimal.ONE, mc);
rlm@10 1116 }
rlm@10 1117 }
rlm@10 1118
rlm@10 1119 final static class IntegerBitOps implements BitOps{
rlm@10 1120 public BitOps combine(BitOps y){
rlm@10 1121 return y.bitOpsWith(this);
rlm@10 1122 }
rlm@10 1123
rlm@10 1124 final public BitOps bitOpsWith(IntegerBitOps x){
rlm@10 1125 return this;
rlm@10 1126 }
rlm@10 1127
rlm@10 1128 final public BitOps bitOpsWith(LongBitOps x){
rlm@10 1129 return LONG_BITOPS;
rlm@10 1130 }
rlm@10 1131
rlm@10 1132 final public BitOps bitOpsWith(BigIntegerBitOps x){
rlm@10 1133 return BIGINTEGER_BITOPS;
rlm@10 1134 }
rlm@10 1135
rlm@10 1136
rlm@10 1137 public Number not(Number x){
rlm@10 1138 return ~x.intValue();
rlm@10 1139 }
rlm@10 1140
rlm@10 1141 public Number and(Number x, Number y){
rlm@10 1142 return x.intValue() & y.intValue();
rlm@10 1143 }
rlm@10 1144
rlm@10 1145 public Number or(Number x, Number y){
rlm@10 1146 return x.intValue() | y.intValue();
rlm@10 1147 }
rlm@10 1148
rlm@10 1149 public Number xor(Number x, Number y){
rlm@10 1150 return x.intValue() ^ y.intValue();
rlm@10 1151 }
rlm@10 1152
rlm@10 1153 public Number andNot(Number x, Number y){
rlm@10 1154 return x.intValue() & ~y.intValue();
rlm@10 1155 }
rlm@10 1156
rlm@10 1157 public Number clearBit(Number x, int n){
rlm@10 1158 if(n < 31)
rlm@10 1159 return x.intValue() & ~(1 << n);
rlm@10 1160 else if(n < 63)
rlm@10 1161 return x.longValue() & ~(1L << n);
rlm@10 1162 else
rlm@10 1163 return toBigInteger(x).clearBit(n);
rlm@10 1164 }
rlm@10 1165
rlm@10 1166 public Number setBit(Number x, int n){
rlm@10 1167 if(n < 31)
rlm@10 1168 return x.intValue() | (1 << n);
rlm@10 1169 else if(n < 63)
rlm@10 1170 return x.longValue() | (1L << n);
rlm@10 1171 else
rlm@10 1172 return toBigInteger(x).setBit(n);
rlm@10 1173 }
rlm@10 1174
rlm@10 1175 public Number flipBit(Number x, int n){
rlm@10 1176 if(n < 31)
rlm@10 1177 return x.intValue() ^ (1 << n);
rlm@10 1178 else if(n < 63)
rlm@10 1179 return x.longValue() ^ (1L << n);
rlm@10 1180 else
rlm@10 1181 return toBigInteger(x).flipBit(n);
rlm@10 1182 }
rlm@10 1183
rlm@10 1184 public boolean testBit(Number x, int n){
rlm@10 1185 if(n < 32)
rlm@10 1186 return (x.intValue() & (1 << n)) != 0;
rlm@10 1187 else if(n < 64)
rlm@10 1188 return (x.longValue() & (1L << n)) != 0;
rlm@10 1189 else
rlm@10 1190 return toBigInteger(x).testBit(n);
rlm@10 1191 }
rlm@10 1192
rlm@10 1193 public Number shiftLeft(Number x, int n){
rlm@10 1194 if(n < 32)
rlm@10 1195 {
rlm@10 1196 if(n < 0)
rlm@10 1197 return shiftRight(x, -n);
rlm@10 1198 return reduce(x.longValue() << n);
rlm@10 1199 }
rlm@10 1200 else
rlm@10 1201 return reduce(toBigInteger(x).shiftLeft(n));
rlm@10 1202 }
rlm@10 1203
rlm@10 1204 public Number shiftRight(Number x, int n){
rlm@10 1205 if(n < 0)
rlm@10 1206 return shiftLeft(x, -n);
rlm@10 1207 return x.intValue() >> n;
rlm@10 1208 }
rlm@10 1209 }
rlm@10 1210
rlm@10 1211 final static class LongBitOps implements BitOps{
rlm@10 1212 public BitOps combine(BitOps y){
rlm@10 1213 return y.bitOpsWith(this);
rlm@10 1214 }
rlm@10 1215
rlm@10 1216 final public BitOps bitOpsWith(IntegerBitOps x){
rlm@10 1217 return this;
rlm@10 1218 }
rlm@10 1219
rlm@10 1220 final public BitOps bitOpsWith(LongBitOps x){
rlm@10 1221 return this;
rlm@10 1222 }
rlm@10 1223
rlm@10 1224 final public BitOps bitOpsWith(BigIntegerBitOps x){
rlm@10 1225 return BIGINTEGER_BITOPS;
rlm@10 1226 }
rlm@10 1227
rlm@10 1228 public Number not(Number x){
rlm@10 1229 return ~x.longValue();
rlm@10 1230 }
rlm@10 1231
rlm@10 1232 public Number and(Number x, Number y){
rlm@10 1233 return x.longValue() & y.longValue();
rlm@10 1234 }
rlm@10 1235
rlm@10 1236 public Number or(Number x, Number y){
rlm@10 1237 return x.longValue() | y.longValue();
rlm@10 1238 }
rlm@10 1239
rlm@10 1240 public Number xor(Number x, Number y){
rlm@10 1241 return x.longValue() ^ y.longValue();
rlm@10 1242 }
rlm@10 1243
rlm@10 1244 public Number andNot(Number x, Number y){
rlm@10 1245 return x.longValue() & ~y.longValue();
rlm@10 1246 }
rlm@10 1247
rlm@10 1248 public Number clearBit(Number x, int n){
rlm@10 1249 if(n < 63)
rlm@10 1250 return x.longValue() & ~(1L << n);
rlm@10 1251 else
rlm@10 1252 return toBigInteger(x).clearBit(n);
rlm@10 1253 }
rlm@10 1254
rlm@10 1255 public Number setBit(Number x, int n){
rlm@10 1256 if(n < 63)
rlm@10 1257 return x.longValue() | (1L << n);
rlm@10 1258 else
rlm@10 1259 return toBigInteger(x).setBit(n);
rlm@10 1260 }
rlm@10 1261
rlm@10 1262 public Number flipBit(Number x, int n){
rlm@10 1263 if(n < 63)
rlm@10 1264 return x.longValue() ^ (1L << n);
rlm@10 1265 else
rlm@10 1266 return toBigInteger(x).flipBit(n);
rlm@10 1267 }
rlm@10 1268
rlm@10 1269 public boolean testBit(Number x, int n){
rlm@10 1270 if(n < 64)
rlm@10 1271 return (x.longValue() & (1L << n)) != 0;
rlm@10 1272 else
rlm@10 1273 return toBigInteger(x).testBit(n);
rlm@10 1274 }
rlm@10 1275
rlm@10 1276 public Number shiftLeft(Number x, int n){
rlm@10 1277 if(n < 0)
rlm@10 1278 return shiftRight(x, -n);
rlm@10 1279 return reduce(toBigInteger(x).shiftLeft(n));
rlm@10 1280 }
rlm@10 1281
rlm@10 1282 public Number shiftRight(Number x, int n){
rlm@10 1283 if(n < 0)
rlm@10 1284 return shiftLeft(x, -n);
rlm@10 1285 return x.longValue() >> n;
rlm@10 1286 }
rlm@10 1287 }
rlm@10 1288
rlm@10 1289 final static class BigIntegerBitOps implements BitOps{
rlm@10 1290 public BitOps combine(BitOps y){
rlm@10 1291 return y.bitOpsWith(this);
rlm@10 1292 }
rlm@10 1293
rlm@10 1294 final public BitOps bitOpsWith(IntegerBitOps x){
rlm@10 1295 return this;
rlm@10 1296 }
rlm@10 1297
rlm@10 1298 final public BitOps bitOpsWith(LongBitOps x){
rlm@10 1299 return this;
rlm@10 1300 }
rlm@10 1301
rlm@10 1302 final public BitOps bitOpsWith(BigIntegerBitOps x){
rlm@10 1303 return this;
rlm@10 1304 }
rlm@10 1305
rlm@10 1306 public Number not(Number x){
rlm@10 1307 return toBigInteger(x).not();
rlm@10 1308 }
rlm@10 1309
rlm@10 1310 public Number and(Number x, Number y){
rlm@10 1311 return toBigInteger(x).and(toBigInteger(y));
rlm@10 1312 }
rlm@10 1313
rlm@10 1314 public Number or(Number x, Number y){
rlm@10 1315 return toBigInteger(x).or(toBigInteger(y));
rlm@10 1316 }
rlm@10 1317
rlm@10 1318 public Number xor(Number x, Number y){
rlm@10 1319 return toBigInteger(x).xor(toBigInteger(y));
rlm@10 1320 }
rlm@10 1321
rlm@10 1322 public Number andNot(Number x, Number y){
rlm@10 1323 return toBigInteger(x).andNot(toBigInteger(y));
rlm@10 1324 }
rlm@10 1325
rlm@10 1326 public Number clearBit(Number x, int n){
rlm@10 1327 return toBigInteger(x).clearBit(n);
rlm@10 1328 }
rlm@10 1329
rlm@10 1330 public Number setBit(Number x, int n){
rlm@10 1331 return toBigInteger(x).setBit(n);
rlm@10 1332 }
rlm@10 1333
rlm@10 1334 public Number flipBit(Number x, int n){
rlm@10 1335 return toBigInteger(x).flipBit(n);
rlm@10 1336 }
rlm@10 1337
rlm@10 1338 public boolean testBit(Number x, int n){
rlm@10 1339 return toBigInteger(x).testBit(n);
rlm@10 1340 }
rlm@10 1341
rlm@10 1342 public Number shiftLeft(Number x, int n){
rlm@10 1343 return toBigInteger(x).shiftLeft(n);
rlm@10 1344 }
rlm@10 1345
rlm@10 1346 public Number shiftRight(Number x, int n){
rlm@10 1347 return toBigInteger(x).shiftRight(n);
rlm@10 1348 }
rlm@10 1349 }
rlm@10 1350
rlm@10 1351 static final IntegerOps INTEGER_OPS = new IntegerOps();
rlm@10 1352 static final LongOps LONG_OPS = new LongOps();
rlm@10 1353 static final FloatOps FLOAT_OPS = new FloatOps();
rlm@10 1354 static final DoubleOps DOUBLE_OPS = new DoubleOps();
rlm@10 1355 static final RatioOps RATIO_OPS = new RatioOps();
rlm@10 1356 static final BigIntegerOps BIGINTEGER_OPS = new BigIntegerOps();
rlm@10 1357 static final BigDecimalOps BIGDECIMAL_OPS = new BigDecimalOps();
rlm@10 1358
rlm@10 1359 static final IntegerBitOps INTEGER_BITOPS = new IntegerBitOps();
rlm@10 1360 static final LongBitOps LONG_BITOPS = new LongBitOps();
rlm@10 1361 static final BigIntegerBitOps BIGINTEGER_BITOPS = new BigIntegerBitOps();
rlm@10 1362
rlm@10 1363 static Ops ops(Object x){
rlm@10 1364 Class xc = x.getClass();
rlm@10 1365
rlm@10 1366 if(xc == Integer.class)
rlm@10 1367 return INTEGER_OPS;
rlm@10 1368 else if(xc == Double.class)
rlm@10 1369 return DOUBLE_OPS;
rlm@10 1370 else if(xc == Float.class)
rlm@10 1371 return FLOAT_OPS;
rlm@10 1372 else if(xc == BigInteger.class)
rlm@10 1373 return BIGINTEGER_OPS;
rlm@10 1374 else if(xc == Long.class)
rlm@10 1375 return LONG_OPS;
rlm@10 1376 else if(xc == Ratio.class)
rlm@10 1377 return RATIO_OPS;
rlm@10 1378 else if(xc == BigDecimal.class)
rlm@10 1379 return BIGDECIMAL_OPS;
rlm@10 1380 else
rlm@10 1381 return INTEGER_OPS;
rlm@10 1382 }
rlm@10 1383
rlm@10 1384 static BitOps bitOps(Object x){
rlm@10 1385 Class xc = x.getClass();
rlm@10 1386
rlm@10 1387 if(xc == Integer.class)
rlm@10 1388 return INTEGER_BITOPS;
rlm@10 1389 else if(xc == Long.class)
rlm@10 1390 return LONG_BITOPS;
rlm@10 1391 else if(xc == BigInteger.class)
rlm@10 1392 return BIGINTEGER_BITOPS;
rlm@10 1393 else if(xc == Double.class || xc == Float.class || xc == BigDecimalOps.class || xc == Ratio.class)
rlm@10 1394 throw new ArithmeticException("bit operation on non integer type: " + xc);
rlm@10 1395 else
rlm@10 1396 return INTEGER_BITOPS;
rlm@10 1397 }
rlm@10 1398
rlm@10 1399 //final static ExecutorService executor = Executors.newCachedThreadPool();
rlm@10 1400 //static public int minChunk = 100;
rlm@10 1401 //static int chunkSize(int alength){
rlm@10 1402 // return Math.max(alength / Runtime.getRuntime().availableProcessors(), minChunk);
rlm@10 1403 //}
rlm@10 1404
rlm@10 1405 // }
rlm@10 1406 // else
rlm@10 1407 // {
rlm@10 1408 // LinkedList<Callable<Float>> ops = new LinkedList<Callable<Float>>();
rlm@10 1409 // for(int offset = 0;offset < xs.length;offset+=chunk)
rlm@10 1410 // {
rlm@10 1411 // final int start = offset;
rlm@10 1412 // final int end = Math.min(xs.length, start + chunk);
rlm@10 1413 // ops.add(new Callable<Float>(){
rlm@10 1414 // public Float call() throws Exception{
rlm@10 1415 // for(int i=start;i<end;i++)
rlm@10 1416 // xs[i] += ys[i];
rlm@10 1417 // return null;
rlm@10 1418 // }});
rlm@10 1419 // }
rlm@10 1420 // executor.invokeAll(ops);
rlm@10 1421 // }
rlm@10 1422
rlm@10 1423
rlm@10 1424 static public float[] float_array(int size, Object init){
rlm@10 1425 float[] ret = new float[size];
rlm@10 1426 if(init instanceof Number)
rlm@10 1427 {
rlm@10 1428 float f = ((Number) init).floatValue();
rlm@10 1429 for(int i = 0; i < ret.length; i++)
rlm@10 1430 ret[i] = f;
rlm@10 1431 }
rlm@10 1432 else
rlm@10 1433 {
rlm@10 1434 ISeq s = RT.seq(init);
rlm@10 1435 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1436 ret[i] = ((Number) s.first()).floatValue();
rlm@10 1437 }
rlm@10 1438 return ret;
rlm@10 1439 }
rlm@10 1440
rlm@10 1441 static public float[] float_array(Object sizeOrSeq){
rlm@10 1442 if(sizeOrSeq instanceof Number)
rlm@10 1443 return new float[((Number) sizeOrSeq).intValue()];
rlm@10 1444 else
rlm@10 1445 {
rlm@10 1446 ISeq s = RT.seq(sizeOrSeq);
rlm@10 1447 int size = RT.count(s);
rlm@10 1448 float[] ret = new float[size];
rlm@10 1449 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1450 ret[i] = ((Number) s.first()).floatValue();
rlm@10 1451 return ret;
rlm@10 1452 }
rlm@10 1453 }
rlm@10 1454
rlm@10 1455 static public double[] double_array(int size, Object init){
rlm@10 1456 double[] ret = new double[size];
rlm@10 1457 if(init instanceof Number)
rlm@10 1458 {
rlm@10 1459 double f = ((Number) init).doubleValue();
rlm@10 1460 for(int i = 0; i < ret.length; i++)
rlm@10 1461 ret[i] = f;
rlm@10 1462 }
rlm@10 1463 else
rlm@10 1464 {
rlm@10 1465 ISeq s = RT.seq(init);
rlm@10 1466 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1467 ret[i] = ((Number) s.first()).doubleValue();
rlm@10 1468 }
rlm@10 1469 return ret;
rlm@10 1470 }
rlm@10 1471
rlm@10 1472 static public double[] double_array(Object sizeOrSeq){
rlm@10 1473 if(sizeOrSeq instanceof Number)
rlm@10 1474 return new double[((Number) sizeOrSeq).intValue()];
rlm@10 1475 else
rlm@10 1476 {
rlm@10 1477 ISeq s = RT.seq(sizeOrSeq);
rlm@10 1478 int size = RT.count(s);
rlm@10 1479 double[] ret = new double[size];
rlm@10 1480 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1481 ret[i] = ((Number) s.first()).doubleValue();
rlm@10 1482 return ret;
rlm@10 1483 }
rlm@10 1484 }
rlm@10 1485
rlm@10 1486 static public int[] int_array(int size, Object init){
rlm@10 1487 int[] ret = new int[size];
rlm@10 1488 if(init instanceof Number)
rlm@10 1489 {
rlm@10 1490 int f = ((Number) init).intValue();
rlm@10 1491 for(int i = 0; i < ret.length; i++)
rlm@10 1492 ret[i] = f;
rlm@10 1493 }
rlm@10 1494 else
rlm@10 1495 {
rlm@10 1496 ISeq s = RT.seq(init);
rlm@10 1497 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1498 ret[i] = ((Number) s.first()).intValue();
rlm@10 1499 }
rlm@10 1500 return ret;
rlm@10 1501 }
rlm@10 1502
rlm@10 1503 static public int[] int_array(Object sizeOrSeq){
rlm@10 1504 if(sizeOrSeq instanceof Number)
rlm@10 1505 return new int[((Number) sizeOrSeq).intValue()];
rlm@10 1506 else
rlm@10 1507 {
rlm@10 1508 ISeq s = RT.seq(sizeOrSeq);
rlm@10 1509 int size = RT.count(s);
rlm@10 1510 int[] ret = new int[size];
rlm@10 1511 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1512 ret[i] = ((Number) s.first()).intValue();
rlm@10 1513 return ret;
rlm@10 1514 }
rlm@10 1515 }
rlm@10 1516
rlm@10 1517 static public long[] long_array(int size, Object init){
rlm@10 1518 long[] ret = new long[size];
rlm@10 1519 if(init instanceof Number)
rlm@10 1520 {
rlm@10 1521 long f = ((Number) init).longValue();
rlm@10 1522 for(int i = 0; i < ret.length; i++)
rlm@10 1523 ret[i] = f;
rlm@10 1524 }
rlm@10 1525 else
rlm@10 1526 {
rlm@10 1527 ISeq s = RT.seq(init);
rlm@10 1528 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1529 ret[i] = ((Number) s.first()).longValue();
rlm@10 1530 }
rlm@10 1531 return ret;
rlm@10 1532 }
rlm@10 1533
rlm@10 1534 static public long[] long_array(Object sizeOrSeq){
rlm@10 1535 if(sizeOrSeq instanceof Number)
rlm@10 1536 return new long[((Number) sizeOrSeq).intValue()];
rlm@10 1537 else
rlm@10 1538 {
rlm@10 1539 ISeq s = RT.seq(sizeOrSeq);
rlm@10 1540 int size = RT.count(s);
rlm@10 1541 long[] ret = new long[size];
rlm@10 1542 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1543 ret[i] = ((Number) s.first()).longValue();
rlm@10 1544 return ret;
rlm@10 1545 }
rlm@10 1546 }
rlm@10 1547
rlm@10 1548 static public short[] short_array(int size, Object init){
rlm@10 1549 short[] ret = new short[size];
rlm@10 1550 if(init instanceof Short)
rlm@10 1551 {
rlm@10 1552 short s = (Short) init;
rlm@10 1553 for(int i = 0; i < ret.length; i++)
rlm@10 1554 ret[i] = s;
rlm@10 1555 }
rlm@10 1556 else
rlm@10 1557 {
rlm@10 1558 ISeq s = RT.seq(init);
rlm@10 1559 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1560 ret[i] = (Short) s.first();
rlm@10 1561 }
rlm@10 1562 return ret;
rlm@10 1563 }
rlm@10 1564
rlm@10 1565 static public short[] short_array(Object sizeOrSeq){
rlm@10 1566 if(sizeOrSeq instanceof Number)
rlm@10 1567 return new short[((Number) sizeOrSeq).intValue()];
rlm@10 1568 else
rlm@10 1569 {
rlm@10 1570 ISeq s = RT.seq(sizeOrSeq);
rlm@10 1571 int size = RT.count(s);
rlm@10 1572 short[] ret = new short[size];
rlm@10 1573 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1574 ret[i] = (Short) s.first();
rlm@10 1575 return ret;
rlm@10 1576 }
rlm@10 1577 }
rlm@10 1578
rlm@10 1579 static public char[] char_array(int size, Object init){
rlm@10 1580 char[] ret = new char[size];
rlm@10 1581 if(init instanceof Character)
rlm@10 1582 {
rlm@10 1583 char c = (Character) init;
rlm@10 1584 for(int i = 0; i < ret.length; i++)
rlm@10 1585 ret[i] = c;
rlm@10 1586 }
rlm@10 1587 else
rlm@10 1588 {
rlm@10 1589 ISeq s = RT.seq(init);
rlm@10 1590 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1591 ret[i] = (Character) s.first();
rlm@10 1592 }
rlm@10 1593 return ret;
rlm@10 1594 }
rlm@10 1595
rlm@10 1596 static public char[] char_array(Object sizeOrSeq){
rlm@10 1597 if(sizeOrSeq instanceof Number)
rlm@10 1598 return new char[((Number) sizeOrSeq).intValue()];
rlm@10 1599 else
rlm@10 1600 {
rlm@10 1601 ISeq s = RT.seq(sizeOrSeq);
rlm@10 1602 int size = RT.count(s);
rlm@10 1603 char[] ret = new char[size];
rlm@10 1604 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1605 ret[i] = (Character) s.first();
rlm@10 1606 return ret;
rlm@10 1607 }
rlm@10 1608 }
rlm@10 1609
rlm@10 1610 static public byte[] byte_array(int size, Object init){
rlm@10 1611 byte[] ret = new byte[size];
rlm@10 1612 if(init instanceof Byte)
rlm@10 1613 {
rlm@10 1614 byte b = (Byte) init;
rlm@10 1615 for(int i = 0; i < ret.length; i++)
rlm@10 1616 ret[i] = b;
rlm@10 1617 }
rlm@10 1618 else
rlm@10 1619 {
rlm@10 1620 ISeq s = RT.seq(init);
rlm@10 1621 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1622 ret[i] = (Byte) s.first();
rlm@10 1623 }
rlm@10 1624 return ret;
rlm@10 1625 }
rlm@10 1626
rlm@10 1627 static public byte[] byte_array(Object sizeOrSeq){
rlm@10 1628 if(sizeOrSeq instanceof Number)
rlm@10 1629 return new byte[((Number) sizeOrSeq).intValue()];
rlm@10 1630 else
rlm@10 1631 {
rlm@10 1632 ISeq s = RT.seq(sizeOrSeq);
rlm@10 1633 int size = RT.count(s);
rlm@10 1634 byte[] ret = new byte[size];
rlm@10 1635 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1636 ret[i] = (Byte)s.first();
rlm@10 1637 return ret;
rlm@10 1638 }
rlm@10 1639 }
rlm@10 1640
rlm@10 1641 static public boolean[] boolean_array(int size, Object init){
rlm@10 1642 boolean[] ret = new boolean[size];
rlm@10 1643 if(init instanceof Boolean)
rlm@10 1644 {
rlm@10 1645 boolean b = (Boolean) init;
rlm@10 1646 for(int i = 0; i < ret.length; i++)
rlm@10 1647 ret[i] = b;
rlm@10 1648 }
rlm@10 1649 else
rlm@10 1650 {
rlm@10 1651 ISeq s = RT.seq(init);
rlm@10 1652 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1653 ret[i] = (Boolean)s.first();
rlm@10 1654 }
rlm@10 1655 return ret;
rlm@10 1656 }
rlm@10 1657
rlm@10 1658 static public boolean[] boolean_array(Object sizeOrSeq){
rlm@10 1659 if(sizeOrSeq instanceof Number)
rlm@10 1660 return new boolean[((Number) sizeOrSeq).intValue()];
rlm@10 1661 else
rlm@10 1662 {
rlm@10 1663 ISeq s = RT.seq(sizeOrSeq);
rlm@10 1664 int size = RT.count(s);
rlm@10 1665 boolean[] ret = new boolean[size];
rlm@10 1666 for(int i = 0; i < size && s != null; i++, s = s.next())
rlm@10 1667 ret[i] = (Boolean)s.first();
rlm@10 1668 return ret;
rlm@10 1669 }
rlm@10 1670 }
rlm@10 1671
rlm@10 1672 static public boolean[] booleans(Object array){
rlm@10 1673 return (boolean[]) array;
rlm@10 1674 }
rlm@10 1675
rlm@10 1676 static public byte[] bytes(Object array){
rlm@10 1677 return (byte[]) array;
rlm@10 1678 }
rlm@10 1679
rlm@10 1680 static public char[] chars(Object array){
rlm@10 1681 return (char[]) array;
rlm@10 1682 }
rlm@10 1683
rlm@10 1684 static public short[] shorts(Object array){
rlm@10 1685 return (short[]) array;
rlm@10 1686 }
rlm@10 1687
rlm@10 1688 static public float[] floats(Object array){
rlm@10 1689 return (float[]) array;
rlm@10 1690 }
rlm@10 1691
rlm@10 1692 static public double[] doubles(Object array){
rlm@10 1693 return (double[]) array;
rlm@10 1694 }
rlm@10 1695
rlm@10 1696 static public int[] ints(Object array){
rlm@10 1697 return (int[]) array;
rlm@10 1698 }
rlm@10 1699
rlm@10 1700 static public long[] longs(Object array){
rlm@10 1701 return (long[]) array;
rlm@10 1702 }
rlm@10 1703
rlm@10 1704 static public Number num(Object x){
rlm@10 1705 return (Number) x;
rlm@10 1706 }
rlm@10 1707
rlm@10 1708 static public Number num(float x){
rlm@10 1709 return x;
rlm@10 1710 }
rlm@10 1711
rlm@10 1712 static public float add(float x, float y){
rlm@10 1713 return x + y;
rlm@10 1714 }
rlm@10 1715
rlm@10 1716 static public float minus(float x, float y){
rlm@10 1717 return x - y;
rlm@10 1718 }
rlm@10 1719
rlm@10 1720 static public float minus(float x){
rlm@10 1721 return -x;
rlm@10 1722 }
rlm@10 1723
rlm@10 1724 static public float inc(float x){
rlm@10 1725 return x + 1;
rlm@10 1726 }
rlm@10 1727
rlm@10 1728 static public float dec(float x){
rlm@10 1729 return x - 1;
rlm@10 1730 }
rlm@10 1731
rlm@10 1732 static public float multiply(float x, float y){
rlm@10 1733 return x * y;
rlm@10 1734 }
rlm@10 1735
rlm@10 1736 static public float divide(float x, float y){
rlm@10 1737 return x / y;
rlm@10 1738 }
rlm@10 1739
rlm@10 1740 static public boolean equiv(float x, float y){
rlm@10 1741 return x == y;
rlm@10 1742 }
rlm@10 1743
rlm@10 1744 static public boolean lt(float x, float y){
rlm@10 1745 return x < y;
rlm@10 1746 }
rlm@10 1747
rlm@10 1748 static public boolean lte(float x, float y){
rlm@10 1749 return x <= y;
rlm@10 1750 }
rlm@10 1751
rlm@10 1752 static public boolean gt(float x, float y){
rlm@10 1753 return x > y;
rlm@10 1754 }
rlm@10 1755
rlm@10 1756 static public boolean gte(float x, float y){
rlm@10 1757 return x >= y;
rlm@10 1758 }
rlm@10 1759
rlm@10 1760 static public boolean isPos(float x){
rlm@10 1761 return x > 0;
rlm@10 1762 }
rlm@10 1763
rlm@10 1764 static public boolean isNeg(float x){
rlm@10 1765 return x < 0;
rlm@10 1766 }
rlm@10 1767
rlm@10 1768 static public boolean isZero(float x){
rlm@10 1769 return x == 0;
rlm@10 1770 }
rlm@10 1771
rlm@10 1772 static public Number num(double x){
rlm@10 1773 return x;
rlm@10 1774 }
rlm@10 1775
rlm@10 1776 static public double add(double x, double y){
rlm@10 1777 return x + y;
rlm@10 1778 }
rlm@10 1779
rlm@10 1780 static public double minus(double x, double y){
rlm@10 1781 return x - y;
rlm@10 1782 }
rlm@10 1783
rlm@10 1784 static public double minus(double x){
rlm@10 1785 return -x;
rlm@10 1786 }
rlm@10 1787
rlm@10 1788 static public double inc(double x){
rlm@10 1789 return x + 1;
rlm@10 1790 }
rlm@10 1791
rlm@10 1792 static public double dec(double x){
rlm@10 1793 return x - 1;
rlm@10 1794 }
rlm@10 1795
rlm@10 1796 static public double multiply(double x, double y){
rlm@10 1797 return x * y;
rlm@10 1798 }
rlm@10 1799
rlm@10 1800 static public double divide(double x, double y){
rlm@10 1801 return x / y;
rlm@10 1802 }
rlm@10 1803
rlm@10 1804 static public boolean equiv(double x, double y){
rlm@10 1805 return x == y;
rlm@10 1806 }
rlm@10 1807
rlm@10 1808 static public boolean lt(double x, double y){
rlm@10 1809 return x < y;
rlm@10 1810 }
rlm@10 1811
rlm@10 1812 static public boolean lte(double x, double y){
rlm@10 1813 return x <= y;
rlm@10 1814 }
rlm@10 1815
rlm@10 1816 static public boolean gt(double x, double y){
rlm@10 1817 return x > y;
rlm@10 1818 }
rlm@10 1819
rlm@10 1820 static public boolean gte(double x, double y){
rlm@10 1821 return x >= y;
rlm@10 1822 }
rlm@10 1823
rlm@10 1824 static public boolean isPos(double x){
rlm@10 1825 return x > 0;
rlm@10 1826 }
rlm@10 1827
rlm@10 1828 static public boolean isNeg(double x){
rlm@10 1829 return x < 0;
rlm@10 1830 }
rlm@10 1831
rlm@10 1832 static public boolean isZero(double x){
rlm@10 1833 return x == 0;
rlm@10 1834 }
rlm@10 1835
rlm@10 1836 static int throwIntOverflow(){
rlm@10 1837 throw new ArithmeticException("integer overflow");
rlm@10 1838 }
rlm@10 1839
rlm@10 1840 static public Number num(int x){
rlm@10 1841 return x;
rlm@10 1842 }
rlm@10 1843
rlm@10 1844 static public int unchecked_add(int x, int y){
rlm@10 1845 return x + y;
rlm@10 1846 }
rlm@10 1847
rlm@10 1848 static public int unchecked_subtract(int x, int y){
rlm@10 1849 return x - y;
rlm@10 1850 }
rlm@10 1851
rlm@10 1852 static public int unchecked_negate(int x){
rlm@10 1853 return -x;
rlm@10 1854 }
rlm@10 1855
rlm@10 1856 static public int unchecked_inc(int x){
rlm@10 1857 return x + 1;
rlm@10 1858 }
rlm@10 1859
rlm@10 1860 static public int unchecked_dec(int x){
rlm@10 1861 return x - 1;
rlm@10 1862 }
rlm@10 1863
rlm@10 1864 static public int unchecked_multiply(int x, int y){
rlm@10 1865 return x * y;
rlm@10 1866 }
rlm@10 1867
rlm@10 1868 static public int add(int x, int y){
rlm@10 1869 int ret = x + y;
rlm@10 1870 if ((ret ^ x) < 0 && (ret ^ y) < 0)
rlm@10 1871 return throwIntOverflow();
rlm@10 1872 return ret;
rlm@10 1873 }
rlm@10 1874
rlm@10 1875 static public int not(int x){
rlm@10 1876 return ~x;
rlm@10 1877 }
rlm@10 1878
rlm@10 1879 static public int and(int x, int y){
rlm@10 1880 return x & y;
rlm@10 1881 }
rlm@10 1882
rlm@10 1883 static public int or(int x, int y){
rlm@10 1884 return x | y;
rlm@10 1885 }
rlm@10 1886
rlm@10 1887 static public int xor(int x, int y){
rlm@10 1888 return x ^ y;
rlm@10 1889 }
rlm@10 1890
rlm@10 1891 static public int minus(int x, int y){
rlm@10 1892 int ret = x - y;
rlm@10 1893 if (((ret ^ x) < 0 && (ret ^ ~y) < 0))
rlm@10 1894 return throwIntOverflow();
rlm@10 1895 return ret;
rlm@10 1896 }
rlm@10 1897
rlm@10 1898 static public int minus(int x){
rlm@10 1899 if(x == Integer.MIN_VALUE)
rlm@10 1900 return throwIntOverflow();
rlm@10 1901 return -x;
rlm@10 1902 }
rlm@10 1903
rlm@10 1904 static public int inc(int x){
rlm@10 1905 if(x == Integer.MAX_VALUE)
rlm@10 1906 return throwIntOverflow();
rlm@10 1907 return x + 1;
rlm@10 1908 }
rlm@10 1909
rlm@10 1910 static public int dec(int x){
rlm@10 1911 if(x == Integer.MIN_VALUE)
rlm@10 1912 return throwIntOverflow();
rlm@10 1913 return x - 1;
rlm@10 1914 }
rlm@10 1915
rlm@10 1916 static public int multiply(int x, int y){
rlm@10 1917 int ret = x * y;
rlm@10 1918 if (y != 0 && ret/y != x)
rlm@10 1919 return throwIntOverflow();
rlm@10 1920 return ret;
rlm@10 1921 }
rlm@10 1922
rlm@10 1923 static public int unchecked_divide(int x, int y){
rlm@10 1924 return x / y;
rlm@10 1925 }
rlm@10 1926
rlm@10 1927 static public int unchecked_remainder(int x, int y){
rlm@10 1928 return x % y;
rlm@10 1929 }
rlm@10 1930
rlm@10 1931 static public boolean equiv(int x, int y){
rlm@10 1932 return x == y;
rlm@10 1933 }
rlm@10 1934
rlm@10 1935 static public boolean lt(int x, int y){
rlm@10 1936 return x < y;
rlm@10 1937 }
rlm@10 1938
rlm@10 1939 static public boolean lte(int x, int y){
rlm@10 1940 return x <= y;
rlm@10 1941 }
rlm@10 1942
rlm@10 1943 static public boolean gt(int x, int y){
rlm@10 1944 return x > y;
rlm@10 1945 }
rlm@10 1946
rlm@10 1947 static public boolean gte(int x, int y){
rlm@10 1948 return x >= y;
rlm@10 1949 }
rlm@10 1950
rlm@10 1951 static public boolean isPos(int x){
rlm@10 1952 return x > 0;
rlm@10 1953 }
rlm@10 1954
rlm@10 1955 static public boolean isNeg(int x){
rlm@10 1956 return x < 0;
rlm@10 1957 }
rlm@10 1958
rlm@10 1959 static public boolean isZero(int x){
rlm@10 1960 return x == 0;
rlm@10 1961 }
rlm@10 1962
rlm@10 1963 static public Number num(long x){
rlm@10 1964 return x;
rlm@10 1965 }
rlm@10 1966
rlm@10 1967 static public long unchecked_add(long x, long y){
rlm@10 1968 return x + y;
rlm@10 1969 }
rlm@10 1970
rlm@10 1971 static public long unchecked_subtract(long x, long y){
rlm@10 1972 return x - y;
rlm@10 1973 }
rlm@10 1974
rlm@10 1975 static public long unchecked_negate(long x){
rlm@10 1976 return -x;
rlm@10 1977 }
rlm@10 1978
rlm@10 1979 static public long unchecked_inc(long x){
rlm@10 1980 return x + 1;
rlm@10 1981 }
rlm@10 1982
rlm@10 1983 static public long unchecked_dec(long x){
rlm@10 1984 return x - 1;
rlm@10 1985 }
rlm@10 1986
rlm@10 1987 static public long unchecked_multiply(long x, long y){
rlm@10 1988 return x * y;
rlm@10 1989 }
rlm@10 1990
rlm@10 1991 static public long add(long x, long y){
rlm@10 1992 long ret = x + y;
rlm@10 1993 if ((ret ^ x) < 0 && (ret ^ y) < 0)
rlm@10 1994 return throwIntOverflow();
rlm@10 1995 return ret;
rlm@10 1996 }
rlm@10 1997
rlm@10 1998 static public long minus(long x, long y){
rlm@10 1999 long ret = x - y;
rlm@10 2000 if (((ret ^ x) < 0 && (ret ^ ~y) < 0))
rlm@10 2001 return throwIntOverflow();
rlm@10 2002 return ret;
rlm@10 2003 }
rlm@10 2004
rlm@10 2005 static public long minus(long x){
rlm@10 2006 if(x == Long.MIN_VALUE)
rlm@10 2007 return throwIntOverflow();
rlm@10 2008 return -x;
rlm@10 2009 }
rlm@10 2010
rlm@10 2011 static public long inc(long x){
rlm@10 2012 if(x == Long.MAX_VALUE)
rlm@10 2013 return throwIntOverflow();
rlm@10 2014 return x + 1;
rlm@10 2015 }
rlm@10 2016
rlm@10 2017 static public long dec(long x){
rlm@10 2018 if(x == Long.MIN_VALUE)
rlm@10 2019 return throwIntOverflow();
rlm@10 2020 return x - 1;
rlm@10 2021 }
rlm@10 2022
rlm@10 2023 static public long multiply(long x, long y){
rlm@10 2024 long ret = x * y;
rlm@10 2025 if (y != 0 && ret/y != x)
rlm@10 2026 return throwIntOverflow();
rlm@10 2027 return ret;
rlm@10 2028 }
rlm@10 2029
rlm@10 2030 static public long unchecked_divide(long x, long y){
rlm@10 2031 return x / y;
rlm@10 2032 }
rlm@10 2033
rlm@10 2034 static public long unchecked_remainder(long x, long y){
rlm@10 2035 return x % y;
rlm@10 2036 }
rlm@10 2037
rlm@10 2038 static public boolean equiv(long x, long y){
rlm@10 2039 return x == y;
rlm@10 2040 }
rlm@10 2041
rlm@10 2042 static public boolean lt(long x, long y){
rlm@10 2043 return x < y;
rlm@10 2044 }
rlm@10 2045
rlm@10 2046 static public boolean lte(long x, long y){
rlm@10 2047 return x <= y;
rlm@10 2048 }
rlm@10 2049
rlm@10 2050 static public boolean gt(long x, long y){
rlm@10 2051 return x > y;
rlm@10 2052 }
rlm@10 2053
rlm@10 2054 static public boolean gte(long x, long y){
rlm@10 2055 return x >= y;
rlm@10 2056 }
rlm@10 2057
rlm@10 2058 static public boolean isPos(long x){
rlm@10 2059 return x > 0;
rlm@10 2060 }
rlm@10 2061
rlm@10 2062 static public boolean isNeg(long x){
rlm@10 2063 return x < 0;
rlm@10 2064 }
rlm@10 2065
rlm@10 2066 static public boolean isZero(long x){
rlm@10 2067 return x == 0;
rlm@10 2068 }
rlm@10 2069
rlm@10 2070 /*
rlm@10 2071 static public class F{
rlm@10 2072 static public float add(float x, float y){
rlm@10 2073 return x + y;
rlm@10 2074 }
rlm@10 2075
rlm@10 2076 static public float subtract(float x, float y){
rlm@10 2077 return x - y;
rlm@10 2078 }
rlm@10 2079
rlm@10 2080 static public float negate(float x){
rlm@10 2081 return -x;
rlm@10 2082 }
rlm@10 2083
rlm@10 2084 static public float inc(float x){
rlm@10 2085 return x + 1;
rlm@10 2086 }
rlm@10 2087
rlm@10 2088 static public float dec(float x){
rlm@10 2089 return x - 1;
rlm@10 2090 }
rlm@10 2091
rlm@10 2092 static public float multiply(float x, float y){
rlm@10 2093 return x * y;
rlm@10 2094 }
rlm@10 2095
rlm@10 2096 static public float divide(float x, float y){
rlm@10 2097 return x / y;
rlm@10 2098 }
rlm@10 2099
rlm@10 2100 static public boolean equiv(float x, float y){
rlm@10 2101 return x == y;
rlm@10 2102 }
rlm@10 2103
rlm@10 2104 static public boolean lt(float x, float y){
rlm@10 2105 return x < y;
rlm@10 2106 }
rlm@10 2107
rlm@10 2108 static public boolean lte(float x, float y){
rlm@10 2109 return x <= y;
rlm@10 2110 }
rlm@10 2111
rlm@10 2112 static public boolean gt(float x, float y){
rlm@10 2113 return x > y;
rlm@10 2114 }
rlm@10 2115
rlm@10 2116 static public boolean gte(float x, float y){
rlm@10 2117 return x >= y;
rlm@10 2118 }
rlm@10 2119
rlm@10 2120 static public boolean pos(float x){
rlm@10 2121 return x > 0;
rlm@10 2122 }
rlm@10 2123
rlm@10 2124 static public boolean neg(float x){
rlm@10 2125 return x < 0;
rlm@10 2126 }
rlm@10 2127
rlm@10 2128 static public boolean zero(float x){
rlm@10 2129 return x == 0;
rlm@10 2130 }
rlm@10 2131
rlm@10 2132 static public float aget(float[] xs, int i){
rlm@10 2133 return xs[i];
rlm@10 2134 }
rlm@10 2135
rlm@10 2136 static public float aset(float[] xs, int i, float v){
rlm@10 2137 xs[i] = v;
rlm@10 2138 return v;
rlm@10 2139 }
rlm@10 2140
rlm@10 2141 static public int alength(float[] xs){
rlm@10 2142 return xs.length;
rlm@10 2143 }
rlm@10 2144
rlm@10 2145 static public float[] aclone(float[] xs){
rlm@10 2146 return xs.clone();
rlm@10 2147 }
rlm@10 2148
rlm@10 2149 static public float[] vec(int size, Object init){
rlm@10 2150 float[] ret = new float[size];
rlm@10 2151 if(init instanceof Number)
rlm@10 2152 {
rlm@10 2153 float f = ((Number) init).floatValue();
rlm@10 2154 for(int i = 0; i < ret.length; i++)
rlm@10 2155 ret[i] = f;
rlm@10 2156 }
rlm@10 2157 else
rlm@10 2158 {
rlm@10 2159 ISeq s = RT.seq(init);
rlm@10 2160 for(int i = 0; i < size && s != null; i++, s = s.rest())
rlm@10 2161 ret[i] = ((Number) s.first()).floatValue();
rlm@10 2162 }
rlm@10 2163 return ret;
rlm@10 2164 }
rlm@10 2165
rlm@10 2166 static public float[] vec(Object sizeOrSeq){
rlm@10 2167 if(sizeOrSeq instanceof Number)
rlm@10 2168 return new float[((Number) sizeOrSeq).intValue()];
rlm@10 2169 else
rlm@10 2170 {
rlm@10 2171 ISeq s = RT.seq(sizeOrSeq);
rlm@10 2172 int size = s.count();
rlm@10 2173 float[] ret = new float[size];
rlm@10 2174 for(int i = 0; i < size && s != null; i++, s = s.rest())
rlm@10 2175 ret[i] = ((Number) s.first()).intValue();
rlm@10 2176 return ret;
rlm@10 2177 }
rlm@10 2178 }
rlm@10 2179
rlm@10 2180
rlm@10 2181 static public float[] vsadd(float[] x, float y){
rlm@10 2182 final float[] xs = x.clone();
rlm@10 2183 for(int i = 0; i < xs.length; i++)
rlm@10 2184 xs[i] += y;
rlm@10 2185 return xs;
rlm@10 2186 }
rlm@10 2187
rlm@10 2188 static public float[] vssub(float[] x, float y){
rlm@10 2189 final float[] xs = x.clone();
rlm@10 2190 for(int i = 0; i < xs.length; i++)
rlm@10 2191 xs[i] -= y;
rlm@10 2192 return xs;
rlm@10 2193 }
rlm@10 2194
rlm@10 2195 static public float[] vsdiv(float[] x, float y){
rlm@10 2196 final float[] xs = x.clone();
rlm@10 2197 for(int i = 0; i < xs.length; i++)
rlm@10 2198 xs[i] /= y;
rlm@10 2199 return xs;
rlm@10 2200 }
rlm@10 2201
rlm@10 2202 static public float[] vsmul(float[] x, float y){
rlm@10 2203 final float[] xs = x.clone();
rlm@10 2204 for(int i = 0; i < xs.length; i++)
rlm@10 2205 xs[i] *= y;
rlm@10 2206 return xs;
rlm@10 2207 }
rlm@10 2208
rlm@10 2209 static public float[] svdiv(float y, float[] x){
rlm@10 2210 final float[] xs = x.clone();
rlm@10 2211 for(int i = 0; i < xs.length; i++)
rlm@10 2212 xs[i] = y / xs[i];
rlm@10 2213 return xs;
rlm@10 2214 }
rlm@10 2215
rlm@10 2216 static public float[] vsmuladd(float[] x, float y, float[] zs){
rlm@10 2217 final float[] xs = x.clone();
rlm@10 2218 for(int i = 0; i < xs.length; i++)
rlm@10 2219 xs[i] = xs[i] * y + zs[i];
rlm@10 2220 return xs;
rlm@10 2221 }
rlm@10 2222
rlm@10 2223 static public float[] vsmulsub(float[] x, float y, float[] zs){
rlm@10 2224 final float[] xs = x.clone();
rlm@10 2225 for(int i = 0; i < xs.length; i++)
rlm@10 2226 xs[i] = xs[i] * y - zs[i];
rlm@10 2227 return xs;
rlm@10 2228 }
rlm@10 2229
rlm@10 2230 static public float[] vsmulsadd(float[] x, float y, float z){
rlm@10 2231 final float[] xs = x.clone();
rlm@10 2232 for(int i = 0; i < xs.length; i++)
rlm@10 2233 xs[i] = xs[i] * y + z;
rlm@10 2234 return xs;
rlm@10 2235 }
rlm@10 2236
rlm@10 2237 static public float[] vsmulssub(float[] x, float y, float z){
rlm@10 2238 final float[] xs = x.clone();
rlm@10 2239 for(int i = 0; i < xs.length; i++)
rlm@10 2240 xs[i] = xs[i] * y - z;
rlm@10 2241 return xs;
rlm@10 2242 }
rlm@10 2243
rlm@10 2244 static public float[] vabs(float[] x){
rlm@10 2245 final float[] xs = x.clone();
rlm@10 2246 for(int i = 0; i < xs.length; i++)
rlm@10 2247 xs[i] = Math.abs(xs[i]);
rlm@10 2248 return xs;
rlm@10 2249 }
rlm@10 2250
rlm@10 2251 static public float[] vnegabs(float[] x){
rlm@10 2252 final float[] xs = x.clone();
rlm@10 2253 for(int i = 0; i < xs.length; i++)
rlm@10 2254 xs[i] = -Math.abs(xs[i]);
rlm@10 2255 return xs;
rlm@10 2256 }
rlm@10 2257
rlm@10 2258 static public float[] vneg(float[] x){
rlm@10 2259 final float[] xs = x.clone();
rlm@10 2260 for(int i = 0; i < xs.length; i++)
rlm@10 2261 xs[i] = -xs[i];
rlm@10 2262 return xs;
rlm@10 2263 }
rlm@10 2264
rlm@10 2265 static public float[] vsqr(float[] x){
rlm@10 2266 final float[] xs = x.clone();
rlm@10 2267 for(int i = 0; i < xs.length; i++)
rlm@10 2268 xs[i] *= xs[i];
rlm@10 2269 return xs;
rlm@10 2270 }
rlm@10 2271
rlm@10 2272 static public float[] vsignedsqr(float[] x){
rlm@10 2273 final float[] xs = x.clone();
rlm@10 2274 for(int i = 0; i < xs.length; i++)
rlm@10 2275 xs[i] *= Math.abs(xs[i]);
rlm@10 2276 return xs;
rlm@10 2277 }
rlm@10 2278
rlm@10 2279 static public float[] vclip(float[] x, float low, float high){
rlm@10 2280 final float[] xs = x.clone();
rlm@10 2281 for(int i = 0; i < xs.length; i++)
rlm@10 2282 {
rlm@10 2283 if(xs[i] < low)
rlm@10 2284 xs[i] = low;
rlm@10 2285 else if(xs[i] > high)
rlm@10 2286 xs[i] = high;
rlm@10 2287 }
rlm@10 2288 return xs;
rlm@10 2289 }
rlm@10 2290
rlm@10 2291 static public IPersistentVector vclipcounts(float[] x, float low, float high){
rlm@10 2292 final float[] xs = x.clone();
rlm@10 2293 int lowc = 0;
rlm@10 2294 int highc = 0;
rlm@10 2295
rlm@10 2296 for(int i = 0; i < xs.length; i++)
rlm@10 2297 {
rlm@10 2298 if(xs[i] < low)
rlm@10 2299 {
rlm@10 2300 ++lowc;
rlm@10 2301 xs[i] = low;
rlm@10 2302 }
rlm@10 2303 else if(xs[i] > high)
rlm@10 2304 {
rlm@10 2305 ++highc;
rlm@10 2306 xs[i] = high;
rlm@10 2307 }
rlm@10 2308 }
rlm@10 2309 return RT.vector(xs, lowc, highc);
rlm@10 2310 }
rlm@10 2311
rlm@10 2312 static public float[] vthresh(float[] x, float thresh, float otherwise){
rlm@10 2313 final float[] xs = x.clone();
rlm@10 2314 for(int i = 0; i < xs.length; i++)
rlm@10 2315 {
rlm@10 2316 if(xs[i] < thresh)
rlm@10 2317 xs[i] = otherwise;
rlm@10 2318 }
rlm@10 2319 return xs;
rlm@10 2320 }
rlm@10 2321
rlm@10 2322 static public float[] vreverse(float[] x){
rlm@10 2323 final float[] xs = x.clone();
rlm@10 2324 for(int i = 0; i < xs.length; i++)
rlm@10 2325 xs[i] = xs[xs.length - i - 1];
rlm@10 2326 return xs;
rlm@10 2327 }
rlm@10 2328
rlm@10 2329 static public float[] vrunningsum(float[] x){
rlm@10 2330 final float[] xs = x.clone();
rlm@10 2331 for(int i = 1; i < xs.length; i++)
rlm@10 2332 xs[i] = xs[i - 1] + xs[i];
rlm@10 2333 return xs;
rlm@10 2334 }
rlm@10 2335
rlm@10 2336 static public float[] vsort(float[] x){
rlm@10 2337 final float[] xs = x.clone();
rlm@10 2338 Arrays.sort(xs);
rlm@10 2339 return xs;
rlm@10 2340 }
rlm@10 2341
rlm@10 2342 static public float vdot(float[] xs, float[] ys){
rlm@10 2343 float ret = 0;
rlm@10 2344 for(int i = 0; i < xs.length; i++)
rlm@10 2345 ret += xs[i] * ys[i];
rlm@10 2346 return ret;
rlm@10 2347 }
rlm@10 2348
rlm@10 2349 static public float vmax(float[] xs){
rlm@10 2350 if(xs.length == 0)
rlm@10 2351 return 0;
rlm@10 2352 float ret = xs[0];
rlm@10 2353 for(int i = 0; i < xs.length; i++)
rlm@10 2354 ret = Math.max(ret, xs[i]);
rlm@10 2355 return ret;
rlm@10 2356 }
rlm@10 2357
rlm@10 2358 static public float vmin(float[] xs){
rlm@10 2359 if(xs.length == 0)
rlm@10 2360 return 0;
rlm@10 2361 float ret = xs[0];
rlm@10 2362 for(int i = 0; i < xs.length; i++)
rlm@10 2363 ret = Math.min(ret, xs[i]);
rlm@10 2364 return ret;
rlm@10 2365 }
rlm@10 2366
rlm@10 2367 static public float vmean(float[] xs){
rlm@10 2368 if(xs.length == 0)
rlm@10 2369 return 0;
rlm@10 2370 return vsum(xs) / xs.length;
rlm@10 2371 }
rlm@10 2372
rlm@10 2373 static public double vrms(float[] xs){
rlm@10 2374 if(xs.length == 0)
rlm@10 2375 return 0;
rlm@10 2376 float ret = 0;
rlm@10 2377 for(int i = 0; i < xs.length; i++)
rlm@10 2378 ret += xs[i] * xs[i];
rlm@10 2379 return Math.sqrt(ret / xs.length);
rlm@10 2380 }
rlm@10 2381
rlm@10 2382 static public float vsum(float[] xs){
rlm@10 2383 float ret = 0;
rlm@10 2384 for(int i = 0; i < xs.length; i++)
rlm@10 2385 ret += xs[i];
rlm@10 2386 return ret;
rlm@10 2387 }
rlm@10 2388
rlm@10 2389 static public boolean vequiv(float[] xs, float[] ys){
rlm@10 2390 return Arrays.equals(xs, ys);
rlm@10 2391 }
rlm@10 2392
rlm@10 2393 static public float[] vadd(float[] x, float[] ys){
rlm@10 2394 final float[] xs = x.clone();
rlm@10 2395 for(int i = 0; i < xs.length; i++)
rlm@10 2396 xs[i] += ys[i];
rlm@10 2397 return xs;
rlm@10 2398 }
rlm@10 2399
rlm@10 2400 static public float[] vsub(float[] x, float[] ys){
rlm@10 2401 final float[] xs = x.clone();
rlm@10 2402 for(int i = 0; i < xs.length; i++)
rlm@10 2403 xs[i] -= ys[i];
rlm@10 2404 return xs;
rlm@10 2405 }
rlm@10 2406
rlm@10 2407 static public float[] vaddmul(float[] x, float[] ys, float[] zs){
rlm@10 2408 final float[] xs = x.clone();
rlm@10 2409 for(int i = 0; i < xs.length; i++)
rlm@10 2410 xs[i] = (xs[i] + ys[i]) * zs[i];
rlm@10 2411 return xs;
rlm@10 2412 }
rlm@10 2413
rlm@10 2414 static public float[] vsubmul(float[] x, float[] ys, float[] zs){
rlm@10 2415 final float[] xs = x.clone();
rlm@10 2416 for(int i = 0; i < xs.length; i++)
rlm@10 2417 xs[i] = (xs[i] - ys[i]) * zs[i];
rlm@10 2418 return xs;
rlm@10 2419 }
rlm@10 2420
rlm@10 2421 static public float[] vaddsmul(float[] x, float[] ys, float z){
rlm@10 2422 final float[] xs = x.clone();
rlm@10 2423 for(int i = 0; i < xs.length; i++)
rlm@10 2424 xs[i] = (xs[i] + ys[i]) * z;
rlm@10 2425 return xs;
rlm@10 2426 }
rlm@10 2427
rlm@10 2428 static public float[] vsubsmul(float[] x, float[] ys, float z){
rlm@10 2429 final float[] xs = x.clone();
rlm@10 2430 for(int i = 0; i < xs.length; i++)
rlm@10 2431 xs[i] = (xs[i] - ys[i]) * z;
rlm@10 2432 return xs;
rlm@10 2433 }
rlm@10 2434
rlm@10 2435 static public float[] vmulsadd(float[] x, float[] ys, float z){
rlm@10 2436 final float[] xs = x.clone();
rlm@10 2437 for(int i = 0; i < xs.length; i++)
rlm@10 2438 xs[i] = (xs[i] * ys[i]) + z;
rlm@10 2439 return xs;
rlm@10 2440 }
rlm@10 2441
rlm@10 2442 static public float[] vdiv(float[] x, float[] ys){
rlm@10 2443 final float[] xs = x.clone();
rlm@10 2444 for(int i = 0; i < xs.length; i++)
rlm@10 2445 xs[i] /= ys[i];
rlm@10 2446 return xs;
rlm@10 2447 }
rlm@10 2448
rlm@10 2449 static public float[] vmul(float[] x, float[] ys){
rlm@10 2450 final float[] xs = x.clone();
rlm@10 2451 for(int i = 0; i < xs.length; i++)
rlm@10 2452 xs[i] *= ys[i];
rlm@10 2453 return xs;
rlm@10 2454 }
rlm@10 2455
rlm@10 2456 static public float[] vmuladd(float[] x, float[] ys, float[] zs){
rlm@10 2457 final float[] xs = x.clone();
rlm@10 2458 for(int i = 0; i < xs.length; i++)
rlm@10 2459 xs[i] = (xs[i] * ys[i]) + zs[i];
rlm@10 2460 return xs;
rlm@10 2461 }
rlm@10 2462
rlm@10 2463 static public float[] vmulsub(float[] x, float[] ys, float[] zs){
rlm@10 2464 final float[] xs = x.clone();
rlm@10 2465 for(int i = 0; i < xs.length; i++)
rlm@10 2466 xs[i] = (xs[i] * ys[i]) - zs[i];
rlm@10 2467 return xs;
rlm@10 2468 }
rlm@10 2469
rlm@10 2470 static public float[] vmax(float[] x, float[] ys){
rlm@10 2471 final float[] xs = x.clone();
rlm@10 2472 for(int i = 0; i < xs.length; i++)
rlm@10 2473 xs[i] = Math.max(xs[i], ys[i]);
rlm@10 2474 return xs;
rlm@10 2475 }
rlm@10 2476
rlm@10 2477 static public float[] vmin(float[] x, float[] ys){
rlm@10 2478 final float[] xs = x.clone();
rlm@10 2479 for(int i = 0; i < xs.length; i++)
rlm@10 2480 xs[i] = Math.min(xs[i], ys[i]);
rlm@10 2481 return xs;
rlm@10 2482 }
rlm@10 2483
rlm@10 2484 static public float[] vmap(IFn fn, float[] x) throws Exception{
rlm@10 2485 float[] xs = x.clone();
rlm@10 2486 for(int i = 0; i < xs.length; i++)
rlm@10 2487 xs[i] = ((Number) fn.invoke(xs[i])).floatValue();
rlm@10 2488 return xs;
rlm@10 2489 }
rlm@10 2490
rlm@10 2491 static public float[] vmap(IFn fn, float[] x, float[] ys) throws Exception{
rlm@10 2492 float[] xs = x.clone();
rlm@10 2493 for(int i = 0; i < xs.length; i++)
rlm@10 2494 xs[i] = ((Number) fn.invoke(xs[i], ys[i])).floatValue();
rlm@10 2495 return xs;
rlm@10 2496 }
rlm@10 2497
rlm@10 2498 }
rlm@10 2499
rlm@10 2500 static public class D{
rlm@10 2501 static public double add(double x, double y){
rlm@10 2502 return x + y;
rlm@10 2503 }
rlm@10 2504
rlm@10 2505 static public double subtract(double x, double y){
rlm@10 2506 return x - y;
rlm@10 2507 }
rlm@10 2508
rlm@10 2509 static public double negate(double x){
rlm@10 2510 return -x;
rlm@10 2511 }
rlm@10 2512
rlm@10 2513 static public double inc(double x){
rlm@10 2514 return x + 1;
rlm@10 2515 }
rlm@10 2516
rlm@10 2517 static public double dec(double x){
rlm@10 2518 return x - 1;
rlm@10 2519 }
rlm@10 2520
rlm@10 2521 static public double multiply(double x, double y){
rlm@10 2522 return x * y;
rlm@10 2523 }
rlm@10 2524
rlm@10 2525 static public double divide(double x, double y){
rlm@10 2526 return x / y;
rlm@10 2527 }
rlm@10 2528
rlm@10 2529 static public boolean equiv(double x, double y){
rlm@10 2530 return x == y;
rlm@10 2531 }
rlm@10 2532
rlm@10 2533 static public boolean lt(double x, double y){
rlm@10 2534 return x < y;
rlm@10 2535 }
rlm@10 2536
rlm@10 2537 static public boolean lte(double x, double y){
rlm@10 2538 return x <= y;
rlm@10 2539 }
rlm@10 2540
rlm@10 2541 static public boolean gt(double x, double y){
rlm@10 2542 return x > y;
rlm@10 2543 }
rlm@10 2544
rlm@10 2545 static public boolean gte(double x, double y){
rlm@10 2546 return x >= y;
rlm@10 2547 }
rlm@10 2548
rlm@10 2549 static public boolean pos(double x){
rlm@10 2550 return x > 0;
rlm@10 2551 }
rlm@10 2552
rlm@10 2553 static public boolean neg(double x){
rlm@10 2554 return x < 0;
rlm@10 2555 }
rlm@10 2556
rlm@10 2557 static public boolean zero(double x){
rlm@10 2558 return x == 0;
rlm@10 2559 }
rlm@10 2560
rlm@10 2561 static public double aget(double[] xs, int i){
rlm@10 2562 return xs[i];
rlm@10 2563 }
rlm@10 2564
rlm@10 2565 static public double aset(double[] xs, int i, double v){
rlm@10 2566 xs[i] = v;
rlm@10 2567 return v;
rlm@10 2568 }
rlm@10 2569
rlm@10 2570 static public int alength(double[] xs){
rlm@10 2571 return xs.length;
rlm@10 2572 }
rlm@10 2573
rlm@10 2574 static public double[] aclone(double[] xs){
rlm@10 2575 return xs.clone();
rlm@10 2576 }
rlm@10 2577
rlm@10 2578 static public double[] vec(int size, Object init){
rlm@10 2579 double[] ret = new double[size];
rlm@10 2580 if(init instanceof Number)
rlm@10 2581 {
rlm@10 2582 double f = ((Number) init).doubleValue();
rlm@10 2583 for(int i = 0; i < ret.length; i++)
rlm@10 2584 ret[i] = f;
rlm@10 2585 }
rlm@10 2586 else
rlm@10 2587 {
rlm@10 2588 ISeq s = RT.seq(init);
rlm@10 2589 for(int i = 0; i < size && s != null; i++, s = s.rest())
rlm@10 2590 ret[i] = ((Number) s.first()).doubleValue();
rlm@10 2591 }
rlm@10 2592 return ret;
rlm@10 2593 }
rlm@10 2594
rlm@10 2595 static public double[] vec(Object sizeOrSeq){
rlm@10 2596 if(sizeOrSeq instanceof Number)
rlm@10 2597 return new double[((Number) sizeOrSeq).intValue()];
rlm@10 2598 else
rlm@10 2599 {
rlm@10 2600 ISeq s = RT.seq(sizeOrSeq);
rlm@10 2601 int size = s.count();
rlm@10 2602 double[] ret = new double[size];
rlm@10 2603 for(int i = 0; i < size && s != null; i++, s = s.rest())
rlm@10 2604 ret[i] = ((Number) s.first()).intValue();
rlm@10 2605 return ret;
rlm@10 2606 }
rlm@10 2607 }
rlm@10 2608
rlm@10 2609 static public double[] vsadd(double[] x, double y){
rlm@10 2610 final double[] xs = x.clone();
rlm@10 2611 for(int i = 0; i < xs.length; i++)
rlm@10 2612 xs[i] += y;
rlm@10 2613 return xs;
rlm@10 2614 }
rlm@10 2615
rlm@10 2616 static public double[] vssub(double[] x, double y){
rlm@10 2617 final double[] xs = x.clone();
rlm@10 2618 for(int i = 0; i < xs.length; i++)
rlm@10 2619 xs[i] -= y;
rlm@10 2620 return xs;
rlm@10 2621 }
rlm@10 2622
rlm@10 2623 static public double[] vsdiv(double[] x, double y){
rlm@10 2624 final double[] xs = x.clone();
rlm@10 2625 for(int i = 0; i < xs.length; i++)
rlm@10 2626 xs[i] /= y;
rlm@10 2627 return xs;
rlm@10 2628 }
rlm@10 2629
rlm@10 2630 static public double[] vsmul(double[] x, double y){
rlm@10 2631 final double[] xs = x.clone();
rlm@10 2632 for(int i = 0; i < xs.length; i++)
rlm@10 2633 xs[i] *= y;
rlm@10 2634 return xs;
rlm@10 2635 }
rlm@10 2636
rlm@10 2637 static public double[] svdiv(double y, double[] x){
rlm@10 2638 final double[] xs = x.clone();
rlm@10 2639 for(int i = 0; i < xs.length; i++)
rlm@10 2640 xs[i] = y / xs[i];
rlm@10 2641 return xs;
rlm@10 2642 }
rlm@10 2643
rlm@10 2644 static public double[] vsmuladd(double[] x, double y, double[] zs){
rlm@10 2645 final double[] xs = x.clone();
rlm@10 2646 for(int i = 0; i < xs.length; i++)
rlm@10 2647 xs[i] = xs[i] * y + zs[i];
rlm@10 2648 return xs;
rlm@10 2649 }
rlm@10 2650
rlm@10 2651 static public double[] vsmulsub(double[] x, double y, double[] zs){
rlm@10 2652 final double[] xs = x.clone();
rlm@10 2653 for(int i = 0; i < xs.length; i++)
rlm@10 2654 xs[i] = xs[i] * y - zs[i];
rlm@10 2655 return xs;
rlm@10 2656 }
rlm@10 2657
rlm@10 2658 static public double[] vsmulsadd(double[] x, double y, double z){
rlm@10 2659 final double[] xs = x.clone();
rlm@10 2660 for(int i = 0; i < xs.length; i++)
rlm@10 2661 xs[i] = xs[i] * y + z;
rlm@10 2662 return xs;
rlm@10 2663 }
rlm@10 2664
rlm@10 2665 static public double[] vsmulssub(double[] x, double y, double z){
rlm@10 2666 final double[] xs = x.clone();
rlm@10 2667 for(int i = 0; i < xs.length; i++)
rlm@10 2668 xs[i] = xs[i] * y - z;
rlm@10 2669 return xs;
rlm@10 2670 }
rlm@10 2671
rlm@10 2672 static public double[] vabs(double[] x){
rlm@10 2673 final double[] xs = x.clone();
rlm@10 2674 for(int i = 0; i < xs.length; i++)
rlm@10 2675 xs[i] = Math.abs(xs[i]);
rlm@10 2676 return xs;
rlm@10 2677 }
rlm@10 2678
rlm@10 2679 static public double[] vnegabs(double[] x){
rlm@10 2680 final double[] xs = x.clone();
rlm@10 2681 for(int i = 0; i < xs.length; i++)
rlm@10 2682 xs[i] = -Math.abs(xs[i]);
rlm@10 2683 return xs;
rlm@10 2684 }
rlm@10 2685
rlm@10 2686 static public double[] vneg(double[] x){
rlm@10 2687 final double[] xs = x.clone();
rlm@10 2688 for(int i = 0; i < xs.length; i++)
rlm@10 2689 xs[i] = -xs[i];
rlm@10 2690 return xs;
rlm@10 2691 }
rlm@10 2692
rlm@10 2693 static public double[] vsqr(double[] x){
rlm@10 2694 final double[] xs = x.clone();
rlm@10 2695 for(int i = 0; i < xs.length; i++)
rlm@10 2696 xs[i] *= xs[i];
rlm@10 2697 return xs;
rlm@10 2698 }
rlm@10 2699
rlm@10 2700 static public double[] vsignedsqr(double[] x){
rlm@10 2701 final double[] xs = x.clone();
rlm@10 2702 for(int i = 0; i < xs.length; i++)
rlm@10 2703 xs[i] *= Math.abs(xs[i]);
rlm@10 2704 return xs;
rlm@10 2705 }
rlm@10 2706
rlm@10 2707 static public double[] vclip(double[] x, double low, double high){
rlm@10 2708 final double[] xs = x.clone();
rlm@10 2709 for(int i = 0; i < xs.length; i++)
rlm@10 2710 {
rlm@10 2711 if(xs[i] < low)
rlm@10 2712 xs[i] = low;
rlm@10 2713 else if(xs[i] > high)
rlm@10 2714 xs[i] = high;
rlm@10 2715 }
rlm@10 2716 return xs;
rlm@10 2717 }
rlm@10 2718
rlm@10 2719 static public IPersistentVector vclipcounts(double[] x, double low, double high){
rlm@10 2720 final double[] xs = x.clone();
rlm@10 2721 int lowc = 0;
rlm@10 2722 int highc = 0;
rlm@10 2723
rlm@10 2724 for(int i = 0; i < xs.length; i++)
rlm@10 2725 {
rlm@10 2726 if(xs[i] < low)
rlm@10 2727 {
rlm@10 2728 ++lowc;
rlm@10 2729 xs[i] = low;
rlm@10 2730 }
rlm@10 2731 else if(xs[i] > high)
rlm@10 2732 {
rlm@10 2733 ++highc;
rlm@10 2734 xs[i] = high;
rlm@10 2735 }
rlm@10 2736 }
rlm@10 2737 return RT.vector(xs, lowc, highc);
rlm@10 2738 }
rlm@10 2739
rlm@10 2740 static public double[] vthresh(double[] x, double thresh, double otherwise){
rlm@10 2741 final double[] xs = x.clone();
rlm@10 2742 for(int i = 0; i < xs.length; i++)
rlm@10 2743 {
rlm@10 2744 if(xs[i] < thresh)
rlm@10 2745 xs[i] = otherwise;
rlm@10 2746 }
rlm@10 2747 return xs;
rlm@10 2748 }
rlm@10 2749
rlm@10 2750 static public double[] vreverse(double[] x){
rlm@10 2751 final double[] xs = x.clone();
rlm@10 2752 for(int i = 0; i < xs.length; i++)
rlm@10 2753 xs[i] = xs[xs.length - i - 1];
rlm@10 2754 return xs;
rlm@10 2755 }
rlm@10 2756
rlm@10 2757 static public double[] vrunningsum(double[] x){
rlm@10 2758 final double[] xs = x.clone();
rlm@10 2759 for(int i = 1; i < xs.length; i++)
rlm@10 2760 xs[i] = xs[i - 1] + xs[i];
rlm@10 2761 return xs;
rlm@10 2762 }
rlm@10 2763
rlm@10 2764 static public double[] vsort(double[] x){
rlm@10 2765 final double[] xs = x.clone();
rlm@10 2766 Arrays.sort(xs);
rlm@10 2767 return xs;
rlm@10 2768 }
rlm@10 2769
rlm@10 2770 static public double vdot(double[] xs, double[] ys){
rlm@10 2771 double ret = 0;
rlm@10 2772 for(int i = 0; i < xs.length; i++)
rlm@10 2773 ret += xs[i] * ys[i];
rlm@10 2774 return ret;
rlm@10 2775 }
rlm@10 2776
rlm@10 2777 static public double vmax(double[] xs){
rlm@10 2778 if(xs.length == 0)
rlm@10 2779 return 0;
rlm@10 2780 double ret = xs[0];
rlm@10 2781 for(int i = 0; i < xs.length; i++)
rlm@10 2782 ret = Math.max(ret, xs[i]);
rlm@10 2783 return ret;
rlm@10 2784 }
rlm@10 2785
rlm@10 2786 static public double vmin(double[] xs){
rlm@10 2787 if(xs.length == 0)
rlm@10 2788 return 0;
rlm@10 2789 double ret = xs[0];
rlm@10 2790 for(int i = 0; i < xs.length; i++)
rlm@10 2791 ret = Math.min(ret, xs[i]);
rlm@10 2792 return ret;
rlm@10 2793 }
rlm@10 2794
rlm@10 2795 static public double vmean(double[] xs){
rlm@10 2796 if(xs.length == 0)
rlm@10 2797 return 0;
rlm@10 2798 return vsum(xs) / xs.length;
rlm@10 2799 }
rlm@10 2800
rlm@10 2801 static public double vrms(double[] xs){
rlm@10 2802 if(xs.length == 0)
rlm@10 2803 return 0;
rlm@10 2804 double ret = 0;
rlm@10 2805 for(int i = 0; i < xs.length; i++)
rlm@10 2806 ret += xs[i] * xs[i];
rlm@10 2807 return Math.sqrt(ret / xs.length);
rlm@10 2808 }
rlm@10 2809
rlm@10 2810 static public double vsum(double[] xs){
rlm@10 2811 double ret = 0;
rlm@10 2812 for(int i = 0; i < xs.length; i++)
rlm@10 2813 ret += xs[i];
rlm@10 2814 return ret;
rlm@10 2815 }
rlm@10 2816
rlm@10 2817 static public boolean vequiv(double[] xs, double[] ys){
rlm@10 2818 return Arrays.equals(xs, ys);
rlm@10 2819 }
rlm@10 2820
rlm@10 2821 static public double[] vadd(double[] x, double[] ys){
rlm@10 2822 final double[] xs = x.clone();
rlm@10 2823 for(int i = 0; i < xs.length; i++)
rlm@10 2824 xs[i] += ys[i];
rlm@10 2825 return xs;
rlm@10 2826 }
rlm@10 2827
rlm@10 2828 static public double[] vsub(double[] x, double[] ys){
rlm@10 2829 final double[] xs = x.clone();
rlm@10 2830 for(int i = 0; i < xs.length; i++)
rlm@10 2831 xs[i] -= ys[i];
rlm@10 2832 return xs;
rlm@10 2833 }
rlm@10 2834
rlm@10 2835 static public double[] vaddmul(double[] x, double[] ys, double[] zs){
rlm@10 2836 final double[] xs = x.clone();
rlm@10 2837 for(int i = 0; i < xs.length; i++)
rlm@10 2838 xs[i] = (xs[i] + ys[i]) * zs[i];
rlm@10 2839 return xs;
rlm@10 2840 }
rlm@10 2841
rlm@10 2842 static public double[] vsubmul(double[] x, double[] ys, double[] zs){
rlm@10 2843 final double[] xs = x.clone();
rlm@10 2844 for(int i = 0; i < xs.length; i++)
rlm@10 2845 xs[i] = (xs[i] - ys[i]) * zs[i];
rlm@10 2846 return xs;
rlm@10 2847 }
rlm@10 2848
rlm@10 2849 static public double[] vaddsmul(double[] x, double[] ys, double z){
rlm@10 2850 final double[] xs = x.clone();
rlm@10 2851 for(int i = 0; i < xs.length; i++)
rlm@10 2852 xs[i] = (xs[i] + ys[i]) * z;
rlm@10 2853 return xs;
rlm@10 2854 }
rlm@10 2855
rlm@10 2856 static public double[] vsubsmul(double[] x, double[] ys, double z){
rlm@10 2857 final double[] xs = x.clone();
rlm@10 2858 for(int i = 0; i < xs.length; i++)
rlm@10 2859 xs[i] = (xs[i] - ys[i]) * z;
rlm@10 2860 return xs;
rlm@10 2861 }
rlm@10 2862
rlm@10 2863 static public double[] vmulsadd(double[] x, double[] ys, double z){
rlm@10 2864 final double[] xs = x.clone();
rlm@10 2865 for(int i = 0; i < xs.length; i++)
rlm@10 2866 xs[i] = (xs[i] * ys[i]) + z;
rlm@10 2867 return xs;
rlm@10 2868 }
rlm@10 2869
rlm@10 2870 static public double[] vdiv(double[] x, double[] ys){
rlm@10 2871 final double[] xs = x.clone();
rlm@10 2872 for(int i = 0; i < xs.length; i++)
rlm@10 2873 xs[i] /= ys[i];
rlm@10 2874 return xs;
rlm@10 2875 }
rlm@10 2876
rlm@10 2877 static public double[] vmul(double[] x, double[] ys){
rlm@10 2878 final double[] xs = x.clone();
rlm@10 2879 for(int i = 0; i < xs.length; i++)
rlm@10 2880 xs[i] *= ys[i];
rlm@10 2881 return xs;
rlm@10 2882 }
rlm@10 2883
rlm@10 2884 static public double[] vmuladd(double[] x, double[] ys, double[] zs){
rlm@10 2885 final double[] xs = x.clone();
rlm@10 2886 for(int i = 0; i < xs.length; i++)
rlm@10 2887 xs[i] = (xs[i] * ys[i]) + zs[i];
rlm@10 2888 return xs;
rlm@10 2889 }
rlm@10 2890
rlm@10 2891 static public double[] vmulsub(double[] x, double[] ys, double[] zs){
rlm@10 2892 final double[] xs = x.clone();
rlm@10 2893 for(int i = 0; i < xs.length; i++)
rlm@10 2894 xs[i] = (xs[i] * ys[i]) - zs[i];
rlm@10 2895 return xs;
rlm@10 2896 }
rlm@10 2897
rlm@10 2898 static public double[] vmax(double[] x, double[] ys){
rlm@10 2899 final double[] xs = x.clone();
rlm@10 2900 for(int i = 0; i < xs.length; i++)
rlm@10 2901 xs[i] = Math.max(xs[i], ys[i]);
rlm@10 2902 return xs;
rlm@10 2903 }
rlm@10 2904
rlm@10 2905 static public double[] vmin(double[] x, double[] ys){
rlm@10 2906 final double[] xs = x.clone();
rlm@10 2907 for(int i = 0; i < xs.length; i++)
rlm@10 2908 xs[i] = Math.min(xs[i], ys[i]);
rlm@10 2909 return xs;
rlm@10 2910 }
rlm@10 2911
rlm@10 2912 static public double[] vmap(IFn fn, double[] x) throws Exception{
rlm@10 2913 double[] xs = x.clone();
rlm@10 2914 for(int i = 0; i < xs.length; i++)
rlm@10 2915 xs[i] = ((Number) fn.invoke(xs[i])).doubleValue();
rlm@10 2916 return xs;
rlm@10 2917 }
rlm@10 2918
rlm@10 2919 static public double[] vmap(IFn fn, double[] x, double[] ys) throws Exception{
rlm@10 2920 double[] xs = x.clone();
rlm@10 2921 for(int i = 0; i < xs.length; i++)
rlm@10 2922 xs[i] = ((Number) fn.invoke(xs[i], ys[i])).doubleValue();
rlm@10 2923 return xs;
rlm@10 2924 }
rlm@10 2925 }
rlm@10 2926
rlm@10 2927 static public class I{
rlm@10 2928 static public int add(int x, int y){
rlm@10 2929 return x + y;
rlm@10 2930 }
rlm@10 2931
rlm@10 2932 static public int subtract(int x, int y){
rlm@10 2933 return x - y;
rlm@10 2934 }
rlm@10 2935
rlm@10 2936 static public int negate(int x){
rlm@10 2937 return -x;
rlm@10 2938 }
rlm@10 2939
rlm@10 2940 static public int inc(int x){
rlm@10 2941 return x + 1;
rlm@10 2942 }
rlm@10 2943
rlm@10 2944 static public int dec(int x){
rlm@10 2945 return x - 1;
rlm@10 2946 }
rlm@10 2947
rlm@10 2948 static public int multiply(int x, int y){
rlm@10 2949 return x * y;
rlm@10 2950 }
rlm@10 2951
rlm@10 2952 static public int divide(int x, int y){
rlm@10 2953 return x / y;
rlm@10 2954 }
rlm@10 2955
rlm@10 2956 static public boolean equiv(int x, int y){
rlm@10 2957 return x == y;
rlm@10 2958 }
rlm@10 2959
rlm@10 2960 static public boolean lt(int x, int y){
rlm@10 2961 return x < y;
rlm@10 2962 }
rlm@10 2963
rlm@10 2964 static public boolean lte(int x, int y){
rlm@10 2965 return x <= y;
rlm@10 2966 }
rlm@10 2967
rlm@10 2968 static public boolean gt(int x, int y){
rlm@10 2969 return x > y;
rlm@10 2970 }
rlm@10 2971
rlm@10 2972 static public boolean gte(int x, int y){
rlm@10 2973 return x >= y;
rlm@10 2974 }
rlm@10 2975
rlm@10 2976 static public boolean pos(int x){
rlm@10 2977 return x > 0;
rlm@10 2978 }
rlm@10 2979
rlm@10 2980 static public boolean neg(int x){
rlm@10 2981 return x < 0;
rlm@10 2982 }
rlm@10 2983
rlm@10 2984 static public boolean zero(int x){
rlm@10 2985 return x == 0;
rlm@10 2986 }
rlm@10 2987
rlm@10 2988 static public int aget(int[] xs, int i){
rlm@10 2989 return xs[i];
rlm@10 2990 }
rlm@10 2991
rlm@10 2992 static public int aset(int[] xs, int i, int v){
rlm@10 2993 xs[i] = v;
rlm@10 2994 return v;
rlm@10 2995 }
rlm@10 2996
rlm@10 2997 static public int alength(int[] xs){
rlm@10 2998 return xs.length;
rlm@10 2999 }
rlm@10 3000
rlm@10 3001 static public int[] aclone(int[] xs){
rlm@10 3002 return xs.clone();
rlm@10 3003 }
rlm@10 3004
rlm@10 3005 static public int[] vec(int size, Object init){
rlm@10 3006 int[] ret = new int[size];
rlm@10 3007 if(init instanceof Number)
rlm@10 3008 {
rlm@10 3009 int f = ((Number) init).intValue();
rlm@10 3010 for(int i = 0; i < ret.length; i++)
rlm@10 3011 ret[i] = f;
rlm@10 3012 }
rlm@10 3013 else
rlm@10 3014 {
rlm@10 3015 ISeq s = RT.seq(init);
rlm@10 3016 for(int i = 0; i < size && s != null; i++, s = s.rest())
rlm@10 3017 ret[i] = ((Number) s.first()).intValue();
rlm@10 3018 }
rlm@10 3019 return ret;
rlm@10 3020 }
rlm@10 3021
rlm@10 3022 static public int[] vec(Object sizeOrSeq){
rlm@10 3023 if(sizeOrSeq instanceof Number)
rlm@10 3024 return new int[((Number) sizeOrSeq).intValue()];
rlm@10 3025 else
rlm@10 3026 {
rlm@10 3027 ISeq s = RT.seq(sizeOrSeq);
rlm@10 3028 int size = s.count();
rlm@10 3029 int[] ret = new int[size];
rlm@10 3030 for(int i = 0; i < size && s != null; i++, s = s.rest())
rlm@10 3031 ret[i] = ((Number) s.first()).intValue();
rlm@10 3032 return ret;
rlm@10 3033 }
rlm@10 3034 }
rlm@10 3035
rlm@10 3036 static public int[] vsadd(int[] x, int y){
rlm@10 3037 final int[] xs = x.clone();
rlm@10 3038 for(int i = 0; i < xs.length; i++)
rlm@10 3039 xs[i] += y;
rlm@10 3040 return xs;
rlm@10 3041 }
rlm@10 3042
rlm@10 3043 static public int[] vssub(int[] x, int y){
rlm@10 3044 final int[] xs = x.clone();
rlm@10 3045 for(int i = 0; i < xs.length; i++)
rlm@10 3046 xs[i] -= y;
rlm@10 3047 return xs;
rlm@10 3048 }
rlm@10 3049
rlm@10 3050 static public int[] vsdiv(int[] x, int y){
rlm@10 3051 final int[] xs = x.clone();
rlm@10 3052 for(int i = 0; i < xs.length; i++)
rlm@10 3053 xs[i] /= y;
rlm@10 3054 return xs;
rlm@10 3055 }
rlm@10 3056
rlm@10 3057 static public int[] vsmul(int[] x, int y){
rlm@10 3058 final int[] xs = x.clone();
rlm@10 3059 for(int i = 0; i < xs.length; i++)
rlm@10 3060 xs[i] *= y;
rlm@10 3061 return xs;
rlm@10 3062 }
rlm@10 3063
rlm@10 3064 static public int[] svdiv(int y, int[] x){
rlm@10 3065 final int[] xs = x.clone();
rlm@10 3066 for(int i = 0; i < xs.length; i++)
rlm@10 3067 xs[i] = y / xs[i];
rlm@10 3068 return xs;
rlm@10 3069 }
rlm@10 3070
rlm@10 3071 static public int[] vsmuladd(int[] x, int y, int[] zs){
rlm@10 3072 final int[] xs = x.clone();
rlm@10 3073 for(int i = 0; i < xs.length; i++)
rlm@10 3074 xs[i] = xs[i] * y + zs[i];
rlm@10 3075 return xs;
rlm@10 3076 }
rlm@10 3077
rlm@10 3078 static public int[] vsmulsub(int[] x, int y, int[] zs){
rlm@10 3079 final int[] xs = x.clone();
rlm@10 3080 for(int i = 0; i < xs.length; i++)
rlm@10 3081 xs[i] = xs[i] * y - zs[i];
rlm@10 3082 return xs;
rlm@10 3083 }
rlm@10 3084
rlm@10 3085 static public int[] vsmulsadd(int[] x, int y, int z){
rlm@10 3086 final int[] xs = x.clone();
rlm@10 3087 for(int i = 0; i < xs.length; i++)
rlm@10 3088 xs[i] = xs[i] * y + z;
rlm@10 3089 return xs;
rlm@10 3090 }
rlm@10 3091
rlm@10 3092 static public int[] vsmulssub(int[] x, int y, int z){
rlm@10 3093 final int[] xs = x.clone();
rlm@10 3094 for(int i = 0; i < xs.length; i++)
rlm@10 3095 xs[i] = xs[i] * y - z;
rlm@10 3096 return xs;
rlm@10 3097 }
rlm@10 3098
rlm@10 3099 static public int[] vabs(int[] x){
rlm@10 3100 final int[] xs = x.clone();
rlm@10 3101 for(int i = 0; i < xs.length; i++)
rlm@10 3102 xs[i] = Math.abs(xs[i]);
rlm@10 3103 return xs;
rlm@10 3104 }
rlm@10 3105
rlm@10 3106 static public int[] vnegabs(int[] x){
rlm@10 3107 final int[] xs = x.clone();
rlm@10 3108 for(int i = 0; i < xs.length; i++)
rlm@10 3109 xs[i] = -Math.abs(xs[i]);
rlm@10 3110 return xs;
rlm@10 3111 }
rlm@10 3112
rlm@10 3113 static public int[] vneg(int[] x){
rlm@10 3114 final int[] xs = x.clone();
rlm@10 3115 for(int i = 0; i < xs.length; i++)
rlm@10 3116 xs[i] = -xs[i];
rlm@10 3117 return xs;
rlm@10 3118 }
rlm@10 3119
rlm@10 3120 static public int[] vsqr(int[] x){
rlm@10 3121 final int[] xs = x.clone();
rlm@10 3122 for(int i = 0; i < xs.length; i++)
rlm@10 3123 xs[i] *= xs[i];
rlm@10 3124 return xs;
rlm@10 3125 }
rlm@10 3126
rlm@10 3127 static public int[] vsignedsqr(int[] x){
rlm@10 3128 final int[] xs = x.clone();
rlm@10 3129 for(int i = 0; i < xs.length; i++)
rlm@10 3130 xs[i] *= Math.abs(xs[i]);
rlm@10 3131 return xs;
rlm@10 3132 }
rlm@10 3133
rlm@10 3134 static public int[] vclip(int[] x, int low, int high){
rlm@10 3135 final int[] xs = x.clone();
rlm@10 3136 for(int i = 0; i < xs.length; i++)
rlm@10 3137 {
rlm@10 3138 if(xs[i] < low)
rlm@10 3139 xs[i] = low;
rlm@10 3140 else if(xs[i] > high)
rlm@10 3141 xs[i] = high;
rlm@10 3142 }
rlm@10 3143 return xs;
rlm@10 3144 }
rlm@10 3145
rlm@10 3146 static public IPersistentVector vclipcounts(int[] x, int low, int high){
rlm@10 3147 final int[] xs = x.clone();
rlm@10 3148 int lowc = 0;
rlm@10 3149 int highc = 0;
rlm@10 3150
rlm@10 3151 for(int i = 0; i < xs.length; i++)
rlm@10 3152 {
rlm@10 3153 if(xs[i] < low)
rlm@10 3154 {
rlm@10 3155 ++lowc;
rlm@10 3156 xs[i] = low;
rlm@10 3157 }
rlm@10 3158 else if(xs[i] > high)
rlm@10 3159 {
rlm@10 3160 ++highc;
rlm@10 3161 xs[i] = high;
rlm@10 3162 }
rlm@10 3163 }
rlm@10 3164 return RT.vector(xs, lowc, highc);
rlm@10 3165 }
rlm@10 3166
rlm@10 3167 static public int[] vthresh(int[] x, int thresh, int otherwise){
rlm@10 3168 final int[] xs = x.clone();
rlm@10 3169 for(int i = 0; i < xs.length; i++)
rlm@10 3170 {
rlm@10 3171 if(xs[i] < thresh)
rlm@10 3172 xs[i] = otherwise;
rlm@10 3173 }
rlm@10 3174 return xs;
rlm@10 3175 }
rlm@10 3176
rlm@10 3177 static public int[] vreverse(int[] x){
rlm@10 3178 final int[] xs = x.clone();
rlm@10 3179 for(int i = 0; i < xs.length; i++)
rlm@10 3180 xs[i] = xs[xs.length - i - 1];
rlm@10 3181 return xs;
rlm@10 3182 }
rlm@10 3183
rlm@10 3184 static public int[] vrunningsum(int[] x){
rlm@10 3185 final int[] xs = x.clone();
rlm@10 3186 for(int i = 1; i < xs.length; i++)
rlm@10 3187 xs[i] = xs[i - 1] + xs[i];
rlm@10 3188 return xs;
rlm@10 3189 }
rlm@10 3190
rlm@10 3191 static public int[] vsort(int[] x){
rlm@10 3192 final int[] xs = x.clone();
rlm@10 3193 Arrays.sort(xs);
rlm@10 3194 return xs;
rlm@10 3195 }
rlm@10 3196
rlm@10 3197 static public int vdot(int[] xs, int[] ys){
rlm@10 3198 int ret = 0;
rlm@10 3199 for(int i = 0; i < xs.length; i++)
rlm@10 3200 ret += xs[i] * ys[i];
rlm@10 3201 return ret;
rlm@10 3202 }
rlm@10 3203
rlm@10 3204 static public int vmax(int[] xs){
rlm@10 3205 if(xs.length == 0)
rlm@10 3206 return 0;
rlm@10 3207 int ret = xs[0];
rlm@10 3208 for(int i = 0; i < xs.length; i++)
rlm@10 3209 ret = Math.max(ret, xs[i]);
rlm@10 3210 return ret;
rlm@10 3211 }
rlm@10 3212
rlm@10 3213 static public int vmin(int[] xs){
rlm@10 3214 if(xs.length == 0)
rlm@10 3215 return 0;
rlm@10 3216 int ret = xs[0];
rlm@10 3217 for(int i = 0; i < xs.length; i++)
rlm@10 3218 ret = Math.min(ret, xs[i]);
rlm@10 3219 return ret;
rlm@10 3220 }
rlm@10 3221
rlm@10 3222 static public double vmean(int[] xs){
rlm@10 3223 if(xs.length == 0)
rlm@10 3224 return 0;
rlm@10 3225 return vsum(xs) / (double) xs.length;
rlm@10 3226 }
rlm@10 3227
rlm@10 3228 static public double vrms(int[] xs){
rlm@10 3229 if(xs.length == 0)
rlm@10 3230 return 0;
rlm@10 3231 int ret = 0;
rlm@10 3232 for(int i = 0; i < xs.length; i++)
rlm@10 3233 ret += xs[i] * xs[i];
rlm@10 3234 return Math.sqrt(ret / (double) xs.length);
rlm@10 3235 }
rlm@10 3236
rlm@10 3237 static public int vsum(int[] xs){
rlm@10 3238 int ret = 0;
rlm@10 3239 for(int i = 0; i < xs.length; i++)
rlm@10 3240 ret += xs[i];
rlm@10 3241 return ret;
rlm@10 3242 }
rlm@10 3243
rlm@10 3244 static public boolean vequiv(int[] xs, int[] ys){
rlm@10 3245 return Arrays.equals(xs, ys);
rlm@10 3246 }
rlm@10 3247
rlm@10 3248 static public int[] vadd(int[] x, int[] ys){
rlm@10 3249 final int[] xs = x.clone();
rlm@10 3250 for(int i = 0; i < xs.length; i++)
rlm@10 3251 xs[i] += ys[i];
rlm@10 3252 return xs;
rlm@10 3253 }
rlm@10 3254
rlm@10 3255 static public int[] vsub(int[] x, int[] ys){
rlm@10 3256 final int[] xs = x.clone();
rlm@10 3257 for(int i = 0; i < xs.length; i++)
rlm@10 3258 xs[i] -= ys[i];
rlm@10 3259 return xs;
rlm@10 3260 }
rlm@10 3261
rlm@10 3262 static public int[] vaddmul(int[] x, int[] ys, int[] zs){
rlm@10 3263 final int[] xs = x.clone();
rlm@10 3264 for(int i = 0; i < xs.length; i++)
rlm@10 3265 xs[i] = (xs[i] + ys[i]) * zs[i];
rlm@10 3266 return xs;
rlm@10 3267 }
rlm@10 3268
rlm@10 3269 static public int[] vsubmul(int[] x, int[] ys, int[] zs){
rlm@10 3270 final int[] xs = x.clone();
rlm@10 3271 for(int i = 0; i < xs.length; i++)
rlm@10 3272 xs[i] = (xs[i] - ys[i]) * zs[i];
rlm@10 3273 return xs;
rlm@10 3274 }
rlm@10 3275
rlm@10 3276 static public int[] vaddsmul(int[] x, int[] ys, int z){
rlm@10 3277 final int[] xs = x.clone();
rlm@10 3278 for(int i = 0; i < xs.length; i++)
rlm@10 3279 xs[i] = (xs[i] + ys[i]) * z;
rlm@10 3280 return xs;
rlm@10 3281 }
rlm@10 3282
rlm@10 3283 static public int[] vsubsmul(int[] x, int[] ys, int z){
rlm@10 3284 final int[] xs = x.clone();
rlm@10 3285 for(int i = 0; i < xs.length; i++)
rlm@10 3286 xs[i] = (xs[i] - ys[i]) * z;
rlm@10 3287 return xs;
rlm@10 3288 }
rlm@10 3289
rlm@10 3290 static public int[] vmulsadd(int[] x, int[] ys, int z){
rlm@10 3291 final int[] xs = x.clone();
rlm@10 3292 for(int i = 0; i < xs.length; i++)
rlm@10 3293 xs[i] = (xs[i] * ys[i]) + z;
rlm@10 3294 return xs;
rlm@10 3295 }
rlm@10 3296
rlm@10 3297 static public int[] vdiv(int[] x, int[] ys){
rlm@10 3298 final int[] xs = x.clone();
rlm@10 3299 for(int i = 0; i < xs.length; i++)
rlm@10 3300 xs[i] /= ys[i];
rlm@10 3301 return xs;
rlm@10 3302 }
rlm@10 3303
rlm@10 3304 static public int[] vmul(int[] x, int[] ys){
rlm@10 3305 final int[] xs = x.clone();
rlm@10 3306 for(int i = 0; i < xs.length; i++)
rlm@10 3307 xs[i] *= ys[i];
rlm@10 3308 return xs;
rlm@10 3309 }
rlm@10 3310
rlm@10 3311 static public int[] vmuladd(int[] x, int[] ys, int[] zs){
rlm@10 3312 final int[] xs = x.clone();
rlm@10 3313 for(int i = 0; i < xs.length; i++)
rlm@10 3314 xs[i] = (xs[i] * ys[i]) + zs[i];
rlm@10 3315 return xs;
rlm@10 3316 }
rlm@10 3317
rlm@10 3318 static public int[] vmulsub(int[] x, int[] ys, int[] zs){
rlm@10 3319 final int[] xs = x.clone();
rlm@10 3320 for(int i = 0; i < xs.length; i++)
rlm@10 3321 xs[i] = (xs[i] * ys[i]) - zs[i];
rlm@10 3322 return xs;
rlm@10 3323 }
rlm@10 3324
rlm@10 3325 static public int[] vmax(int[] x, int[] ys){
rlm@10 3326 final int[] xs = x.clone();
rlm@10 3327 for(int i = 0; i < xs.length; i++)
rlm@10 3328 xs[i] = Math.max(xs[i], ys[i]);
rlm@10 3329 return xs;
rlm@10 3330 }
rlm@10 3331
rlm@10 3332 static public int[] vmin(int[] x, int[] ys){
rlm@10 3333 final int[] xs = x.clone();
rlm@10 3334 for(int i = 0; i < xs.length; i++)
rlm@10 3335 xs[i] = Math.min(xs[i], ys[i]);
rlm@10 3336 return xs;
rlm@10 3337 }
rlm@10 3338
rlm@10 3339 static public int[] vmap(IFn fn, int[] x) throws Exception{
rlm@10 3340 int[] xs = x.clone();
rlm@10 3341 for(int i = 0; i < xs.length; i++)
rlm@10 3342 xs[i] = ((Number) fn.invoke(xs[i])).intValue();
rlm@10 3343 return xs;
rlm@10 3344 }
rlm@10 3345
rlm@10 3346 static public int[] vmap(IFn fn, int[] x, int[] ys) throws Exception{
rlm@10 3347 int[] xs = x.clone();
rlm@10 3348 for(int i = 0; i < xs.length; i++)
rlm@10 3349 xs[i] = ((Number) fn.invoke(xs[i], ys[i])).intValue();
rlm@10 3350 return xs;
rlm@10 3351 }
rlm@10 3352
rlm@10 3353 }
rlm@10 3354
rlm@10 3355 static public class L{
rlm@10 3356 static public long add(long x, long y){
rlm@10 3357 return x + y;
rlm@10 3358 }
rlm@10 3359
rlm@10 3360 static public long subtract(long x, long y){
rlm@10 3361 return x - y;
rlm@10 3362 }
rlm@10 3363
rlm@10 3364 static public long negate(long x){
rlm@10 3365 return -x;
rlm@10 3366 }
rlm@10 3367
rlm@10 3368 static public long inc(long x){
rlm@10 3369 return x + 1;
rlm@10 3370 }
rlm@10 3371
rlm@10 3372 static public long dec(long x){
rlm@10 3373 return x - 1;
rlm@10 3374 }
rlm@10 3375
rlm@10 3376 static public long multiply(long x, long y){
rlm@10 3377 return x * y;
rlm@10 3378 }
rlm@10 3379
rlm@10 3380 static public long divide(long x, long y){
rlm@10 3381 return x / y;
rlm@10 3382 }
rlm@10 3383
rlm@10 3384 static public boolean equiv(long x, long y){
rlm@10 3385 return x == y;
rlm@10 3386 }
rlm@10 3387
rlm@10 3388 static public boolean lt(long x, long y){
rlm@10 3389 return x < y;
rlm@10 3390 }
rlm@10 3391
rlm@10 3392 static public boolean lte(long x, long y){
rlm@10 3393 return x <= y;
rlm@10 3394 }
rlm@10 3395
rlm@10 3396 static public boolean gt(long x, long y){
rlm@10 3397 return x > y;
rlm@10 3398 }
rlm@10 3399
rlm@10 3400 static public boolean gte(long x, long y){
rlm@10 3401 return x >= y;
rlm@10 3402 }
rlm@10 3403
rlm@10 3404 static public boolean pos(long x){
rlm@10 3405 return x > 0;
rlm@10 3406 }
rlm@10 3407
rlm@10 3408 static public boolean neg(long x){
rlm@10 3409 return x < 0;
rlm@10 3410 }
rlm@10 3411
rlm@10 3412 static public boolean zero(long x){
rlm@10 3413 return x == 0;
rlm@10 3414 }
rlm@10 3415
rlm@10 3416 static public long aget(long[] xs, int i){
rlm@10 3417 return xs[i];
rlm@10 3418 }
rlm@10 3419
rlm@10 3420 static public long aset(long[] xs, int i, long v){
rlm@10 3421 xs[i] = v;
rlm@10 3422 return v;
rlm@10 3423 }
rlm@10 3424
rlm@10 3425 static public int alength(long[] xs){
rlm@10 3426 return xs.length;
rlm@10 3427 }
rlm@10 3428
rlm@10 3429 static public long[] aclone(long[] xs){
rlm@10 3430 return xs.clone();
rlm@10 3431 }
rlm@10 3432
rlm@10 3433 static public long[] vec(int size, Object init){
rlm@10 3434 long[] ret = new long[size];
rlm@10 3435 if(init instanceof Number)
rlm@10 3436 {
rlm@10 3437 long f = ((Number) init).longValue();
rlm@10 3438 for(int i = 0; i < ret.length; i++)
rlm@10 3439 ret[i] = f;
rlm@10 3440 }
rlm@10 3441 else
rlm@10 3442 {
rlm@10 3443 ISeq s = RT.seq(init);
rlm@10 3444 for(int i = 0; i < size && s != null; i++, s = s.rest())
rlm@10 3445 ret[i] = ((Number) s.first()).longValue();
rlm@10 3446 }
rlm@10 3447 return ret;
rlm@10 3448 }
rlm@10 3449
rlm@10 3450 static public long[] vec(Object sizeOrSeq){
rlm@10 3451 if(sizeOrSeq instanceof Number)
rlm@10 3452 return new long[((Number) sizeOrSeq).intValue()];
rlm@10 3453 else
rlm@10 3454 {
rlm@10 3455 ISeq s = RT.seq(sizeOrSeq);
rlm@10 3456 int size = s.count();
rlm@10 3457 long[] ret = new long[size];
rlm@10 3458 for(int i = 0; i < size && s != null; i++, s = s.rest())
rlm@10 3459 ret[i] = ((Number) s.first()).intValue();
rlm@10 3460 return ret;
rlm@10 3461 }
rlm@10 3462 }
rlm@10 3463
rlm@10 3464
rlm@10 3465 static public long[] vsadd(long[] x, long y){
rlm@10 3466 final long[] xs = x.clone();
rlm@10 3467 for(int i = 0; i < xs.length; i++)
rlm@10 3468 xs[i] += y;
rlm@10 3469 return xs;
rlm@10 3470 }
rlm@10 3471
rlm@10 3472 static public long[] vssub(long[] x, long y){
rlm@10 3473 final long[] xs = x.clone();
rlm@10 3474 for(int i = 0; i < xs.length; i++)
rlm@10 3475 xs[i] -= y;
rlm@10 3476 return xs;
rlm@10 3477 }
rlm@10 3478
rlm@10 3479 static public long[] vsdiv(long[] x, long y){
rlm@10 3480 final long[] xs = x.clone();
rlm@10 3481 for(int i = 0; i < xs.length; i++)
rlm@10 3482 xs[i] /= y;
rlm@10 3483 return xs;
rlm@10 3484 }
rlm@10 3485
rlm@10 3486 static public long[] vsmul(long[] x, long y){
rlm@10 3487 final long[] xs = x.clone();
rlm@10 3488 for(int i = 0; i < xs.length; i++)
rlm@10 3489 xs[i] *= y;
rlm@10 3490 return xs;
rlm@10 3491 }
rlm@10 3492
rlm@10 3493 static public long[] svdiv(long y, long[] x){
rlm@10 3494 final long[] xs = x.clone();
rlm@10 3495 for(int i = 0; i < xs.length; i++)
rlm@10 3496 xs[i] = y / xs[i];
rlm@10 3497 return xs;
rlm@10 3498 }
rlm@10 3499
rlm@10 3500 static public long[] vsmuladd(long[] x, long y, long[] zs){
rlm@10 3501 final long[] xs = x.clone();
rlm@10 3502 for(int i = 0; i < xs.length; i++)
rlm@10 3503 xs[i] = xs[i] * y + zs[i];
rlm@10 3504 return xs;
rlm@10 3505 }
rlm@10 3506
rlm@10 3507 static public long[] vsmulsub(long[] x, long y, long[] zs){
rlm@10 3508 final long[] xs = x.clone();
rlm@10 3509 for(int i = 0; i < xs.length; i++)
rlm@10 3510 xs[i] = xs[i] * y - zs[i];
rlm@10 3511 return xs;
rlm@10 3512 }
rlm@10 3513
rlm@10 3514 static public long[] vsmulsadd(long[] x, long y, long z){
rlm@10 3515 final long[] xs = x.clone();
rlm@10 3516 for(int i = 0; i < xs.length; i++)
rlm@10 3517 xs[i] = xs[i] * y + z;
rlm@10 3518 return xs;
rlm@10 3519 }
rlm@10 3520
rlm@10 3521 static public long[] vsmulssub(long[] x, long y, long z){
rlm@10 3522 final long[] xs = x.clone();
rlm@10 3523 for(int i = 0; i < xs.length; i++)
rlm@10 3524 xs[i] = xs[i] * y - z;
rlm@10 3525 return xs;
rlm@10 3526 }
rlm@10 3527
rlm@10 3528 static public long[] vabs(long[] x){
rlm@10 3529 final long[] xs = x.clone();
rlm@10 3530 for(int i = 0; i < xs.length; i++)
rlm@10 3531 xs[i] = Math.abs(xs[i]);
rlm@10 3532 return xs;
rlm@10 3533 }
rlm@10 3534
rlm@10 3535 static public long[] vnegabs(long[] x){
rlm@10 3536 final long[] xs = x.clone();
rlm@10 3537 for(int i = 0; i < xs.length; i++)
rlm@10 3538 xs[i] = -Math.abs(xs[i]);
rlm@10 3539 return xs;
rlm@10 3540 }
rlm@10 3541
rlm@10 3542 static public long[] vneg(long[] x){
rlm@10 3543 final long[] xs = x.clone();
rlm@10 3544 for(int i = 0; i < xs.length; i++)
rlm@10 3545 xs[i] = -xs[i];
rlm@10 3546 return xs;
rlm@10 3547 }
rlm@10 3548
rlm@10 3549 static public long[] vsqr(long[] x){
rlm@10 3550 final long[] xs = x.clone();
rlm@10 3551 for(int i = 0; i < xs.length; i++)
rlm@10 3552 xs[i] *= xs[i];
rlm@10 3553 return xs;
rlm@10 3554 }
rlm@10 3555
rlm@10 3556 static public long[] vsignedsqr(long[] x){
rlm@10 3557 final long[] xs = x.clone();
rlm@10 3558 for(int i = 0; i < xs.length; i++)
rlm@10 3559 xs[i] *= Math.abs(xs[i]);
rlm@10 3560 return xs;
rlm@10 3561 }
rlm@10 3562
rlm@10 3563 static public long[] vclip(long[] x, long low, long high){
rlm@10 3564 final long[] xs = x.clone();
rlm@10 3565 for(int i = 0; i < xs.length; i++)
rlm@10 3566 {
rlm@10 3567 if(xs[i] < low)
rlm@10 3568 xs[i] = low;
rlm@10 3569 else if(xs[i] > high)
rlm@10 3570 xs[i] = high;
rlm@10 3571 }
rlm@10 3572 return xs;
rlm@10 3573 }
rlm@10 3574
rlm@10 3575 static public IPersistentVector vclipcounts(long[] x, long low, long high){
rlm@10 3576 final long[] xs = x.clone();
rlm@10 3577 int lowc = 0;
rlm@10 3578 int highc = 0;
rlm@10 3579
rlm@10 3580 for(int i = 0; i < xs.length; i++)
rlm@10 3581 {
rlm@10 3582 if(xs[i] < low)
rlm@10 3583 {
rlm@10 3584 ++lowc;
rlm@10 3585 xs[i] = low;
rlm@10 3586 }
rlm@10 3587 else if(xs[i] > high)
rlm@10 3588 {
rlm@10 3589 ++highc;
rlm@10 3590 xs[i] = high;
rlm@10 3591 }
rlm@10 3592 }
rlm@10 3593 return RT.vector(xs, lowc, highc);
rlm@10 3594 }
rlm@10 3595
rlm@10 3596 static public long[] vthresh(long[] x, long thresh, long otherwise){
rlm@10 3597 final long[] xs = x.clone();
rlm@10 3598 for(int i = 0; i < xs.length; i++)
rlm@10 3599 {
rlm@10 3600 if(xs[i] < thresh)
rlm@10 3601 xs[i] = otherwise;
rlm@10 3602 }
rlm@10 3603 return xs;
rlm@10 3604 }
rlm@10 3605
rlm@10 3606 static public long[] vreverse(long[] x){
rlm@10 3607 final long[] xs = x.clone();
rlm@10 3608 for(int i = 0; i < xs.length; i++)
rlm@10 3609 xs[i] = xs[xs.length - i - 1];
rlm@10 3610 return xs;
rlm@10 3611 }
rlm@10 3612
rlm@10 3613 static public long[] vrunningsum(long[] x){
rlm@10 3614 final long[] xs = x.clone();
rlm@10 3615 for(int i = 1; i < xs.length; i++)
rlm@10 3616 xs[i] = xs[i - 1] + xs[i];
rlm@10 3617 return xs;
rlm@10 3618 }
rlm@10 3619
rlm@10 3620 static public long[] vsort(long[] x){
rlm@10 3621 final long[] xs = x.clone();
rlm@10 3622 Arrays.sort(xs);
rlm@10 3623 return xs;
rlm@10 3624 }
rlm@10 3625
rlm@10 3626 static public long vdot(long[] xs, long[] ys){
rlm@10 3627 long ret = 0;
rlm@10 3628 for(int i = 0; i < xs.length; i++)
rlm@10 3629 ret += xs[i] * ys[i];
rlm@10 3630 return ret;
rlm@10 3631 }
rlm@10 3632
rlm@10 3633 static public long vmax(long[] xs){
rlm@10 3634 if(xs.length == 0)
rlm@10 3635 return 0;
rlm@10 3636 long ret = xs[0];
rlm@10 3637 for(int i = 0; i < xs.length; i++)
rlm@10 3638 ret = Math.max(ret, xs[i]);
rlm@10 3639 return ret;
rlm@10 3640 }
rlm@10 3641
rlm@10 3642 static public long vmin(long[] xs){
rlm@10 3643 if(xs.length == 0)
rlm@10 3644 return 0;
rlm@10 3645 long ret = xs[0];
rlm@10 3646 for(int i = 0; i < xs.length; i++)
rlm@10 3647 ret = Math.min(ret, xs[i]);
rlm@10 3648 return ret;
rlm@10 3649 }
rlm@10 3650
rlm@10 3651 static public double vmean(long[] xs){
rlm@10 3652 if(xs.length == 0)
rlm@10 3653 return 0;
rlm@10 3654 return vsum(xs) / (double) xs.length;
rlm@10 3655 }
rlm@10 3656
rlm@10 3657 static public double vrms(long[] xs){
rlm@10 3658 if(xs.length == 0)
rlm@10 3659 return 0;
rlm@10 3660 long ret = 0;
rlm@10 3661 for(int i = 0; i < xs.length; i++)
rlm@10 3662 ret += xs[i] * xs[i];
rlm@10 3663 return Math.sqrt(ret / (double) xs.length);
rlm@10 3664 }
rlm@10 3665
rlm@10 3666 static public long vsum(long[] xs){
rlm@10 3667 long ret = 0;
rlm@10 3668 for(int i = 0; i < xs.length; i++)
rlm@10 3669 ret += xs[i];
rlm@10 3670 return ret;
rlm@10 3671 }
rlm@10 3672
rlm@10 3673 static public boolean vequiv(long[] xs, long[] ys){
rlm@10 3674 return Arrays.equals(xs, ys);
rlm@10 3675 }
rlm@10 3676
rlm@10 3677 static public long[] vadd(long[] x, long[] ys){
rlm@10 3678 final long[] xs = x.clone();
rlm@10 3679 for(int i = 0; i < xs.length; i++)
rlm@10 3680 xs[i] += ys[i];
rlm@10 3681 return xs;
rlm@10 3682 }
rlm@10 3683
rlm@10 3684 static public long[] vsub(long[] x, long[] ys){
rlm@10 3685 final long[] xs = x.clone();
rlm@10 3686 for(int i = 0; i < xs.length; i++)
rlm@10 3687 xs[i] -= ys[i];
rlm@10 3688 return xs;
rlm@10 3689 }
rlm@10 3690
rlm@10 3691 static public long[] vaddmul(long[] x, long[] ys, long[] zs){
rlm@10 3692 final long[] xs = x.clone();
rlm@10 3693 for(int i = 0; i < xs.length; i++)
rlm@10 3694 xs[i] = (xs[i] + ys[i]) * zs[i];
rlm@10 3695 return xs;
rlm@10 3696 }
rlm@10 3697
rlm@10 3698 static public long[] vsubmul(long[] x, long[] ys, long[] zs){
rlm@10 3699 final long[] xs = x.clone();
rlm@10 3700 for(int i = 0; i < xs.length; i++)
rlm@10 3701 xs[i] = (xs[i] - ys[i]) * zs[i];
rlm@10 3702 return xs;
rlm@10 3703 }
rlm@10 3704
rlm@10 3705 static public long[] vaddsmul(long[] x, long[] ys, long z){
rlm@10 3706 final long[] xs = x.clone();
rlm@10 3707 for(int i = 0; i < xs.length; i++)
rlm@10 3708 xs[i] = (xs[i] + ys[i]) * z;
rlm@10 3709 return xs;
rlm@10 3710 }
rlm@10 3711
rlm@10 3712 static public long[] vsubsmul(long[] x, long[] ys, long z){
rlm@10 3713 final long[] xs = x.clone();
rlm@10 3714 for(int i = 0; i < xs.length; i++)
rlm@10 3715 xs[i] = (xs[i] - ys[i]) * z;
rlm@10 3716 return xs;
rlm@10 3717 }
rlm@10 3718
rlm@10 3719 static public long[] vmulsadd(long[] x, long[] ys, long z){
rlm@10 3720 final long[] xs = x.clone();
rlm@10 3721 for(int i = 0; i < xs.length; i++)
rlm@10 3722 xs[i] = (xs[i] * ys[i]) + z;
rlm@10 3723 return xs;
rlm@10 3724 }
rlm@10 3725
rlm@10 3726 static public long[] vdiv(long[] x, long[] ys){
rlm@10 3727 final long[] xs = x.clone();
rlm@10 3728 for(int i = 0; i < xs.length; i++)
rlm@10 3729 xs[i] /= ys[i];
rlm@10 3730 return xs;
rlm@10 3731 }
rlm@10 3732
rlm@10 3733 static public long[] vmul(long[] x, long[] ys){
rlm@10 3734 final long[] xs = x.clone();
rlm@10 3735 for(int i = 0; i < xs.length; i++)
rlm@10 3736 xs[i] *= ys[i];
rlm@10 3737 return xs;
rlm@10 3738 }
rlm@10 3739
rlm@10 3740 static public long[] vmuladd(long[] x, long[] ys, long[] zs){
rlm@10 3741 final long[] xs = x.clone();
rlm@10 3742 for(int i = 0; i < xs.length; i++)
rlm@10 3743 xs[i] = (xs[i] * ys[i]) + zs[i];
rlm@10 3744 return xs;
rlm@10 3745 }
rlm@10 3746
rlm@10 3747 static public long[] vmulsub(long[] x, long[] ys, long[] zs){
rlm@10 3748 final long[] xs = x.clone();
rlm@10 3749 for(int i = 0; i < xs.length; i++)
rlm@10 3750 xs[i] = (xs[i] * ys[i]) - zs[i];
rlm@10 3751 return xs;
rlm@10 3752 }
rlm@10 3753
rlm@10 3754 static public long[] vmax(long[] x, long[] ys){
rlm@10 3755 final long[] xs = x.clone();
rlm@10 3756 for(int i = 0; i < xs.length; i++)
rlm@10 3757 xs[i] = Math.max(xs[i], ys[i]);
rlm@10 3758 return xs;
rlm@10 3759 }
rlm@10 3760
rlm@10 3761 static public long[] vmin(long[] x, long[] ys){
rlm@10 3762 final long[] xs = x.clone();
rlm@10 3763 for(int i = 0; i < xs.length; i++)
rlm@10 3764 xs[i] = Math.min(xs[i], ys[i]);
rlm@10 3765 return xs;
rlm@10 3766 }
rlm@10 3767
rlm@10 3768 static public long[] vmap(IFn fn, long[] x) throws Exception{
rlm@10 3769 long[] xs = x.clone();
rlm@10 3770 for(int i = 0; i < xs.length; i++)
rlm@10 3771 xs[i] = ((Number) fn.invoke(xs[i])).longValue();
rlm@10 3772 return xs;
rlm@10 3773 }
rlm@10 3774
rlm@10 3775 static public long[] vmap(IFn fn, long[] x, long[] ys) throws Exception{
rlm@10 3776 long[] xs = x.clone();
rlm@10 3777 for(int i = 0; i < xs.length; i++)
rlm@10 3778 xs[i] = ((Number) fn.invoke(xs[i], ys[i])).longValue();
rlm@10 3779 return xs;
rlm@10 3780 }
rlm@10 3781
rlm@10 3782 }
rlm@10 3783 */
rlm@10 3784
rlm@10 3785
rlm@10 3786 //overload resolution
rlm@10 3787
rlm@10 3788 static public Number add(int x, Object y){
rlm@10 3789 return add((Object)x,y);
rlm@10 3790 }
rlm@10 3791
rlm@10 3792 static public Number add(Object x, int y){
rlm@10 3793 return add(x,(Object)y);
rlm@10 3794 }
rlm@10 3795
rlm@10 3796 static public Number and(int x, Object y){
rlm@10 3797 return and((Object)x,y);
rlm@10 3798 }
rlm@10 3799
rlm@10 3800 static public Number and(Object x, int y){
rlm@10 3801 return and(x,(Object)y);
rlm@10 3802 }
rlm@10 3803
rlm@10 3804 static public Number or(int x, Object y){
rlm@10 3805 return or((Object)x,y);
rlm@10 3806 }
rlm@10 3807
rlm@10 3808 static public Number or(Object x, int y){
rlm@10 3809 return or(x,(Object)y);
rlm@10 3810 }
rlm@10 3811
rlm@10 3812 static public Number xor(int x, Object y){
rlm@10 3813 return xor((Object)x,y);
rlm@10 3814 }
rlm@10 3815
rlm@10 3816 static public Number xor(Object x, int y){
rlm@10 3817 return xor(x,(Object)y);
rlm@10 3818 }
rlm@10 3819
rlm@10 3820 static public Number add(float x, Object y){
rlm@10 3821 return add((Object)x,y);
rlm@10 3822 }
rlm@10 3823
rlm@10 3824 static public Number add(Object x, float y){
rlm@10 3825 return add(x,(Object)y);
rlm@10 3826 }
rlm@10 3827
rlm@10 3828 static public Number add(long x, Object y){
rlm@10 3829 return add((Object)x,y);
rlm@10 3830 }
rlm@10 3831
rlm@10 3832 static public Number add(Object x, long y){
rlm@10 3833 return add(x,(Object)y);
rlm@10 3834 }
rlm@10 3835
rlm@10 3836 static public Number add(double x, Object y){
rlm@10 3837 return add((Object)x,y);
rlm@10 3838 }
rlm@10 3839
rlm@10 3840 static public Number add(Object x, double y){
rlm@10 3841 return add(x,(Object)y);
rlm@10 3842 }
rlm@10 3843
rlm@10 3844 static public Number minus(int x, Object y){
rlm@10 3845 return minus((Object)x,y);
rlm@10 3846 }
rlm@10 3847
rlm@10 3848 static public Number minus(Object x, int y){
rlm@10 3849 return minus(x,(Object)y);
rlm@10 3850 }
rlm@10 3851
rlm@10 3852 static public Number minus(float x, Object y){
rlm@10 3853 return minus((Object)x,y);
rlm@10 3854 }
rlm@10 3855
rlm@10 3856 static public Number minus(Object x, float y){
rlm@10 3857 return minus(x,(Object)y);
rlm@10 3858 }
rlm@10 3859
rlm@10 3860 static public Number minus(long x, Object y){
rlm@10 3861 return minus((Object)x,y);
rlm@10 3862 }
rlm@10 3863
rlm@10 3864 static public Number minus(Object x, long y){
rlm@10 3865 return minus(x,(Object)y);
rlm@10 3866 }
rlm@10 3867
rlm@10 3868 static public Number minus(double x, Object y){
rlm@10 3869 return minus((Object)x,y);
rlm@10 3870 }
rlm@10 3871
rlm@10 3872 static public Number minus(Object x, double y){
rlm@10 3873 return minus(x,(Object)y);
rlm@10 3874 }
rlm@10 3875
rlm@10 3876 static public Number multiply(int x, Object y){
rlm@10 3877 return multiply((Object)x,y);
rlm@10 3878 }
rlm@10 3879
rlm@10 3880 static public Number multiply(Object x, int y){
rlm@10 3881 return multiply(x,(Object)y);
rlm@10 3882 }
rlm@10 3883
rlm@10 3884 static public Number multiply(float x, Object y){
rlm@10 3885 return multiply((Object)x,y);
rlm@10 3886 }
rlm@10 3887
rlm@10 3888 static public Number multiply(Object x, float y){
rlm@10 3889 return multiply(x,(Object)y);
rlm@10 3890 }
rlm@10 3891
rlm@10 3892 static public Number multiply(long x, Object y){
rlm@10 3893 return multiply((Object)x,y);
rlm@10 3894 }
rlm@10 3895
rlm@10 3896 static public Number multiply(Object x, long y){
rlm@10 3897 return multiply(x,(Object)y);
rlm@10 3898 }
rlm@10 3899
rlm@10 3900 static public Number multiply(double x, Object y){
rlm@10 3901 return multiply((Object)x,y);
rlm@10 3902 }
rlm@10 3903
rlm@10 3904 static public Number multiply(Object x, double y){
rlm@10 3905 return multiply(x,(Object)y);
rlm@10 3906 }
rlm@10 3907
rlm@10 3908 static public Number divide(int x, Object y){
rlm@10 3909 return divide((Object)x,y);
rlm@10 3910 }
rlm@10 3911
rlm@10 3912 static public Number divide(Object x, int y){
rlm@10 3913 return divide(x,(Object)y);
rlm@10 3914 }
rlm@10 3915
rlm@10 3916 static public Number divide(float x, Object y){
rlm@10 3917 return divide((Object)x,y);
rlm@10 3918 }
rlm@10 3919
rlm@10 3920 static public Number divide(Object x, float y){
rlm@10 3921 return divide(x,(Object)y);
rlm@10 3922 }
rlm@10 3923
rlm@10 3924 static public Number divide(long x, Object y){
rlm@10 3925 return divide((Object)x,y);
rlm@10 3926 }
rlm@10 3927
rlm@10 3928 static public Number divide(Object x, long y){
rlm@10 3929 return divide(x,(Object)y);
rlm@10 3930 }
rlm@10 3931
rlm@10 3932 static public Number divide(double x, Object y){
rlm@10 3933 return divide((Object)x,y);
rlm@10 3934 }
rlm@10 3935
rlm@10 3936 static public Number divide(Object x, double y){
rlm@10 3937 return divide(x,(Object)y);
rlm@10 3938 }
rlm@10 3939
rlm@10 3940 static public boolean lt(int x, Object y){
rlm@10 3941 return lt((Object)x,y);
rlm@10 3942 }
rlm@10 3943
rlm@10 3944 static public boolean lt(Object x, int y){
rlm@10 3945 return lt(x,(Object)y);
rlm@10 3946 }
rlm@10 3947
rlm@10 3948 static public boolean lt(float x, Object y){
rlm@10 3949 return lt((Object)x,y);
rlm@10 3950 }
rlm@10 3951
rlm@10 3952 static public boolean lt(Object x, float y){
rlm@10 3953 return lt(x,(Object)y);
rlm@10 3954 }
rlm@10 3955
rlm@10 3956 static public boolean lt(long x, Object y){
rlm@10 3957 return lt((Object)x,y);
rlm@10 3958 }
rlm@10 3959
rlm@10 3960 static public boolean lt(Object x, long y){
rlm@10 3961 return lt(x,(Object)y);
rlm@10 3962 }
rlm@10 3963
rlm@10 3964 static public boolean lt(double x, Object y){
rlm@10 3965 return lt((Object)x,y);
rlm@10 3966 }
rlm@10 3967
rlm@10 3968 static public boolean lt(Object x, double y){
rlm@10 3969 return lt(x,(Object)y);
rlm@10 3970 }
rlm@10 3971
rlm@10 3972 static public boolean lte(int x, Object y){
rlm@10 3973 return lte((Object)x,y);
rlm@10 3974 }
rlm@10 3975
rlm@10 3976 static public boolean lte(Object x, int y){
rlm@10 3977 return lte(x,(Object)y);
rlm@10 3978 }
rlm@10 3979
rlm@10 3980 static public boolean lte(float x, Object y){
rlm@10 3981 return lte((Object)x,y);
rlm@10 3982 }
rlm@10 3983
rlm@10 3984 static public boolean lte(Object x, float y){
rlm@10 3985 return lte(x,(Object)y);
rlm@10 3986 }
rlm@10 3987
rlm@10 3988 static public boolean lte(long x, Object y){
rlm@10 3989 return lte((Object)x,y);
rlm@10 3990 }
rlm@10 3991
rlm@10 3992 static public boolean lte(Object x, long y){
rlm@10 3993 return lte(x,(Object)y);
rlm@10 3994 }
rlm@10 3995
rlm@10 3996 static public boolean lte(double x, Object y){
rlm@10 3997 return lte((Object)x,y);
rlm@10 3998 }
rlm@10 3999
rlm@10 4000 static public boolean lte(Object x, double y){
rlm@10 4001 return lte(x,(Object)y);
rlm@10 4002 }
rlm@10 4003
rlm@10 4004 static public boolean gt(int x, Object y){
rlm@10 4005 return gt((Object)x,y);
rlm@10 4006 }
rlm@10 4007
rlm@10 4008 static public boolean gt(Object x, int y){
rlm@10 4009 return gt(x,(Object)y);
rlm@10 4010 }
rlm@10 4011
rlm@10 4012 static public boolean gt(float x, Object y){
rlm@10 4013 return gt((Object)x,y);
rlm@10 4014 }
rlm@10 4015
rlm@10 4016 static public boolean gt(Object x, float y){
rlm@10 4017 return gt(x,(Object)y);
rlm@10 4018 }
rlm@10 4019
rlm@10 4020 static public boolean gt(long x, Object y){
rlm@10 4021 return gt((Object)x,y);
rlm@10 4022 }
rlm@10 4023
rlm@10 4024 static public boolean gt(Object x, long y){
rlm@10 4025 return gt(x,(Object)y);
rlm@10 4026 }
rlm@10 4027
rlm@10 4028 static public boolean gt(double x, Object y){
rlm@10 4029 return gt((Object)x,y);
rlm@10 4030 }
rlm@10 4031
rlm@10 4032 static public boolean gt(Object x, double y){
rlm@10 4033 return gt(x,(Object)y);
rlm@10 4034 }
rlm@10 4035
rlm@10 4036 static public boolean gte(int x, Object y){
rlm@10 4037 return gte((Object)x,y);
rlm@10 4038 }
rlm@10 4039
rlm@10 4040 static public boolean gte(Object x, int y){
rlm@10 4041 return gte(x,(Object)y);
rlm@10 4042 }
rlm@10 4043
rlm@10 4044 static public boolean gte(float x, Object y){
rlm@10 4045 return gte((Object)x,y);
rlm@10 4046 }
rlm@10 4047
rlm@10 4048 static public boolean gte(Object x, float y){
rlm@10 4049 return gte(x,(Object)y);
rlm@10 4050 }
rlm@10 4051
rlm@10 4052 static public boolean gte(long x, Object y){
rlm@10 4053 return gte((Object)x,y);
rlm@10 4054 }
rlm@10 4055
rlm@10 4056 static public boolean gte(Object x, long y){
rlm@10 4057 return gte(x,(Object)y);
rlm@10 4058 }
rlm@10 4059
rlm@10 4060 static public boolean gte(double x, Object y){
rlm@10 4061 return gte((Object)x,y);
rlm@10 4062 }
rlm@10 4063
rlm@10 4064 static public boolean gte(Object x, double y){
rlm@10 4065 return gte(x,(Object)y);
rlm@10 4066 }
rlm@10 4067
rlm@10 4068
rlm@10 4069 static public boolean equiv(int x, Object y){
rlm@10 4070 return equiv((Object)x,y);
rlm@10 4071 }
rlm@10 4072
rlm@10 4073 static public boolean equiv(Object x, int y){
rlm@10 4074 return equiv(x,(Object)y);
rlm@10 4075 }
rlm@10 4076
rlm@10 4077 static public boolean equiv(float x, Object y){
rlm@10 4078 return equiv((Object)x,y);
rlm@10 4079 }
rlm@10 4080
rlm@10 4081 static public boolean equiv(Object x, float y){
rlm@10 4082 return equiv(x,(Object)y);
rlm@10 4083 }
rlm@10 4084
rlm@10 4085 static public boolean equiv(long x, Object y){
rlm@10 4086 return equiv((Object)x,y);
rlm@10 4087 }
rlm@10 4088
rlm@10 4089 static public boolean equiv(Object x, long y){
rlm@10 4090 return equiv(x,(Object)y);
rlm@10 4091 }
rlm@10 4092
rlm@10 4093 static public boolean equiv(double x, Object y){
rlm@10 4094 return equiv((Object)x,y);
rlm@10 4095 }
rlm@10 4096
rlm@10 4097 static public boolean equiv(Object x, double y){
rlm@10 4098 return equiv(x,(Object)y);
rlm@10 4099 }
rlm@10 4100
rlm@10 4101
rlm@10 4102 static public float add(int x, float y){
rlm@10 4103 return add((float)x,y);
rlm@10 4104 }
rlm@10 4105
rlm@10 4106 static public float add(float x, int y){
rlm@10 4107 return add(x,(float)y);
rlm@10 4108 }
rlm@10 4109
rlm@10 4110 static public double add(int x, double y){
rlm@10 4111 return add((double)x,y);
rlm@10 4112 }
rlm@10 4113
rlm@10 4114 static public double add(double x, int y){
rlm@10 4115 return add(x,(double)y);
rlm@10 4116 }
rlm@10 4117
rlm@10 4118 static public long add(int x, long y){
rlm@10 4119 return add((long)x,y);
rlm@10 4120 }
rlm@10 4121
rlm@10 4122 static public long add(long x, int y){
rlm@10 4123 return add(x,(long)y);
rlm@10 4124 }
rlm@10 4125
rlm@10 4126 static public float add(long x, float y){
rlm@10 4127 return add((float)x,y);
rlm@10 4128 }
rlm@10 4129
rlm@10 4130 static public float add(float x, long y){
rlm@10 4131 return add(x,(float)y);
rlm@10 4132 }
rlm@10 4133
rlm@10 4134 static public double add(long x, double y){
rlm@10 4135 return add((double)x,y);
rlm@10 4136 }
rlm@10 4137
rlm@10 4138 static public double add(double x, long y){
rlm@10 4139 return add(x,(double)y);
rlm@10 4140 }
rlm@10 4141
rlm@10 4142 static public double add(float x, double y){
rlm@10 4143 return add((double)x,y);
rlm@10 4144 }
rlm@10 4145
rlm@10 4146 static public double add(double x, float y){
rlm@10 4147 return add(x,(double)y);
rlm@10 4148 }
rlm@10 4149
rlm@10 4150 static public float minus(int x, float y){
rlm@10 4151 return minus((float)x,y);
rlm@10 4152 }
rlm@10 4153
rlm@10 4154 static public float minus(float x, int y){
rlm@10 4155 return minus(x,(float)y);
rlm@10 4156 }
rlm@10 4157
rlm@10 4158 static public double minus(int x, double y){
rlm@10 4159 return minus((double)x,y);
rlm@10 4160 }
rlm@10 4161
rlm@10 4162 static public double minus(double x, int y){
rlm@10 4163 return minus(x,(double)y);
rlm@10 4164 }
rlm@10 4165
rlm@10 4166 static public long minus(int x, long y){
rlm@10 4167 return minus((long)x,y);
rlm@10 4168 }
rlm@10 4169
rlm@10 4170 static public long minus(long x, int y){
rlm@10 4171 return minus(x,(long)y);
rlm@10 4172 }
rlm@10 4173
rlm@10 4174 static public float minus(long x, float y){
rlm@10 4175 return minus((float)x,y);
rlm@10 4176 }
rlm@10 4177
rlm@10 4178 static public float minus(float x, long y){
rlm@10 4179 return minus(x,(float)y);
rlm@10 4180 }
rlm@10 4181
rlm@10 4182 static public double minus(long x, double y){
rlm@10 4183 return minus((double)x,y);
rlm@10 4184 }
rlm@10 4185
rlm@10 4186 static public double minus(double x, long y){
rlm@10 4187 return minus(x,(double)y);
rlm@10 4188 }
rlm@10 4189
rlm@10 4190 static public double minus(float x, double y){
rlm@10 4191 return minus((double)x,y);
rlm@10 4192 }
rlm@10 4193
rlm@10 4194 static public double minus(double x, float y){
rlm@10 4195 return minus(x,(double)y);
rlm@10 4196 }
rlm@10 4197
rlm@10 4198 static public float multiply(int x, float y){
rlm@10 4199 return multiply((float)x,y);
rlm@10 4200 }
rlm@10 4201
rlm@10 4202 static public float multiply(float x, int y){
rlm@10 4203 return multiply(x,(float)y);
rlm@10 4204 }
rlm@10 4205
rlm@10 4206 static public double multiply(int x, double y){
rlm@10 4207 return multiply((double)x,y);
rlm@10 4208 }
rlm@10 4209
rlm@10 4210 static public double multiply(double x, int y){
rlm@10 4211 return multiply(x,(double)y);
rlm@10 4212 }
rlm@10 4213
rlm@10 4214 static public long multiply(int x, long y){
rlm@10 4215 return multiply((long)x,y);
rlm@10 4216 }
rlm@10 4217
rlm@10 4218 static public long multiply(long x, int y){
rlm@10 4219 return multiply(x,(long)y);
rlm@10 4220 }
rlm@10 4221
rlm@10 4222 static public float multiply(long x, float y){
rlm@10 4223 return multiply((float)x,y);
rlm@10 4224 }
rlm@10 4225
rlm@10 4226 static public float multiply(float x, long y){
rlm@10 4227 return multiply(x,(float)y);
rlm@10 4228 }
rlm@10 4229
rlm@10 4230 static public double multiply(long x, double y){
rlm@10 4231 return multiply((double)x,y);
rlm@10 4232 }
rlm@10 4233
rlm@10 4234 static public double multiply(double x, long y){
rlm@10 4235 return multiply(x,(double)y);
rlm@10 4236 }
rlm@10 4237
rlm@10 4238 static public double multiply(float x, double y){
rlm@10 4239 return multiply((double)x,y);
rlm@10 4240 }
rlm@10 4241
rlm@10 4242 static public double multiply(double x, float y){
rlm@10 4243 return multiply(x,(double)y);
rlm@10 4244 }
rlm@10 4245
rlm@10 4246 static public float divide(int x, float y){
rlm@10 4247 return divide((float)x,y);
rlm@10 4248 }
rlm@10 4249
rlm@10 4250 static public float divide(float x, int y){
rlm@10 4251 return divide(x,(float)y);
rlm@10 4252 }
rlm@10 4253
rlm@10 4254 static public double divide(int x, double y){
rlm@10 4255 return divide((double)x,y);
rlm@10 4256 }
rlm@10 4257
rlm@10 4258 static public double divide(double x, int y){
rlm@10 4259 return divide(x,(double)y);
rlm@10 4260 }
rlm@10 4261
rlm@10 4262 static public float divide(long x, float y){
rlm@10 4263 return divide((float)x,y);
rlm@10 4264 }
rlm@10 4265
rlm@10 4266 static public float divide(float x, long y){
rlm@10 4267 return divide(x,(float)y);
rlm@10 4268 }
rlm@10 4269
rlm@10 4270 static public double divide(long x, double y){
rlm@10 4271 return divide((double)x,y);
rlm@10 4272 }
rlm@10 4273
rlm@10 4274 static public double divide(double x, long y){
rlm@10 4275 return divide(x,(double)y);
rlm@10 4276 }
rlm@10 4277
rlm@10 4278 static public double divide(float x, double y){
rlm@10 4279 return divide((double)x,y);
rlm@10 4280 }
rlm@10 4281
rlm@10 4282 static public double divide(double x, float y){
rlm@10 4283 return divide(x,(double)y);
rlm@10 4284 }
rlm@10 4285
rlm@10 4286 static public boolean lt(int x, float y){
rlm@10 4287 return lt((float)x,y);
rlm@10 4288 }
rlm@10 4289
rlm@10 4290 static public boolean lt(float x, int y){
rlm@10 4291 return lt(x,(float)y);
rlm@10 4292 }
rlm@10 4293
rlm@10 4294 static public boolean lt(int x, double y){
rlm@10 4295 return lt((double)x,y);
rlm@10 4296 }
rlm@10 4297
rlm@10 4298 static public boolean lt(double x, int y){
rlm@10 4299 return lt(x,(double)y);
rlm@10 4300 }
rlm@10 4301
rlm@10 4302 static public boolean lt(int x, long y){
rlm@10 4303 return lt((long)x,y);
rlm@10 4304 }
rlm@10 4305
rlm@10 4306 static public boolean lt(long x, int y){
rlm@10 4307 return lt(x,(long)y);
rlm@10 4308 }
rlm@10 4309
rlm@10 4310 static public boolean lt(long x, float y){
rlm@10 4311 return lt((float)x,y);
rlm@10 4312 }
rlm@10 4313
rlm@10 4314 static public boolean lt(float x, long y){
rlm@10 4315 return lt(x,(float)y);
rlm@10 4316 }
rlm@10 4317
rlm@10 4318 static public boolean lt(long x, double y){
rlm@10 4319 return lt((double)x,y);
rlm@10 4320 }
rlm@10 4321
rlm@10 4322 static public boolean lt(double x, long y){
rlm@10 4323 return lt(x,(double)y);
rlm@10 4324 }
rlm@10 4325
rlm@10 4326 static public boolean lt(float x, double y){
rlm@10 4327 return lt((double)x,y);
rlm@10 4328 }
rlm@10 4329
rlm@10 4330 static public boolean lt(double x, float y){
rlm@10 4331 return lt(x,(double)y);
rlm@10 4332 }
rlm@10 4333
rlm@10 4334
rlm@10 4335 static public boolean lte(int x, float y){
rlm@10 4336 return lte((float)x,y);
rlm@10 4337 }
rlm@10 4338
rlm@10 4339 static public boolean lte(float x, int y){
rlm@10 4340 return lte(x,(float)y);
rlm@10 4341 }
rlm@10 4342
rlm@10 4343 static public boolean lte(int x, double y){
rlm@10 4344 return lte((double)x,y);
rlm@10 4345 }
rlm@10 4346
rlm@10 4347 static public boolean lte(double x, int y){
rlm@10 4348 return lte(x,(double)y);
rlm@10 4349 }
rlm@10 4350
rlm@10 4351 static public boolean lte(int x, long y){
rlm@10 4352 return lte((long)x,y);
rlm@10 4353 }
rlm@10 4354
rlm@10 4355 static public boolean lte(long x, int y){
rlm@10 4356 return lte(x,(long)y);
rlm@10 4357 }
rlm@10 4358
rlm@10 4359 static public boolean lte(long x, float y){
rlm@10 4360 return lte((float)x,y);
rlm@10 4361 }
rlm@10 4362
rlm@10 4363 static public boolean lte(float x, long y){
rlm@10 4364 return lte(x,(float)y);
rlm@10 4365 }
rlm@10 4366
rlm@10 4367 static public boolean lte(long x, double y){
rlm@10 4368 return lte((double)x,y);
rlm@10 4369 }
rlm@10 4370
rlm@10 4371 static public boolean lte(double x, long y){
rlm@10 4372 return lte(x,(double)y);
rlm@10 4373 }
rlm@10 4374
rlm@10 4375 static public boolean lte(float x, double y){
rlm@10 4376 return lte((double)x,y);
rlm@10 4377 }
rlm@10 4378
rlm@10 4379 static public boolean lte(double x, float y){
rlm@10 4380 return lte(x,(double)y);
rlm@10 4381 }
rlm@10 4382
rlm@10 4383 static public boolean gt(int x, float y){
rlm@10 4384 return gt((float)x,y);
rlm@10 4385 }
rlm@10 4386
rlm@10 4387 static public boolean gt(float x, int y){
rlm@10 4388 return gt(x,(float)y);
rlm@10 4389 }
rlm@10 4390
rlm@10 4391 static public boolean gt(int x, double y){
rlm@10 4392 return gt((double)x,y);
rlm@10 4393 }
rlm@10 4394
rlm@10 4395 static public boolean gt(double x, int y){
rlm@10 4396 return gt(x,(double)y);
rlm@10 4397 }
rlm@10 4398
rlm@10 4399 static public boolean gt(int x, long y){
rlm@10 4400 return gt((long)x,y);
rlm@10 4401 }
rlm@10 4402
rlm@10 4403 static public boolean gt(long x, int y){
rlm@10 4404 return gt(x,(long)y);
rlm@10 4405 }
rlm@10 4406
rlm@10 4407 static public boolean gt(long x, float y){
rlm@10 4408 return gt((float)x,y);
rlm@10 4409 }
rlm@10 4410
rlm@10 4411 static public boolean gt(float x, long y){
rlm@10 4412 return gt(x,(float)y);
rlm@10 4413 }
rlm@10 4414
rlm@10 4415 static public boolean gt(long x, double y){
rlm@10 4416 return gt((double)x,y);
rlm@10 4417 }
rlm@10 4418
rlm@10 4419 static public boolean gt(double x, long y){
rlm@10 4420 return gt(x,(double)y);
rlm@10 4421 }
rlm@10 4422
rlm@10 4423 static public boolean gt(float x, double y){
rlm@10 4424 return gt((double)x,y);
rlm@10 4425 }
rlm@10 4426
rlm@10 4427 static public boolean gt(double x, float y){
rlm@10 4428 return gt(x,(double)y);
rlm@10 4429 }
rlm@10 4430
rlm@10 4431 static public boolean gte(int x, float y){
rlm@10 4432 return gte((float)x,y);
rlm@10 4433 }
rlm@10 4434
rlm@10 4435 static public boolean gte(float x, int y){
rlm@10 4436 return gte(x,(float)y);
rlm@10 4437 }
rlm@10 4438
rlm@10 4439 static public boolean gte(int x, double y){
rlm@10 4440 return gte((double)x,y);
rlm@10 4441 }
rlm@10 4442
rlm@10 4443 static public boolean gte(double x, int y){
rlm@10 4444 return gte(x,(double)y);
rlm@10 4445 }
rlm@10 4446
rlm@10 4447 static public boolean gte(int x, long y){
rlm@10 4448 return gte((long)x,y);
rlm@10 4449 }
rlm@10 4450
rlm@10 4451 static public boolean gte(long x, int y){
rlm@10 4452 return gte(x,(long)y);
rlm@10 4453 }
rlm@10 4454
rlm@10 4455 static public boolean gte(long x, float y){
rlm@10 4456 return gte((float)x,y);
rlm@10 4457 }
rlm@10 4458
rlm@10 4459 static public boolean gte(float x, long y){
rlm@10 4460 return gte(x,(float)y);
rlm@10 4461 }
rlm@10 4462
rlm@10 4463 static public boolean gte(long x, double y){
rlm@10 4464 return gte((double)x,y);
rlm@10 4465 }
rlm@10 4466
rlm@10 4467 static public boolean gte(double x, long y){
rlm@10 4468 return gte(x,(double)y);
rlm@10 4469 }
rlm@10 4470
rlm@10 4471 static public boolean gte(float x, double y){
rlm@10 4472 return gte((double)x,y);
rlm@10 4473 }
rlm@10 4474
rlm@10 4475 static public boolean gte(double x, float y){
rlm@10 4476 return gte(x,(double)y);
rlm@10 4477 }
rlm@10 4478
rlm@10 4479 static public boolean equiv(int x, float y){
rlm@10 4480 return equiv((float)x,y);
rlm@10 4481 }
rlm@10 4482
rlm@10 4483 static public boolean equiv(float x, int y){
rlm@10 4484 return equiv(x,(float)y);
rlm@10 4485 }
rlm@10 4486
rlm@10 4487 static public boolean equiv(int x, double y){
rlm@10 4488 return equiv((double)x,y);
rlm@10 4489 }
rlm@10 4490
rlm@10 4491 static public boolean equiv(double x, int y){
rlm@10 4492 return equiv(x,(double)y);
rlm@10 4493 }
rlm@10 4494
rlm@10 4495 static public boolean equiv(int x, long y){
rlm@10 4496 return equiv((long)x,y);
rlm@10 4497 }
rlm@10 4498
rlm@10 4499 static public boolean equiv(long x, int y){
rlm@10 4500 return equiv(x,(long)y);
rlm@10 4501 }
rlm@10 4502
rlm@10 4503 static public boolean equiv(long x, float y){
rlm@10 4504 return equiv((float)x,y);
rlm@10 4505 }
rlm@10 4506
rlm@10 4507 static public boolean equiv(float x, long y){
rlm@10 4508 return equiv(x,(float)y);
rlm@10 4509 }
rlm@10 4510
rlm@10 4511 static public boolean equiv(long x, double y){
rlm@10 4512 return equiv((double)x,y);
rlm@10 4513 }
rlm@10 4514
rlm@10 4515 static public boolean equiv(double x, long y){
rlm@10 4516 return equiv(x,(double)y);
rlm@10 4517 }
rlm@10 4518
rlm@10 4519 static public boolean equiv(float x, double y){
rlm@10 4520 return equiv((double)x,y);
rlm@10 4521 }
rlm@10 4522
rlm@10 4523 static public boolean equiv(double x, float y){
rlm@10 4524 return equiv(x,(double)y);
rlm@10 4525 }
rlm@10 4526
rlm@10 4527 }