jas

1 '''jython interface to JAS. 2 ''' 3 4 # $Id: jas.py 5901 2018-08-22 21:06:06Z kredel $ 5 6 from java.lang import System 7 from java.io import StringReader 8 from java.util import ArrayList, List, Collections 9 10 from edu.jas.structure import RingElem, RingFactory, Power 11 from edu.jas.arith import BigInteger, BigRational, BigComplex, BigDecimal,\ 12 ModInteger, ModIntegerRing, ModLong, ModLongRing,\ 13 BigQuaternion, BigQuaternionRing, BigOctonion,\ 14 Product, ProductRing, PrimeList 15 from edu.jas.poly import GenPolynomial, GenPolynomialRing, Monomial,\ 16 GenSolvablePolynomial, GenSolvablePolynomialRing,\ 17 RecSolvablePolynomial, RecSolvablePolynomialRing,\ 18 RecSolvableWordPolynomial, RecSolvableWordPolynomialRing,\ 19 QLRSolvablePolynomial, QLRSolvablePolynomialRing,\ 20 GenWordPolynomial, GenWordPolynomialRing,\ 21 ExpVector,\ 22 Word, WordFactory,\ 23 GenPolynomialTokenizer, OrderedPolynomialList, PolyUtil,\ 24 TermOrderOptimization, TermOrder, TermOrderByName,\ 25 PolynomialList, AlgebraicNumber, AlgebraicNumberRing,\ 26 OrderedModuleList, ModuleList,\ 27 Complex, ComplexRing 28 from edu.jas.ps import UnivPowerSeries, UnivPowerSeriesRing,\ 29 UnivPowerSeriesMap, Coefficients, \ 30 MultiVarPowerSeries, MultiVarPowerSeriesRing,\ 31 MultiVarPowerSeriesMap, MultiVarCoefficients,\ 32 StandardBaseSeq 33 from edu.jas.gb import EReductionSeq, DGroebnerBaseSeq, EGroebnerBaseSeq,\ 34 GroebnerBaseDistributedEC, GroebnerBaseDistributedHybridEC,\ 35 GroebnerBaseSeq, GroebnerBaseSeqIter, GroebnerBaseSeqPairSeq,\ 36 OrderedPairlist, OrderedSyzPairlist, ReductionSeq,\ 37 GroebnerBaseParallel, GroebnerBaseSeqPairParallel,\ 38 SolvableGroebnerBaseParallel, SolvableGroebnerBaseSeq,\ 39 SolvableReductionSeq, WordGroebnerBaseSeq 40 from edu.jas.gbufd import GroebnerBasePseudoRecSeq, GroebnerBasePseudoSeq,\ 41 SolvableGroebnerBasePseudoSeq, SolvablePseudoReductionSeq,\ 42 PseudoReductionSeq, GroebnerBasePseudoParallel,\ 43 WordGroebnerBasePseudoSeq, WordPseudoReductionSeq,\ 44 SolvableGroebnerBasePseudoRecSeq, WordGroebnerBasePseudoRecSeq,\ 45 RGroebnerBasePseudoSeq, RGroebnerBaseSeq, RReductionSeq,\ 46 GroebnerBaseFGLM, GroebnerBaseWalk,\ 47 CharacteristicSetWu,\ 48 SolvableSyzygySeq, SyzygySeq 49 #from edu.jas.gbmod import ModGroebnerBaseSeq, ModSolvableGroebnerBaseSeq 50 from edu.jas.vector import GenVector, GenVectorModul,\ 51 GenMatrix, GenMatrixRing 52 from edu.jas.application import PolyUtilApp, RingFactoryTokenizer,\ 53 Residue, ResidueRing, Ideal,\ 54 Local, LocalRing, IdealWithRealAlgebraicRoots,\ 55 SolvableIdeal, SolvableResidue, SolvableResidueRing,\ 56 SolvableLocal, SolvableLocalRing,\ 57 SolvableLocalResidue, SolvableLocalResidueRing,\ 58 ResidueSolvablePolynomial, ResidueSolvablePolynomialRing,\ 59 LocalSolvablePolynomial, LocalSolvablePolynomialRing,\ 60 WordIdeal, WordResidue, WordResidueRing,\ 61 AlgebraicRootsPrimElem, RootFactoryApp,\ 62 ComprehensiveGroebnerBaseSeq, ExtensionFieldBuilder 63 from edu.jas.kern import ComputerThreads, StringUtil, Scripting 64 from edu.jas.ufd import GreatestCommonDivisor, PolyUfdUtil, GCDFactory,\ 65 FactorFactory, SquarefreeFactory, Quotient, QuotientRing 66 from edu.jas.fd import SolvableQuotient, SolvableQuotientRing,\ 67 QuotSolvablePolynomial, QuotSolvablePolynomialRing 68 from edu.jas.root import RealRootsSturm, Interval, RealAlgebraicNumber, RealAlgebraicRing,\ 69 ComplexRootsSturm, Rectangle, RootFactory 70 from edu.jas.integrate import ElementaryIntegration 71 from edu.jas.util import ExecutableServer 72 #from edu.jas import structure, arith, poly, ps, gb, gbmod, vector,\ 73 # application, util, ufd 74 from edu import jas 75 #PrettyPrint.setInternal(); 76 77 from org.python.core import PyInstance, PyList, PyTuple,\ 78 PyInteger, PyLong, PyFloat, PyString 79 # not suitable PySequence 80 81 # set output to Python scripting 82 Scripting.setLang(Scripting.Lang.Python); 83

84 -def startLog():

85 '''Configure the log4j system and start logging. 86 87 BasicConfigurator from log4j version 1 is no more supported, please use log4j2 configuration. 88 '''

89 #print "BasicConfigurator from log4j version 1 is no more supported, please use log4j2 configuration"; 90 91 print "Java Algebra System (JAS) version 2.6" 92

93 -def terminate():

94 '''Terminate the running thread pools. 95 ''' 96 ComputerThreads.terminate();

97

98 -def noThreads():

99 '''Turn off automatic parallel threads usage. 100 ''' 101 print "nt = ", ComputerThreads.NO_THREADS; 102 ComputerThreads.setNoThreads(); #NO_THREADS = #0; #1; #True; 103 print "nt = ", ComputerThreads.NO_THREADS;

104 105 auto_inject = True 106 '''Define variables automatically in the global namespace. 107 ''' 108

109 -def inject_variable(name, value):

110 '''Inject a variable into the main global namespace 111 112 INPUT: 113 - "name" - a string 114 - "value" - anything 115 116 Found in Sage. 117 AUTHORS: 118 - William Stein 119 ''' 120 assert type(name) is str 121 import sys 122 depth = 0 123 redef = None 124 while True: 125 G = sys._getframe(depth).f_globals 126 #print "G = `%s` " % G; 127 depth += 1 128 if depth > 100: 129 print "depth limit %s reached " % depth; 130 break 131 if G is None: 132 continue 133 # orig: if G["__name__"] == "__main__" and G["__package__"] is None: 134 try: 135 if G["__name__"] is None: 136 break 137 except: 138 #print "G[__name__] undefined"; 139 break 140 if G["__name__"] == "__main__": 141 try: 142 if G["__package__"] is None: 143 break 144 except: 145 break 146 if G is None: 147 print "error at G no global environment found for `%s` = `%s` " % (name, value); 148 return 149 if name in G: 150 redef = name; 151 #print "redefining global variable `%s` from `%s` " % (name, G[name]); 152 G[name] = value 153 return redef

154

155 -def inject_generators(gens):

156 '''Inject generators as variables into the main global namespace 157 158 INPUT: 159 - "gens" - generators 160 ''' 161 for v in gens: 162 #print "vars = " + str(v); 163 redef = []; 164 s = str(v); 165 if s.find("/") < 0 and s.find("(") < 0 and s.find(",") < 0 and s.find("{") < 0 and s.find("[") < 0 and s.find("|") < 0: 166 if s[0:1] == "1": 167 s = "one" + s[1:] 168 #print "var = " + s; 169 rd = inject_variable(s,v) 170 if rd != None: 171 redef.append(rd); 172 if redef != []: 173 print "WARN: redefined variables " + ", ".join(redef);

174

175 -def nameFromValue(v):

176 '''Get a meaningful name from a value. 177 178 INPUT: 179 - "v" - the given value. 180 ''' 181 import re; 182 ri = re.compile(r'\A[0-9].*'); 183 vs = str(v); 184 vs = vs.replace(" ",""); 185 vs = vs.replace("\n",""); 186 if vs.find("(") >= 0: 187 vs = vs.replace("(",""); 188 vs = vs.replace(")",""); 189 if vs.find("{") >= 0: 190 vs = vs.replace("{",""); 191 vs = vs.replace("}",""); 192 if vs.find("[") >= 0: 193 vs = vs.replace("[",""); 194 vs = vs.replace("]",""); 195 if vs.find(",") >= 0: 196 vs = vs.replace(",",""); 197 #if vs.find("|") >= 0: 198 # vs = vs.replace("|","div"); # case "1"? 199 if vs.find("/") >= 0: 200 vs = vs.replace("/","div"); 201 if vs[0:1] == "1" and not ri.match(vs): 202 vs = 'one' + vs[1:]; 203 if vs == "1": 204 vs = "one"; 205 if vs == "0i1" or vs == "0I1": 206 vs = "I"; 207 if vs.find("|") >= 0 or ri.match(vs): 208 #print "0vs = " + str(vs); 209 return None; 210 return vs;

211 212

213 -class Ring:

214 '''Represents a JAS polynomial ring: GenPolynomialRing. 215 216 Methods to create ideals and ideals with parametric coefficients. 217 ''' 218

219 - def __init__(self,ringstr="",ring=None,fast=False):

220 '''Ring constructor. 221 222 ringstr string representation to be parsed. 223 ring JAS ring object. 224 ''' 225 if ring == None: 226 sr = StringReader( ringstr ); 227 tok = RingFactoryTokenizer(sr); 228 pfac = tok.nextPolynomialRing(); 229 #tok = GenPolynomialTokenizer(pfac,sr); 230 #plist = tok.nextPolynomialList(); 231 #self.pset = PolynomialList(pfac,plist); 232 self.ring = pfac; 233 else: 234 if isinstance(ring,Ring): 235 self.ring = ring.ring; 236 else: 237 self.ring = ring; 238 if fast: 239 return; 240 self.engine = Ring.getEngineGcd(self.ring); 241 self.sqf = Ring.getEngineSqf(self.ring); 242 self.factor = Ring.getEngineFactor(self.ring); 243 self.variable_generators();

244

245 - def getEngineGcd(r):

246 '''Get the polynomial gcd engine implementation. 247 248 r is the given polynomial ring. 249 ''' 250 if isinstance(r,RingElem): 251 r = r.elem; 252 if not isinstance(r,GenPolynomialRing): 253 return None; 254 try: 255 i = GCDFactory.getProxy(r.coFac); 256 except: 257 i = None 258 return i;

259 260 getEngineGcd = staticmethod(getEngineGcd); 261

262 - def getEngineSqf(r):

263 '''Get the polynomial squarefree engine implementation. 264 265 r is the given polynomial ring. 266 ''' 267 if isinstance(r,RingElem): 268 r = r.elem; 269 if not isinstance(r,GenPolynomialRing): 270 return None; 271 try: 272 i = SquarefreeFactory.getImplementation(r.coFac); 273 except: 274 i = None 275 return i;

276 277 getEngineSqf = staticmethod(getEngineSqf); 278

279 - def getEngineFactor(r):

280 '''Get the polynomial factorization engine implementation. 281 282 r is the given polynomial ring. 283 ''' 284 if isinstance(r,RingElem): 285 r = r.elem; 286 if not isinstance(r,GenPolynomialRing): 287 return None; 288 try: 289 i = FactorFactory.getImplementation(r.coFac); 290 except: 291 i = None 292 return i;

293 294 getEngineFactor = staticmethod(getEngineFactor); 295

296 - def variable_generators(self):

297 '''Define instance variables for generators. 298 ''' 299 vns = [] 300 redef = [] 301 #print "dict: " + str(self.__dict__) 302 for v in self.gens(): #ring.generators(): 303 #vr = RingElem(v); 304 #print "vars = " + str(v); 305 vs = nameFromValue(v); 306 if vs is None: 307 #print "0vs = " + str(vs); 308 continue; 309 try: 310 if self.__dict__[vs] is None: 311 self.__dict__[vs] = v; 312 else: 313 print vs + " not redefined to " + str(v); 314 except: 315 self.__dict__[vs] = v; 316 if auto_inject: 317 rd = inject_variable(vs,v) 318 vns.append(vs) 319 if rd != None: 320 redef.append(rd); 321 if auto_inject: 322 print "globally defined variables: " + ", ".join(vns) 323 if redef != []: 324 print "WARN: redefined global variables: " + ", ".join(redef);

325 #print "dict: " + str(self.__dict__) 326

327 - def __str__(self):

328 '''Create a string representation. 329 ''' 330 return str(self.ring.toScript());

331

332 - def __eq__(self,other):

333 '''Test if two rings are equal. 334 ''' 335 if not isinstance(other, Ring): 336 return False; 337 s = self.ring; 338 t = other.ring; 339 return s.equals(t)

340

341 - def ideal(self,ringstr="",list=None):

342 '''Create an ideal. 343 ''' 344 return Ideal(self,ringstr,list=list);

345

346 - def paramideal(self,ringstr="",list=None,gbsys=None):

347 '''Create an ideal in a polynomial ring with parameter coefficients. 348 ''' 349 return ParamIdeal(self,ringstr,list,gbsys);

350

351 - def powerseriesRing(self):

352 '''Get a power series ring from this ring. 353 ''' 354 pr = MultiVarPowerSeriesRing(self.ring); 355 return MultiSeriesRing(ring=pr);

356

357 - def gens(self):

358 '''Get list of generators of the polynomial ring. 359 ''' 360 L = self.ring.generators(); 361 N = [ RingElem(e) for e in L ]; 362 return N;

363

364 - def inject_variables(self):

365 '''Inject generators as variables into the main global namespace 366 ''' 367 inject_generators(self.gens());

368

369 - def one(self):

370 '''Get the one of the polynomial ring. 371 ''' 372 return RingElem( self.ring.getONE() );

373

374 - def zero(self):

375 '''Get the zero of the polynomial ring. 376 ''' 377 return RingElem( self.ring.getZERO() );

378

379 - def random(self,k=5,l=7,d=3,q=0.3):

380 '''Get a random polynomial. 381 ''' 382 r = self.ring.random(k,l,d,q); 383 if self.ring.coFac.isField(): 384 r = r.monic(); 385 return RingElem( r );

386

387 - def element(self,poly):

388 '''Create an element from a string or object. 389 ''' 390 if not isinstance(poly,str): 391 try: 392 if self.ring == poly.ring: 393 return RingElem(poly); 394 except Exception, e: 395 pass 396 poly = str(poly); 397 I = Ideal(self, "( " + poly + " )"); 398 list = I.pset.list; 399 if len(list) > 0: 400 return RingElem( list[0] );

401

402 - def gcd(self,a,b):

403 '''Compute the greatest common divisor of a and b. 404 ''' 405 if isinstance(a,RingElem): 406 a = a.elem; 407 else: 408 a = self.element( a ); 409 a = a.elem; 410 if isinstance(b,RingElem): 411 b = b.elem; 412 else: 413 b = self.element( b ); 414 b = b.elem; 415 return RingElem( self.engine.gcd(a,b) );

416

417 - def squarefreeFactors(self,a):

418 '''Compute squarefree factors of polynomial. 419 ''' 420 if isinstance(a,RingElem): 421 a = a.elem; 422 else: 423 a = self.element( a ); 424 a = a.elem; 425 cf = self.ring.coFac; 426 if isinstance(cf,GenPolynomialRing): 427 e = self.sqf.recursiveSquarefreeFactors( a ); 428 else: 429 e = self.sqf.squarefreeFactors( a ); 430 L = {}; 431 for a in e.keySet(): 432 i = e.get(a); 433 L[ RingElem( a ) ] = i; 434 return L;

435

436 - def factors(self,a):

437 '''Compute irreducible factorization for modular, integer, 438 rational number and algebriac number coefficients. 439 ''' 440 if isinstance(a,RingElem): 441 a = a.elem; 442 else: 443 a = self.element( a ); 444 a = a.elem; 445 try: 446 cf = self.ring.coFac; 447 if isinstance(cf,GenPolynomialRing) and cf.isCommutative(): 448 e = self.factor.recursiveFactors( a ); 449 else: 450 e = self.factor.factors( a ); 451 L = {}; 452 for a in e.keySet(): 453 i = e.get(a); 454 L[ RingElem( a ) ] = i; 455 return L; 456 except Exception, e: 457 print "error " + str(e) 458 return None

459

460 - def factorsAbsolute(self,a):

461 '''Compute absolute irreducible factorization for (modular,) 462 rational number coefficients. 463 ''' 464 if isinstance(a,RingElem): 465 a = a.elem; 466 else: 467 a = self.element( a ); 468 a = a.elem; 469 try: 470 L = self.factor.factorsAbsolute( a ); 471 ## L = {}; 472 ## for a in e.keySet(): 473 ## i = e.get(a); 474 ## L[ RingElem( a ) ] = i; 475 return L; 476 except Exception, e: 477 print "error in factorsAbsolute " + str(e) 478 return None

479

480 - def realRoots(self,a,eps=None):

481 '''Compute real roots of univariate polynomial. 482 ''' 483 if not isinstance(a,RingElem): 484 a = RingElem(a); 485 return a.realRoots(eps);

486

487 - def complexRoots(self,a,eps=None):

488 '''Compute complex roots of univariate polynomial. 489 ''' 490 if not isinstance(a,RingElem): 491 a = RingElem(a); 492 return a.complexRoots(eps);

493

494 - def algebraicRoots(self,a,eps=None):

495 '''Algebraic real and Compute complex roots of univariate polynomial. 496 ''' 497 if not isinstance(a,RingElem): 498 a = RingElem(a); 499 return a.algebraicRoots(eps);

500

501 - def rootRefine(self,a,eps=None):

502 '''Compute algebraic roots refinement. 503 ''' 504 if not isinstance(a,RingElem): 505 a = RingElem(a); 506 return a.rootRefine(eps);

507

508 - def decimalRoots(self,a,eps=None):

509 '''Compute decimal approximation of real and complex roots of univariate polynomial. 510 ''' 511 if not isinstance(a,RingElem): 512 a = RingElem(a); 513 return a.decimalRoots(eps);

514

515 - def rootsOfUnity(self,a):

516 '''Roots of unity of real and complex algebraic numbers. 517 ''' 518 if not isinstance(a,RingElem): 519 a = RingElem(a); 520 return a.rootsOfUnity();

521

522 - def rootReduce(self,a, b):

523 '''Root reduce of real and complex algebraic numbers. 524 Compute an extension field with a primitive element. 525 ''' 526 if not isinstance(a,RingElem): 527 a = RingElem(a); 528 return a.rootReduce(b);

529

530 - def integrate(self,a):

531 '''Integrate rational function or power series. 532 ''' 533 if not isinstance(a,RingElem): 534 a = RingElem(a); 535 return a.integrate();

536 537

538 -class Ideal:

539 '''Represents a JAS polynomial ideal: PolynomialList and Ideal. 540 541 Methods for Groebner bases, ideal sum, intersection and others. 542 ''' 543

544 - def __init__(self,ring,polystr="",list=None):

545 '''Ideal constructor. 546 ''' 547 self.ring = ring; 548 if list == None: 549 sr = StringReader( polystr ); 550 tok = GenPolynomialTokenizer(ring.ring,sr); 551 self.list = tok.nextPolynomialList(); 552 else: 553 self.list = pylist2arraylist(list,rec=1); 554 self.pset = OrderedPolynomialList(ring.ring,self.list); 555 self.roots = None; 556 self.croots = None; 557 self.prime = None; 558 self.primary = None;

559

560 - def __str__(self):

561 '''Create a string representation. 562 ''' 563 return str(self.pset.toScript());

564

565 - def __eq__(self,other):

566 '''Test if two ideals are equal. 567 ''' 568 o = other; 569 if isinstance(other,Ideal): 570 o = other.pset; 571 return self.pset.equals(o)

572

573 - def paramideal(self):

574 '''Create an ideal in a polynomial ring with parameter coefficients. 575 ''' 576 return ParamIdeal(self.ring,"",self.list);

577

578 - def GB(self):

