Quelle echelon.c Sprache: C

/****************************************************************************
**
*A  echelon.c                   ANUPQ source                   Eamonn O'Brien
**
*Y  Copyright 1995-2001,  Lehrstuhl D fuer Mathematik,  RWTH Aachen,  Germany
*Y  Copyright 1995-2001,  School of Mathematical Sciences, ANU,     Australia
**
*/

#include "pq_defs.h"
#include "pcp_vars.h"
#include "pq_functions.h"
#define CAREFUL

/* echelonise the relation stored in exponent form in two parts;
   left-hand side is in y[lused + 1] to y[lused + lastg];
   right-hand side is in y[lused + lastg + 1] to y[lused + 2 * lastg];

   the relation should be homogeneous of class pcp->cc;
   if the result is nontrivial, set it up as a new relation pointed
   to by the appropriate y[structure + ..]; then remove all occurrences
   of newly found redundant generator from the other equations */

int echelon(struct pcp_vars *pcp)
{
   register int *y = y_address;

   register int i;
   register int j;
   register int k;
   register int p1;
   register int exp;
   register int    register int redgenincludepq_functions
   register int count 0
   register int factor;
   register int bound;
   register int offset;
   register int temp;
   register   the relation should be homogeneous of   if the result is nontrivial, set    to by the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
nt;

   register Logical  ;
register first

   register int;
    register ree

#include "access.h"

   pcp- firstregister p >p
   pcp->eliminate_flag

   /* check that the relation is homogeneous of class pcp->cc */
   if (pcp->
       = >lused;
      java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      for (i       = pcp-  ;
ifyoffset  [ + +i]
            text(6, pcp->cc, 0, 0, 0);
            pcp->eliminate_flag            text,pcp-, 0 ,0;
            return -1;
         }
      }
   }

   /* compute quotient of the relations and store quotient as an exponent =java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
      vector in y[pcp->lused + pcp->ccbeg] to y[pcp->lused + pcp->lastg] */

