Changeset e28e6d in git

Timestamp:

Jul 6, 2011, 10:31:05 AM (12 years ago)

Author:

Martin Lee <martinlee84@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')

Children:

ec970ef2b3d7d5253124f91a7c731ac3c7c540c3

Parents:

276c3f35a3633a214a6c43c7426a9f3e9609bd35

Message:

towards better arithmetic in Z_p[x]/(f) for reducible f 


git-svn-id: file:///usr/local/Singular/svn/trunk@14326 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

factory

Files:

• canonicalform.cc (modified) (2 diffs)
• canonicalform.h (modified) (2 diffs)
• int_cf.cc (modified) (1 diff)
• int_cf.h (modified) (3 diffs)

factory/canonicalform.cc

@@ -791 +791 @@
 }
 
+//same as divremt but handles zero divisors in case we are in Z_p[x]/(f) where f is not irreducible
+CanonicalForm &
+CanonicalForm::tryDiv ( const CanonicalForm & cf, const CanonicalForm& M, bool& fail )
+{
+    ASSERT (getCharacteristic() > 0, "expected positive characteristic");
+    ASSERT (!getReduce (M.mvar()), "do not reduce modulo M");
+    fail= false;
+    int what = is_imm( value );
+    if ( what ) {
+        ASSERT ( ! is_imm( cf.value ) || (what==is_imm( cf.value )), "illegal base coefficients" );
+        if ( (what = is_imm( cf.value )) == FFMARK )
+            value = imm_div_p( value, cf.value );
+        else  if ( what == GFMARK )
+            value = imm_div_gf( value, cf.value );
+        else {
+            InternalCF * dummy = cf.value->copyObject();
+            value = dummy->divcoeff( value, true );
+        }
+    }
+    else  if ( is_imm( cf.value ) )
+        value = value->tryDivcoeff (cf.value, false, M, fail);
+    else  if ( value->level() == cf.value->level() ) {
+        if ( value->levelcoeff() == cf.value->levelcoeff() )
+            value = value->tryDivsame( cf.value, M, fail );
+        else  if ( value->levelcoeff() > cf.value->levelcoeff() )
+            value = value->tryDivcoeff( cf.value, false, M, fail );
+        else {
+            InternalCF * dummy = cf.value->copyObject();
+            dummy = dummy->tryDivcoeff( value, true, M, fail );
+            if ( value->deleteObject() ) delete value;
+            value = dummy;
+        }
+    }
+    else  if ( level() > cf.level() )
+        value = value->tryDivcoeff( cf.value, false, M, fail );
+    else {
+        InternalCF * dummy = cf.value->copyObject();
+        dummy = dummy->tryDivcoeff( value, true, M, fail );
+        if ( value->deleteObject() ) delete value;
+        value = dummy;
+    }
+    return *this;
+}
+
 CanonicalForm &
 CanonicalForm::operator %= ( const CanonicalForm & cf )
@@ -949 +993 @@
     return result;
 }
+
+//same as divremt but handles zero divisors in case we are in Z_p[x]/(f) where f is not irreducible
+bool
+tryDivremt ( const CanonicalForm & f, const CanonicalForm & g, CanonicalForm & q, CanonicalForm & r, const CanonicalForm& M, bool& fail )
+{
+    ASSERT (getCharacteristic() > 0, "expected positive characteristic");
+    ASSERT (!getReduce (M.mvar()), "do not reduce modulo M");
+    fail= false;
+    InternalCF * qq = 0, * rr = 0;
+    int what = is_imm( f.value );
+    bool result = true;
+    if ( what )
+        if ( is_imm( g.value ) ) {
+            if ( what == FFMARK )
+                imm_divrem_p( f.value, g.value, qq, rr );
+            else  if ( what == GFMARK )
+                imm_divrem_gf( f.value, g.value, qq, rr );
+        }
+        else
+            result = g.value->tryDivremcoefft( f.value, qq, rr, true, M, fail );
+    else  if ( (what=is_imm( g.value )) )
+        result = f.value->tryDivremcoefft( g.value, qq, rr, false, M, fail );
+    else  if ( f.value->level() == g.value->level() )
+        if ( f.value->levelcoeff() == g.value->levelcoeff() )
+            result = f.value->tryDivremsamet( g.value, qq, rr, M, fail );
+        else  if ( f.value->levelcoeff() > g.value->levelcoeff() )
+            result = f.value->tryDivremcoefft( g.value, qq, rr, false, M, fail );
+        else
+            result = g.value->tryDivremcoefft( f.value, qq, rr, true, M, fail );
+    else  if ( f.value->level() > g.value->level() )
+        result = f.value->tryDivremcoefft( g.value, qq, rr, false, M, fail );
+    else
+        result = g.value->tryDivremcoefft( f.value, qq, rr, true, M, fail );
+    if (fail)
+    {
+      q= 0;
+      r= 0;
+      return false;
+    }
+    if ( result ) {
+        ASSERT( qq != 0 && rr != 0, "error in divrem" );
+        q = CanonicalForm( qq );
+        r = CanonicalForm( rr );
+        q= reduce (q, M);
+        r= reduce (r, M);
+    }
+    else {
+        q = 0; r = 0;
+    }
+    return result;
+}
+
 //}}}
 

factory/canonicalform.h

@@ -131 +131 @@
     CanonicalForm& operator %= ( const CanonicalForm& );
     CanonicalForm& div ( const CanonicalForm& );
+    CanonicalForm& tryDiv (const CanonicalForm&, const CanonicalForm&, bool& );
     CanonicalForm& mod ( const CanonicalForm& );
 