579 '''Compute a Groebner base. 580 ''' 581 s = self.pset; 582 cofac = s.ring.coFac; 583 F = s.list; 584 kind = ""; 585 t = System.currentTimeMillis(); 586 if cofac.isField(): 587 G = GroebnerBaseSeq(ReductionSeq(),OrderedSyzPairlist()).GB(F); 588 #G = GroebnerBaseSeqIter(ReductionSeq(),OrderedSyzPairlist()).GB(F); 589 #G = GroebnerBaseSeq().GB(F); 590 kind = "field" 591 else: 592 if isinstance(cofac,GenPolynomialRing) and cofac.isCommutative(): 593 G = GroebnerBasePseudoRecSeq(cofac).GB(F); 594 kind = "pseudorec" 595 else: 596 G = GroebnerBasePseudoSeq(cofac).GB(F); 597 kind = "pseudo" 598 t = System.currentTimeMillis() - t; 599 print "sequential(%s) GB executed in %s ms" % (kind, t); 600 return Ideal(self.ring,"",G);

601

602 - def isGB(self):

603 '''Test if this is a Groebner base. 604 ''' 605 s = self.pset; 606 cofac = s.ring.coFac; 607 F = s.list; 608 t = System.currentTimeMillis(); 609 if cofac.isField(): 610 b = GroebnerBaseSeq().isGB(F); 611 else: 612 if isinstance(cofac,GenPolynomialRing) and cofac.isCommutative(): 613 b = GroebnerBasePseudoRecSeq(cofac).isGB(F); 614 else: 615 b = GroebnerBasePseudoSeq(cofac).isGB(F); 616 t = System.currentTimeMillis() - t; 617 #print "isGB executed in %s ms" % t; 618 return b;

619

620 - def eGB(self):

621 '''Compute an e-Groebner base. 622 ''' 623 s = self.pset; 624 cofac = s.ring.coFac; 625 F = s.list; 626 t = System.currentTimeMillis(); 627 G = EGroebnerBaseSeq().GB(F) 628 t = System.currentTimeMillis() - t; 629 print "sequential e-GB executed in %s ms" % t; 630 return Ideal(self.ring,"",G);

631

632 - def iseGB(self):

633 '''Test if this is an e-Groebner base. 634 ''' 635 s = self.pset; 636 cofac = s.ring.coFac; 637 F = s.list; 638 t = System.currentTimeMillis(); 639 b = EGroebnerBaseSeq().isGB(F) 640 t = System.currentTimeMillis() - t; 641 print "is e-GB test executed in %s ms" % t; 642 return b;

643

644 - def dGB(self):

645 '''Compute an d-Groebner base. 646 ''' 647 s = self.pset; 648 cofac = s.ring.coFac; 649 F = s.list; 650 t = System.currentTimeMillis(); 651 G = DGroebnerBaseSeq().GB(F) 652 t = System.currentTimeMillis() - t; 653 print "sequential d-GB executed in %s ms" % t; 654 return Ideal(self.ring,"",G);

655

656 - def isdGB(self):

657 '''Test if this is a d-Groebner base. 658 ''' 659 s = self.pset; 660 cofac = s.ring.coFac; 661 F = s.list; 662 t = System.currentTimeMillis(); 663 b = DGroebnerBaseSeq().isGB(F) 664 t = System.currentTimeMillis() - t; 665 print "is d-GB test executed in %s ms" % t; 666 return b;

667

668 - def parNewGB(self,th):

669 '''Compute in parallel a Groebner base. 670 ''' 671 s = self.pset; 672 F = s.list; 673 bbpar = GroebnerBaseSeqPairParallel(th); 674 t = System.currentTimeMillis(); 675 G = bbpar.GB(F); 676 t = System.currentTimeMillis() - t; 677 bbpar.terminate(); 678 print "parallel-new %s executed in %s ms" % (th, t); 679 return Ideal(self.ring,"",G);

680

681 - def parGB(self,th):

682 '''Compute in parallel a Groebner base. 683 ''' 684 s = self.pset; 685 F = s.list; 686 cofac = s.ring.coFac; 687 if cofac.isField(): 688 bbpar = GroebnerBaseParallel(th); 689 else: 690 bbpar = GroebnerBasePseudoParallel(th,cofac); 691 t = System.currentTimeMillis(); 692 G = bbpar.GB(F); 693 t = System.currentTimeMillis() - t; 694 bbpar.terminate(); 695 print "parallel %s executed in %s ms" % (th, t); 696 return Ideal(self.ring,"",G);

697

698 - def distGB(self,th=2,machine="examples/machines.localhost",port=55711):

699 '''Compute on a distributed system a Groebner base. 700 ''' 701 s = self.pset; 702 F = s.list; 703 t = System.currentTimeMillis(); 704 #old: gbd = GBDist(th,machine,port); 705 gbd = GroebnerBaseDistributedEC(machine,th,port); 706 #gbd = GroebnerBaseDistributedHybridEC(machine,th,port); 707 t1 = System.currentTimeMillis(); 708 G = gbd.GB(F); 709 t1 = System.currentTimeMillis() - t1; 710 gbd.terminate(); 711 t = System.currentTimeMillis() - t; 712 print "distributed %s executed in %s ms (%s ms start-up)" % (th,t1,t-t1); 713 return Ideal(self.ring,"",G);

714

715 - def distClient(self,port=4711): #8114

716 '''Client for a distributed computation. 717 ''' 718 e1 = ExecutableServer( port ); 719 e1.init(); 720 e2 = ExecutableServer( port+1 ); 721 e2.init(); 722 self.exers = [e1,e2]; 723 return None;

724

725 - def distClientStop(self):

726 '''Stop client for a distributed computation. 727 ''' 728 for es in self.exers: 729 es.terminate(); 730 return None;

731

732 - def eReduction(self,p):

733 '''Compute a e-normal form of p with respect to this ideal. 734 ''' 735 s = self.pset; 736 G = s.list; 737 if isinstance(p,RingElem): 738 p = p.elem; 739 t = System.currentTimeMillis(); 740 n = EReductionSeq().normalform(G,p); 741 t = System.currentTimeMillis() - t; 742 print "sequential eReduction executed in %s ms" % t; 743 return RingElem(n);

744

745 - def reduction(self,p):

746 '''Compute a normal form of p with respect to this ideal. 747 ''' 748 s = self.pset; 749 G = s.list; 750 if isinstance(p,RingElem): 751 p = p.elem; 752 if self.ring.ring.coFac.isField(): 753 n = ReductionSeq().normalform(G,p); 754 else: 755 n = PseudoReductionSeq().normalform(G,p); 756 #F = PseudoReductionSeq().normalformFactor(G,p); 757 #print "F.multiplicator = " + str(F.multiplicator) 758 #n = F.pol 759 return RingElem(n);

760

761 - def NF(self,reducer):

762 '''Compute a normal form of this ideal with respect to reducer. 763 ''' 764 s = self.pset; 765 F = s.list; 766 G = reducer.list; 767 t = System.currentTimeMillis(); 768 N = ReductionSeq().normalform(G,F); 769 t = System.currentTimeMillis() - t; 770 print "sequential NF executed in %s ms" % t; 771 return Ideal(self.ring,"",N);

772

773 - def lift(self,p):

774 '''Represent p as element of this ideal. 775 ''' 776 G = self.pset.list; 777 z = self.ring.ring.getZERO(); 778 R = [ z for x in G]; 779 if isinstance(p,RingElem): 780 p = p.elem; 781 if self.ring.ring.coFac.isField(): 782 n = ReductionSeq().normalform(R,G,p); 783 else: 784 n = PseudoReductionSeq().normalform(R,G,p); 785 if not n.isZERO(): 786 raise ValueError, "p ist not a member of the ideal" 787 return [ RingElem(f) for f in R ];

788

789 - def interreduced_basis(self):

790 '''Compute a interreduced ideal basis of this. 791 792 Compatibility method for Sage/Singular. 793 ''' 794 F = self.pset.list; 795 if self.ring.ring.coFac.isField(): 796 N = ReductionSeq().irreducibleSet(F); 797 else: 798 N = PseudoReductionSeq().irreducibleSet(F); 799 #N = GroebnerBaseSeq().minimalGB(F); 800 return [ RingElem(n) for n in N ];

801

802 - def intersectRing(self,ring):

803 '''Compute the intersection of this and the given polynomial ring. 804 ''' 805 s = jas.application.Ideal(self.pset); 806 N = s.intersect(ring.ring); 807 return Ideal(ring,"",N.getList());

808

809 - def intersect(self,id2):

810 '''Compute the intersection of this and the given ideal id2. 811 ''' 812 s1 = jas.application.Ideal(self.pset); 813 s2 = jas.application.Ideal(id2.pset); 814 N = s1.intersect(s2); 815 return Ideal(self.ring,"",N.getList());

816

817 - def eliminateRing(self,ring):

818 '''Compute the elimination ideal of this and the given polynomial ring. 819 ''' 820 s = jas.application.Ideal(self.pset); 821 N = s.eliminate(ring.ring); 822 r = Ring( ring=N.getRing() ); 823 return Ideal(r,"",N.getList());

824

825 - def sat(self,id2):

826 '''Compute the saturation of this with respect to given ideal id2. 827 ''' 828 s1 = jas.application.Ideal(self.pset); 829 s2 = jas.application.Ideal(id2.pset); 830 #Q = s1.infiniteQuotient(s2); 831 Q = s1.infiniteQuotientRab(s2); 832 return Ideal(self.ring,"",Q.getList());

833

834 - def sum(self,other):

835 '''Compute the sum of this and the ideal. 836 ''' 837 s = jas.application.Ideal(self.pset); 838 t = jas.application.Ideal(other.pset); 839 N = s.sum( t ); 840 return Ideal(self.ring,"",N.getList());

841

842 - def univariates(self):

843 '''Compute the univariate polynomials in each variable of this ideal. 844 ''' 845 s = jas.application.Ideal(self.pset); 846 L = s.constructUnivariate(); 847 N = [ RingElem(e) for e in L ]; 848 return N;

849

850 - def inverse(self,p):

851 '''Compute the inverse polynomial modulo this ideal, if it exists. 852 ''' 853 s = jas.application.Ideal(self.pset); 854 if isinstance(p,RingElem): 855 p = p.elem; 856 i = s.inverse(p); 857 return RingElem(i);

858 859

860 - def optimize(self):

861 '''Optimize the term order on the variables. 862 ''' 863 p = self.pset; 864 o = TermOrderOptimization.optimizeTermOrder(p); 865 r = Ring("",o.ring); 866 return Ideal(r,"",o.list);

867

868 - def realRoots(self):

869 '''Compute real roots of 0-dim ideal. 870 ''' 871 I = jas.application.Ideal(self.pset); 872 self.roots = jas.application.PolyUtilApp.realAlgebraicRoots(I); 873 for R in self.roots: 874 R.doDecimalApproximation(); 875 return self.roots;

876

877 - def realRootsPrint(self):

878 '''Print decimal approximation of real roots of 0-dim ideal. 879 ''' 880 if self.roots == None: 881 I = jas.application.Ideal(self.pset); 882 self.roots = jas.application.PolyUtilApp.realAlgebraicRoots(I); 883 for R in self.roots: 884 R.doDecimalApproximation(); 885 for Ir in self.roots: 886 for Dr in Ir.decimalApproximation(): 887 print str(Dr); 888 print;

889

890 - def radicalDecomp(self):

891 '''Compute radical decomposition of this ideal. 892 ''' 893 I = jas.application.Ideal(self.pset); 894 self.radical = I.radicalDecomposition(); 895 return self.radical;

896

897 - def decomposition(self):

898 '''Compute irreducible decomposition of this ideal. 899 ''' 900 I = jas.application.Ideal(self.pset); 901 self.irrdec = I.decomposition(); 902 return self.irrdec;

903

904 - def complexRoots(self):

905 '''Compute complex roots of 0-dim ideal. 906 ''' 907 I = jas.application.Ideal(self.pset); 908 self.croots = jas.application.PolyUtilApp.complexAlgebraicRoots(I); 909 for R in self.croots: 910 R.doDecimalApproximation(); 911 return self.croots;

912

913 - def complexRootsPrint(self):

914 '''Print decimal approximation of complex roots of 0-dim ideal. 915 ''' 916 if self.croots == None: 917 I = jas.application.Ideal(self.pset); 918 self.croots = jas.application.PolyUtilApp.realAlgebraicRoots(I); 919 for R in self.croots: 920 R.doDecimalApproximation(); 921 for Ic in self.croots: 922 for Dc in Ic.decimalApproximation(): 923 print str(Dc); 924 print;

925

926 - def primeDecomp(self):

927 '''Compute prime decomposition of this ideal. 928 ''' 929 I = jas.application.Ideal(self.pset); 930 self.prime = I.primeDecomposition(); 931 return self.prime;

932

933 - def primaryDecomp(self):

934 '''Compute primary decomposition of this ideal. 935 ''' 936 I = jas.application.Ideal(self.pset); 937 ## if self.prime == None: 938 ## self.prime = I.primeDecomposition(); 939 self.primary = I.primaryDecomposition(); 940 return self.primary;

941

942 - def toInteger(self):

943 '''Convert rational coefficients to integer coefficients. 944 ''' 945 p = self.pset; 946 l = p.list; 947 r = p.ring; 948 ri = GenPolynomialRing( BigInteger(), r.nvar, r.tord, r.vars ); 949 pi = PolyUtil.integerFromRationalCoefficients(ri,l); 950 r = Ring("",ri); 951 return Ideal(r,"",pi);

952

953 - def toModular(self,mf):

954 '''Convert integer coefficients to modular coefficients. 955 ''' 956 p = self.pset; 957 l = p.list; 958 r = p.ring; 959 if isinstance(mf,RingElem): 960 mf = mf.ring; 961 rm = GenPolynomialRing( mf, r.nvar, r.tord, r.vars ); 962 pm = PolyUtil.fromIntegerCoefficients(rm,l); 963 r = Ring("",rm); 964 return Ideal(r,"",pm);

965

966 - def CS(self):

967 '''Compute a Characteristic Set. 968 ''' 969 s = self.pset; 970 cofac = s.ring.coFac; 971 F = s.list; 972 t = System.currentTimeMillis(); 973 if cofac.isField(): 974 G = CharacteristicSetWu().characteristicSet(F); 975 else: 976 print "CS not implemented for coefficients %s" % cofac.toScriptFactory(); 977 G = None; 978 t = System.currentTimeMillis() - t; 979 print "sequential CS executed in %s ms" % t; 980 return Ideal(self.ring,"",G);

981

982 - def isCS(self):

983 '''Test for Characteristic Set. 984 ''' 985 s = self.pset; 986 cofac = s.ring.coFac; 987 F = s.list.clone(); 988 Collections.reverse(F); # todo 989 t = System.currentTimeMillis(); 990 if cofac.isField(): 991 b = CharacteristicSetWu().isCharacteristicSet(F); 992 else: 993 print "isCS not implemented for coefficients %s" % cofac.toScriptFactory(); 994 b = False; 995 t = System.currentTimeMillis() - t; 996 return b;

997

998 - def csReduction(self,p):

999 '''Compute a normal form of p with respect to this characteristic set. 1000 ''' 1001 s = self.pset; 1002 F = s.list.clone(); 1003 Collections.reverse(F); # todo 1004 if isinstance(p,RingElem): 1005 p = p.elem; 1006 t = System.currentTimeMillis(); 1007 n = CharacteristicSetWu().characteristicSetReduction(F,p); 1008 t = System.currentTimeMillis() - t; 1009 #print "sequential char set reduction executed in %s ms" % t; 1010 return RingElem(n);

1011

1012 - def syzygy(self):

1013 '''Syzygy of generating polynomials. 1014 ''' 1015 p = self.pset; 1016 l = p.list; 1017 t = System.currentTimeMillis(); 1018 s = SyzygySeq(p.ring.coFac).zeroRelations( l ); 1019 t = System.currentTimeMillis() - t; 1020 print "executed syzygy in %s ms" % t; 1021 m = Module("",p.ring); #cols=s[0].size() 1022 return SubModule(m,"",s);

1023

1024 - def isSyzygy(self,m):

1025 '''Test if this is a syzygy of the module in m. 1026 ''' 1027 p = self.pset; 1028 g = p.list; 1029 l = m.list; 1030 t = System.currentTimeMillis(); 1031 z = SyzygySeq(p.ring.coFac).isZeroRelation( l, g ); 1032 t = System.currentTimeMillis() - t; 1033 print "executed isSyzygy in %s ms" % t; 1034 return z;

1035 1036

1037 -class ParamIdeal:

1038 '''Represents a JAS polynomial ideal with polynomial coefficients. 1039 1040 Methods to compute comprehensive Groebner bases. 1041 ''' 1042

1043 - def __init__(self,ring,polystr="",list=None,gbsys=None):

1044 '''Parametric ideal constructor. 1045 ''' 1046 self.ring = ring; 1047 if list == None and polystr != None: 1048 sr = StringReader( polystr ); 1049 tok = GenPolynomialTokenizer(ring.ring,sr); 1050 self.list = tok.nextPolynomialList(); 1051 else: 1052 self.list = pylist2arraylist(list,rec=1); 1053 self.gbsys = gbsys; 1054 self.pset = OrderedPolynomialList(ring.ring,self.list);

1055

1056 - def __str__(self):

1057 '''Create a string representation. 1058 ''' 1059 if self.gbsys == None: 1060 return self.pset.toScript(); 1061 else: 1062 # return self.gbsys.toString(); # toScript() not available 1063 return self.pset.toScript() + "\n" + self.gbsys.toScript();

1064

1065 - def optimizeCoeff(self):

1066 '''Optimize the term order on the variables of the coefficients. 1067 ''' 1068 p = self.pset; 1069 o = TermOrderOptimization.optimizeTermOrderOnCoefficients(p); 1070 r = Ring("",o.ring); 1071 return ParamIdeal(r,"",o.list);

1072

1073 - def optimizeCoeffQuot(self):

1074 '''Optimize the term order on the variables of the quotient coefficients. 1075 ''' 1076 p = self.pset; 1077 l = p.list; 1078 r = p.ring; 1079 q = r.coFac; 1080 c = q.ring; 1081 rc = GenPolynomialRing( c, r.nvar, r.tord, r.vars ); 1082 #print "rc = ", rc; 1083 lp = PolyUfdUtil.integralFromQuotientCoefficients(rc,l); 1084 #print "lp = ", lp; 1085 pp = PolynomialList(rc,lp); 1086 #print "pp = ", pp; 1087 oq = TermOrderOptimization.optimizeTermOrderOnCoefficients(pp); 1088 oor = oq.ring; 1089 qo = oor.coFac; 1090 cq = QuotientRing( qo ); 1091 rq = GenPolynomialRing( cq, r.nvar, r.tord, r.vars ); 1092 #print "rq = ", rq; 1093 o = PolyUfdUtil.quotientFromIntegralCoefficients(rq,oq.list); 1094 r = Ring("",rq); 1095 return ParamIdeal(r,"",o);

1096

1097 - def toIntegralCoeff(self):

1098 '''Convert rational function coefficients to integral function coefficients. 1099 ''' 1100 p = self.pset; 1101 l = p.list; 1102 r = p.ring; 1103 q = r.coFac; 1104 c = q.ring; 1105 rc = GenPolynomialRing( c, r.nvar, r.tord, r.vars ); 1106 #print "rc = ", rc; 1107 lp = PolyUfdUtil.integralFromQuotientCoefficients(rc,l); 1108 #print "lp = ", lp; 1109 r = Ring("",rc); 1110 return ParamIdeal(r,"",lp);

1111

1112 - def toModularCoeff(self,mf):

1113 '''Convert integral function coefficients to modular function coefficients. 1114 ''' 1115 p = self.pset; 1116 l = p.list; 1117 r = p.ring; 1118 c = r.coFac; 1119 #print "c = ", c; 1120 if isinstance(mf,RingElem): 1121 mf = mf.ring; 1122 cm = GenPolynomialRing( mf, c.nvar, c.tord, c.vars ); 1123 #print "cm = ", cm; 1124 rm = GenPolynomialRing( cm, r.nvar, r.tord, r.vars ); 1125 #print "rm = ", rm; 1126 pm = PolyUfdUtil.fromIntegerCoefficients(rm,l); 1127 r = Ring("",rm); 1128 return ParamIdeal(r,"",pm);

1129

1130 - def toQuotientCoeff(self):

1131 '''Convert integral function coefficients to rational function coefficients. 1132 ''' 1133 p = self.pset; 1134 l = p.list; 1135 r = p.ring; 1136 c = r.coFac; 1137 #print "c = ", c; 1138 q = QuotientRing(c); 1139 #print "q = ", q; 1140 qm = GenPolynomialRing( q, r.nvar, r.tord, r.vars ); 1141 #print "qm = ", qm; 1142 pm = PolyUfdUtil.quotientFromIntegralCoefficients(qm,l); 1143 r = Ring("",qm); 1144 return ParamIdeal(r,"",pm);

1145

