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