001/* 002 * $Id$ 003 */ 004 005package edu.jas.poly; 006 007 008import java.util.ArrayList; 009import java.util.Arrays; 010import java.util.List; 011 012 013/** 014 * ExpVectorLong implements exponent vectors for polynomials using arrays of 015 * long as storage unit. This class is used by ExpVector internally, there is no 016 * need to use this class directly. 017 * @see ExpVector 018 * @author Heinz Kredel 019 */ 020 021public final class ExpVectorLong extends ExpVector 022/*implements AbelianGroupElem<ExpVectorLong>*/{ 023 024 025 /** 026 * The data structure is an array of longs. 027 */ 028 /*package*/final long[] val; 029 030 031 /** 032 * Constructor for ExpVector. 033 * @param n length of exponent vector. 034 */ 035 public ExpVectorLong(int n) { 036 this(new long[n], true); 037 } 038 039 040 /** 041 * Constructor for ExpVector. Sets exponent i to e. 042 * @param n length of exponent vector. 043 * @param i index of exponent to be set. 044 * @param e exponent to be set. 045 */ 046 public ExpVectorLong(int n, int i, long e) { 047 this(new long[n], true); 048 val[i] = e; 049 } 050 051 052 /** 053 * Constructor for ExpVector. Sets val. 054 * @param v representation array. 055 */ 056 public ExpVectorLong(long[] v) { 057 this(v, false); 058 } 059 060 061 /** 062 * Internal constructor for ExpVector. Sets val. 063 * @param v internal representation array. 064 * @param alloc true if internal representation array is newly 065 * allocated, else false. 066 */ 067 protected ExpVectorLong(long[] v, boolean alloc) { 068 super(); 069 if (v == null) { 070 throw new IllegalArgumentException("null val not allowed"); 071 } 072 if (alloc) { 073 val = v; 074 } else { 075 val = Arrays.copyOf(v, v.length); // > Java-5 076 } 077 } 078 079 080 /** 081 * Constructor for ExpVector. Converts a String representation to an 082 * ExpVector. Accepted format = (1,2,3,4,5,6,7). 083 * @param s String representation. 084 */ 085 public ExpVectorLong(String s) throws NumberFormatException { 086 this(parse(s).val, true); 087 } 088 089 090 /** 091 * parser for ExpVector. Converts a String representation to an 092 * ExpVector. Accepted format = (1,2,3,4,5,6,7). 093 * @param s String representation. 094 * @return paresed ExpVector 095 */ 096 public static ExpVectorLong parse(String s) throws NumberFormatException { 097 long[] v = null; 098 // first format = (1,2,3,4,5,6,7) 099 List<Long> exps = new ArrayList<Long>(); 100 s = s.trim(); 101 int b = s.indexOf('('); 102 int e = s.indexOf(')', b + 1); 103 String teil; 104 int k; 105 long a; 106 if (b >= 0 && e >= 0) { 107 b++; 108 while ((k = s.indexOf(',', b)) >= 0) { 109 teil = s.substring(b, k); 110 a = Long.parseLong(teil); 111 exps.add(Long.valueOf(a)); 112 b = k + 1; 113 } 114 if (b <= e) { 115 teil = s.substring(b, e); 116 a = Long.parseLong(teil); 117 exps.add(Long.valueOf(a)); 118 } 119 int length = exps.size(); 120 v = new long[length]; 121 for (int j = 0; j < length; j++) { 122 v[j] = exps.get(j).longValue(); 123 } 124 } 125 return new ExpVectorLong(v,true); 126 } 127 128 129 /** 130 * Value of other. 131 * @param e other ExpVector. 132 * @return value in sub class of ExpVector. 133 */ 134 //@Override 135 public static ExpVector valueOf(ExpVector e) { 136 return new ExpVectorLong(e.getVal()); 137 } 138 139 140 /** 141 * Clone this. 142 * @see java.lang.Object#clone() 143 */ 144 @Override 145 public ExpVectorLong copy() { 146 long[] w = new long[val.length]; 147 System.arraycopy(val, 0, w, 0, val.length); 148 return new ExpVectorLong(w, true); 149 } 150 151 152 /** 153 * Get the exponent vector. 154 * @return val. 155 */ 156 @Override 157 public long[] getVal() { 158 long[] w = new long[val.length]; 159 System.arraycopy(val, 0, w, 0, val.length); 160 return w; 161 //return val; 162 } 163 164 165 /** 166 * Get the exponent at position i. 167 * @param i position. 168 * @return val[i]. 169 */ 170 @Override 171 public long getVal(int i) { 172 return val[i]; 173 } 174 175 176 /** 177 * Set the exponent at position i to e. 178 * @param i 179 * @param e 180 * @return old val[i]. 181 */ 182 @Override 183 protected long setVal(int i, long e) { 184 long x = val[i]; 185 val[i] = e; 186 hash = -1; // beware of race condition 187 return x; 188 } 189 190 191 /** 192 * Get the length of this exponent vector. 193 * @return val.length. 194 */ 195 @Override 196 public int length() { 197 return val.length; 198 } 199 200 201 /** 202 * Extend variables. Used e.g. in module embedding. Extend this by i 203 * elements and set val[j] to e. 204 * @param i number of elements to extend. 205 * @param j index of element to be set. 206 * @param e new exponent for val[j]. 207 * @return extended exponent vector. 208 */ 209 @Override 210 public ExpVectorLong extend(int i, int j, long e) { 211 long[] w = new long[val.length + i]; 212 System.arraycopy(val, 0, w, i, val.length); 213 if (j >= i) { 214 throw new IllegalArgumentException("i " + i + " <= j " + j + " invalid"); 215 } 216 w[j] = e; 217 return new ExpVectorLong(w, true); 218 } 219 220 221 /** 222 * Extend lower variables. Extend this by i lower elements and set val[j] to 223 * e. 224 * @param i number of elements to extend. 225 * @param j index of element to be set. 226 * @param e new exponent for val[j]. 227 * @return extended exponent vector. 228 */ 229 @Override 230 public ExpVectorLong extendLower(int i, int j, long e) { 231 long[] w = new long[val.length + i]; 232 System.arraycopy(val, 0, w, 0, val.length); 233 if (j >= i) { 234 throw new IllegalArgumentException("i " + i + " <= j " + j + " invalid"); 235 } 236 w[val.length + j] = e; 237 return new ExpVectorLong(w, true); 238 } 239 240 241 /** 242 * Contract variables. Used e.g. in module embedding. Contract this to len 243 * elements. 244 * @param i position of first element to be copied. 245 * @param len new length. 246 * @return contracted exponent vector. 247 */ 248 @Override 249 public ExpVectorLong contract(int i, int len) { 250 if (i + len > val.length) { 251 throw new IllegalArgumentException("len " + len + " > val.len " + val.length); 252 } 253 long[] w = new long[len]; 254 System.arraycopy(val, i, w, 0, len); 255 return new ExpVectorLong(w, true); 256 } 257 258 259 /** 260 * Reverse variables. Used e.g. in opposite rings. 261 * @return reversed exponent vector. 262 */ 263 @Override 264 public ExpVectorLong reverse() { 265 long[] w = new long[val.length]; 266 for (int i = 0; i < val.length; i++) { 267 w[i] = val[val.length - 1 - i]; 268 } 269 return new ExpVectorLong(w, true); 270 } 271 272 273 /** 274 * Reverse lower j variables. Used e.g. in opposite rings. Reverses the 275 * first j-1 variables, the rest is unchanged. 276 * @param j index of first variable reversed. 277 * @return reversed exponent vector. 278 */ 279 @Override 280 public ExpVectorLong reverse(int j) { 281 if (j < 0 || j > val.length) { 282 return this; 283 } 284 long[] w = new long[val.length]; 285 // copy first 286 for (int i = 0; i < j; i++) { 287 w[i] = val[i]; 288 } 289 // reverse rest 290 for (int i = j; i < val.length; i++) { 291 w[i] = val[val.length + j - 1 - i]; 292 } 293 //System.out.println("val = " + Arrays.toString(val)); 294 //System.out.println("w = " + Arrays.toString(w)); 295 return new ExpVectorLong(w, true); 296 } 297 298 299 /** 300 * Reverse upper j variables. Reverses the last j-1 variables, the rest is 301 * unchanged. 302 * @param j index of first variable not reversed. 303 * @return reversed exponent vector. 304 */ 305 public ExpVectorLong reverseUpper(int j) { 306 if (j < 0 || j > val.length) { 307 return this; 308 } 309 long[] w = new long[val.length]; 310 for (int i = 0; i < j; i++) { 311 w[i] = val[j - 1 - i]; 312 } 313 // copy rest 314 for (int i = j; i < val.length; i++) { 315 w[i] = val[i]; 316 } 317 return new ExpVectorLong(w, true); 318 } 319 320 321 /** 322 * Combine with ExpVector. Combine this with the other ExpVector V. 323 * @param V the other exponent vector. 324 * @return combined exponent vector. 325 */ 326 @Override 327 public ExpVectorLong combine(ExpVector V) { 328 if (V == null || V.length() == 0) { 329 return this; 330 } 331 ExpVectorLong Vl = (ExpVectorLong) V; 332 if (val.length == 0) { 333 return Vl; 334 } 335 long[] w = new long[val.length + Vl.val.length]; 336 System.arraycopy(val, 0, w, 0, val.length); 337 System.arraycopy(Vl.val, 0, w, val.length, Vl.val.length); 338 return new ExpVectorLong(w, true); 339 } 340 341 342 /** 343 * Permutation of exponent vector. 344 * @param P permutation. 345 * @return P(e). 346 */ 347 @Override 348 public ExpVectorLong permutation(List<Integer> P) { 349 long[] w = new long[val.length]; 350 int j = 0; 351 for (Integer i : P) { 352 w[j++] = val[i]; 353 } 354 return new ExpVectorLong(w, true); 355 } 356 357 358 /** 359 * Get the string representation. 360 * @see java.lang.Object#toString() 361 */ 362 @Override 363 public String toString() { 364 return super.toString() + ":long"; 365 } 366 367 368 /** 369 * Comparison with any other object. 370 * @see java.lang.Object#equals(java.lang.Object) 371 */ 372 @Override 373 public boolean equals(Object B) { 374 if (!(B instanceof ExpVectorLong)) { 375 return false; 376 } 377 ExpVectorLong b = (ExpVectorLong) B; 378 int t = this.invLexCompareTo(b); 379 //System.out.println("equals: this = " + this + " B = " + B + " t = " + t); 380 return (0 == t); 381 } 382 383 384 /** 385 * hashCode for this exponent vector. 386 * @see java.lang.Object#hashCode() Only for findbugs. 387 */ 388 @Override 389 public int hashCode() { 390 return super.hashCode(); 391 } 392 393 394 /** 395 * ExpVector absolute value. 396 * @return abs(this). 397 */ 398 @Override 399 public ExpVectorLong abs() { 400 long[] u = val; 401 long[] w = new long[u.length]; 402 for (int i = 0; i < u.length; i++) { 403 if (u[i] >= 0L) { 404 w[i] = u[i]; 405 } else { 406 w[i] = -u[i]; 407 } 408 } 409 return new ExpVectorLong(w, true); 410 } 411 412 413 /** 414 * ExpVector negate. 415 * @return -this. 416 */ 417 @Override 418 public ExpVectorLong negate() { 419 long[] u = val; 420 long[] w = new long[u.length]; 421 for (int i = 0; i < u.length; i++) { 422 w[i] = -u[i]; 423 } 424 return new ExpVectorLong(w, true); 425 } 426 427 428 /** 429 * ExpVector summation. 430 * @param V 431 * @return this+V. 432 */ 433 @Override 434 public ExpVectorLong sum(ExpVector V) { 435 long[] u = val; 436 long[] v = ((ExpVectorLong) V).val; 437 long[] w = new long[u.length]; 438 for (int i = 0; i < u.length; i++) { 439 w[i] = u[i] + v[i]; 440 } 441 return new ExpVectorLong(w, true); 442 } 443 444 445 /** 446 * ExpVector subtract. Result may have negative entries. 447 * @param V 448 * @return this-V. 449 */ 450 @Override 451 public ExpVectorLong subtract(ExpVector V) { 452 long[] u = val; 453 long[] v = ((ExpVectorLong) V).val; 454 long[] w = new long[u.length]; 455 for (int i = 0; i < u.length; i++) { 456 w[i] = u[i] - v[i]; 457 } 458 return new ExpVectorLong(w, true); 459 } 460 461 462 /** 463 * ExpVector multiply by scalar. 464 * @param s scalar 465 * @return s*this. 466 */ 467 @Override 468 public ExpVectorLong scalarMultiply(long s) { 469 long[] u = val; 470 long[] w = new long[u.length]; 471 for (int i = 0; i < u.length; i++) { 472 w[i] = s * u[i]; 473 } 474 return new ExpVectorLong(w, true); 475 } 476 477 478 /** 479 * ExpVector substitution. Clone and set exponent to d at position i. 480 * @param i position. 481 * @param d new exponent. 482 * @return substituted ExpVector. 483 */ 484 @Override 485 public ExpVectorLong subst(int i, long d) { 486 ExpVectorLong V = this.copy(); 487 //long e = 488 V.setVal(i, d); 489 return V; 490 } 491 492 493 /** 494 * ExpVector signum. 495 * @return 0 if this is zero, -1 if some entry is negative, 1 if no entry is 496 * negative and at least one entry is positive. 497 */ 498 @Override 499 public int signum() { 500 int t = 0; 501 long[] u = val; 502 for (int i = 0; i < u.length; i++) { 503 if (u[i] < 0) { 504 return -1; 505 } 506 if (u[i] > 0) { 507 t = 1; 508 } 509 } 510 return t; 511 } 512 513 514 /** 515 * ExpVector total degree. 516 * @return sum of all exponents. 517 */ 518 @Override 519 public long totalDeg() { 520 long t = 0; 521 long[] u = val; // U.val; 522 for (int i = 0; i < u.length; i++) { 523 t += u[i]; 524 } 525 return t; 526 } 527 528 529 /** 530 * ExpVector maximal degree. 531 * @return maximal exponent. 532 */ 533 @Override 534 public long maxDeg() { 535 long t = 0; 536 long[] u = val; 537 for (int i = 0; i < u.length; i++) { 538 if (u[i] > t) { 539 t = u[i]; 540 } 541 } 542 return t; 543 } 544 545 546 /** 547 * ExpVector minimal degree. 548 * @return minimal exponent. 549 */ 550 @Override 551 public long minDeg() { 552 long t = Long.MAX_VALUE; 553 long[] u = val; 554 for (int i = 0; i < u.length; i++) { 555 if (u[i] < t) { 556 t = u[i]; 557 } 558 } 559 return t; 560 } 561 562 563 /** 564 * ExpVector weighted degree. 565 * @param w weights. 566 * @return weighted sum of all exponents. 567 */ 568 @Override 569 public long weightDeg(long[][] w) { 570 if (w == null || w.length == 0) { 571 return totalDeg(); // assume weight 1 572 } 573 long t = 0; 574 long[] u = val; 575 for (int j = 0; j < w.length; j++) { 576 long[] wj = w[j]; 577 for (int i = 0; i < u.length; i++) { 578 t += wj[i] * u[i]; 579 } 580 } 581 return t; 582 } 583 584 585 /** 586 * ExpVector weighted degree. 587 * @param w weights. 588 * @return weighted sum of all exponents. 589 */ 590 @Override 591 public long weightDeg(long[] w) { 592 if (w == null || w.length == 0) { 593 return totalDeg(); // assume weight 1 594 } 595 long t = 0; 596 long[] u = val; 597 for (int i = 0; i < w.length; i++) { 598 t += w[i] * u[i]; 599 } 600 return t; 601 } 602 603 604 /** 605 * ExpVector least common multiple. 606 * @param V 607 * @return component wise maximum of this and V. 608 */ 609 @Override 610 public ExpVectorLong lcm(ExpVector V) { 611 long[] u = val; 612 long[] v = ((ExpVectorLong) V).val; 613 long[] w = new long[u.length]; 614 for (int i = 0; i < u.length; i++) { 615 w[i] = (u[i] >= v[i] ? u[i] : v[i]); 616 } 617 return new ExpVectorLong(w, true); 618 } 619 620 621 /** 622 * ExpVector greatest common divisor. 623 * @param V 624 * @return component wise minimum of this and V. 625 */ 626 @Override 627 public ExpVectorLong gcd(ExpVector V) { 628 long[] u = val; 629 long[] v = ((ExpVectorLong) V).val; 630 long[] w = new long[u.length]; 631 for (int i = 0; i < u.length; i++) { 632 w[i] = (u[i] <= v[i] ? u[i] : v[i]); 633 } 634 return new ExpVectorLong(w, true); 635 } 636 637 638 /** 639 * ExpVector dependent variables. 640 * @return number of indices where val has positive exponents. 641 */ 642 public int dependentVariables() { 643 int l = 0; 644 for (int i = 0; i < val.length; i++) { 645 if (val[i] > 0) { 646 l++; 647 } 648 } 649 return l; 650 } 651 652 653 /** 654 * ExpVector dependency on variables. 655 * @return array of indices where val has positive exponents. 656 */ 657 @Override 658 public int[] dependencyOnVariables() { 659 long[] u = val; 660 int l = dependentVariables(); 661 int[] dep = new int[l]; 662 if (l == 0) { 663 return dep; 664 } 665 int j = 0; 666 for (int i = 0; i < u.length; i++) { 667 if (u[i] > 0) { 668 dep[j] = i; 669 j++; 670 } 671 } 672 return dep; 673 } 674 675 676 /** 677 * ExpVector multiple test. Test if this is component wise greater or equal 678 * to V. 679 * @param V 680 * @return true if this is a multiple of V, else false. 681 */ 682 @Override 683 public boolean multipleOf(ExpVector V) { 684 long[] u = val; 685 long[] v = ((ExpVectorLong) V).val; 686 for (int i = 0; i < u.length; i++) { 687 if (u[i] < v[i]) { 688 return false; 689 } 690 } 691 return true; 692 } 693 694 695 /** 696 * ExpVector compareTo. 697 * @param V 698 * @return 0 if U == V, -1 if U < V, 1 if U > V. 699 */ 700 @Override 701 public int compareTo(ExpVector V) { 702 return this.invLexCompareTo(V); 703 } 704 705 706 /** 707 * ExpVector inverse lexicographical compareTo. 708 * @param V 709 * @return 0 if U == V, -1 if U < V, 1 if U > V. 710 */ 711 @Override 712 public int invLexCompareTo(ExpVector V) { 713 long[] u = val; 714 long[] v = ((ExpVectorLong) V).val; 715 int t = 0; 716 for (int i = 0; i < u.length; i++) { 717 if (u[i] > v[i]) 718 return 1; 719 if (u[i] < v[i]) 720 return -1; 721 } 722 return t; 723 } 724 725 726 /** 727 * ExpVector inverse lexicographical compareTo. 728 * @param V 729 * @param begin 730 * @param end 731 * @return 0 if U == V, -1 if U < V, 1 if U > V. 732 */ 733 @Override 734 public int invLexCompareTo(ExpVector V, int begin, int end) { 735 long[] u = val; 736 long[] v = ((ExpVectorLong) V).val; 737 if (begin < 0) { 738 begin = 0;; 739 } 740 if (end >= val.length) { 741 end = val.length; 742 } 743 int t = 0; 744 for (int i = begin; i < end; i++) { 745 if (u[i] > v[i]) 746 return 1; 747 if (u[i] < v[i]) 748 return -1; 749 } 750 return t; 751 } 752 753 754 /** 755 * ExpVector inverse graded lexicographical compareTo. 756 * @param V 757 * @return 0 if U == V, -1 if U < V, 1 if U > V. 758 */ 759 @Override 760 public int invGradCompareTo(ExpVector V) { 761 long[] u = val; 762 long[] v = ((ExpVectorLong) V).val; 763 int t = 0; 764 int i; 765 for (i = 0; i < u.length; i++) { 766 if (u[i] > v[i]) { 767 t = 1; 768 break; 769 } 770 if (u[i] < v[i]) { 771 t = -1; 772 break; 773 } 774 } 775 if (t == 0) { 776 return t; 777 } 778 long up = 0; 779 long vp = 0; 780 for (int j = i; j < u.length; j++) { 781 up += u[j]; 782 vp += v[j]; 783 } 784 if (up > vp) { 785 t = 1; 786 } else { 787 if (up < vp) { 788 t = -1; 789 } 790 } 791 return t; 792 } 793 794 795 /** 796 * ExpVector inverse graded lexicographical compareTo. 797 * @param V 798 * @param begin 799 * @param end 800 * @return 0 if U == V, -1 if U < V, 1 if U > V. 801 */ 802 @Override 803 public int invGradCompareTo(ExpVector V, int begin, int end) { 804 long[] u = val; 805 long[] v = ((ExpVectorLong) V).val; 806 if (begin < 0) { 807 begin = 0;; 808 } 809 if (end >= val.length) { 810 end = val.length; 811 } 812 int t = 0; 813 int i; 814 for (i = begin; i < end; i++) { 815 if (u[i] > v[i]) { 816 t = 1; 817 break; 818 } 819 if (u[i] < v[i]) { 820 t = -1; 821 break; 822 } 823 } 824 if (t == 0) { 825 return t; 826 } 827 long up = 0; 828 long vp = 0; 829 for (int j = i; j < end; j++) { 830 up += u[j]; 831 vp += v[j]; 832 } 833 if (up > vp) { 834 t = 1; 835 } else { 836 if (up < vp) { 837 t = -1; 838 } 839 } 840 return t; 841 } 842 843 844 /** 845 * ExpVector reverse inverse lexicographical compareTo. 846 * @param V 847 * @return 0 if U == V, -1 if U < V, 1 if U > V. 848 */ 849 @Override 850 public int revInvLexCompareTo(ExpVector V) { 851 long[] u = val; 852 long[] v = ((ExpVectorLong) V).val; 853 int t = 0; 854 for (int i = u.length - 1; i >= 0; i--) { 855 if (u[i] > v[i]) 856 return 1; 857 if (u[i] < v[i]) 858 return -1; 859 } 860 return t; 861 } 862 863 864 /** 865 * ExpVector reverse inverse lexicographical compareTo. 866 * @param V 867 * @param begin 868 * @param end 869 * @return 0 if U == V, -1 if U < V, 1 if U > V. 870 */ 871 @Override 872 public int revInvLexCompareTo(ExpVector V, int begin, int end) { 873 long[] u = val; 874 long[] v = ((ExpVectorLong) V).val; 875 if (begin < 0) { 876 begin = 0;; 877 } 878 if (end >= val.length) { 879 end = val.length; 880 } 881 int t = 0; 882 for (int i = end - 1; i >= begin; i--) { 883 if (u[i] > v[i]) 884 return 1; 885 if (u[i] < v[i]) 886 return -1; 887 } 888 return t; 889 } 890 891 892 /** 893 * ExpVector reverse inverse graded compareTo. 894 * @param V 895 * @return 0 if U == V, -1 if U < V, 1 if U > V. 896 */ 897 @Override 898 public int revInvGradCompareTo(ExpVector V) { 899 long[] u = val; 900 long[] v = ((ExpVectorLong) V).val; 901 int t = 0; 902 int i; 903 for (i = u.length - 1; i >= 0; i--) { 904 if (u[i] > v[i]) { 905 t = 1; 906 break; 907 } 908 if (u[i] < v[i]) { 909 t = -1; 910 break; 911 } 912 } 913 if (t == 0) { 914 return t; 915 } 916 long up = 0; 917 long vp = 0; 918 for (int j = i; j >= 0; j--) { 919 up += u[j]; 920 vp += v[j]; 921 } 922 if (up > vp) { 923 t = 1; 924 } else { 925 if (up < vp) { 926 t = -1; 927 } 928 } 929 return t; 930 } 931 932 933 /** 934 * ExpVector reverse inverse graded compareTo. 935 * @param V 936 * @param begin 937 * @param end 938 * @return 0 if U == V, -1 if U < V, 1 if U > V. 939 */ 940 @Override 941 public int revInvGradCompareTo(ExpVector V, int begin, int end) { 942 long[] u = val; 943 long[] v = ((ExpVectorLong) V).val; 944 if (begin < 0) { 945 begin = 0;; 946 } 947 if (end >= val.length) { 948 end = val.length; 949 } 950 int t = 0; 951 int i; 952 for (i = end - 1; i >= begin; i--) { 953 if (u[i] > v[i]) { 954 t = 1; 955 break; 956 } 957 if (u[i] < v[i]) { 958 t = -1; 959 break; 960 } 961 } 962 if (t == 0) { 963 return t; 964 } 965 long up = 0; 966 long vp = 0; 967 for (int j = i; j >= begin; j--) { 968 up += u[j]; 969 vp += v[j]; 970 } 971 if (up > vp) { 972 t = 1; 973 } else { 974 if (up < vp) { 975 t = -1; 976 } 977 } 978 return t; 979 } 980 981 982 /** 983 * ExpVector inverse total degree lexicographical compareTo. 984 * @param V 985 * @return 0 if U == V, -1 if U < V, 1 if U > V. 986 */ 987 @Override 988 public int invTdegCompareTo(ExpVector V) { 989 long[] u = val; 990 long[] v = ((ExpVectorLong) V).val; 991 int t = 0; 992 int i; 993 for (i = 0; i < u.length; i++) { 994 if (u[i] < v[i]) { 995 t = 1; 996 break; 997 } 998 if (u[i] > v[i]) { 999 t = -1; 1000 break; 1001 } 1002 } 1003 if (t == 0) { 1004 return t; 1005 } 1006 long up = 0; 1007 long vp = 0; 1008 for (int j = i; j < u.length; j++) { 1009 up += u[j]; 1010 vp += v[j]; 1011 } 1012 if (up > vp) { 1013 t = 1; 1014 } else { 1015 if (up < vp) { 1016 t = -1; 1017 } 1018 } 1019 return t; 1020 } 1021 1022 1023 /** 1024 * ExpVector reverse lexicographical inverse total degree compareTo. 1025 * @param V 1026 * @return 0 if U == V, -1 if U < V, 1 if U > V. 1027 */ 1028 @Override 1029 public int revLexInvTdegCompareTo(ExpVector V) { 1030 long[] u = val; 1031 long[] v = ((ExpVectorLong) V).val; 1032 int t = 0; 1033 int i; 1034 for (i = u.length - 1; i >= 0; i--) { 1035 if (u[i] < v[i]) { 1036 t = 1; 1037 break; 1038 } 1039 if (u[i] > v[i]) { 1040 t = -1; 1041 break; 1042 } 1043 } 1044 if (t == 0) { 1045 return t; 1046 } 1047 long up = 0; 1048 long vp = 0; 1049 for (int j = i; j >= 0; j--) { 1050 up += u[j]; 1051 vp += v[j]; 1052 } 1053 if (up > vp) { 1054 t = 1; 1055 } else { 1056 if (up < vp) { 1057 t = -1; 1058 } 1059 } 1060 return t; 1061 } 1062 1063 1064 /** 1065 * ExpVector inverse weighted lexicographical compareTo. 1066 * @param w weight array. 1067 * @param V 1068 * @return 0 if U == V, -1 if U < V, 1 if U > V. 1069 */ 1070 @Override 1071 public int invWeightCompareTo(long[][] w, ExpVector V) { 1072 long[] u = val; 1073 long[] v = ((ExpVectorLong) V).val; 1074 int t = 0; 1075 int i; 1076 for (i = 0; i < u.length; i++) { 1077 if (u[i] > v[i]) { 1078 t = 1; 1079 break; 1080 } 1081 if (u[i] < v[i]) { 1082 t = -1; 1083 break; 1084 } 1085 } 1086 if (t == 0) { 1087 return t; 1088 } 1089 for (int k = 0; k < w.length; k++) { 1090 long[] wk = w[k]; 1091 long up = 0; 1092 long vp = 0; 1093 for (int j = i; j < u.length; j++) { 1094 up += wk[j] * u[j]; 1095 vp += wk[j] * v[j]; 1096 } 1097 if (up > vp) { 1098 return 1; 1099 } else if (up < vp) { 1100 return -1; 1101 } 1102 } 1103 return t; 1104 } 1105 1106 1107 /** 1108 * ExpVector inverse weighted lexicographical compareTo. 1109 * @param w weight array. 1110 * @param V 1111 * @param begin 1112 * @param end 1113 * @return 0 if U == V, -1 if U < V, 1 if U > V. 1114 */ 1115 @Override 1116 public int invWeightCompareTo(long[][] w, ExpVector V, int begin, int end) { 1117 long[] u = val; 1118 long[] v = ((ExpVectorLong) V).val; 1119 if (begin < 0) { 1120 begin = 0;; 1121 } 1122 if (end >= val.length) { 1123 end = val.length; 1124 } 1125 int t = 0; 1126 int i; 1127 for (i = begin; i < end; i++) { 1128 if (u[i] > v[i]) { 1129 t = 1; 1130 break; 1131 } 1132 if (u[i] < v[i]) { 1133 t = -1; 1134 break; 1135 } 1136 } 1137 if (t == 0) { 1138 return t; 1139 } 1140 for (int k = 0; k < w.length; k++) { 1141 long[] wk = w[k]; 1142 long up = 0; 1143 long vp = 0; 1144 for (int j = i; j < end; j++) { 1145 up += wk[j] * u[j]; 1146 vp += wk[j] * v[j]; 1147 } 1148 if (up > vp) { 1149 return 1; 1150 } else if (up < vp) { 1151 return -1; 1152 } 1153 } 1154 return t; 1155 } 1156 1157}