1146 - def GB(self):

1147 '''Compute a Groebner base. 1148 ''' 1149 I = Ideal(self.ring,"",self.pset.list); 1150 g = I.GB(); 1151 return ParamIdeal(g.ring,"",g.pset.list);

1152

1153 - def isGB(self):

1154 '''Test if this is a Groebner base. 1155 ''' 1156 I = Ideal(self.ring,"",self.pset.list); 1157 return I.isGB();

1158

1159 - def CGB(self):

1160 '''Compute a comprehensive Groebner base. 1161 ''' 1162 s = self.pset; 1163 F = s.list; 1164 t = System.currentTimeMillis(); 1165 if self.gbsys == None: 1166 self.gbsys = ComprehensiveGroebnerBaseSeq(self.ring.ring.coFac).GBsys(F); 1167 G = self.gbsys.getCGB(); 1168 t = System.currentTimeMillis() - t; 1169 print "sequential comprehensive executed in %s ms" % t; 1170 return ParamIdeal(self.ring,"",G,self.gbsys);

1171

1172 - def CGBsystem(self):

1173 '''Compute a comprehensive Groebner system. 1174 ''' 1175 s = self.pset; 1176 F = s.list; 1177 t = System.currentTimeMillis(); 1178 S = ComprehensiveGroebnerBaseSeq(self.ring.ring.coFac).GBsys(F); 1179 t = System.currentTimeMillis() - t; 1180 print "sequential comprehensive system executed in %s ms" % t; 1181 return ParamIdeal(self.ring,None,F,S);

1182

1183 - def isCGB(self):

1184 '''Test if this is a comprehensive Groebner base. 1185 ''' 1186 s = self.pset; 1187 F = s.list; 1188 t = System.currentTimeMillis(); 1189 b = ComprehensiveGroebnerBaseSeq(self.ring.ring.coFac).isGB(F); 1190 t = System.currentTimeMillis() - t; 1191 print "isCGB executed in %s ms" % t; 1192 return b;

1193

1194 - def isCGBsystem(self):

1195 '''Test if this is a comprehensive Groebner system. 1196 ''' 1197 s = self.pset; 1198 S = self.gbsys; 1199 t = System.currentTimeMillis(); 1200 b = ComprehensiveGroebnerBaseSeq(self.ring.ring.coFac).isGBsys(S); 1201 t = System.currentTimeMillis() - t; 1202 print "isCGBsystem executed in %s ms" % t; 1203 return b;

1204

1205 - def regularRepresentation(self):

1206 '''Convert Groebner system to a representation with regular ring coefficents. 1207 ''' 1208 if self.gbsys == None: 1209 return None; 1210 G = PolyUtilApp.toProductRes(self.gbsys.list); 1211 ring = Ring(None,G[0].ring); 1212 return ParamIdeal(ring,None,G);

1213

1214 - def regularRepresentationBC(self):

1215 '''Convert Groebner system to a boolean closed representation with regular ring coefficents. 1216 ''' 1217 if self.gbsys == None: 1218 return None; 1219 G = PolyUtilApp.toProductRes(self.gbsys.list); 1220 ring = Ring(None,G[0].ring); 1221 res = RReductionSeq(); 1222 G = res.booleanClosure(G); 1223 return ParamIdeal(ring,None,G);

1224

1225 - def regularGB(self):

1226 '''Compute a Groebner base over a regular ring. 1227 ''' 1228 s = self.pset; 1229 F = s.list; 1230 t = System.currentTimeMillis(); 1231 G = RGroebnerBasePseudoSeq(self.ring.ring.coFac).GB(F); 1232 t = System.currentTimeMillis() - t; 1233 print "sequential regular GB executed in %s ms" % t; 1234 return ParamIdeal(self.ring,None,G);

1235

1236 - def isRegularGB(self):

1237 '''Test if this is Groebner base over a regular ring. 1238 ''' 1239 s = self.pset; 1240 F = s.list; 1241 t = System.currentTimeMillis(); 1242 b = RGroebnerBasePseudoSeq(self.ring.ring.coFac).isGB(F); 1243 t = System.currentTimeMillis() - t; 1244 print "isRegularGB executed in %s ms" % t; 1245 return b;

1246

1247 - def stringSlice(self):

1248 '''Get each component (slice) of regular ring coefficients separate. 1249 ''' 1250 s = self.pset; 1251 b = PolyUtilApp.productToString(s); 1252 return b;

1253 1254

1255 -class SolvableRing(Ring):

1256 '''Represents a JAS solvable polynomial ring: GenSolvablePolynomialRing. 1257 1258 Has a method to create solvable ideals. 1259 ''' 1260

1261 - def __init__(self,ringstr="",ring=None):

1262 '''Solvable polynomial ring constructor. 1263 ''' 1264 if ring == None: 1265 sr = StringReader( ringstr ); 1266 tok = RingFactoryTokenizer(sr); 1267 pfac = tok.nextSolvablePolynomialRing(); 1268 #tok = GenPolynomialTokenizer(pfac,sr); 1269 #plist = tok.nextSolvablePolynomialList(); 1270 #self.pset = PolynomialList(pfac,plist); 1271 self.ring = pfac; 1272 else: 1273 if isinstance(ring,Ring): 1274 self.ring = ring.ring; 1275 else: 1276 self.ring = ring; 1277 if not self.ring.isAssociative(): 1278 print "warning: ring is not associative"; 1279 else: 1280 print "ring is associative"; 1281 Ring.__init__(self,ring=self.ring)

1282

1283 - def __str__(self):

1284 '''Create a string representation. 1285 ''' 1286 return str(self.ring.toScript());

1287

1288 - def ideal(self,ringstr="",list=None):

1289 '''Create a solvable ideal. 1290 ''' 1291 return SolvableIdeal(self,ringstr,list);

1292

1293 - def one(self):

1294 '''Get the one of the solvable polynomial ring. 1295 ''' 1296 return RingElem( self.ring.getONE() );

1297

1298 - def zero(self):

1299 '''Get the zero of the solvable polynomial ring. 1300 ''' 1301 return RingElem( self.ring.getZERO() );

1302

1303 - def element(self,poly):

1304 '''Create an element from a string or object. 1305 ''' 1306 if not isinstance(poly,str): 1307 try: 1308 if self.ring == poly.ring: 1309 return RingElem(poly); 1310 except Exception, e: 1311 pass 1312 poly = str(poly); 1313 I = SolvableIdeal(self, "( " + poly + " )"); 1314 list = I.pset.list; 1315 if len(list) > 0: 1316 return RingElem( list[0] );

1317 1318

1319 -class SolvableIdeal:

1320 '''Represents a JAS solvable polynomial ideal. 1321 1322 Methods for left, right two-sided Groebner basees and others. 1323 ''' 1324

1325 - def __init__(self,ring,ringstr="",list=None):

1326 '''Constructor for an ideal in a solvable polynomial ring. 1327 ''' 1328 self.ring = ring; 1329 if list == None: 1330 sr = StringReader( ringstr ); 1331 tok = GenPolynomialTokenizer(ring.ring,sr); 1332 self.list = tok.nextSolvablePolynomialList(); 1333 else: 1334 self.list = pylist2arraylist(list,rec=1); 1335 self.pset = OrderedPolynomialList(ring.ring,self.list);

1336 #self.pset = PolynomialList(ring.ring,self.list); 1337

1338 - def __str__(self):

1339 '''Create a string representation. 1340 ''' 1341 return str(self.pset.toScript());

1342

1343 - def __cmp__(self,other):

1344 '''Compare two ideals. 1345 ''' 1346 t = False; 1347 if not isinstance(other,SolvableIdeal): 1348 return t; 1349 t = self.pset.compareTo(other.pset); 1350 return t;

1351

1352 - def __eq__(self,other):

1353 '''Test if two ideals are equal. 1354 ''' 1355 if not isinstance(other, SolvableIdeal): 1356 return False; 1357 s = self.pset; 1358 t = other.pset; 1359 return s.equals(t)

1360

1361 - def leftGB(self):

1362 '''Compute a left Groebner base. 1363 ''' 1364 cofac = self.ring.ring.coFac; 1365 F = self.pset.list; 1366 kind = ""; 1367 t = System.currentTimeMillis(); 1368 if isinstance(cofac,GenPolynomialRing): #and cofac.isCommutative(): 1369 G = SolvableGroebnerBasePseudoRecSeq(cofac).leftGB(F); 1370 kind = "pseudorec" 1371 else: 1372 if cofac.isField() or not cofac.isCommutative(): 1373 G = SolvableGroebnerBaseSeq().leftGB(F); 1374 kind = "field|nocom" 1375 else: 1376 G = SolvableGroebnerBasePseudoSeq(cofac).leftGB(F); 1377 kind = "pseudo" 1378 t = System.currentTimeMillis() - t; 1379 print "sequential(%s) left GB executed in %s ms" % (kind, t); 1380 return SolvableIdeal(self.ring,"",G);

1381

1382 - def isLeftGB(self):

1383 '''Test if this is a left Groebner base. 1384 ''' 1385 cofac = self.ring.ring.coFac; 1386 F = self.pset.list; 1387 kind = ""; 1388 t = System.currentTimeMillis(); 1389 if isinstance(cofac,GenPolynomialRing): #and cofac.isCommutative(): 1390 b = SolvableGroebnerBasePseudoRecSeq(cofac).isLeftGB(F); 1391 kind = "pseudorec" 1392 else: 1393 if cofac.isField() or not cofac.isCommutative(): 1394 b = SolvableGroebnerBaseSeq().isLeftGB(F); 1395 kind = "field|nocom" 1396 else: 1397 b = SolvableGroebnerBasePseudoSeq(cofac).isLeftGB(F); 1398 kind = "pseudo" 1399 t = System.currentTimeMillis() - t; 1400 print "sequential(%s) isLeftGB executed in %s ms" % (kind, t); 1401 return b;

1402

1403 - def twosidedGB(self):

1404 '''Compute a two-sided Groebner base. 1405 ''' 1406 cofac = self.ring.ring.coFac; 1407 F = self.pset.list; 1408 kind = ""; 1409 t = System.currentTimeMillis(); 1410 if isinstance(cofac,GenPolynomialRing): # and cofac.isCommutative(): 1411 G = SolvableGroebnerBasePseudoRecSeq(cofac).twosidedGB(F); 1412 kind = "pseudorec" 1413 else: 1414 if cofac.isField() or not cofac.isCommutative(): 1415 G = SolvableGroebnerBaseSeq().twosidedGB(F); 1416 kind = "field|nocom" 1417 else: 1418 G = SolvableGroebnerBasePseudoSeq(cofac).twosidedGB(F); 1419 kind = "pseudo" 1420 t = System.currentTimeMillis() - t; 1421 print "sequential(%s) twosided GB executed in %s ms" % (kind, t); 1422 return SolvableIdeal(self.ring,"",G);

1423

1424 - def isTwosidedGB(self):

1425 '''Test if this is a two-sided Groebner base. 1426 ''' 1427 cofac = self.ring.ring.coFac; 1428 F = self.pset.list; 1429 kind = ""; 1430 t = System.currentTimeMillis(); 1431 if isinstance(cofac,GenPolynomialRing): # and cofac.isCommutative(): 1432 b = SolvableGroebnerBasePseudoRecSeq(cofac).isTwosidedGB(F); 1433 kind = "pseudorec" 1434 else: 1435 if cofac.isField() or not cofac.isCommutative(): 1436 b = SolvableGroebnerBaseSeq().isTwosidedGB(F); 1437 kind = "field|nocom" 1438 else: 1439 b = SolvableGroebnerBasePseudoSeq(cofac).isTwosidedGB(F); 1440 kind = "pseudo" 1441 t = System.currentTimeMillis() - t; 1442 print "sequential(%s) isTwosidedGB executed in %s ms" % (kind, t); 1443 return b;

1444

1445 - def rightGB(self):

1446 '''Compute a right Groebner base. 1447 ''' 1448 cofac = self.ring.ring.coFac; 1449 F = self.pset.list; 1450 kind = ""; 1451 t = System.currentTimeMillis(); 1452 if isinstance(cofac,GenPolynomialRing): # and cofac.isCommutative(): 1453 G = SolvableGroebnerBasePseudoRecSeq(cofac).rightGB(F); 1454 kind = "pseudorec" 1455 else: 1456 if cofac.isField() or not cofac.isCommutative(): 1457 G = SolvableGroebnerBaseSeq().rightGB(F); 1458 kind = "field|nocom" 1459 else: 1460 G = SolvableGroebnerBasePseudoSeq(cofac).rightGB(F); 1461 kind = "pseudo" 1462 t = System.currentTimeMillis() - t; 1463 print "sequential(%s) right GB executed in %s ms" % (kind, t); 1464 return SolvableIdeal(self.ring,"",G);

1465

1466 - def isRightGB(self):

1467 '''Test if this is a right Groebner base. 1468 ''' 1469 cofac = self.ring.ring.coFac; 1470 F = self.pset.list; 1471 kind = ""; 1472 t = System.currentTimeMillis(); 1473 if isinstance(cofac,GenPolynomialRing): # and cofac.isCommutative(): 1474 b = SolvableGroebnerBasePseudoRecSeq(cofac).isRightGB(F); 1475 kind = "pseudorec" 1476 else: 1477 if cofac.isField() or not cofac.isCommutative(): 1478 b = SolvableGroebnerBaseSeq().isRightGB(F); 1479 kind = "field|nocom" 1480 else: 1481 b = SolvableGroebnerBasePseudoSeq(cofac).isRightGB(F); 1482 kind = "pseudo" 1483 t = System.currentTimeMillis() - t; 1484 print "sequential(%s) isRightGB executed in %s ms" % (kind, t); 1485 return b;

1486

1487 - def intersectRing(self,ring):

1488 '''Compute the intersection of this and the polynomial ring. 1489 ''' 1490 s = jas.application.SolvableIdeal(self.pset); 1491 N = s.intersect(ring.ring); 1492 return SolvableIdeal(self.ring,"",N.getList());

1493

1494 - def intersect(self,other):

1495 '''Compute the intersection of this and the other ideal. 1496 ''' 1497 s = jas.application.SolvableIdeal(self.pset); 1498 t = jas.application.SolvableIdeal(other.pset); 1499 N = s.intersect( t ); 1500 return SolvableIdeal(self.ring,"",N.getList());

1501

1502 - def sum(self,other):

1503 '''Compute the sum of this and the other ideal. 1504 ''' 1505 s = jas.application.SolvableIdeal(self.pset); 1506 t = jas.application.SolvableIdeal(other.pset); 1507 N = s.sum( t ); 1508 return SolvableIdeal(self.ring,"",N.getList());

1509

1510 - def univariates(self):

1511 '''Compute the univariate polynomials in each variable of this twosided ideal. 1512 ''' 1513 s = jas.application.SolvableIdeal(self.pset); 1514 L = s.constructUnivariate(); 1515 N = [ RingElem(e) for e in L ]; 1516 return N;

1517

1518 - def toQuotientCoefficients(self):

1519 '''Convert to polynomials with SolvableQuotient coefficients. 1520 ''' 1521 if isinstance(self.pset.ring.coFac,SolvableResidueRing): 1522 cf = self.pset.ring.coFac.ring; 1523 else: 1524 if isinstance(self.pset.ring.coFac,GenSolvablePolynomialRing): 1525 cf = self.pset.ring.coFac; 1526 #else: if @pset.ring.coFac.getClass().getSimpleName() == "GenPolynomialRing" 1527 # cf = @pset.ring.coFac; 1528 # puts "cf = " + cf.toScript(); 1529 else: 1530 return self; 1531 rrel = self.pset.ring.table.relationList(); 1532 rrel.addAll(self.pset.ring.polCoeff.coeffTable.relationList()); 1533 #print "rrel = " + str(rrel); 1534 qf = SolvableQuotientRing(cf); 1535 qr = QuotSolvablePolynomialRing(qf,self.pset.ring); 1536 #print "qr = " + str(qr); 1537 qrel = [ RingElem(qr.fromPolyCoefficients(r)) for r in rrel ]; 1538 qring = SolvPolyRing(qf,self.ring.ring.getVars(),self.ring.ring.tord,qrel); 1539 #print "qring = " + str(qring); 1540 qlist = [ qr.fromPolyCoefficients(self.ring.ring.toPolyCoefficients(r)) for r in self.list ]; 1541 qlist = [ RingElem(r) for r in qlist ]; 1542 return SolvableIdeal(qring,"",qlist);

1543

1544 - def inverse(self,p):

1545 '''Compute the inverse polynomial modulo this ideal, if it exists. 1546 ''' 1547 s = jas.application.SolvableIdeal(self.pset); 1548 if isinstance(p,RingElem): 1549 p = p.elem; 1550 i = s.inverse(p); 1551 return RingElem(i);

1552

1553 - def leftReduction(self,p):

1554 '''Compute a left normal form of p with respect to this ideal. 1555 ''' 1556 s = self.pset; 1557 G = s.list; 1558 if isinstance(p,RingElem): 1559 p = p.elem; 1560 n = SolvableReductionSeq().leftNormalform(G,p); 1561 return RingElem(n);

1562

1563 - def rightReduction(self,p):

1564 '''Compute a right normal form of p with respect to this ideal. 1565 ''' 1566 s = self.pset; 1567 G = s.list; 1568 if isinstance(p,RingElem): 1569 p = p.elem; 1570 n = SolvableReductionSeq().rightNormalform(G,p); 1571 return RingElem(n);

1572

1573 - def parLeftGB(self,th):

1574 '''Compute a left Groebner base in parallel. 1575 ''' 1576 s = self.pset; 1577 F = s.list; 1578 bbpar = SolvableGroebnerBaseParallel(th); 1579 t = System.currentTimeMillis(); 1580 G = bbpar.leftGB(F); 1581 t = System.currentTimeMillis() - t; 1582 bbpar.terminate(); 1583 print "parallel %s leftGB executed in %s ms" % (th, t); 1584 return SolvableIdeal(self.ring,"",G);

1585

1586 - def parTwosidedGB(self,th):

1587 '''Compute a two-sided Groebner base in parallel. 1588 ''' 1589 s = self.pset; 1590 F = s.list; 1591 bbpar = SolvableGroebnerBaseParallel(th); 1592 t = System.currentTimeMillis(); 1593 G = bbpar.twosidedGB(F); 1594 t = System.currentTimeMillis() - t; 1595 bbpar.terminate(); 1596 print "parallel %s twosidedGB executed in %s ms" % (th, t); 1597 return SolvableIdeal(self.ring,"",G);

1598

1599 - def leftSyzygy(self):

1600 '''left Syzygy of generating polynomials. 1601 ''' 1602 p = self.pset; 1603 l = p.list; 1604 t = System.currentTimeMillis(); 1605 s = SolvableSyzygySeq(p.ring.coFac).leftZeroRelationsArbitrary( l ); 1606 t = System.currentTimeMillis() - t; 1607 print "executed left syzygy in %s ms" % t; 1608 m = SolvableModule("",p.ring); 1609 return SolvableSubModule(m,"",s);

1610

1611 - def isLeftSyzygy(self,m):

1612 '''Test if this is a left syzygy of the module in m. 1613 ''' 1614 p = self.pset; 1615 g = p.list; 1616 l = m.list; 1617 t = System.currentTimeMillis(); 1618 z = SolvableSyzygySeq(p.ring.coFac).isLeftZeroRelation( l, g ); 1619 t = System.currentTimeMillis() - t; 1620 print "executed isLeftSyzygy in %s ms" % t; 1621 return z;

1622

1623 - def rightSyzygy(self):

1624 '''right Syzygy of generating polynomials. 1625 ''' 1626 p = self.pset; 1627 l = p.list; 1628 t = System.currentTimeMillis(); 1629 s = SolvableSyzygySeq(p.ring.coFac).rightZeroRelationsArbitrary( l ); 1630 t = System.currentTimeMillis() - t; 1631 print "executed right syzygy in %s ms" % t; 1632 m = SolvableModule("",p.ring); 1633 return SolvableSubModule(m,"",s);

1634

1635 - def isRightSyzygy(self,m):

1636 '''Test if this is a right syzygy of the module in m. 1637 ''' 1638 p = self.pset; 1639 g = p.list; 1640 l = m.list; 1641 t = System.currentTimeMillis(); 1642 z = SolvableSyzygySeq(p.ring.coFac).isRightZeroRelation( l, g ); 1643 t = System.currentTimeMillis() - t; 1644 print "executed isRightSyzygy in %s ms" % t; 1645 return z;

1646 1647

1648 -class Module:

1649 '''Represents a JAS module over a polynomial ring. 1650 1651 Method to create sub-modules. 1652 ''' 1653

1654 - def __init__(self,modstr="",ring=None,cols=0):