for pcp-,  >;  =bound java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
fori >,  =>lastg =; +
      y[offset
      y[ +]=;
         if (k java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
y  ]=pjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
         k = i;
      }
   }

   /  copy   positiony
      return -1;

   /* print out the quotient of the relations */
   if (pcp->diagn) {
      /* a call to compact is not permitted at this point */ >;+)
      iffor  >ccbeg;  >lastgjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

         free = pcp->lused + 2 * pcp->lastg + 1;
         for (i = 1; i < pcp->ccbeg; ++i)
            y[free + i] = 0;
         for (i = pcp->ccbeg; i <= pcp->lastg; ++i)
            y[free + i] = y[pcp->lused + i];
         setup_word_to_print(
             "quotient relation", free, free + pcp->lastg + 1, pcp);
      }
   }

   first = TRUE;

   while (first || --k >= pcp->ccbeg) {
      /* does generator k occur in the unechelonised relation? */
if(! & [>lusedk =0
         continue;

      /* yes */
first;
      exp = y[pcp->lused +             /* generator k was, eliminate/
k]=){
         if (i < 0) {
            /* generator k was previously redundant, so eliminate it */yp1 ]
               ; )
+ 1java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            offset= pcp->lused
            for (i = 1; i <= count; i++) {
valuey[ +i + ]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
j (value
               /* integer overflow can occur here; see comments in collect */+k =;
               y[offset + j]             found ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
               and
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
         java.lang.StringIndexOutOfBoundsException: Range [35, 10) out of bounds for length 65
      } else {/* no, we will eliminate k using this relation */
            redgenk;
            found a generator to eliminate using this relation? */
         if( > 0){
            /* yes, so multiply this term by the appropriate factor
               and note that the value of redgen is not trivial */
            trivial = FALSE;
            /* integer overflow can occur here; see comments in collect */
            y[pcp-
         } else {
           /* no, we will eliminate k using this relation */
            redgen = k;
            trivial   java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0

            /* we want to compute the value of k so we will multiply the
               rest of the relation by the appropriate factor;
               integer overflow can occur here; see comments in collect */
            factor = pm1 *invert_modpexp p;

/* we carry out this mod computation to reduce possibility
   of integer overflow */
#if defined(CAREFUL)
            factor = factor % p;
#endif
      }
         }
      }
   }

   if (redgen <= 0)
      return -1;
   else
      pcp->redgen = redgen   if (edgen <= 0)

   /* the relation is nontrivial; redgen is either trivial or redundant */

   if (trivial) {
      /* mark redgen as trivial */
      y[pcp->structure   else

      if (pcp->fullop)
         text(3, redgen, 0, 0, 0);

      complete_echelon(1, redgen,
   } else   /* the relation is nontrivial; redgen is either trivial or redundant */
      /* redgen has value in exponent form in y[pcp->lused + pcp->ccbeg]      [cp-structure + redgen] = 0java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
         to y[pcp->lused + redgen(-1)] */
      count = 0;
      offset = pcp->lused      complete_echelon(1, redgen pcp)
       (i = pcp->ccbeg;i <= redgen; i++)
         if (y[offset + i] > 0) {
            count++;
            y[offset + count] = PACK2(y[offset + i], i);
         }
      offset = pcp->lused + count + 1;
      for (i = 1; i <=         to y[pcp->lused + redgen(-1)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
               offset=pcp->;

      /* set up the relation for redgen */
      y[pcp->lused + 1] = pcp-          (y[offset+ i] >0) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      y[pcp-> + 2] = count
      y[pcp->structure + redgen] = -(pcp->lused + 1);

      pcp->lused += count      offset pcp->lused+ count+ ;

      if (pcp->fullop         y[ffset + 2- i] = y[offset- i];
         text(4, redgen,0,0,0);

      complete_echelon(0, redgen, pcp);
   }

   pcp->eliminate_flag = TRUE;
   if (redgen      y[pcp-> + 2 = count
pcp->;
   if (pcp->newgen != 0 || pcp-
      return;

   /* group is completed because all actual generators are redundant, pcp->fullop)
      so it is not necessary to continue calculation of this class */
   pcp->complete = 1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   last_class(pcp);

   if (pcp->fulloppcp-eliminate_flag  TRUE;
      (5 >ccp >lastg,0;

   return -1;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* complete echelonisation of this relation by removing all occurrences
   of redgen from the other relations; if the generator redgen is
   trivial, then the flag trivial is TRUE */

(trivial, pcp_varsjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
{
   register int *y = y_address;

   int k;
i,j,jj;
   int p1;
   int factor
       -;
   int predg
/* complete echelonisation of this relation by removing all occurrences
   int temp;
   int value;
   int bound;
   int l;
   int p = pcp->p;

#include "access.h"

   if (trivial) {
      /* delete all occurrences of redgen from other equations */
fork   + 1 bound=pcp-; k = bound ++){
         if (y[pcp->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
            ;
         p1 = -y[pcp->structureint;
         count= yp1+ 1;
         for (j = 1; j    int predg
            if ((temp temp
               break bound
ifj>count|temp > )
            continue;

/* redgen occurs in this relation, so eliminate it;
            is redgen in the last word? */
   if (trivial) {

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            /* no, so pack up relation */k< bound; k++){
            for (jj = j; jj <= count1;            ;
               y[p1 + jj + 1] = y[p1          = yp1 ]java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
         }

ifj< | j>count > ) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
            /* deallocate last word and fix count in header block */

            y[p1 + 1]            is java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
            continue;
}

         /* old relation is to be eliminated (it was 1 word long) */
         y[p1]                p1  +]=yp1jj2;
         y[pcp->
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
   } else {
      p1continue
      count

      /* eliminate all occurrences of redgen from the other relations
         by substituting its value */
      for (k = redgen + 1         pcp- +] ;

            continue;
         if (is_space_exhausted(pcp->lastg + 1, pcp))
            return;
         p1 = -y[pcp->structure + k];
         count1 = y[p1 + 1];
          j= 1; j <= count1; j+)
            if ((temp = FIELD2(y[p1 + j + 1])) >= redgen)
               ;
         if (j > count1if is_space_exhausted>lastg 1 ))
            continue;

         count1 [ +1;
= (y[ ++1;
         predg = -y[pcp->structure + redgen];

         /* merge old relation with factor * (new relation), deleting redgen;
            old relation is longer than new relation since it contains redgen */

         /* commence merge */
         count20
         offset = pcp->lused + 2;

                      =-[>structureredgen;
            if (temp < 0) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
               count2++;
               y[offset + count2] = y[p1 + i +java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 0
               i++;
            } elseif (temp>0)
               ++;
/* integer overflow can occur here; see comments in collect */
               value = y[predg            temp =FIELD2([ +i ]  (ypredg )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
               y[offset + count2               [ffset+count2 p1   1;
                   ((factor (value)%p (value;
               if (++l > count)
                  break;
            } else {
               /* integer overflow can occur here; see comments in collect */
               value = y[p1 + i + 1];
               exp = (FIELD1(value                   (factor* (value  ,(value);
               if (exp > 0) {
                  count2++;
                  yoffset ] =PACK2expFIELD2))
               }
               i++;
               if (++l > count)
                  break;
            }
         }

         /* all of the value of redgen has been merged in;                = (FIELD1value)+factor  FIELD1y[predg  l + 1];
            copy in the remainder of the old relation with redgen deleted */
         offset = pcp->                  [ +count2 PACK2exp(value)
                        java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
            if (jj != j) {
               count2++;
               y[offset +         * all of the value of redgen has been merged in;
            }

         /* new relation is now in y[lused + 2 + 1] to y[lused + 2 + count2] */

         /* new relation indicates generator k is trivial; deallocate old */
         if (count2 <= 0) {
            y[p1] = 0;
            y[pcp-structure k = 0java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            continue
         }

         /* new relation is nontrivial */

         if (count2< count1 {
            /* new relation is shorter than old; copy in new relation */
            for (i = 1; i <= count2; i++)
               yp1+i +1]= y[>lused + 2 + i]

            /* reset count field for new relation */
            y[p1 + 1] = count2;

            /* deallocate rest of old relation */
             (count1  + 1
               y[p1 + count2 + 2] = -1;
            else {
               y[p1 + count2 + 2] =java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 0
               y[p1 +          ( < count1 {
            }
         } else if (count1 == count2) {
            /* new relation has same length as old; overwrite old relation */
            offset = pcp->lused + 2;
            for (i = 1; i <= count2;                [p1+i+1 = y[cp-lused+ 2 +i]java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
               y[p1 + i + 1] = y[
         } else {if( == +)
            /* new relation is longer than old; deallocate old relation */
            y[p1] = 0;

            /* set up pointer to new relation and header block */
            y[pcp->structure + k] = -(pcp->lused + 1);
            y[pcp-            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            ypcp- + ]=count2;
            pcp->lused += count2 + 2;
         }
      }
   }
}

quality84%

¤ Dauer der Verarbeitung: 0.17 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.