@@ -157 +158 @@
     friend void divrem ( const CanonicalForm&, const CanonicalForm&, CanonicalForm&, CanonicalForm& );
     friend bool divremt ( const CanonicalForm&, const CanonicalForm&, CanonicalForm&, CanonicalForm& );
+    friend bool tryDivremt ( const CanonicalForm&, const CanonicalForm&, CanonicalForm&, CanonicalForm&, const CanonicalForm&, bool& );
 
     friend CanonicalForm bgcd ( const CanonicalForm &, const CanonicalForm & );

factory/int_cf.cc

@@ -173 +173 @@
     return 0;
 }
+
+InternalCF*
+InternalCF::tryMulsame( InternalCF* F, const CanonicalForm& M)
+{
+    ASSERT1( 0, "tryMulsame() not implemented for class %s", this->classname() );
+    return 0;
+}
+
+InternalCF*
+InternalCF::tryInvert ( const CanonicalForm& M, bool& fail)
+{
+    ASSERT1( 0, "tryInvert() not implemented for class %s", this->classname() );
+    return 0;
+}
+
+bool
+InternalCF::tryDivremsamet ( InternalCF* F, InternalCF*& S, InternalCF*& T, const CanonicalForm& M, bool& fail)
+{
+    ASSERT1( 0, "tryDivremsamet() not implemented for class %s", this->classname() );
+    return 0;
+}
+
+bool
+InternalCF::tryDivremcoefft ( InternalCF* F, InternalCF*& S, InternalCF*& T, bool invert, const CanonicalForm& M, bool& fail)
+{
+    ASSERT1( 0, "tryDivremcoefft() not implemented for class %s", this->classname() );
+    return 0;
+}
+
+InternalCF*
+InternalCF::tryDivsame ( InternalCF* F, const CanonicalForm& M, bool& fail)
+{
+    ASSERT1( 0, "tryDivsame() not implemented for class %s", this->classname() );
+    return 0;
+}
+
+InternalCF*
+InternalCF::tryDivcoeff ( InternalCF* F, bool invert, const CanonicalForm& M, bool& fail)
+{
+    ASSERT1( 0, "tryDivcoeff() not implemented for class %s", this->classname() );
+    return 0;
+}
+
+InternalCF*
+InternalCF::tryDividecoeff ( InternalCF* F, bool invert, const CanonicalForm& M, bool& fail)
+{
+    ASSERT1( 0, "tryDividecoeff() not implemented for class %s", this->classname() );
+    return 0;
+}

factory/int_cf.h

@@ -68 +68 @@
     virtual InternalCF* neg() PVIRT_INTCF("neg");
     virtual InternalCF* invert(); // semantically const, changes refCount
+    virtual InternalCF* tryInvert( const CanonicalForm&, bool& );
     virtual int comparesame ( InternalCF * ) PVIRT_INT("comparesame");
     virtual int comparecoeff ( InternalCF * ) PVIRT_INT("comparecoeff");
@@ -74 +75 @@
     virtual InternalCF* subsame( InternalCF* ) PVIRT_INTCF("subsame");
     virtual InternalCF* mulsame( InternalCF* ) PVIRT_INTCF("mulsame");
+    virtual InternalCF* tryMulsame( InternalCF*, const CanonicalForm& );
     virtual InternalCF* dividesame( InternalCF* ) PVIRT_INTCF("dividesame");
     virtual InternalCF* modulosame( InternalCF* ) PVIRT_INTCF("modulosame");
     virtual InternalCF* divsame( InternalCF* ) PVIRT_INTCF("divsame");
+    virtual InternalCF* tryDivsame ( InternalCF* , const CanonicalForm&, bool& );
     virtual InternalCF* modsame( InternalCF* ) PVIRT_INTCF("modsame");
     virtual void divremsame( InternalCF*, InternalCF*&, InternalCF*& ) PVIRT_VOID("divremsame");
     virtual bool divremsamet( InternalCF*, InternalCF*&, InternalCF*& ) PVIRT_BOOL("divremsamet");
+    virtual bool tryDivremsamet ( InternalCF*, InternalCF*&, InternalCF*&, const CanonicalForm&, bool& );
 
     virtual InternalCF* addcoeff( InternalCF* ) PVIRT_INTCF("addcoeff");
@@ -85 +89 @@
     virtual InternalCF* mulcoeff( InternalCF* ) PVIRT_INTCF("mulcoeff");
     virtual InternalCF* dividecoeff( InternalCF*, bool ) PVIRT_INTCF("dividecoeff");
+    virtual InternalCF* tryDividecoeff ( InternalCF*, bool, const CanonicalForm&, bool& );
     virtual InternalCF* modulocoeff( InternalCF*, bool ) PVIRT_INTCF("dividecoeff");
     virtual InternalCF* divcoeff( InternalCF*, bool ) PVIRT_INTCF("divcoeff");
+    virtual InternalCF* tryDivcoeff ( InternalCF*, bool, const CanonicalForm&, bool& );
     virtual InternalCF* modcoeff( InternalCF*, bool ) PVIRT_INTCF("modcoeff");
     virtual void divremcoeff( InternalCF*, InternalCF*&, InternalCF*&, bool ) PVIRT_VOID("divremcoeff");
     virtual bool divremcoefft( InternalCF*, InternalCF*&, InternalCF*&, bool ) PVIRT_BOOL("divremcoefft");
+    virtual bool tryDivremcoefft( InternalCF*, InternalCF*&, InternalCF*&, bool, const CanonicalForm&, bool& );
 
     virtual InternalCF * bgcdsame ( const InternalCF * const ) const;