1655 '''Module constructor. 1656 ''' 1657 if ring == None: 1658 sr = StringReader( modstr ); 1659 tok = RingFactoryTokenizer(sr); 1660 pfac = tok.nextPolynomialRing(); 1661 #tok = GenPolynomialTokenizer(pfac,sr); 1662 #mlist = tok.nextSubModuleList(); 1663 #self.mset = ModuleList(pfac,mlist); 1664 #if self.mset.cols >= 0: 1665 # self.cols = self.mset.cols; 1666 #else: 1667 self.ring = pfac 1668 else: 1669 if isinstance(ring,Ring): 1670 self.ring = ring.ring; 1671 else: 1672 self.ring = ring; 1673 self.mset = ModuleList(self.ring,None); # because of toScript 1674 if cols < 0: 1675 cols = 0; 1676 self.cols = cols;

1677

1678 - def __str__(self):

1679 '''Create a string representation. 1680 ''' 1681 return str(self.mset.toScript());

1682

1683 - def submodul(self,modstr="",list=None):

1684 '''Create a sub-module. 1685 ''' 1686 return SubModule(self,modstr,list);

1687

1688 - def element(self,poly):

1689 '''Create an element from a string or object. 1690 ''' 1691 if not isinstance(poly,str): 1692 try: 1693 if self.ring == poly.ring: 1694 return RingElem(poly); 1695 except Exception, e: 1696 pass 1697 poly = str(poly); 1698 I = SubModule(self, "( " + poly + " )"); 1699 list = I.mset.list; 1700 if len(list) > 0: 1701 return RingElem( list[0] );

1702

1703 - def gens(self):

1704 '''Get the generators of this module. 1705 ''' 1706 gm = GenVectorModul(self.ring,self.cols); 1707 L = gm.generators(); 1708 #for g in L: 1709 # print "g = ", str(g); 1710 N = [ RingElem(e) for e in L ]; # want use val here, but can not 1711 return N;

1712

1713 - def inject_variables(self):

1714 '''Inject generators as variables into the main global namespace 1715 ''' 1716 inject_generators(self.gens());

1717 1718

1719 -class SubModule:

1720 '''Represents a JAS sub-module over a polynomial ring. 1721 1722 Methods to compute Groebner bases. 1723 ''' 1724

1725 - def __init__(self,module,modstr="",list=None):

1726 '''Constructor for a sub-module. 1727 ''' 1728 self.module = module; 1729 if list == None: 1730 sr = StringReader( modstr ); 1731 tok = GenPolynomialTokenizer(module.ring,sr); 1732 self.list = tok.nextSubModuleList(); 1733 else: 1734 if isinstance(list,PyList) or isinstance(list,PyTuple): 1735 if len(list) != 0: 1736 if isinstance(list[0],RingElem): 1737 list = [ re.elem for re in list ]; 1738 self.list = pylist2arraylist(list,self.module.ring,rec=2); 1739 else: 1740 self.list = list; 1741 #print "list = ", str(list); 1742 #e = self.list[0]; 1743 #print "e = ", e; 1744 self.mset = OrderedModuleList(module.ring,self.list); 1745 self.cols = self.mset.cols; 1746 self.rows = self.mset.rows; 1747 #print "list = %s" % self.list; 1748 #print "cols = %s" % self.cols; 1749 #print "mset = %s" % self.mset.toString(); 1750 #print "mset = %s" % self.mset.toScript(); 1751 self.pset = self.mset.getPolynomialList();

1752

1753 - def __str__(self):

1754 '''Create a string representation. 1755 ''' 1756 return str(self.mset.toScript()); # + "\n\n" + str(self.pset);

1757

1758 - def GB(self):

1759 '''Compute a Groebner base. 1760 ''' 1761 t = System.currentTimeMillis(); 1762 #G = ModGroebnerBaseSeq(self.module.ring.coFac).GB(self.mset); 1763 G = GroebnerBaseSeq().GB(self.mset); 1764 t = System.currentTimeMillis() - t; 1765 print "executed module GB in %s ms" % t; 1766 return SubModule(self.module,"",G.list);

1767

1768 - def isGB(self):

1769 '''Test if this is a Groebner base. 1770 ''' 1771 t = System.currentTimeMillis(); 1772 #b = ModGroebnerBaseSeq(self.module.ring.coFac).isGB(self.mset); 1773 b = GroebnerBaseSeq().isGB(self.mset); 1774 t = System.currentTimeMillis() - t; 1775 print "module isGB executed in %s ms" % t; 1776 return b;

1777

1778 - def isSyzygy(self,g):

1779 '''Test if this is a syzygy of the vectors in g. 1780 ''' 1781 l = self.list; 1782 if isinstance(g,Ideal): 1783 s = g.pset.list; 1784 else: 1785 if isinstance(g,SubModule): 1786 s = g.mset; 1787 l = self.mset; 1788 else: 1789 raise ValueError, "unknown type %s" % g.getClass().getName(); 1790 #print "l = %s" % l; 1791 #print "s = %s" % s; 1792 t = System.currentTimeMillis(); 1793 z = SyzygySeq(self.module.ring.coFac).isZeroRelation( l, s ); 1794 t = System.currentTimeMillis() - t; 1795 print "executed isSyzygy in %s ms" % t; 1796 return z;

1797

1798 - def syzygy(self):

1799 '''Compute syzygys of this module. 1800 ''' 1801 l = self.mset; 1802 t = System.currentTimeMillis(); 1803 p = SyzygySeq(self.module.ring.coFac).zeroRelations( l ); 1804 t = System.currentTimeMillis() - t; 1805 print "executed module syzygy in %s ms" % t; 1806 #print "p = " + str(p.ring.toScript()); 1807 m = Module("",p.ring,p.cols); 1808 return SubModule(m,"",p.list);

1809 1810

1811 -class SolvableModule(Module):

1812 '''Represents a JAS module over a solvable polynomial ring. 1813 1814 Method to create solvable sub-modules. 1815 ''' 1816

1817 - def __init__(self,modstr="",ring=None,cols=0):

1818 '''Solvable module constructor. 1819 ''' 1820 if ring == None: 1821 sr = StringReader( modstr ); 1822 tok = RingFactoryTokenizer(sr); 1823 pfac = tok.nextSolvablePolynomialRing(); 1824 #tok = GenPolynomialTokenizer(pfac,sr); 1825 #mlist = tok.nextSolvableSubModuleList(); 1826 #self.mset = PolynomialList(pfac,mlist); 1827 #if self.mset.cols >= 0: 1828 # self.cols = self.mset.cols; 1829 self.ring = pfac; 1830 else: 1831 if isinstance(ring,Ring): 1832 self.ring = ring.ring; 1833 else: 1834 self.ring = ring; 1835 self.mset = ModuleList(self.ring,None); 1836 if cols < 0: 1837 cols = 0; 1838 self.cols = cols;

1839

1840 - def __str__(self):

1841 '''Create a string representation. 1842 ''' 1843 return str(self.mset.toScript());

1844

1845 - def submodul(self,modstr="",list=None):

1846 '''Create a solvable sub-module. 1847 ''' 1848 return SolvableSubModule(self,modstr,list);

1849

1850 - def element(self,poly):

1851 '''Create an element from a string or object. 1852 ''' 1853 if not isinstance(poly,str): 1854 try: 1855 if self.ring == poly.ring: 1856 return RingElem(poly); 1857 except Exception, e: 1858 pass 1859 poly = str(poly); 1860 I = SolvableSubModule(self, "( " + poly + " )"); 1861 list = I.mset.list; 1862 if len(list) > 0: 1863 return RingElem( list[0] );

1864 1865

1866 -class SolvableSubModule:

1867 '''Represents a JAS sub-module over a solvable polynomial ring. 1868 1869 Methods to compute left, right and two-sided Groebner bases. 1870 ''' 1871

1872 - def __init__(self,module,modstr="",list=None):

1873 '''Constructor for sub-module over a solvable polynomial ring. 1874 ''' 1875 self.module = module; 1876 if list == None: 1877 sr = StringReader( modstr ); 1878 tok = GenPolynomialTokenizer(module.ring,sr); 1879 self.list = tok.nextSolvableSubModuleList(); 1880 else: 1881 if isinstance(list,PyList) or isinstance(list,PyTuple): 1882 self.list = pylist2arraylist(list,self.module.ring,rec=2); 1883 else: 1884 self.list = list; 1885 self.mset = OrderedModuleList(module.ring,self.list); 1886 self.cols = self.mset.cols; 1887 self.rows = self.mset.rows;

1888

1889 - def __str__(self):

1890 '''Create a string representation. 1891 ''' 1892 return str(self.mset.toScript()); # + "\n\n" + str(self.pset);

1893

1894 - def leftGB(self):

1895 '''Compute a left Groebner base. 1896 ''' 1897 t = System.currentTimeMillis(); 1898 #G = SolvableGroebnerBaseSeq(self.module.ring.coFac).leftGB(self.mset); 1899 G = SolvableGroebnerBaseSeq().leftGB(self.mset); 1900 t = System.currentTimeMillis() - t; 1901 print "executed left module GB in %s ms" % t; 1902 return SolvableSubModule(self.module,"",G.list);

1903

1904 - def isLeftGB(self):

1905 '''Test if this is a left Groebner base. 1906 ''' 1907 t = System.currentTimeMillis(); 1908 #b = SolvableGroebnerBaseSeq(self.module.ring.coFac).isLeftGB(self.mset); 1909 b = SolvableGroebnerBaseSeq().isLeftGB(self.mset); 1910 t = System.currentTimeMillis() - t; 1911 print "module isLeftGB executed in %s ms" % t; 1912 return b;

1913

1914 - def twosidedGB(self):

1915 '''Compute a two-sided Groebner base. 1916 ''' 1917 t = System.currentTimeMillis(); 1918 #G = SolvableGroebnerBaseSeq(self.module.ring.coFac).twosidedGB(self.mset); 1919 G = SolvableGroebnerBaseSeq().twosidedGB(self.mset); 1920 t = System.currentTimeMillis() - t; 1921 print "executed twosided module GB in %s ms" % t; 1922 return SolvableSubModule(self.module,"",G.list);

1923

1924 - def isTwosidedGB(self):

1925 '''Test if this is a two-sided Groebner base. 1926 ''' 1927 t = System.currentTimeMillis(); 1928 #b = SolvableGroebnerBaseSeq(self.module.ring.coFac).isTwosidedGB(self.mset); 1929 b = SolvableGroebnerBaseSeq().isTwosidedGB(self.mset); 1930 t = System.currentTimeMillis() - t; 1931 print "module isTwosidedGB executed in %s ms" % t; 1932 return b;

1933

1934 - def rightGB(self):

1935 '''Compute a right Groebner base. 1936 ''' 1937 t = System.currentTimeMillis(); 1938 #G = SolvableGroebnerBaseSeq(self.module.ring.coFac).rightGB(self.mset); 1939 G = SolvableGroebnerBaseSeq().rightGB(self.mset); 1940 t = System.currentTimeMillis() - t; 1941 print "executed right module GB in %s ms" % t; 1942 return SolvableSubModule(self.module,"",G.list);

1943

1944 - def isRightGB(self):

1945 '''Test if this is a right Groebner base. 1946 ''' 1947 t = System.currentTimeMillis(); 1948 #b = SolvableGroebnerBaseSeq(self.module.ring.coFac).isRightGB(self.mset); 1949 b = SolvableGroebnerBaseSeq().isRightGB(self.mset); 1950 t = System.currentTimeMillis() - t; 1951 print "module isRightGB executed in %s ms" % t; 1952 return b;

1953

1954 - def isLeftSyzygy(self,g):

1955 '''Test if this is a syzygy of the vectors in g. 1956 ''' 1957 l = self.list; 1958 if isinstance(g,SolvableIdeal): 1959 s = g.pset.list; 1960 else: 1961 if isinstance(g,SolvableSubModule): 1962 s = g.mset; 1963 l = self.mset; 1964 else: 1965 raise ValueError, "unknown type %s" % g.getClass().getName(); 1966 #print "l = %s" % l; 1967 #print "g = %s" % g; 1968 t = System.currentTimeMillis(); 1969 z = SolvableSyzygySeq(self.module.ring.coFac).isLeftZeroRelation( l, s ); 1970 t = System.currentTimeMillis() - t; 1971 print "executed isLeftSyzygy in %s ms" % t; 1972 return z;

1973

1974 - def leftSyzygy(self):

1975 '''Compute left syzygys of this module. 1976 ''' 1977 l = self.mset; 1978 t = System.currentTimeMillis(); 1979 p = SolvableSyzygySeq(self.module.ring.coFac).leftZeroRelationsArbitrary( l ); 1980 t = System.currentTimeMillis() - t; 1981 print "executed left module syzygy in %s ms" % t; 1982 #print "p = " + str(p.ring.toScript()); 1983 m = SolvableModule("",p.ring,p.cols); 1984 return SolvableSubModule(m,"",p.list);

1985

1986 - def isRightSyzygy(self,g):

1987 '''Test if this is a syzygy of the vectors in g. 1988 ''' 1989 l = self.list; 1990 if isinstance(g,SolvableIdeal): 1991 s = g.pset.list; 1992 else: 1993 if isinstance(g,SolvableSubModule): 1994 s = g.mset; 1995 l = self.mset; 1996 else: 1997 raise ValueError, "unknown type %s" % g.getClass().getName(); 1998 #print "l = %s" % l; 1999 #print "g = %s" % g; 2000 t = System.currentTimeMillis(); 2001 z = SolvableSyzygySeq(self.module.ring.coFac).isRightZeroRelation( l, s ); 2002 t = System.currentTimeMillis() - t; 2003 print "executed isRightSyzygy in %s ms" % t; 2004 return z;

2005

2006 - def rightSyzygy(self):

2007 '''Compute right syzygys of this module. 2008 ''' 2009 l = self.mset; 2010 t = System.currentTimeMillis(); 2011 # no: p = SolvableSyzygySeq(self.module.ring.coFac).rightZeroRelations( l ); 2012 p = SolvableSyzygySeq(self.module.ring.coFac).rightZeroRelationsArbitrary( l ); 2013 t = System.currentTimeMillis() - t; 2014 print "executed right module syzygy in %s ms" % t; 2015 #print "p = " + str(p.ring.toScript()); 2016 m = SolvableModule("",p.ring,p.cols); 2017 return SolvableSubModule(m,"",p.list);

2018 2019

2020 -class SeriesRing:

2021 '''Represents a JAS power series ring: UnivPowerSeriesRing. 2022 2023 Methods for univariate power series arithmetic. 2024 ''' 2025

2026 - def __init__(self,ringstr="",truncate=None,ring=None,cofac=None,name="z"):

2027 '''Ring constructor. 2028 ''' 2029 if ring == None: 2030 if len(ringstr) > 0: 2031 sr = StringReader( ringstr ); 2032 tok = RingFactoryTokenizer(sr); 2033 pfac = tok.nextPolynomialRing(); 2034 #tok = GenPolynomialTokenizer(pfac,sr); 2035 #plist = tok.nextPolynomialList(); 2036 #pset = PolynomialList(pfac,plist); 2037 ring = pfac; 2038 vname = ring.vars; 2039 name = vname[0]; 2040 cofac = ring.coFac; 2041 if isinstance(cofac,RingElem): 2042 cofac = cofac.elem; 2043 if truncate == None: 2044 self.ring = UnivPowerSeriesRing(cofac,name); 2045 else: 2046 self.ring = UnivPowerSeriesRing(cofac,truncate,name); 2047 else: 2048 self.ring = ring;

2049

2050 - def __str__(self):

2051 '''Create a string representation. 2052 ''' 2053 return str(self.ring.toScript());

2054

2055 - def gens(self):

2056 '''Get the generators of the power series ring. 2057 ''' 2058 L = self.ring.generators(); 2059 N = [ RingElem(e) for e in L ]; 2060 return N;

2061

2062 - def inject_variables(self):

2063 '''Inject generators as variables into the main global namespace 2064 ''' 2065 inject_generators(self.gens());

2066

2067 - def one(self):

2068 '''Get the one of the power series ring. 2069 ''' 2070 return RingElem( self.ring.getONE() );

2071

2072 - def zero(self):

2073 '''Get the zero of the power series ring. 2074 ''' 2075 return RingElem( self.ring.getZERO() );

2076

2077 - def random(self,n):

2078 '''Get a random power series. 2079 ''' 2080 return RingElem( self.ring.random(n) );

2081

2082 - def exp(self):

2083 '''Get the exponential power series. 2084 ''' 2085 return RingElem( self.ring.getEXP() );

2086

2087 - def sin(self):

2088 '''Get the sinus power series. 2089 ''' 2090 return RingElem( self.ring.getSIN() );

2091

2092 - def cos(self):

2093 '''Get the cosinus power series. 2094 ''' 2095 return RingElem( self.ring.getCOS() );

2096

2097 - def tan(self):

2098 '''Get the tangens power series. 2099 ''' 2100 return RingElem( self.ring.getTAN() );

2101

2102 - def create(self,ifunc=None,jfunc=None,clazz=None):

2103 '''Create a power series with given generating function. 2104 2105 ifunc(int i) must return a value which is used in RingFactory.fromInteger(). 2106 jfunc(int i) must return a value of type ring.coFac. 2107 clazz must implement the Coefficients abstract class. 2108 ''' 2109 class coeff( Coefficients ): 2110 def __init__(self,cofac): 2111 self.coFac = cofac;

2112 def generate(self,i): 2113 if jfunc == None: 2114 return self.coFac.fromInteger( ifunc(i) ); 2115 else: 2116 return jfunc(i);

2117 if clazz == None: 2118 ps = UnivPowerSeries( self.ring, coeff(self.ring.coFac) ); 2119 else: 2120 ps = UnivPowerSeries( self.ring, clazz ); 2121 return RingElem( ps ); 2122

2123 - def fixPoint(self,psmap):

2124 '''Create a power series as fixed point of the given mapping. 2125 2126 psmap must implement the UnivPowerSeriesMap interface. 2127 ''' 2128 ps = self.ring.fixPoint( psmap ); 2129 return RingElem( ps );

2130

2131 - def gcd(self,a,b):

2132 '''Compute the greatest common divisor of a and b. 2133 ''' 2134 if isinstance(a,RingElem): 2135 a = a.elem; 2136 if isinstance(b,RingElem): 2137 b = b.elem; 2138 return RingElem( a.gcd(b) );

2139

2140 - def fromPoly(self,a):

2141 '''Convert a GenPolynomial to a power series. 2142 ''' 2143 if isinstance(a,RingElem): 2144 a = a.elem; 2145 return RingElem( self.ring.fromPolynomial(a) );

2146 2147

2148 -class MultiSeriesRing:

2149 '''Represents a JAS power series ring: MultiVarPowerSeriesRing. 2150 2151 Methods for multivariate power series arithmetic. 2152 ''' 2153

2154 - def __init__(self,ringstr="",truncate=None,ring=None,cofac=None,names=None):

2155 '''Ring constructor. 2156 ''' 2157 if ring == None: 2158 if len(ringstr) > 0: 2159 sr = StringReader( ringstr ); 2160 tok = RingFactoryTokenizer(sr); 2161 pfac = tok.nextPolynomialRing(); 2162 #tok = GenPolynomialTokenizer(pfac,sr); 2163 #plist = tok.nextPolynomialList(); 2164 #pset = PolynomialList(pfac,plist); 2165 ring = pfac; 2166 names = ring.vars; 2167 cofac = ring.coFac; 2168 if isinstance(cofac,RingElem): 2169 cofac = cofac.elem; 2170 if truncate == None: 2171 self.ring = MultiVarPowerSeriesRing(cofac,names); 2172 else: 2173 self.ring = MultiVarPowerSeriesRing(cofac,len(names),truncate,names); 2174 else: 2175 self.ring = ring;

2176

2177 - def __str__(self):

2178 '''Create a string representation. 2179 ''' 2180 return str(self.ring.toScript());

2181

2182 - def gens(self):

2183 '''Get the generators of the power series ring. 2184 ''' 2185 L = self.ring.generators(); 2186 N = [ RingElem(e) for e in L ]; 2187 return N;

2188

2189 - def inject_variables(self):

2190 '''Inject generators as variables into the main global namespace 2191 ''' 2192 inject_generators(self.gens());

2193

2194 - def one(self):

2195 '''Get the one of the power series ring. 2196 ''' 2197 return RingElem( self.ring.getONE() );

2198

2199 - def zero(self):

2200 '''Get the zero of the power series ring. 2201 ''' 2202 return RingElem( self.ring.getZERO() );

2203

2204 - def random(self,n):

2205 '''Get a random power series. 2206 ''' 2207 return RingElem( self.ring.random(n) );

2208

2209 - def exp(self,r):

2210 '''Get the exponential power series, var r. 2211 ''' 2212 return RingElem( self.ring.getEXP(r) );

2213

2214 - def sin(self,r):

2215 '''Get the sinus power series, var r. 2216 ''' 2217 return RingElem( self.ring.getSIN(r) );

2218

2219 - def cos(self,r):

2220 '''Get the cosinus power series, var r. 2221 ''' 2222 return RingElem( self.ring.getCOS(r) );

2223

2224 - def tan(self,r):

2225 '''Get the tangens power series, var r. 2226 ''' 2227 return RingElem( self.ring.getTAN(r) );

2228

2229 - def create(self,ifunc=None,jfunc=None,clazz=None):

2230 '''Create a power series with given generating function. 2231 2232 ifunc(int i) must return a value which is used in RingFactory.fromInteger(). 2233 jfunc(int i) must return a value of type ring.coFac. 2234 clazz must implement the Coefficients abstract class. 2235 ''' 2236 class coeff( MultiVarCoefficients ): 2237 def __init__(self,r): 2238 MultiVarCoefficients.__init__(self,r); 2239 self.coFac = r.coFac;

2240 def generate(self,i): 2241 if jfunc == None: 2242 return self.coFac.fromInteger( ifunc(i) ); 2243 else: 2244 return jfunc(i);

2245 #print "ifunc" 2246 if clazz == None: 2247 ps = MultiVarPowerSeries( self.ring, coeff(self.ring) ); 2248 else: 2249 ps = MultiVarPowerSeries( self.ring, clazz ); 2250 #print "ps ", ps.toScript(); 2251 return RingElem( ps ); 2252

2253 - def fixPoint(self,psmap):

2254 '''Create a power series as fixed point of the given mapping. 2255 2256 psmap must implement the UnivPowerSeriesMap interface. 2257 ''' 2258 ps = self.ring.fixPoint( psmap ); 2259 return RingElem( ps );

2260

2261 - def gcd(self,a,b):

2262 '''Compute the greatest common divisor of a and b. 2263 ''' 2264 if isinstance(a,RingElem): 2265 a = a.elem; 2266 if isinstance(b,RingElem): 2267 b = b.elem; 2268 return RingElem( a.gcd(b) );

2269

2270 - def fromPoly(self,a):

2271 '''Convert a GenPolynomial to a power series. 2272 ''' 2273 if isinstance(a,RingElem): 2274 a = a.elem; 2275 return RingElem( self.ring.fromPolynomial(a) );

2276 2277

2278 -class PSIdeal:

2279 '''Represents a JAS power series ideal. 2280 2281 Method for Standard bases. 2282 ''' 2283

2284 - def __init__(self,ring,polylist,ideal=None,list=None):

2285 '''PSIdeal constructor. 2286 ''' 2287 if isinstance(ring,Ring) or isinstance(ring,PolyRing): 2288 ring = MultiVarPowerSeriesRing(ring.ring); 2289 if isinstance(ring,MultiSeriesRing): 2290 ring = ring.ring; 2291 self.ring = ring; 2292 #print "ring = ", ring.toScript(); 2293 if ideal != None: 2294 polylist = ideal.pset.list; 2295 if list == None: 2296 self.polylist = pylist2arraylist( [ a.elem for a in polylist ] ); 2297 #print "polylist = ", self.polylist; 2298 self.list = self.ring.fromPolynomial(self.polylist); 2299 else: 2300 self.polylist = None; 2301 self.list = pylist2arraylist( [ a.elem for a in list ] );

2302

2303 - def __str__(self):

2304 '''Create a string representation. 2305 ''' 2306 ll = [ e.toScript() for e in self.list ] 2307 return "( " + ", ".join(ll) + " )";

2308

2309 - def STD(self,trunc=None):

2310 '''Compute a standard base. 2311 ''' 2312 pr = self.ring; 2313 if trunc != None: 2314 pr.setTruncate(trunc); 2315 #print "pr = ", pr.toScript(); 2316 F = self.list; 2317 #print "F = ", F; 2318 tm = StandardBaseSeq(); 2319 t = System.currentTimeMillis(); 2320 S = tm.STD(F); 2321 t = System.currentTimeMillis() - t; 2322 print "sequential standard base executed in %s ms" % t; 2323 #Sp = [ RingElem(a.asPolynomial()) for a in S ]; 2324 Sp = [ RingElem(a) for a in S ]; 2325 #return Sp; 2326 return PSIdeal(self.ring,None,list=Sp);

2327 2328

2329 -def pylist2arraylist(list,fac=None,rec=1):

2330 '''Convert a Python list to a Java ArrayList. 2331 2332 If list is a Python list, it is converted, else list is left unchanged. 2333 ''' 2334 #print "list type(%s) = %s" % (list,type(list)); 2335 if isinstance(list,PyList) or isinstance(list,PyTuple): 2336 L = ArrayList(); 2337 for e in list: 2338 t = True; 2339 if isinstance(e,RingElem): 2340 t = False; 2341 e = e.elem; 2342 if isinstance(e,PyList) or isinstance(e,PyTuple): 2343 if rec <= 1: 2344 e = makeJasArith(e); 2345 else: 2346 t = False; 2347 e = pylist2arraylist(e,fac,rec-1); 2348 try: 2349 #n = e.getClass().getSimpleName(); 2350 if isinstance(e,ArrayList) or isinstance(e,LinkedList): 2351 t = False; 2352 except: 2353 pass; 2354 if t and fac != None: 2355 #print "e.p(%s) = %s" % (e,e.getClass().getName()); 2356 e = fac.parse( str(e) ); #or makeJasArith(e) ? 2357 L.add(e); 2358 list = L; 2359 #print "list type(%s) = %s" % (list,type(list)); 2360 return list

2361 2362

2363 -def arraylist2pylist(list,rec=1):

2364 '''Convert a Java ArrayList to a Python list. 2365 2366 If list is a Java ArrayList list, it is converted, else list is left unchanged. 2367 ''' 2368 #print "list type(%s) = %s" % (list,type(list)); 2369 if isinstance(list,List): 2370 L = []; 2371 for e in list: 2372 if not isinstance(e,RingElem): 2373 e = RingElem(e); 2374 L.append(e); 2375 list = L; 2376 #print "list type(%s) = %s" % (list,type(list)); 2377 return list

2378 2379

2380 -def makeJasArith(item):

2381 '''Construct a jas.arith object. 2382 If item is a python tuple or list then a BigRational, BigComplex is constructed. 2383 If item is a python float then a BigDecimal is constructed. 2384 ''' 2385 #print "item type(%s) = %s" % (item,type(item)); 2386 if isinstance(item,PyInteger) or isinstance(item,PyLong): 2387 return BigInteger( item ); 2388 if isinstance(item,PyFloat): # ?? what to do ?? 2389 return BigDecimal( str(item) ); 2390 if isinstance(item,PyTuple) or isinstance(item,PyList): 2391 if len(item) > 2: 2392 print "len(item) > 2, remaining items ignored"; 2393 #print "item[0] type(%s) = %s" % (item[0],type(item[0])); 2394 isc = isinstance(item[0],PyTuple) or isinstance(item[0],PyList) 2395 if len(item) > 1: 2396 isc = isc or isinstance(item[1],PyTuple) or isinstance(item[1],PyList); 2397 if isc: 2398 if len(item) > 1: 2399 re = makeJasArith( item[0] ); 2400 if not re.isField(): 2401 re = BigRational( re.val ); 2402 im = makeJasArith( item[1] ); 2403 if not im.isField(): 2404 im = BigRational( im.val ); 2405 jasArith = BigComplex( re, im ); 2406 else: 2407 re = makeJasArith( item[0] ); 2408 jasArith = BigComplex( re ); 2409 else: 2410 if len(item) > 1: 2411 jasArith = BigRational( item[0] ).divide( BigRational( item[1] ) ); 2412 else: 2413 jasArith = BigRational( item[0] ); 2414 return jasArith; 2415 print "makeJasArith: unknown item type(%s) = %s" % (item,type(item)); 2416 return item;

2417 2418

2419 -def ZZ(z=0):

2420 '''Create JAS BigInteger as ring element. 2421 ''' 2422 if isinstance(z,RingElem): 2423 z = z.elem; 2424 r = BigInteger(z); 2425 return RingElem(r);

2426

2427 -def ZM(m,z=0,field=False):

2428 '''Create JAS ModInteger as ring element. 2429 ''' 2430 if isinstance(m,RingElem): 2431 m = m.elem; 2432 if isinstance(z,RingElem): 2433 z = z.elem; 2434 # if z != 0 and ( z == False ): # never true 2435 # field = z; 2436 # z = 0; 2437 if m < ModLongRing.MAX_LONG: 2438 if field: 2439 mf = ModLongRing(m,field); 2440 else: 2441 mf = ModLongRing(m); 2442 r = ModLong(mf,z); 2443 else: 2444 if field: 2445 mf = ModIntegerRing(m,field); 2446 else: 2447 mf = ModIntegerRing(m); 2448 r = ModInteger(mf,z); 2449 return RingElem(r);

2450 2451

2452 -def ZML(m,z=0,field=False):

2453 '''Create JAS ModLong as ring element. 2454 ''' 2455 return ZM(m,z,field);

2456 2457

2458 -def GF(m,z=0):

2459 '''Create JAS ModInteger as field element. 2460 ''' 2461 #print "m = %s" % m 2462 return ZM(m,z,True);

2463 2464

2465 -def GFL(m,z=0):

2466 '''Create JAS ModLong as field element. 2467 ''' 2468 #print "m = %s" % m 2469 return ZM(m,z,True);

2470 2471

2472 -def QQ(d=0,n=1):

2473 '''Create JAS BigRational as ring element. 2474 ''' 2475 if isinstance(d,PyTuple) or isinstance(d,PyList): 2476 if n != 1: 2477 print "%s ignored" % n; 2478 if len(d) > 1: 2479 n = d[1]; 2480 d = d[0]; 2481 if isinstance(d,RingElem): 2482 d = d.elem; 2483 if isinstance(n,RingElem): 2484 n = n.elem; 2485 if n == 1: 2486 if d == 0: 2487 r = BigRational(); 2488 else: 2489 r = BigRational(d); 2490 else: 2491 d = BigRational(d); 2492 n = BigRational(n); 2493 r = d.divide(n); # BigRational(d,n); only for short integers 2494 return RingElem(r);

2495 2496

2497 -def CC(re=BigRational(),im=BigRational()):

2498 '''Create JAS BigComplex as ring element. 2499 ''' 2500 if re == 0: 2501 re = BigRational(); 2502 if im == 0: 2503 im = BigRational(); 2504 if isinstance(re,PyTuple) or isinstance(re,PyList): 2505 if isinstance(re[0],PyTuple) or isinstance(re[0],PyList): 2506 if len(re) > 1: 2507 im = QQ( re[1] ); 2508 re = QQ( re[0] ); 2509 else: 2510 re = QQ(re); 2511 # re = makeJasArith( re ); 2512 if isinstance(im,PyTuple) or isinstance(im,PyList): 2513 im = QQ( im ); 2514 # im = makeJasArith( im ); 2515 if isinstance(re,RingElem): 2516 re = re.elem; 2517 if isinstance(im,RingElem): 2518 im = im.elem; 2519 if im.isZERO(): 2520 if re.isZERO(): 2521 c = BigComplex(); 2522 else: 2523 c = BigComplex(re); 2524 else: 2525 c = BigComplex(re,im); 2526 return RingElem(c);

2527 2528

2529 -def CR(re=BigRational(),im=BigRational(),ring=None):

2530 '''Create JAS generic Complex as ring element. 2531 ''' 2532 if re == 0: 2533 re = BigRational(); 2534 if im == 0: 2535 im = BigRational(); 2536 if isinstance(re,PyTuple) or isinstance(re,PyList): 2537 if isinstance(re[0],PyTuple) or isinstance(re[0],PyList): 2538 if len(re) > 1: 2539 im = QQ( re[1] ); 2540 re = QQ( re[0] ); 2541 else: 2542 re = QQ(re); 2543 # re = makeJasArith( re ); 2544 if isinstance(im,PyTuple) or isinstance(im,PyList): 2545 im = QQ( im ); 2546 # im = makeJasArith( im ); 2547 if isinstance(re,RingElem): 2548 re = re.elem; 2549 if isinstance(im,RingElem): 2550 im = im.elem; 2551 if ring == None: 2552 ring = re.factory(); 2553 r = ComplexRing(ring); 2554 #print "d type(%s) = %s" % (r,type(r)); 2555 if im.isZERO(): 2556 if re.isZERO(): 2557 c = Complex(r); 2558 else: 2559 c = Complex(r,re); 2560 else: 2561 c = Complex(r,re,im); 2562 #print "d type(%s) = %s" % (c,type(c)); 2563 return RingElem(c);

2564 2565

2566 -def DD(d=0):

2567 '''Create JAS BigDecimal as ring element. 2568 ''' 2569 if isinstance(d,RingElem): 2570 d = d.elem; 2571 if isinstance(d,PyFloat): 2572 d = str(d); 2573 #print "d type(%s) = %s" % (d,type(d)); 2574 if d == 0: 2575 r = BigDecimal(); 2576 else: 2577 r = BigDecimal(d); 2578 return RingElem(r);

2579 2580

2581 -def Quat(re=BigRational(),im=BigRational(),jm=BigRational(),km=BigRational()):

2582 '''Create JAS BigQuaternion as ring element. 2583 ''' 2584 if re == 0: 2585 re = BigRational(); 2586 if im == 0: 2587 im = BigRational(); 2588 if jm == 0: 2589 jm = BigRational(); 2590 if km == 0: 2591 km = BigRational(); 2592 if isinstance(re,PyTuple) or isinstance(re,PyList): 2593 if isinstance(re[0],PyTuple) or isinstance(re[0],PyList): 2594 if len(re) > 1: 2595 im = QQ( re[1] ); 2596 re = QQ( re[0] ); 2597 else: 2598 re = QQ(re); 2599 # re = makeJasArith( re ); 2600 if isinstance(im,PyTuple) or isinstance(im,PyList): 2601 im = QQ( im ); 2602 if isinstance(jm,PyTuple) or isinstance(jm,PyList): 2603 jm = QQ( jm ); 2604 if isinstance(km,PyTuple) or isinstance(km,PyList): 2605 kim = QQ( km ); 2606 # im = makeJasArith( im ); 2607 if isinstance(re,RingElem): 2608 re = re.elem; 2609 if isinstance(im,RingElem): 2610 im = im.elem; 2611 if isinstance(jm,RingElem): 2612 jm = jm.elem; 2613 if isinstance(km,RingElem): 2614 km = km.elem; 2615 cf = BigQuaternionRing(); 2616 c = BigQuaternion(cf, re,im,jm,km); 2617 return RingElem(c);

2618 2619

2620 -def Oct(ro=0,io=0):

2621 '''Create JAS BigOctonion as ring element. 2622 ''' 2623 cf = BigQuaternionRing(); 2624 if ro == 0: 2625 ro = BigQuaternion(cf); 2626 if io == 0: 2627 io = BigQuaternion(cf); 2628 if isinstance(ro,PyTuple) or isinstance(ro,PyList): 2629 if isinstance(ro[0],PyTuple) or isinstance(ro[0],PyList): 2630 if len(ro) > 1: 2631 io = QQ( ro[1] ); 2632 ro = QQ( ro[0] ); 2633 else: 2634 ro = QQ(ro); 2635 # re = makeJasArith( re ); 2636 if isinstance(io,PyTuple) or isinstance(io,PyList): 2637 io = QQ( io ); 2638 # im = makeJasArith( im ); 2639 if isinstance(ro,RingElem): 2640 ro = ro.elem; 2641 if isinstance(io,RingElem): 2642 io = io.elem; 2643 c = BigOctonion(ro,io); 2644 return RingElem(c);

2645 2646

2647 -def AN(m,z=0,field=False,pr=None):

2648 '''Create JAS AlgebraicNumber as ring element. 2649 ''' 2650 if isinstance(m,RingElem): 2651 m = m.elem; 2652 if isinstance(z,RingElem): 2653 z = z.elem; 2654 # if (z == True or z == False): # not working 2655 # field = z; 2656 # z = 0; 2657 #print "m.getClass() = " + str(m.getClass().getName()); 2658 #print "field = " + str(field); 2659 if isinstance(m,AlgebraicNumber): 2660 mf = AlgebraicNumberRing(m.factory().modul,m.factory().isField()); 2661 else: 2662 if field: 2663 mf = AlgebraicNumberRing(m,field); 2664 else: 2665 mf = AlgebraicNumberRing(m); 2666 #print "mf = " + mf.toString(); 2667 if z == 0: 2668 r = AlgebraicNumber(mf); 2669 else: 2670 r = AlgebraicNumber(mf,z); 2671 return RingElem(r);

2672 2673

2674 -def RealN(m,i,r=0):

2675 '''Create JAS RealAlgebraicNumber as ring element. 2676 ''' 2677 if isinstance(m,RingElem): 2678 m = m.elem; 2679 if isinstance(r,RingElem): 2680 r = r.elem; 2681 if isinstance(i,PyTuple) or isinstance(i,PyList): 2682 il = BigRational(i[0]); 2683 ir = BigRational(i[1]); 2684 i = Interval(il,ir); 2685 #print "m.getClass() = " + str(m.getClass().getName()); 2686 if isinstance(m,RealAlgebraicNumber): 2687 mf = RealAlgebraicRing(m.factory().algebraic.modul,i); 2688 else: 2689 mf = RealAlgebraicRing(m,i); 2690 if r == 0: 2691 rr = RealAlgebraicNumber(mf); 2692 else: 2693 rr = RealAlgebraicNumber(mf,r); 2694 return RingElem(rr);

2695 2696

2697 -def RF(pr,d=0,n=1):

2698 '''Create JAS rational function Quotient as ring element. 2699 ''' 2700 if isinstance(d,PyTuple) or isinstance(d,PyList): 2701 if n != 1: 2702 print "%s ignored" % n; 2703 if len(d) > 1: 2704 n = d[1]; 2705 d = d[0]; 2706 if isinstance(d,RingElem): 2707 d = d.elem; 2708 if isinstance(n,RingElem): 2709 n = n.elem; 2710 if isinstance(pr,RingElem): 2711 pr = pr.elem; 2712 if isinstance(pr,Ring): 2713 pr = pr.ring; 2714 qr = QuotientRing(pr); 2715 if d == 0: 2716 r = Quotient(qr); 2717 else: 2718 if n == 1: 2719 r = Quotient(qr,d); 2720 else: 2721 r = Quotient(qr,d,n); 2722 return RingElem(r);

2723 2724

2725 -def RC(ideal,r=0):

2726 '''Create JAS polynomial Residue as ring element. 2727 ''' 2728 if ideal == None: 2729 raise ValueError, "No ideal given." 2730 if isinstance(ideal,Ideal): 2731 ideal = jas.application.Ideal(ideal.pset); 2732 #ideal.doGB(); 2733 #print "ideal.getList().get(0).ring.ideal = %s" % ideal.getList().get(0).ring.ideal; 2734 if isinstance(ideal.getList().get(0).ring,ResidueRing): 2735 rc = ResidueRing( ideal.getList().get(0).ring.ideal ); 2736 else: 2737 rc = ResidueRing(ideal); 2738 if isinstance(r,RingElem): 2739 r = r.elem; 2740 if r == 0: 2741 r = Residue(rc); 2742 else: 2743 r = Residue(rc,r); 2744 return RingElem(r);

2745 2746

2747 -def LC(ideal,d=0,n=1):

2748 '''Create JAS polynomial Local as ring element. 2749 ''' 2750 if ideal == None: 2751 raise ValueError, "No ideal given." 2752 if isinstance(ideal,Ideal): 2753 ideal = jas.application.Ideal(ideal.pset); 2754 #ideal.doGB(); 2755 #print "ideal.getList().get(0).ring.ideal = %s" % ideal.getList().get(0).ring.ideal; 2756 if isinstance(ideal.getList().get(0).ring,LocalRing): 2757 lc = LocalRing( ideal.getList().get(0).ring.ideal ); 2758 else: 2759 lc = LocalRing(ideal); 2760 if isinstance(d,PyTuple) or isinstance(d,PyList): 2761 if n != 1: 2762 print "%s ignored" % n; 2763 if len(d) > 1: 2764 n = d[1]; 2765 d = d[0]; 2766 if isinstance(d,RingElem): 2767 d = d.elem; 2768 if isinstance(n,RingElem): 2769 n = n.elem; 2770 if d == 0: 2771 r = Local(lc); 2772 else: 2773 if n == 1: 2774 r = Local(lc,d); 2775 else: 2776 r = Local(lc,d,n); 2777 return RingElem(r);

2778 2779

2780 -def SRF(pr,d=0,n=1):

2781 '''Create JAS rational function SolvableQuotient as ring element. 2782 ''' 2783 if isinstance(d,PyTuple) or isinstance(d,PyList): 2784 if n != 1: 2785 print "%s ignored" % n; 2786 if len(d) > 1: 2787 n = d[1]; 2788 d = d[0]; 2789 if isinstance(d,RingElem): 2790 d = d.elem; 2791 if isinstance(n,RingElem): 2792 n = n.elem; 2793 if isinstance(pr,RingElem): 2794 pr = pr.elem; 2795 if isinstance(pr,Ring): 2796 pr = pr.ring; 2797 qr = SolvableQuotientRing(pr); 2798 if d == 0: 2799 r = SolvableQuotient(qr); 2800 else: 2801 if n == 1: 2802 r = SolvableQuotient(qr,d); 2803 else: 2804 r = SolvableQuotient(qr,d,n); 2805 return RingElem(r);

2806 2807

2808 -def SRC(ideal,r=0):

2809 '''Create JAS polynomial SolvableResidue as ring element. 2810 ''' 2811 #print "ideal = " + str(ideal); 2812 if ideal == None: # does not work 2813 print "ideal = " + str(ideal); 2814 if False: 2815 raise ValueError, "No ideal given." 2816 if isinstance(ideal,SolvableIdeal): 2817 ideal = jas.application.SolvableIdeal(ideal.pset); 2818 #ideal.doGB(); 2819 #print "ideal.getList().get(0).ring.ideal = %s" % ideal.getList().get(0).ring.ideal; 2820 if isinstance(ideal.getList().get(0).ring,SolvableResidueRing): 2821 rc = SolvableResidueRing( ideal.getList().get(0).ring.ideal ); 2822 else: 2823 rc = SolvableResidueRing(ideal); 2824 if isinstance(r,RingElem): 2825 r = r.elem; 2826 if r == 0: 2827 r = SolvableResidue(rc); 2828 else: 2829 r = SolvableResidue(rc,r); 2830 return RingElem(r);

2831 2832

2833 -def SLC(ideal,d=0,n=1):

2834 '''Create JAS polynomial SolvableLocal as ring element. 2835 ''' 2836 if ideal == None: 2837 #print "ideal = " + str(ideal); 2838 if False: 2839 raise ValueError, "No ideal given." 2840 if isinstance(ideal,SolvableIdeal): 2841 ideal = jas.application.SolvableIdeal(ideal.pset); 2842 #ideal.doGB(); 2843 #print "ideal.getList().get(0).ring.ideal = %s" % ideal.getList().get(0).ring.ideal; 2844 if isinstance(ideal.getList().get(0).ring,SolvableLocalRing): 2845 lc = SolvableLocalRing( ideal.getList().get(0).ring.ideal ); 2846 else: 2847 lc = SolvableLocalRing(ideal); 2848 if isinstance(d,PyTuple) or isinstance(d,PyList): 2849 if n != 1: 2850 print "%s ignored" % n; 2851 if len(d) > 1: 2852 n = d[1]; 2853 d = d[0]; 2854 if isinstance(d,RingElem): 2855 d = d.elem; 2856 if isinstance(n,RingElem): 2857 n = n.elem; 2858 if d == 0: 2859 r = SolvableLocal(lc); 2860 else: 2861 if n == 1: 2862 r = SolvableLocal(lc,d); 2863 else: 2864 r = SolvableLocal(lc,d,n); 2865 return RingElem(r);

2866 2867

2868 -def SLR(ideal,d=0,n=1):

2869 '''Create JAS polynomial SolvableLocalResidue as ring element. 2870 ''' 2871 if ideal == None: 2872 #print "ideal = " + str(ideal); 2873 if False: 2874 raise ValueError, "No ideal given." 2875 if isinstance(ideal,SolvableIdeal): 2876 ideal = jas.application.SolvableIdeal(ideal.pset); 2877 #ideal.doGB(); 2878 #print "ideal.getList().get(0).ring.ideal = %s" % ideal.getList().get(0).ring.ideal; 2879 cfr = ideal.getList().get(0).ring; 2880 if isinstance(cfr,SolvableLocalResidueRing): 2881 lc = SolvableLocalResidueRing( cfr.ideal ); 2882 else: 2883 lc = SolvableLocalResidueRing(ideal); 2884 if isinstance(d,PyTuple) or isinstance(d,PyList): 2885 if n != 1: 2886 print "%s ignored" % n; 2887 if len(d) > 1: 2888 n = d[1]; 2889 d = d[0]; 2890 if isinstance(d,RingElem): 2891 d = d.elem; 2892 if isinstance(n,RingElem): 2893 n = n.elem; 2894 if d == 0: 2895 r = SolvableLocalResidue(lc); 2896 else: 2897 if n == 1: 2898 r = SolvableLocalResidue(lc,d); 2899 else: 2900 r = SolvableLocalResidue(lc,d,n); 2901 return RingElem(r);

2902 2903 2904

2905 -def RR(flist,n=1,r=0):

2906 '''Create JAS regular ring Product as ring element. 2907 ''' 2908 if not isinstance(n,PyInteger): 2909 r = n; 2910 n = 1; 2911 if flist == None: 2912 raise ValueError, "No list given." 2913 if isinstance(flist,PyList) or isinstance(flist,PyTuple): 2914 flist = pylist2arraylist( [ x.factory() for x in flist ], rec=1); 2915 ncop = 0; 2916 else: 2917 ncop = n; 2918 if isinstance(flist,RingElem): 2919 flist = flist.elem; 2920 flist = flist.factory(); 2921 ncop = n; 2922 #print "flist = " + str(flist); 2923 #print "ncop = " + str(ncop); 2924 if ncop == 0: 2925 pr = ProductRing(flist); 2926 else: 2927 pr = ProductRing(flist,ncop); 2928 #print "r type(%s) = %s" % (r,type(r)); 2929 if isinstance(r,RingElem): 2930 r = r.elem; 2931 try: 2932 #print "r.class() = %s" % r.getClass().getSimpleName(); 2933 if isinstance(r,Product): 2934 #print "r.val = %s" % r.val; 2935 r = r.val; 2936 except: 2937 pass; 2938 #print "r = " + str(r); 2939 if r == 0: 2940 r = Product(pr); 2941 else: 2942 r = Product(pr,r); 2943 return RingElem(r);

2944 2945

2946 -def PS(cofac,name,f=None,truncate=None):

2947 '''Create JAS UnivPowerSeries as ring element. 2948 ''' 2949 cf = cofac; 2950 if isinstance(cofac,RingElem): 2951 cf = cofac.elem.factory(); 2952 if isinstance(cofac,Ring): 2953 cf = cofac.ring; 2954 if isinstance(truncate,RingElem): 2955 truncate = truncate.elem; 2956 if truncate == None: 2957 ps = UnivPowerSeriesRing(cf,name); 2958 else: 2959 ps = UnivPowerSeriesRing(cf,truncate,name); 2960 if f == None: 2961 r = ps.getZERO(); 2962 else: 2963 class Coeff( Coefficients ): 2964 def __init__(self,cofac): 2965 self.coFac = cofac;

2966 def generate(self,i): 2967 a = f(i); 2968 if isinstance(a,RingElem): 2969 a = a.elem; 2970 #print "a = " + str(a); 2971 return a; 2972 r = UnivPowerSeries(ps,Coeff(cf)); 2973 return RingElem(r); 2974 2975

2976 -def MPS(cofac,names,f=None,truncate=None):

2977 '''Create JAS MultiVarPowerSeries as ring element. 2978 ''' 2979 cf = cofac; 2980 if isinstance(cofac,RingElem): 2981 cf = cofac.elem.factory(); 2982 if isinstance(cofac,Ring): 2983 cf = cofac.ring; 2984 vars = names; 2985 if isinstance(vars,PyString): 2986 vars = GenPolynomialTokenizer.variableList(vars); 2987 nv = len(vars); 2988 if isinstance(truncate,RingElem): 2989 truncate = truncate.elem; 2990 if truncate == None: 2991 ps = MultiVarPowerSeriesRing(cf,nv,vars); 2992 else: 2993 ps = MultiVarPowerSeriesRing(cf,nv,vars,truncate); 2994 if f == None: 2995 r = ps.getZERO(); 2996 else: 2997 class MCoeff( MultiVarCoefficients ): 2998 def __init__(self,r): 2999 MultiVarCoefficients.__init__(self,r); 3000 self.coFac = r.coFac;

3001 def generate(self,i): 3002 a = f(i); 3003 if isinstance(a,RingElem): 3004 a = a.elem; 3005 return a; 3006 r = MultiVarPowerSeries(ps,MCoeff(ps)); 3007 #print "r = " + str(r); 3008 return RingElem(r); 3009 3010

3011 -def Vec(cofac,n,v=None):

3012 '''Create JAS GenVector ring element. 3013 ''' 3014 cf = cofac; 3015 if isinstance(cofac,RingElem): 3016 cf = cofac.elem.factory(); 3017 if isinstance(cofac,Ring): 3018 cf = cofac.ring; 3019 if isinstance(n,RingElem): 3020 n = n.elem; 3021 if isinstance(v,RingElem): 3022 v = v.elem; 3023 vr = GenVectorModul(cf,n); 3024 if v == None: 3025 r = GenVector(vr); 3026 else: 3027 r = GenVector(vr,v); 3028 return RingElem(r);

3029 3030

3031 -def Mat(cofac,n,m,v=None):

3032 '''Create JAS GenMatrix ring element. 3033 ''' 3034 cf = cofac; 3035 if isinstance(cofac,RingElem): 3036 cf = cofac.elem.factory(); 3037 if isinstance(cofac,Ring): 3038 cf = cofac.ring; 3039 if isinstance(n,RingElem): 3040 n = n.elem; 3041 if isinstance(m,RingElem): 3042 m = m.elem; 3043 if isinstance(v,RingElem): 3044 v = v.elem; 3045 #print "cf type(%s) = %s" % (cf,type(cf)); 3046 mr = GenMatrixRing(cf,n,m); 3047 if v == None: 3048 r = GenMatrix(mr); 3049 else: 3050 r = GenMatrix(mr,v); 3051 return RingElem(r);

3052 3053

3054 -def coercePair(a,b):

3055 '''Coerce type a to type b or type b to type a. 3056 ''' 3057 #print "a type(%s) = %s" % (a,type(a)); 3058 #print "b type(%s) = %s" % (b,type(b)); 3059 try: 3060 if not a.isPolynomial() and b.isPolynomial(): 3061 s = b.coerce(a); 3062 o = b; 3063 else: 3064 s = a; 3065 o = a.coerce(b); 3066 except: 3067 s = a; 3068 o = a.coerce(b); 3069 return (s,o);

3070 3071

3072 -def isJavaInstance(a):

3073 '''Test if a is a Java instance. 3074 ''' 3075 #print "a type(%s) = %s" % (a,type(a)); 3076 try: 3077 c = a.getClass(); 3078 except: 3079 return False; 3080 return True;

3081 3082

3083 -class RingElem:

3084 '''Proxy for JAS ring elements. 3085 3086 Methods to be used as + - * ** / %. 3087 ''' 3088

3089 - def __init__(self,elem):

3090 '''Constructor for ring element. 3091 ''' 3092 if isinstance(elem,RingElem): 3093 self.elem = elem.elem; 3094 else: 3095 self.elem = elem; 3096 try: 3097 self.ring = self.elem.factory(); 3098 except: 3099 self.ring = self.elem;

3100

3101 - def __str__(self):

3102 '''Create a string representation. 3103 ''' 3104 try: 3105 return str(self.elem.toScript()); 3106 except: 3107 return str(self.elem);

3108

3109 - def zero(self):

3110 '''Zero element of this ring. 3111 ''' 3112 return RingElem( self.ring.getZERO() );

3113

3114 - def isZERO(self):

3115 '''Test if this is the zero element of the ring. 3116 ''' 3117 return self.elem.isZERO();

3118

3119 - def one(self):

3120 '''One element of this ring. 3121 ''' 3122 return RingElem( self.ring.getONE() );

3123

3124 - def isONE(self):

3125 '''Test if this is the one element of the ring. 3126 ''' 3127 return self.elem.isONE();

3128

3129 - def signum(self):

3130 '''Get the sign of this element. 3131 ''' 3132 return self.elem.signum();

3133

3134 - def __abs__(self):

3135 '''Absolute value. 3136 ''' 3137 return RingElem( self.elem.abs() );

3138

3139 - def __neg__(self):

3140 '''Negative value. 3141 ''' 3142 return RingElem( self.elem.negate() );

3143

3144 - def __pos__(self):

3145 '''Positive value. 3146 ''' 3147 return self;

3148

3149 - def coerce(self,other):

3150 '''Coerce other to self. 3151 ''' 3152 #print "self type(%s) = %s" % (self,type(self)); 3153 #print "other type(%s) = %s" % (other,type(other)); 3154 #print "self.elem class(%s) = %s" % (self.elem,self.elem.getClass()); 3155 if isinstance(self.elem,GenVector): 3156 #print "self, other = %s, %s " % (self,other); 3157 if isinstance(other,PyTuple) or isinstance(other,PyList): 3158 o = pylist2arraylist(other,self.elem.factory().coFac,rec=1); 3159 o = GenVector(self.elem.factory(),o); 3160 return RingElem( o ); 3161 if isinstance(self.elem,GenMatrix): 3162 #print "self, other = %s, %s " % (type(self),type(other)); 3163 #print "o type(%s) = %s, str = %s" % (o,type(o),str(o)); 3164 if isinstance(other,PyTuple) or isinstance(other,PyList): 3165 o = pylist2arraylist(other,self.elem.factory().coFac,rec=2); 3166 o = GenMatrix(self.elem.factory(),o); 3167 return RingElem( o ); 3168 if isinstance(self.elem,GenPolynomial): 3169 #print "self, other = %s, %s " % (type(self),type(other)); 3170 #print "o type(%s) = %s, str = %s" % (o,type(o),str(o)); 3171 if isinstance(other,PyInteger) or isinstance(other,PyLong): 3172 o = self.ring.fromInteger(other); 3173 return RingElem( o ); 3174 if isinstance(other,RingElem): 3175 o = other.elem; 3176 else: 3177 o = other; 3178 if o == None: 3179 return RingElem( GenPolynomial(self.ring) ) 3180 if isJavaInstance(o): 3181 #print "self.elem, o = %s, %s " % (type(self.ring.coFac),type(o)); 3182 if isinstance(o,ExpVector): # want startsWith or substring(0,8) == "ExpVector": 3183 o = GenPolynomial(self.ring,o); 3184 return RingElem( o ); 3185 if self.ring.coFac.getClass().getSimpleName() == o.getClass().getSimpleName(): 3186 o = GenPolynomial(self.ring,o); 3187 return RingElem( o ); 3188 if isinstance(other,RingElem): 3189 if self.isPolynomial() and not other.isPolynomial(): 3190 #print "self.ring = %s" % (self.ring); 3191 o = self.ring.parse( other.elem.toString() ); # not toScript() 3192 #print "o type(%s) = %s, str = %s" % (o,type(o),str(o)); 3193 return RingElem( o ); 3194 return other; 3195 #print "--1"; 3196 if isinstance(other,PyTuple) or isinstance(other,PyList): 3197 # assume BigRational or BigComplex 3198 # assume self will be compatible with them. todo: check this 3199 o = makeJasArith(other); 3200 #print "other class(%s) = %s" % (o,o.getClass()); 3201 if self.isPolynomial(): 3202 #print "other type(%s) = %s" % (o,type(o)); 3203 o = self.ring.parse( o.toString() ); # not toScript(); 3204 #o = o.elem; 3205 if isinstance(self.elem,BigComplex): 3206 #print "other type(%s) = %s" % (o,type(o)); 3207 o = CC( o ); 3208 o = o.elem; 3209 if isinstance(self.elem,BigQuaternion): 3210 #print "other type(%s) = %s" % (o,type(o)); 3211 o = Quat( o ); 3212 o = o.elem; 3213 if isinstance(self.elem,BigOctonion): 3214 #print "other type(%s) = %s" % (o,type(o)); 3215 o = Oct( Quat(o) ); 3216 o = o.elem; 3217 if isinstance(self.elem,Product): 3218 #print "other type(%s) = %s" % (o,type(o)); 3219 o = RR(self.ring, self.elem.multiply(o) ); # valueOf 3220 #print "o = %s" % o; 3221 o = o.elem; 3222 return RingElem(o); 3223 #print "--2"; 3224 # test if self.elem is a factory itself 3225 if self.isFactory(): 3226 if isinstance(other,PyInteger) or isinstance(other,PyLong): 3227 o = self.elem.fromInteger(other); 3228 else: 3229 if isinstance(other,PyFloat): # ?? what to do ?? 3230 o = self.elem.fromInteger( int(other) ); 3231 else: 3232 print "coerce_1: unknown other type(%s) = %s" % (other,type(other)); 3233 o = self.elem.parse( str(other) ); 3234 return RingElem(o); 3235 #print "--3"; 3236 #print "other type(%s) = %s" % (other,type(other)); 3237 # self.elem has a ring factory 3238 if isinstance(other,PyInteger) or isinstance(other,PyLong): 3239 o = self.elem.factory().fromInteger(other); 3240 else: 3241 if isinstance(other,PyFloat): # ?? what to do ?? 3242 #print "other type(%s) = %s" % (other,type(other)); 3243 #print "self type(%s) = %s" % (self.elem,self.elem.getClass().getName()); 3244 o = BigDecimal(other); 3245 if isinstance(self.elem,Product): 3246 o = RR(self.ring, self.elem.idempotent().multiply(o) ); # valueOf 3247 o = o.elem; 3248 else: 3249 o = self.elem.factory().getZERO().sum( o ); 3250 else: 3251 print "coerce_2: unknown other type(%s) = %s" % (other,type(other)); 3252 print "coerce_2: self type(%s) = %s" % (self,type(self)); 3253 o = self.elem.factory().parse( str(other) ); 3254 #print "--4"; 3255 return RingElem(o);

3256

3257 - def isFactory(self):

3258 '''Test if this is itself a ring factory. 3259 ''' 3260 f = self.elem.factory(); 3261 if self.elem == f: 3262 return True; 3263 else: 3264 return False;

3265

3266 - def isPolynomial(self):

3267 '''Test if this is a polynomial. 3268 ''' 3269 try: 3270 nv = self.elem.ring.nvar; 3271 except: 3272 return False; 3273 return True;

3274

3275 - def __cmp__(self,other):

3276 '''Compare two ring elements. 3277 ''' 3278 [s,o] = coercePair(self,other); 3279 return s.elem.compareTo( o.elem );

3280

3281 - def __hash__(self):

3282 '''Hash value. 3283 ''' 3284 return self.elem.hashCode();

3285

3286 - def __len__(self):

3287 '''Length of the element. 3288 ''' 3289 return self.elem.length();

3290

3291 - def __mul__(self,other):

3292 '''Multiply two ring elements. 3293 ''' 3294 [s,o] = coercePair(self,other); 3295 #print "self type(%s) = %s" % (s,type(s)); 3296 #print "other type(%s) = %s" % (o,type(o)); 3297 return RingElem( s.elem.multiply( o.elem ) );

3298

3299 - def __rmul__(self,other):

3300 '''Reverse multiply two ring elements. 3301 ''' 3302 [s,o] = coercePair(self,other); 3303 return o.__mul__(s);

3304

3305 - def __add__(self,other):

3306 '''Add two ring elements. 3307 ''' 3308 [s,o] = coercePair(self,other); 3309 return RingElem( s.elem.sum( o.elem ) );

3310

3311 - def __radd__(self,other):

3312 '''Reverse add two ring elements. 3313 ''' 3314 [s,o] = coercePair(self,other); 3315 return o.__add__(s);

3316

3317 - def __sub__(self,other):

3318 '''Subtract two ring elements. 3319 ''' 3320 [s,o] = coercePair(self,other); 3321 return RingElem( s.elem.subtract( o.elem ) );

3322

3323 - def __rsub__(self,other):

3324 '''Reverse subtract two ring elements. 3325 ''' 3326 [s,o] = coercePair(self,other); 3327 return o.__sub__(self);

3328

3329 - def __div__(self,other):

3330 '''Divide two ring elements. 3331 ''' 3332 [s,o] = coercePair(self,other); 3333 return RingElem( s.elem.divide( o.elem ) );

3334

3335 - def __rdiv__(self,other):

3336 '''Reverse divide two ring elements. 3337 ''' 3338 [s,o] = coercePair(self,other); 3339 return o.__div__(s);

3340

3341 - def __mod__(self,other):

3342 '''Modular remainder of two ring elements. 3343 ''' 3344 [s,o] = coercePair(self,other); 3345 return RingElem( s.elem.remainder( o.elem ) );

3346

3347 - def __xor__(self,other):

3348 '''Can not be used as power. 3349 ''' 3350 return None;

3351

3352 - def __pow__(self,other,n=None):

3353 '''Power of this to other. 3354 ''' 3355 #print "self type(%s) = %s" % (self,type(self)); 3356 #print "pow other type(%s) = %s" % (other,type(other)); 3357 if isinstance(other,PyInteger) or isinstance(other,PyLong): 3358 n = other; 3359 else: 3360 if isinstance(other,RingElem): 3361 n = other.elem; 3362 #if isinstance(n,BigRational): # does not work 3363 if isinstance(n,BigRational): 3364 n = n.numerator().intValue() / n.denominator().intValue(); 3365 #if isinstance(n,BigInteger): # does not work 3366 if isinstance(n,BigInteger) or isinstance(n,Long) or isinstance(n,Integer): 3367 n = n.intValue(); 3368 if n == None: 3369 n = other; 3370 if self.isFactory(): 3371 p = Power(self.elem).power( self.elem, n ); 3372 else: 3373 p = Power(self.ring).power( self.elem, n ); 3374 return RingElem( p );

3375

3376 - def __eq__(self,other):

3377 '''Test if two ring elements are equal. 3378 ''' 3379 if other == None: 3380 return False; 3381 [s,o] = coercePair(self,other); 3382 return s.elem.equals(o.elem)

3383

3384 - def __ne__(self,other):

3385 '''Test if two ring elements are not equal. 3386 ''' 3387 if other == None: 3388 return False; 3389 [s,o] = coercePair(self,other); 3390 return not self.elem.equals(o.elem)

3391

3392 - def __float__(self):

3393 '''Convert to Python float. 3394 ''' 3395 #print "self type(%s) = %s" % (self,type(self)); 3396 e = self.elem; 3397 if isinstance(e,BigInteger): 3398 e = BigRational(e); 3399 if isinstance(e,BigRational): 3400 e = BigDecimal(e); 3401 if isinstance(e,BigDecimal): 3402 e = e.toString(); 3403 e = float(e); 3404 return e;

3405

3406 - def factory(self):

3407 '''Get the factory of this element. 3408 ''' 3409 fac = self.elem.factory(); 3410 try: 3411 nv = fac.nvar; 3412 except: 3413 return RingElem(fac); 3414 #return PolyRing(fac.coFac,fac.getVars(),fac.tord); 3415 return RingElem(fac);

3416

3417 - def gens(self):

3418 '''Get the generators for the factory of this element. 3419 ''' 3420 L = self.elem.factory().generators(); 3421 #print "L = %s" % L; 3422 N = [ RingElem(e) for e in L ]; 3423 #print "N = %s" % N; 3424 return N;

3425

3426 - def inject_variables(self):

3427 '''Inject generators as variables into the main global namespace 3428 ''' 3429 inject_generators(self.gens());

3430

3431 - def monic(self):

3432 '''Monic polynomial. 3433 ''' 3434 return RingElem( self.elem.monic() );

3435

3436 - def homogenize(self,var='h'):

3437 '''homogenize polynomial. 3438 3439 INPUT: 3440 - "var" - variable name to use for homogenization 3441 ''' 3442 if not self.isPolynomial(): 3443 return self 3444 if var in self.ring.vars: 3445 r = self.ring.extend(1); 3446 print "WARN: case for variable %s not implemented, new name %s" % (var,r.vars[-1]) 3447 else: 3448 r = self.ring.extend([var]); 3449 h = self.elem; 3450 h = h.homogenize(r); 3451 return RingElem(h);

3452

3453 - def evaluate(self,a):

3454 '''Evaluate at a for power series or polynomial. 3455 ''' 3456 #print "self type(%s) = %s" % (self,type(self)); 3457 #print "a type(%s) = %s" % (a,type(a)); 3458 x = None; 3459 if isinstance(a,RingElem): 3460 x = a.elem; 3461 if isinstance(a,PyTuple) or isinstance(a,PyList): 3462 # assume BigRational or BigComplex 3463 # assume self will be compatible with them. todo: check this 3464 #x = makeJasArith(a); 3465 x = pylist2arraylist(a); 3466 else: 3467 x = pylist2arraylist([a]); 3468 try: 3469 if isinstance(self.elem,UnivPowerSeries): 3470 e = self.elem.evaluate(x[0]); 3471 else: 3472 if isinstance(self.elem,MultiVarPowerSeries): 3473 e = self.elem.evaluate(x); 3474 else: 3475 x = [ p.leadingBaseCoefficient() for p in x ]; 3476 #puts "x = " + x[0].getClass().getSimpleName().to_s; 3477 e = PolyUtil.evaluateAll(self.ring.coFac, self.elem, x); 3478 except: 3479 e = 0; 3480 return RingElem( e );

3481

3482 - def integrate(self,a=0,r=None):

3483 '''Integrate a power series or rational function with constant a. 3484 3485 a is the integration constant, r is for partial integration in variable r. 3486 ''' 3487 #print "self type(%s) = %s" % (self,type(self)); 3488 #print "a type(%s) = %s" % (a,type(a)); 3489 x = None; 3490 if isinstance(a,RingElem): 3491 x = a.elem; 3492 if isinstance(a,PyTuple) or isinstance(a,PyList): 3493 # assume BigRational or BigComplex 3494 # assume self will be compatible with them. todo: check this 3495 x = makeJasArith(a); 3496 # power series 3497 try: 3498 if r != None: 3499 e = self.elem.integrate(x,r); 3500 else: 3501 e = self.elem.integrate(x); 3502 return RingElem( e ); 3503 except: 3504 pass; 3505 cf = self.elem.ring; 3506 try: 3507 cf = cf.ring; 3508 except: 3509 pass; 3510 # rational function 3511 integrator = ElementaryIntegration(cf.coFac); 3512 ei = integrator.integrate(self.elem); 3513 return ei;

3514

3515 - def differentiate(self,r=None):

3516 '''Differentiate a power series. 3517 3518 r is for partial differentiation in variable r. 3519 ''' 3520 try: 3521 if r != None: 3522 e = self.elem.differentiate(r); 3523 else: 3524 e = self.elem.differentiate(); 3525 except: 3526 e = self.elem.factory().getZERO(); 3527 return RingElem( e );

3528

3529 - def random(self,n=3):

3530 '''Random element. 3531 3532 n size for random element will be less than 2**n. 3533 ''' 3534 if isinstance(n,RingElem): 3535 n = n.elem; 3536 return RingElem( self.elem.factory().random(n) );

3537

3538 - def gcd(self,b):

3539 '''Compute the greatest common divisor of this/self and b. 3540 3541 ''' 3542 a = self.elem; 3543 if isinstance(b,RingElem): 3544 b = b.elem; 3545 else: 3546 b = element( b ); 3547 b = b.elem; 3548 if self.isPolynomial(): 3549 engine = Ring.getEngineGcd(self.ring); 3550 return RingElem( engine.gcd(a,b) ); 3551 else: 3552 return RingElem( a.gcd(b) );

3553

3554 - def squarefreeFactors(self):

3555 '''Compute squarefree factors of polynomial. 3556 3557 ''' 3558 a = self.elem; 3559 if self.isPolynomial(): 3560 sqf = Ring.getEngineSqf(self.ring); 3561 if sqf == None: 3562 raise ValueError, "squarefreeFactors not implemented for " + self.ring.to_s; 3563 cf = self.ring.coFac; 3564 if isinstance(cf,GenPolynomialRing): 3565 e = sqf.recursiveSquarefreeFactors( a ); 3566 else: 3567 e = sqf.squarefreeFactors( a ); 3568 L = {}; 3569 for a in e.keySet(): 3570 i = e.get(a); 3571 L[ RingElem( a ) ] = i; 3572 return L; 3573 else: 3574 raise ValueError, "squarefreeFactors not implemented for " + a.to_s;

3575

3576 - def factors(self):

3577 '''Compute irreducible factorization for modular, integer, 3578 rational number and algebriac number coefficients. 3579 3580 ''' 3581 a = self.elem; 3582 if self.isPolynomial(): 3583 factor = Ring.getEngineFactor(self.ring); 3584 if factor == None: 3585 raise ValueError, "factors not implemented for " + self.ring.to_s; 3586 cf = self.ring.coFac; 3587 if isinstance(cf,GenPolynomialRing): 3588 e = factor.recursiveFactors( a ); 3589 else: 3590 e = factor.factors( a ); 3591 L = {}; 3592 for a in e.keySet(): 3593 i = e.get(a); 3594 L[ RingElem( a ) ] = i; 3595 return L; 3596 else: 3597 raise ValueError, "factors not implemented for " + a.to_s;

3598

3599 - def factorsAbsolute(self):

3600 '''Compute absolute irreducible factorization for (modular,) 3601 rational number coefficients. 3602 ''' 3603 a = self.elem; 3604 if self.isPolynomial(): 3605 factor = Ring.getEngineFactor(self.ring); 3606 if factor == None: 3607 raise ValueError, "factors not implemented for " + self.ring.to_s; 3608 try: 3609 L = factor.factorsAbsolute( a ); 3610 ## L = {}; 3611 ## for a in e.keySet(): 3612 ## i = e.get(a); 3613 ## L[ RingElem( a ) ] = i; 3614 return L; 3615 except Exception, e: 3616 raise ValueError, "error in factorsAbsolute " + str(e) 3617 else: 3618 raise ValueError, "factors not implemented for " + a.to_s;

3619

3620 - def realRoots(self,eps=None):

3621 '''Compute real roots of univariate polynomial. 3622 ''' 3623 a = self.elem; 3624 if isinstance(eps,RingElem): 3625 eps = eps.elem; 3626 try: 3627 if eps == None: 3628 #R = RealRootsSturm().realRoots( a ); 3629 R = RootFactory.realAlgebraicNumbers( a ); 3630 else: 3631 R = RootFactory.realAlgebraicNumbers( a, eps ); 3632 R = [ RingElem(r) for r in R ]; 3633 #R = [ RingElem(BigDecimal(r.getRational())) for r in R ]; 3634 return R; 3635 except Exception, e: 3636 print "error " + str(e) 3637 return None

3638

3639 - def complexRoots(self,eps=None):

3640 '''Compute complex roots of univariate polynomial. 3641 ''' 3642 a = self.elem; 3643 if isinstance(eps,RingElem): 3644 eps = eps.elem; 3645 cmplx = False; 3646 try: 3647 x = a.ring.coFac.getONE().getRe(); 3648 cmplx = True; 3649 except Exception, e: 3650 pass; 3651 try: 3652 if eps == None: 3653 if cmplx: 3654 R = RootFactory.complexAlgebraicNumbersComplex(a); 3655 else: 3656 R = RootFactory.complexAlgebraicNumbers(a); 3657 # R = ComplexRootsSturm(a.ring.coFac).complexRoots( a ); 3658 # R = [ r.centerApprox() for r in R ]; 3659 # R = [ r.ring.getRoot() for r in R ]; 3660 R = [ RingElem(r) for r in R ]; 3661 else: 3662 if cmplx: 3663 R = RootFactory.complexAlgebraicNumbersComplex(a,eps); 3664 else: 3665 R = RootFactory.complexAlgebraicNumbers(a,eps); 3666 R = [ RingElem(r) for r in R ]; 3667 # R = [ r.decimalMagnitude() for r in R ]; 3668 # R = ComplexRootsSturm(a.ring.coFac).complexRoots( a, eps ); 3669 # R = ComplexRootsSturm(a.ring.coFac).approximateRoots( a, eps ); 3670 return R; 3671 except Exception, e: 3672 print "error " + str(e) 3673 return None

3674

3675 - def algebraicRoots(self,eps=None):

3676 '''Compute algebraic roots, i.e. the real and complex roots of univariate polynomial. 3677 ''' 3678 a = self.elem; 3679 if isinstance(eps,RingElem): 3680 eps = eps.elem; 3681 try: 3682 if eps == None: 3683 R = RootFactory.algebraicRoots(a); 3684 else: 3685 R = RootFactory.algebraicRoots(a, eps); 3686 #R = [ RingElem(r) for r in R ]; 3687 return RingElem(R); 3688 except Exception, e: 3689 print "error " + str(e) 3690 return None

3691

3692 - def rootRefine(self,eps=None):

3693 '''Compute algebraic roots refinement. 3694 ''' 3695 a = self.elem; 3696 if isinstance(eps,RingElem): 3697 eps = eps.elem; 3698 try: 3699 RootFactory.rootRefine(a, eps); 3700 #R = [ RingElem(r) for r in R ]; 3701 return RingElem(a); 3702 except Exception, e: 3703 print "error " + str(e) 3704 return None

3705

3706 - def decimalRoots(self,eps=None):

3707 '''Compute decimal approximation of real and complex roots of univariate polynomial. 3708 ''' 3709 a = self.elem; 3710 if isinstance(eps,RingElem): 3711 eps = eps.elem; 3712 try: 3713 R = RootFactory.decimalRoots(a, eps); 3714 #R = [ RingElem(r) for r in R ]; 3715 return RingElem(R); 3716 except Exception, e: 3717 print "error " + str(e) 3718 return None

3719

3720 - def rootsOfUnity(self):

3721 '''Roots of unity of real and complex algebraic numbers. 3722 ''' 3723 a = self.elem; 3724 try: 3725 if isinstance(a,AlgebraicRootsPrimElem): 3726 R = RootFactoryApp.rootsOfUnity(a); 3727 else: 3728 R = RootFactory.rootsOfUnity(a); 3729 #R = [ RingElem(r) for r in R ]; 3730 return RingElem(R); 3731 except Exception, e: 3732 print "error " + str(e) 3733 return None

3734

3735 - def rootReduce(self, other):

3736 '''Root reduce of real and complex algebraic numbers. 3737 Compute an extension field with a primitive element. 3738 ''' 3739 a = self.elem; 3740 b = other; 3741 if isinstance(b,RingElem): 3742 b = b.elem; 3743 try: 3744 R = RootFactoryApp.rootReduce(a, b); 3745 #R = [ RingElem(r) for r in R ]; 3746 return RingElem(R); 3747 except Exception, e: 3748 print "error " + str(e) 3749 return None

3750

3751 - def coefficients(self):

3752 '''Get the coefficients of a polynomial. 3753 ''' 3754 a = self.elem; 3755 #L = [ c.toScriptFactory() for c in a.coefficientIterator() ]; 3756 L = [ RingElem(c) for c in a.coefficientIterator() ]; 3757 return L

3758 3759 #---------------- 3760 # Compatibility methods for Sage/Singular: 3761 # Note: the meaning of lt and lm is swapped compared to JAS. 3762 #---------------- 3763

3764 - def parent(self):

3765 '''Parent in Sage is factory in JAS. 3766 3767 Compatibility method for Sage/Singular. 3768 ''' 3769 return self.factory();

3770

3771 - def __call__(self,num):

3772 '''Apply this to num. 3773 ''' 3774 if num == 0: 3775 return self.zero(); 3776 if num == 1: 3777 return self.one(); 3778 return RingElem( self.ring.fromInteger(num) );

3779

3780 - def lm(self):

3781 '''Leading monomial of a polynomial. 3782 3783 Compatibility method for Sage/Singular. 3784 Note: the meaning of lt and lm is swapped compared to JAS. 3785 ''' 3786 ev = self.elem.leadingExpVector(); 3787 return ev;

3788

3789 - def lc(self):

3790 '''Leading coefficient of a polynomial. 3791 3792 Compatibility method for Sage/Singular. 3793 ''' 3794 c = self.elem.leadingBaseCoefficient(); 3795 return RingElem(c);

3796

3797 - def lt(self):

3798 '''Leading term of a polynomial. 3799 3800 Compatibility method for Sage/Singular. 3801 Note: the meaning of lt and lm is swapped compared to JAS. 3802 ''' 3803 ev = self.elem.leadingMonomial(); 3804 return Monomial(ev);

3805

3806 - def degree(self):

3807 '''Degree of a polynomial. 3808 ''' 3809 try: 3810 ev = self.elem.degree(); 3811 #ev = self.elem.totalDegree(); 3812 except: 3813 return None; 3814 return ev;

3815

3816 - def base_ring(self):

3817 '''Coefficient ring of a polynomial. 3818 ''' 3819 try: 3820 ev = self.elem.ring.coFac; 3821 except: 3822 return None; 3823 return RingElem(ev);

3824

3825 - def is_field(self):

3826 '''Test if this RingElem is field. 3827 ''' 3828 return self.elem.isField();

3829

3830 - def monomials(self):

3831 '''All monomials of a polynomial. 3832 3833 Compatibility method for Sage/Singular. 3834 ''' 3835 ev = self.elem.getMap().keySet(); 3836 return ev;

3837

3838 - def divides(self,other):

3839 '''Test if self divides other. 3840 3841 Compatibility method for Sage/Singular. 3842 ''' 3843 [s,o] = coercePair(self,other); 3844 return o.elem.remainder( s.elem ).isZERO();

3845

3846 - def ideal(self,list):

3847 '''Create an ideal. 3848 3849 Compatibility method for Sage/Singular. 3850 ''' 3851 r = Ring("",ring=self.ring,fast=True); 3852 return r.ideal("",list=list);

3853

3854 - def monomial_quotient(self,a,b,coeff=False):

3855 '''Quotient of ExpVectors. 3856 3857 Compatibility method for Sage/Singular. 3858 ''' 3859 if isinstance(a,RingElem): 3860 a = a.elem; 3861 if isinstance(b,RingElem): 3862 b = b.elem; 3863 if coeff == False: 3864 if isinstance(a,GenPolynomial): 3865 return RingElem( a.divide(b) ); 3866 else: 3867 return RingElem( GenPolynomial(self.ring, a.subtract(b)) ); 3868 else: 3869 # assume JAS Monomial 3870 c = a.coefficient().divide(b.coefficient()); 3871 e = a.exponent().subtract(b.exponent()) 3872 return RingElem( GenPolynomial(self.ring, c, e) );

3873

3874 - def monomial_divides(self,a,b):

3875 '''Test divide of ExpVectors. 3876 3877 Compatibility method for Sage/Singular. 3878 ''' 3879 #print "JAS a = " + str(a) + ", b = " + str(b); 3880 if isinstance(a,RingElem): 3881 a = a.elem; 3882 if isinstance(a,GenPolynomial): 3883 a = a.leadingExpVector(); 3884 if not isinstance(a,ExpVector): 3885 raise ValueError, "No ExpVector a given " + str(a) + ", " + str(b) 3886 if b == None: 3887 return False; 3888 if isinstance(b,RingElem): 3889 b = b.elem; 3890 if isinstance(b,GenPolynomial): 3891 b = b.leadingExpVector(); 3892 if not isinstance(b,ExpVector): 3893 raise ValueError, "No ExpVector b given " + str(a) + ", " + str(b) 3894 return a.divides(b);

3895

3896 - def monomial_pairwise_prime(self,e,f):

3897 '''Test if ExpVectors are pairwise prime. 3898 3899 Compatibility method for Sage/Singular. 3900 ''' 3901 if isinstance(e,RingElem): 3902 e = e.elem; 3903 if isinstance(f,RingElem): 3904 f = f.elem; 3905 # assume JAS ExpVector 3906 c = e.gcd(f); 3907 return c.isZERO();

3908

3909 - def monomial_lcm(self,e,f):

3910 '''Lcm of ExpVectors. 3911 3912 Compatibility method for Sage/Singular. 3913 ''' 3914 if isinstance(e,RingElem): 3915 e = e.elem; 3916 if isinstance(f,RingElem): 3917 f = f.elem; 3918 # assume JAS ExpVector 3919 c = e.lcm(f); 3920 return c;

3921

3922 - def reduce(self,F):

3923 '''Compute a normal form of self with respect to F. 3924 3925 Compatibility method for Sage/Singular. 3926 ''' 3927 s = self.elem; 3928 Fe = [ e.elem for e in F ]; 3929 if self.ring.coFac.isField(): 3930 n = ReductionSeq().normalform(Fe,s); 3931 else: 3932 n = PseudoReductionSeq().normalform(Fe,s); 3933 return RingElem(n);

3934 3935 #---------------- 3936 # End of compatibility methods 3937 #---------------- 3938 3939

3940 -class Order(TermOrderByName):

3941 '''Collection of JAS and other CAS term order names. 3942 3943 Defines names for TermOrders. 3944 See U{TermOrderByName<http://krum.rz.uni-mannheim.de/jas/doc/api/edu/jas/poly/TermOrderByName.html>}. 3945 '''

3946 # empty 3947 3948

3949 -class PolyRing(Ring):

3950 '''Represents a JAS polynomial ring: GenPolynomialRing. 3951 3952 Provides more convenient constructor. 3953 Then returns a Ring. 3954 3955 Example of the construction a polynomial ring over the 3956 rational numbers QQ() in the variables 'x' and 'y', together 3957 with the input of a polynomial (x+y)**3. 3958 >>> from jas import PolyRing, QQ 3959 >>> r = PolyRing(QQ(),"x,y") 3960 globally defined variables: one, x, y 3961 3962 The example works with p = (x+y)**3, but in doctests the 3963 full notation r.x and r.y must be used for x respectively y. 3964 >>> p = (r.x+r.y)**3 3965 >>> print p 3966 ( y**3 + 3 * x * y**2 + 3 * x**2 * y + x**3 ) 3967 3968 ''' 3969

3970 - def __init__(self,coeff,vars,order=Order.IGRLEX):

3971 '''Ring constructor. 3972 3973 coeff = factory for coefficients, 3974 vars = string with variable names, 3975 order = term order or weight matrix. 3976 ''' 3977 if coeff == None: 3978 raise ValueError, "No coefficient given." 3979 cf = coeff; 3980 if isinstance(coeff,RingElem): 3981 cf = coeff.elem.factory(); 3982 if isinstance(coeff,Ring): 3983 cf = coeff.ring; 3984 if vars == None: 3985 raise ValueError, "No variable names given." 3986 names = vars; 3987 if isinstance(vars,PyString): 3988 names = GenPolynomialTokenizer.variableList(vars); 3989 nv = len(names); 3990 to = Order.IGRLEX; 3991 if isinstance(order,TermOrder): 3992 to = order; 3993 if isinstance(order,PyList) or isinstance(order,PyTuple): 3994 #print "order = " + str(order); 3995 to = TermOrder.reverseWeight(order); 3996 tring = GenPolynomialRing(cf,nv,to,names); 3997 self.ring = tring; 3998 Ring.__init__(self,ring=tring)

3999

4000 - def __str__(self):

4001 '''Create a string representation. 4002 ''' 4003 return self.ring.toScript();

4004 4005 lex = Order.INVLEX 4006 '''Abreviation for INVLEX. 4007 ''' 4008 4009 grad = Order.IGRLEX 4010 '''Abreviation for IGRLEX. 4011 '''

4012 4013

4014 -class SolvPolyRing(SolvableRing):

4015 '''Represents a JAS solvable polynomial ring: GenSolvablePolynomialRing. 4016 4017 Provides more convenient constructor. 4018 Then returns a Ring. 4019 ''' 4020

4021 - def __init__(self,coeff,vars,order=Order.IGRLEX,rel=[]):

4022 '''Ring constructor. 4023 4024 coeff = factory for coefficients, 4025 vars = string with variable names, 4026 order = term order, 4027 rel = triple list of relations. (e,f,p,...) with e * f = p as relation 4028 and e, f and p are commutative polynomials. 4029 ''' 4030 if coeff == None: 4031 raise ValueError, "No coefficient given." 4032 cf = coeff; 4033 if isinstance(coeff,RingElem): 4034 cf = coeff.elem.factory(); 4035 if isinstance(coeff,Ring): 4036 cf = coeff.ring; 4037 if vars == None: 4038 raise ValueError, "No variable names given." 4039 names = vars; 4040 if isinstance(vars,PyString): 4041 names = GenPolynomialTokenizer.variableList(vars); 4042 nv = len(names); 4043 #to = PolyRing.lex; 4044 to = Order.IGRLEX; 4045 if isinstance(order,TermOrder): 4046 to = order; 4047 L = []; 4048 for x in rel: 4049 if isinstance(x,RingElem): 4050 x = x.elem; 4051 L.append(x); 4052 constSolv = False; 4053 for i in range(0,len(L),3): 4054 #print "L[i+1] = " + str(L[i+1]); 4055 if L[i+1].isConstant(): 4056 constSolv = True; 4057 cfs = cf.toScript(); 4058 if cfs[0] == "0": 4059 cfs = cf.toScriptFactory(); 4060 recSolv = isinstance(cf,GenPolynomialRing); 4061 recSolvWord = isinstance(cf,GenWordPolynomialRing); 4062 resWord = isinstance(cf,WordResidueRing); 4063 quotSolv = isinstance(cf,SolvableQuotientRing); 4064 resSolv = isinstance(cf,SolvableResidueRing); 4065 locSolv = isinstance(cf,SolvableLocalRing); 4066 locresSolv = isinstance(cf,SolvableLocalResidueRing); 4067 if recSolv and not constSolv: 4068 recSolv = False; 4069 #print "cf = " + str(cf.getClass().getSimpleName()) + ", quotSolv = " + str(quotSolv) + ", recSolv = " + str(recSolv); 4070 if recSolv: 4071 ring = RecSolvablePolynomialRing(cf,nv,to,names); 4072 table = ring.table; 4073 coeffTable = ring.coeffTable; 4074 else: 4075 if resSolv: 4076 #ring = ResidueSolvablePolynomialRing(cf,nv,to,names); 4077 ring = QLRSolvablePolynomialRing(cf,nv,to,names); 4078 table = ring.table; 4079 coeffTable = ring.polCoeff.coeffTable; 4080 else: 4081 if recSolvWord: 4082 print "RecSolvableWordPolynomialRing: " + cfs; 4083 ring = RecSolvableWordPolynomialRing(cf,nv,to,names); 4084 table = ring.table; 4085 coeffTable = ring.coeffTable; 4086 else: 4087 if resWord: 4088 print "ResWordSolvablePolynomialRing: " + cfs; 4089 ring = GenSolvablePolynomialRing.new(cf,nv,to,names); 4090 #ring = RecSolvableWordPolynomialRing.new(cf,nv,to,names); 4091 #ring = QLRSolvablePolynomialRing.new(cf,nv,to,names); 4092 print "ring = " + str(ring.toScript()); 4093 table = ring.table; 4094 #coeffTable = ring.polCoeff.coeffTable; 4095 #coeffTable = ring.coeffTable; 4096 else: 4097 if quotSolv: 4098 #ring = QuotSolvablePolynomialRing(cf,nv,to,names); 4099 ring = QLRSolvablePolynomialRing(cf,nv,to,names); 4100 table = ring.table; 4101 coeffTable = ring.polCoeff.coeffTable; 4102 else: 4103 if locSolv: 4104 #ring = LocalSolvablePolynomialRing(cf,nv,to,names); 4105 ring = QLRSolvablePolynomialRing(cf,nv,to,names); 4106 table = ring.table; 4107 coeffTable = ring.polCoeff.coeffTable; 4108 else: 4109 if locresSolv: 4110 ring = QLRSolvablePolynomialRing(cf,nv,to,names); 4111 table = ring.table; 4112 coeffTable = ring.polCoeff.coeffTable; 4113 else: 4114 ring = GenSolvablePolynomialRing(cf,nv,to,names); 4115 table = ring.table; 4116 coeffTable = table; 4117 #print "rel = " + str(L); 4118 for i in range(0,len(L),3): 4119 print "adding relation: " + str(L[i]) + " * " + str(L[i+1]) + " = " + str(L[i+2]); 4120 if L[i+1].isConstant(): 4121 if recSolv: 4122 coeffTable.update( L[i], L[i+1], L[i+2] ); 4123 else: 4124 if resSolv: 4125 coeffTable.update(ring.toPolyCoefficients(L[i]), 4126 ring.toPolyCoefficients(L[i+1]), 4127 ring.toPolyCoefficients(L[i+2]) ); 4128 else: 4129 if recSolvWord: 4130 coeffTable.update(L[i],L[i+1],L[i+2]); 4131 else: 4132 if resWord: 4133 print "cf = " + cfs; 4134 #coeffTable.update(L[i],L[i+1],L[i+2]); 4135 else: 4136 if quotSolv: 4137 coeffTable.update(ring.toPolyCoefficients(L[i]), 4138 ring.toPolyCoefficients(L[i+1]), 4139 ring.toPolyCoefficients(L[i+2]) ); 4140 else: 4141 if locSolv: 4142 coeffTable.update(ring.toPolyCoefficients(L[i]), 4143 ring.toPolyCoefficients(L[i+1]), 4144 ring.toPolyCoefficients(L[i+2]) ); 4145 else: 4146 if locresSolv: 4147 coeffTable.update(ring.toPolyCoefficients(L[i]), 4148 ring.toPolyCoefficients(L[i+1]), 4149 ring.toPolyCoefficients(L[i+2]) ); 4150 else: 4151 #print "L[i], L[i+1], L[i+2]: " + str(L[i]) + ", " + str(L[i+1]) + ", " + str(L[i+2]); 4152 table.update( L[i], L[i+1], L[i+2] ); 4153 if locresSolv or locSolv or quotSolv or resSolv or resWord: 4154 #print "ring.polCoeff.table " + str(ring.polCoeff.table.toScript()); 4155 ring.polCoeff.table.update( ring.toPolyCoefficients(L[i]), 4156 ring.toPolyCoefficients(L[i+1]), 4157 ring.toPolyCoefficients(L[i+2]) ); 4158 4159 self.ring = ring; 4160 SolvableRing.__init__(self,ring=self.ring)

4161

4162 - def __str__(self):

4163 '''Create a string representation. 4164 ''' 4165 return self.ring.toScript();

4166 4167

4168 -class EF:

4169 '''Extension field builder. 4170 4171 Construction of extension field towers according to the builder pattern. 4172 ''' 4173

4174 - def __init__(self,base):

4175 '''Constructor to set base field. 4176 ''' 4177 if isinstance(base,RingElem): 4178 #factory = base.elem; 4179 factory = base.ring; 4180 else: 4181 factory = base; 4182 try: 4183 factory = self.factory.factory(); 4184 except: 4185 pass 4186 print "extension field factory: " + factory.toScript(); # + " :: " + factory.toString(); 4187 #print "d type(%s) = %s" % (factory,type(factory)); 4188 if isinstance(factory,ExtensionFieldBuilder): 4189 self.builder = factory; 4190 else: 4191 self.builder = ExtensionFieldBuilder(factory);

4192

4193 - def __str__(self):

4194 '''Create a string representation. 4195 ''' 4196 return str(self.builder.toScript());

4197

4198 - def extend(self,vars,algebraic=None):

4199 '''Create an extension field. 4200 4201 If algebraic is given as string expression, then an algebraic 4202 extension field is constructed, else a transcendental 4203 extension field is constructed. 4204 ''' 4205 if algebraic == None: 4206 ef = self.builder.transcendentExtension(vars); 4207 else: 4208 ef = self.builder.algebraicExtension(vars,algebraic); 4209 return EF(ef.build());

4210

4211 - def realExtend(self,vars,algebraic,interval):

4212 '''Create a real extension field. 4213 4214 Construct a real algebraic extension field with an isolating interval for a real root. 4215 ''' 4216 ef = self.builder.realAlgebraicExtension(vars,algebraic,interval); 4217 return EF(ef.build());

4218

4219 - def complexExtend(self,vars,algebraic,rectangle):

4220 '''Create a complex extension field. 4221 4222 Construct a complex algebraic extension field with an isolating rectangle for a complex root. 4223 ''' 4224 ef = self.builder.complexAlgebraicExtension(vars,algebraic,rectangle); 4225 return EF(ef.build());

4226

4227 - def polynomial(self,vars):

4228 '''Create an polynomial ring extension. 4229 ''' 4230 ef = self.builder.polynomialExtension(vars); 4231 return EF(ef.build());

4232

4233 - def build(self):

4234 '''Get extension field tower. 4235 4236 ''' 4237 rf = self.builder.build(); 4238 if isinstance(rf,GenPolynomialRing): 4239 return PolyRing(rf.coFac,rf.getVars(),rf.tord); 4240 else: 4241 return RingElem(rf.getZERO());

4242 4243

4244 -class WordRing(Ring):

4245 '''Represents a JAS free non-commutative polynomial ring: GenWordPolynomialRing. 4246 4247 Has a method to create word ideals. 4248 Note: watch your step: check that jython does not reorder multiplication. 4249 ''' 4250

4251 - def __init__(self,ringstr="",ring=None):

4252 '''Word polynomial ring constructor. 4253 ''' 4254 if ring == None: 4255 raise ValueError, "parse of word polynomials not implemented" 4256 sr = StringReader( ringstr ); 4257 tok = RingFactoryTokenizer(sr); 4258 pfac = tok.nextPolynomialRing(); 4259 #tok = GenPolynomialTokenizer(pfac,sr); 4260 #plist = tok.nextWordPolynomialList(); 4261 #self.pset = PolynomialList(pfac,plist); 4262 self.ring = pfac; 4263 else: 4264 if isinstance(ring,Ring): 4265 self.ring = ring.ring; 4266 else: 4267 self.ring = ring;

4268

4269 - def __str__(self):

4270 '''Create a string representation. 4271 ''' 4272 return str(self.ring.toScript());

4273

4274 - def ideal(self,ringstr="",list=None):

4275 '''Create a word ideal. 4276 ''' 4277 return WordPolyIdeal(self,ringstr,list);

4278

4279 - def one(self):

4280 '''Get the one of the word polynomial ring. 4281 ''' 4282 return RingElem( self.ring.getONE() );

4283

4284 - def zero(self):

4285 '''Get the zero of the word polynomial ring. 4286 ''' 4287 return RingElem( self.ring.getZERO() );

4288

4289 - def random(self,n):

4290 '''Get a random word polynomial. 4291 ''' 4292 return RingElem( self.ring.random(n) );

4293

4294 - def random(self,k,l,d):

4295 '''Get a random word polynomial. 4296 ''' 4297 return RingElem( self.ring.random(k,l,d) );

4298

4299 - def element(self,poly):

4300 '''Create an element from a string or object. 4301 ''' 4302 if not isinstance(poly,str): 4303 try: 4304 if self.ring == poly.ring: 4305 return RingElem(poly); 4306 except Exception, e: 4307 pass 4308 poly = str(poly); 4309 I = WordPolyIdeal(self, "( " + poly + " )"); # not working 4310 list = I.list; 4311 if len(list) > 0: 4312 return RingElem( list[0] );

4313 4314

4315 -class WordPolyRing(WordRing):

4316 '''Represents a JAS free non-commutative polynomial ring: GenWordPolynomialRing. 4317 4318 Provides more convenient constructor. 4319 Then returns a Ring. 4320 Note: watch your step: check that jython does not reorder multiplication. 4321 ''' 4322

4323 - def __init__(self,coeff,vars):

4324 '''Ring constructor. 4325 4326 coeff = factory for coefficients, 4327 vars = string with variable names. 4328 ''' 4329 if coeff == None: 4330 raise ValueError, "No coefficient given." 4331 cf = coeff; 4332 if isinstance(coeff,RingElem): 4333 cf = coeff.elem.factory(); 4334 if isinstance(coeff,Ring): 4335 cf = coeff.ring; 4336 if vars == None: 4337 raise ValueError, "No variable names given." 4338 names = vars; 4339 if isinstance(vars,PyString): 4340 names = GenPolynomialTokenizer.variableList(vars); 4341 wf = WordFactory(names); 4342 ring = GenWordPolynomialRing(cf,wf); 4343 self.ring = ring;

4344

4345 - def __str__(self):

4346 '''Create a string representation. 4347 ''' 4348 return self.ring.toScript();

4349 4350

4351 -class WordPolyIdeal:

4352 '''Represents a JAS word polynomial ideal. 4353 4354 Methods for two-sided Groebner basees and others. 4355 Note: watch your step: check that jython does not reorder multiplication. 4356 ''' 4357

4358 - def __init__(self,ring,ringstr="",list=None):

4359 '''Constructor for an ideal in a word polynomial ring. 4360 ''' 4361 self.ring = ring; 4362 if list == None: 4363 raise ValueError, "parse of word polynomials not implemented" 4364 sr = StringReader( ringstr ); 4365 tok = GenPolynomialTokenizer(ring.ring,sr); 4366 self.list = tok.nextSolvablePolynomialList(); 4367 else: 4368 if isinstance(list,WordPolyIdeal): 4369 self.list = list.list; 4370 self.ideal = list; 4371 else: 4372 self.list = pylist2arraylist(list,rec=1); 4373 self.ideal = jas.application.WordIdeal(ring.ring, self.list);

4374

4375 - def __str__(self):

4376 '''Create a string representation. 4377 ''' 4378 #ll = [ e.toScript() for e in self.list ] 4379 #return "( " + ", ".join(ll) + " )"; 4380 return self.ideal.toScript();

4381

4382 - def GB(self):

4383 '''Compute a two-sided Groebner base. 4384 ''' 4385 return self.twosidedGB();

4386

4387 - def twosidedGB(self):

4388 '''Compute a two-sided Groebner base. 4389 ''' 4390 cofac = self.ring.ring.coFac; 4391 F = self.ideal.list; 4392 kind = ""; 4393 t = System.currentTimeMillis(); 4394 if cofac.isField() or not cofac.isCommutative(): 4395 G = self.ideal.GB(); 4396 kind = "field|nocom" 4397 else: 4398 if isinstance(cofac,GenPolynomialRing): # and cofac.isCommutative(): 4399 G = WordGroebnerBasePseudoRecSeq(cofac).GB(F); 4400 self.ideal = WordIdeal(self.ring.ring, G); 4401 kind = "pseudorec" 4402 else: 4403 G = WordGroebnerBasePseudoSeq(cofac).GB(F); 4404 self.ideal = WordIdeal(self.ring.ring, G); 4405 kind = "pseudo" 4406 t = System.currentTimeMillis() - t; 4407 print "sequential(%s) twosidedGB executed in %s ms" % (kind, t); 4408 return self;

4409

4410 - def isGB(self):

4411 '''Test if this is a two-sided Groebner base. 4412 ''' 4413 return self.isTwosidedGB();

4414

4415 - def isTwosidedGB(self):

4416 '''Test if this is a two-sided Groebner base. 4417 ''' 4418 cofac = self.ring.ring.coFac; 4419 F = self.ideal.list; 4420 kind = ""; 4421 t = System.currentTimeMillis(); 4422 if cofac.isField() or not cofac.isCommutative(): 4423 b = self.ideal.isGB(); 4424 kind = "field|nocom" 4425 else: 4426 if isinstance(cofac,GenPolynomialRing): 4427 b = WordGroebnerBasePseudoRecSeq(cofac).isGB(F); 4428 kind = "pseudorec" 4429 else: 4430 b = WordGroebnerBasePseudoSeq(cofac).isGB(F); 4431 kind = "pseudo" 4432 t = System.currentTimeMillis() - t; 4433 print "sequential(%s) isTwosidedGB executed in %s ms" % (kind, t); 4434 return b;

4435

4436 - def __cmp__(self, other):

4437 '''Compare two ideals. 4438 ''' 4439 if not isinstance(other, WordPolyIdeal): 4440 return False; 4441 s = self.ideal; 4442 t = other.ideal; 4443 return s.compareTo(t);

4444

4445 - def __eq__(self,other):

4446 '''Test if two ideals are equal. 4447 ''' 4448 if not isinstance(other, WordPolyIdeal): 4449 return False; 4450 s = self.ideal; 4451 t = other.ideal; 4452 return s.equals(t)

4453

4454 - def sum(self,other):

4455 '''Compute the sum of this and the other ideal. 4456 ''' 4457 s = self.ideal; 4458 t = other.ideal; 4459 N = s.sum(t); 4460 return WordIdeal(self.ring, "", N);

4461 4462

4463 -def WRC(ideal,r=0):

4464 '''Create JAS polynomial WordResidue as ring element. 4465 ''' 4466 #print "ideal = " + str(ideal); 4467 if ideal == None: # does not work 4468 print "ideal = " + str(ideal); 4469 if False: 4470 raise ValueError, "No ideal given." 4471 if isinstance(ideal,WordPolyIdeal): 4472 ideal = ideal.ideal 4473 #ideal.doGB(); 4474 if not isinstance(ideal,WordIdeal): 4475 raise ValueError, "No ideal given." 4476 #print "ideal.getList().get(0).ring.ideal = %s" % ideal.getList().get(0).ring.ideal; 4477 if isinstance(ideal.getList().get(0).ring,WordResidueRing): 4478 rc = WordResidueRing( ideal.getList().get(0).ring.ideal ); 4479 else: 4480 rc = WordResidueRing(ideal); 4481 if isinstance(r,RingElem): 4482 r = r.elem; 4483 if r == 0: 4484 r = WordResidue(rc); 4485 else: 4486 r = WordResidue(rc,r); 4487 return RingElem(r);

4488 4489 4490 # doctest: 4491 if __name__ == '__main__': 4492 import doctest, sys 4493 doctest.testmod(sys.modules[__name__]) 4494

Source Code for Module jas