Xreferat.com » Рефераты по математике » Алгоритм компактного хранения и решения СЛАУ высокого порядка

Алгоритм компактного хранения и решения СЛАУ высокого порядка

Num2,

               m;

 DWORD         i,

               j,

               p[6],

               pp[6],

               Index;

 Matrix BoundList(4 * NumTr,6);

 double        cx,

               cy,

               cz,

               x1,

               y1,

               z1,

               x2,

               y2,

               z2,

               x3,

               y3,

               z3;

 Bounds.ReSize(4 * NumTr,6);

 switch (CurrentType)

  {

    case BASE3D_4:

         Num1 = 4;

         Num2 = 3;

         for (l = 0; l < Num1; l++)

          for (m = 0; m < Num2+1; m++)

           cData[l][m] = cData4[l][m];

         break;

    case BASE3D_8:

         Num1 = 6;

         Num2 = 4;

         for (l = 0; l < Num1; l++)

          for (m = 0; m < Num2 + 1; m++)

           cData[l][m] = cData8[l][m];

         break;

    case BASE3D_10:

         Num1 = 4;

         Num2 = 6;

         for (l = 0; l < Num1; l++)

          for (m = 0; m < Num2+1; m++)

           cData[l][m] = cData10[l][m];

  }

 printf("Create bounds...r");

 for (i = 0; i < NumTr - 1; i++)

  for (int j = 0; j < Num1; j++)

   if (!BoundList[i][j])

    {

     for (l = 0; l < Num2; l++)

      p[l]  = FE[i][cData[j][l]];

     for (DWORD k = i + 1; k < NumTr; k++)

      for (int m = 0; m < Num1; m++)

       if (!BoundList[k][m])

        {

         for (int l = 0; l < Num2; l++)

          pp[l] = FE[k][cData[m][l]];

         if (Test(p,pp))

          BoundList[i][j] = BoundList[k][m] = 1;

        }

    }

 for (i = 0; i < NumTr; i++)

  for (j = 0; j < (DWORD)Num1; j++)

   if (BoundList[i][j] == 0)

    {

         if (CurrentType == BASE3D_4)

          {

            cx = X[FE[i][cData[j][3]]];

            cy = Y[FE[i][cData[j][3]]];

            cz = Z[FE[i][cData[j][3]]];

          }

         else

         if (CurrentType == BASE3D_10)

          {

            cx = X[FE[i][cData[j][6]]];

            cy = Y[FE[i][cData[j][6]]];

            cz = Z[FE[i][cData[j][6]]];

          }

         else

          {

            cx = X[FE[i][cData[j][4]]];

            cy = Y[FE[i][cData[j][4]]];

            cz = Z[FE[i][cData[j][4]]];

          }

      x1 = X[FE[i][cData[j][0]]];

      y1 = Y[FE[i][cData[j][0]]];

      z1 = Z[FE[i][cData[j][0]]];

      x2 = X[FE[i][cData[j][1]]];

      y2 = Y[FE[i][cData[j][1]]];

      z2 = Z[FE[i][cData[j][1]]];

      x3 = X[FE[i][cData[j][2]]];

      y3 = Y[FE[i][cData[j][2]]];

      z3 = Z[FE[i][cData[j][2]]];

      for (l = 0; l < Num2; l++)

        Data[l] = cData[j][l];

      if ( ((cx-x1)*(y2-y1)*(z3-z1) + (cy-y1)*(z2-z1)*(x3-x1) + (y3-y1)*(cz-z1)*(x2-x1) -

            (x3-x1)*(y2-y1)*(cz-z1) - (y3-y1)*(z2-z1)*(cx-x1) - (cy-y1)*(z3-z1)*(x2-x1)) > 0)

       {

         if (CurrentType == BASE3D_4)

          {

            Data[0] = cData[j][0];

            Data[1] = cData[j][2];

            Data[2] = cData[j][1];

          }

         else

         if (CurrentType == BASE3D_10)

          {

            Data[0] = cData[j][0];

            Data[1] = cData[j][2];

            Data[2] = cData[j][1];

            Data[3] = cData[j][5];

            Data[5] = cData[j][3];

          }

         else

          {

            Data[0] = cData[j][0];

            Data[1] = cData[j][3];

            Data[2] = cData[j][2];

            Data[3] = cData[j][1];

          }

       }

      for (l = 0; l < Num2; l++)

       Bounds[BnCount][l] = FE[i][Data[l]];

      BnCount++;

    }

}

void main(int argc,char** argv)

{

   char *input1,

        *input2,

        *input3,

        *op = "",

        *sw;

   bool CreateFile(char*,char*,char*,char*);

   printf("ANSYS->FORL file convertor. ZSU(c) 1998.nn");

   if (argc < 5 || argc > 6)

    {

      PrintHeader();

      return;

    }

   sw     = argv[1];

   input1 = argv[2];

   input2 = argv[3];

   input3 = argv[4];

   if (!strcmp(sw,"-t10"))

    CurrentType = BASE3D_10;

   else

   if (!strcmp(sw,"-c8"))

    CurrentType = BASE3D_8;

   else

    {

      printf("Unknown switch %snn",sw);

      PrintHeader();

      return;

    }

   if (argc == 6)

    {

      op = argv[5];

      if (strcmp(op,"/8") && strcmp(op,"/6"))

       {

         printf("Unknown options %snn",op);

         PrintHeader();

         return;

       }

    }

   if (CreateFile(input1,input2,input3,op))

    printf("OKn");

}

bool CreateFile(char* fn1,char* fn2,char* fn3,char* Op)

{

   FILE           *in1,

                  *in2,

                  *in3;

   Vector X(1000),

                  Y(1000),

                  Z(1000);

   DWORD          NumPoints,

                  NumFE,

                  NumBounds = 0,

                  tmp;

   Matrix  FE(1000,10),

                  Bounds;

   bool           ReadTetraedrData(char*,char*,FILE*,FILE*,Vector&,Vector&,Vector&,

                                   Matrix&,DWORD&,DWORD&),

                  ReadCubeData(char*,char*,FILE*,FILE*,Vector&,Vector&,Vector&,

                                   Matrix&,DWORD&,DWORD&);

   void           Convert824(Matrix&,DWORD&),

                  Convert1024(Matrix&,DWORD&);

   if ((in1 = fopen(fn1,"r")) == NULL)

    {

      printf("Unable open file %s",fn1);

      return false;

    }

   if ((in2 = fopen(fn2,"r")) == NULL)

    {

      printf("Unable open file %s",fn2);

      return false;

    }

   if (CurrentType == BASE3D_10)

    {

       if (!ReadTetraedrData(fn1,fn2,in1,in2,X,Y,Z,FE,NumPoints,NumFE)) return false;

       if (!strcmp(Op,"/8"))

        {

          // Create 8*Tetraedr(4)

          Convert1024(FE,NumFE);

        }

       Convert(X,Y,Z,FE,NumFE,Bounds,NumBounds);

       return !Output(fn3,X,Y,Z,FE,NumPoints,0,NumFE,Bounds,NumBounds);

    }

   if (CurrentType == BASE3D_8)

    {

       if (!ReadCubeData(fn1,fn2,in1,in2,X,Y,Z,FE,NumPoints,NumFE)) return false;

       if (!strcmp(Op,"/6"))

        {

          // Create 6*Tetraedr(4)

          Convert824(FE,NumFE);

        }

       Convert(X,Y,Z,FE,NumFE,Bounds,NumBounds);

       return !Output(fn3,X,Y,Z,FE,NumPoints,0,NumFE,Bounds,NumBounds);

    }

  return false;

}

void Convert824(Matrix& FE,DWORD& NumFE)

{

  Matrix nFE(6 * NumFE,4);

  DWORD  data[][4] = {

                      { 0,2,3,6 },

                      { 4,5,1,7 },

                      { 0,4,1,3 },

                      { 6,7,3,4 },

                      { 1,3,7,4 },

                      { 0,4,6,3 }

                     },

         Current = 0;

  for (DWORD i = 0; i < NumFE; i++)

   for (DWORD j = 0; j < 6; j++)

    {

      for (DWORD k = 0; k < 4; k++)

      nFE[Current][k] = FE[i][data[j][k]];

      Current++;

    }

  CurrentType = BASE3D_4;

  NumFE = Current;

  FE    = nFE;

}

void Convert1024(Matrix& FE,DWORD& NumFE)

{

  Matrix nFE(8 * NumFE,4);

  DWORD  data[][4] = {

                      { 3,7,8,9 },

                      { 0,4,7,6 },

                      { 2,5,9,6 },

                      { 7,9,8,6 },

                      { 4,8,5,1 },

                      { 4,5,8,6 },

                      { 7,8,4,6 },

                      { 8,9,5,6 }

                     },

         Current = 0;

  for (DWORD i = 0; i < NumFE; i++)

   for (DWORD j = 0; j < 8; j++)

    {

      for (DWORD k = 0; k < 4; k++)

      nFE[Current][k] = FE[i][data[j][k]];

      Current++;

    }

  CurrentType = BASE3D_4;

  NumFE = Current;

  FE    = nFE;

}

bool ReadTetraedrData(char* fn1,char* fn2,FILE* in1,FILE* in2,Vector& X,Vector& Y,Vector& Z,

                      Matrix& FE,DWORD& NumPoints,DWORD& NumFE)

{

   double         tx,

                  ty,

                  tz;

   char           TextBuffer[1001];

   DWORD          Current = 0L,

                  tmp;

   while (!feof(in1))

    {

      if (fgets(TextBuffer,1000,in1) == NULL)

       {

         if (feof(in1)) break;

         printf("Unable read file %s",fn1);

         fclose(in1);

         fclose(in2);

         return false;

       }

      if (sscanf(TextBuffer,"%ld %lf %lf %lf", &NumPoints,&tx,&ty,&tz) != 4) continue;

      X[Current] = tx;

      Y[Current] = ty;

      Z[Current] = tz;

      if (++Current == 999)

       {

         Vector t1 = X,

                        t2 = Y,

                        t3 = Z;

         X.ReSize(2 * X.Size());

         Y.ReSize(2 * X.Size());

         Z.ReSize(2 * X.Size());

         for (DWORD i = 0; i < Current; i++)

          {

            X[i] = t1[i];

            Y[i] = t2[i];

            Z[i] = t3[i];

          }

       }

      if (Current % 100 == 0)

       printf("Line: %ldr",Current);

    }

   fclose(in1);

   printf("                            r");

   NumPoints = Current;

   Current = 0L;

   while (!feof(in2))

    {

      if (fgets(TextBuffer,1000,in2) == NULL)

       {

         if (feof(in2)) break;

         printf("Unable read file %s",fn2);

         fclose(in2);

         return false;

       }

      if (sscanf(TextBuffer,"%d %d %d %d %d %ld %ld %ld %ld %ld %ld %ld %ld",

          &tmp,&tmp,&tmp,&tmp,&tmp,

          &FE[Current][0],&FE[Current][1],&FE[Current][2],&FE[Current][3],

          &FE[Current][4],&FE[Current][5],&FE[Current][6],&FE[Current][7]) != 13) continue;

      if (fgets(TextBuffer,1000,in2) == NULL)

       {

         printf("Unable read file %s",fn2);

         fclose(in2);

         return false;

       }

      if (sscanf(TextBuffer,"%ld %ld",&FE[Current][8],&FE[Current][9]) != 2)

       {

         printf("Unable read file %s",fn2);

         fclose(in2);

         return false;

       }

{

       if (fabs((tx = 0.5*(X[FE[Current][0] - 1] + X[FE[Current][1] - 1])) - X[FE[Current][4] - 1]) > Eps)

        X[FE[Current][4] - 1] = tx;

       if (fabs((ty = 0.5*(Y[FE[Current][0] - 1] + Y[FE[Current][1] - 1])) - Y[FE[Current][4] - 1]) > Eps)

          Y[FE[Current][4] - 1] = ty;

       if (fabs((tz = 0.5*(Z[FE[Current][0] - 1] + Z[FE[Current][1] - 1])) - Z[FE[Current][4] - 1]) > Eps)

          Z[FE[Current][4] - 1] = tz;

       if (fabs((tx = 0.5*(X[FE[Current][2] - 1] + X[FE[Current][1] - 1])) - X[FE[Current][5] - 1]) > Eps)

          X[FE[Current][5] - 1] = tx;

       if (fabs((ty = 0.5*(Y[FE[Current][2] - 1] + Y[FE[Current][1] - 1])) - Y[FE[Current][5] - 1]) > Eps)

          Y[FE[Current][5] - 1] = ty;

       if (fabs((tz = 0.5*(Z[FE[Current][2] - 1] + Z[FE[Current][1] - 1])) - Z[FE[Current][5] - 1]) > Eps)

          Z[FE[Current][5] - 1] = tz;

       if (fabs((tx = 0.5*(X[FE[Current][0] - 1] + X[FE[Current][2] - 1])) - X[FE[Current][6] - 1]) > Eps)

          X[FE[Current][6] - 1] = tx;

       if (fabs((ty = 0.5*(Y[FE[Current][0] - 1] + Y[FE[Current][2] - 1])) - Y[FE[Current][6] - 1]) > Eps)

          Y[FE[Current][6] - 1] = ty;

       if (fabs((tz = 0.5*(Z[FE[Current][0] - 1] + Z[FE[Current][2] - 1])) - Z[FE[Current][6] - 1]) > Eps)

          Z[FE[Current][6] - 1] = tz;

       if (fabs((tx = 0.5*(X[FE[Current][0] - 1] + X[FE[Current][3] - 1])) - X[FE[Current][7] - 1]) > Eps)

          X[FE[Current][7] - 1] = tx;

       if (fabs((ty = 0.5*(Y[FE[Current][0] - 1] + Y[FE[Current][3] - 1])) - Y[FE[Current][7] - 1]) > Eps)

          Y[FE[Current][7] - 1] = ty;

       if (fabs((tz = 0.5*(Z[FE[Current][0] - 1] + Z[FE[Current][3] - 1])) - Z[FE[Current][7] - 1]) > Eps)

          Z[FE[Current][7] - 1] = tz;

       if (fabs((tx = 0.5*(X[FE[Current][3] - 1] + X[FE[Current][1] - 1])) - X[FE[Current][8] - 1]) > Eps)

          X[FE[Current][8] - 1] = tx;

       if (fabs((ty = 0.5*(Y[FE[Current][3] - 1] + Y[FE[Current][1] - 1])) - Y[FE[Current][8] - 1]) > Eps)

          Y[FE[Current][8] - 1] = ty;

       if (fabs((tz = 0.5*(Z[FE[Current][3] - 1] + Z[FE[Current][1] - 1])) - Z[FE[Current][8] - 1]) > Eps)

          Z[FE[Current][8] - 1] = tz;

       if (fabs((tx = 0.5*(X[FE[Current][3] - 1] + X[FE[Current][2] - 1])) - X[FE[Current][9] - 1]) > Eps)

          X[FE[Current][9] - 1] = tx;

       if (fabs((ty = 0.5*(Y[FE[Current][3] - 1] + Y[FE[Current][2] - 1])) - Y[FE[Current][9] - 1]) > Eps)

          Y[FE[Current][9] - 1] = ty;

       if (fabs((tz = 0.5*(Z[FE[Current][3] - 1] + Z[FE[Current][2] - 1])) - Z[FE[Current][9] - 1]) > Eps)

          Z[FE[Current][9] - 1] = tz;

}

      if (++Current == 999)

       {

         Matrix t = FE;

         FE.ReSize(2 * FE.Size1(),10);

         for (DWORD i = 0; i < Current; i++)

          for (DWORD j = 0; j < 10; j++)

           FE[i][j] = t[i][j];

       }

      if (Current % 100 == 0)

       printf("Line: %ldr",Current);

    }

   NumFE = Current;

   for (DWORD i = 0; i < NumFE; i++)

    for (DWORD j = 0; j < 10; j++)

      FE[i][j]--;

   printf("                            r");

   return true;

}

bool ReadCubeData(char* fn1,char*fn2,FILE* in1,FILE* in2,Vector& X,Vector& Y,Vector& Z,

                      Matrix& FE,DWORD& NumPoints,DWORD& NumFE)

{

   double         tx,

                  ty,

                  tz;

   char           TextBuffer[1001];

   DWORD          Current = 0L,

                  tmp;

   while (!feof(in1))

    {

      if (fgets(TextBuffer,1000,in1) == NULL)

       {

         if (feof(in1)) break;

         printf("Unable read file %s",fn1);

         fclose(in1);

         fclose(in2);

         return false;

       }

      if (sscanf(TextBuffer,"%ld %lf %lf %lf", &NumPoints,&tx,&ty,&tz) != 4) continue;

      X[Current] = tx;

      Y[Current] = ty;

      Z[Current] = tz;

      if (++Current == 999)

       {

         Vector t1 = X,

                        t2 = Y,

                        t3 = Z;

         X.ReSize(2 * X.Size());

         Y.ReSize(2 * X.Size());

         Z.ReSize(2 * X.Size());

         for (DWORD i = 0; i < Current; i++)

          {

            X[i] = t1[i];

            Y[i] = t2[i];

            Z[i] = t3[i];

          }

       }

      if (Current % 100 == 0)

       printf("Line: %ldr",Current);

    }

   fclose(in1);

   printf("                            r");

   NumPoints = Current;

   Current = 0L;

   while (!feof(in2))

    {

      if (fgets(TextBuffer,1000,in2) == NULL)

       {

         if (feof(in2)) break;

         printf("Unable read file %s",fn2);

         fclose(in2);

         return false;

       }

      if (sscanf(TextBuffer,"%d %d %d %d %d %ld %ld %ld %ld %ld %ld %ld %ld",

          &tmp,&tmp,&tmp,&tmp,&tmp,

          &FE[Current][0],&FE[Current][1],&FE[Current][3],&FE[Current][2],

          &FE[Current][4],&FE[Current][5],&FE[Current][7],&FE[Current][6]) != 13) continue;

      if (++Current == 999)

       {

         Matrix t = FE;

         FE.ReSize(2 * FE.Size1(),10);

         for (DWORD i = 0; i < Current; i++)

          for (DWORD j = 0; j < 10; j++)

           FE[i][j] = t[i][j];

       }

      if (Current % 100 == 0)

       printf("Line: %ldr",Current);}

   NumFE = Current;

   for (DWORD i = 0; i < NumFE; i++)

    for (DWORD j = 0; j < 10; j++)

      FE[i][j]--;

   printf("                            r");

return true;}ПРИЛОЖЕНИЕ 2.

Исходный текст программы, реализующей алгоритм компактного хранения и решения СЛАУ высокого порядка.

#include "matrix.h"

class RVector

{

  private:

   Vector Buffer;

  public:

   RVector(void) {}

  ~RVector() {}

   RVector(DWORD Size) { Buffer.ReSize(Size);  }

   RVector(RVector& right) { Buffer = right.Buffer;  }

   RVector(Vector& right) { Buffer = right;  }

   DWORD Size(void)    { return Buffer.Size(); }

   void  ReSize(DWORD Size) { Buffer.ReSize(Size); }

   double&  operator [] (DWORD i) { return Buffer[i]; }

   RVector& operator = (RVector& right) { Buffer = right.Buffer; return *this; }

   RVector& operator = (Vector& right) { Buffer = right; return *this; }

   void Sub(RVector&);

   void Sub(RVector&,double);

   void Mul(double);

   void Add(RVector&);

   friend double Norm(RVector&,RVector&);

};

class TSMatrix

{

  private:

    Vector   Right;

    Vector*  Array;

    Vector*   Links;

    uint             Dim;

    DWORD            Size;

  public:

   TSMatrix(void) { Size = 0; Dim = 0; Array = NULL; Links = NULL; }

   TSMatrix(Vector*,DWORD,uint);

  ~TSMatrix(void) { if (Array) delete [] Array; }

   Vector& GetRight(void) { return Right; }

   DWORD GetSize(void) { return Size; }

   uint  GetDim(void) { return Dim; }

   Vector& GetVector(DWORD i) { return Array[i]; }

   Vector*  GetLinks(void) { return Links; }

   void  SetLinks(Vector* l) { Links = l; }

   void  Add(Matrix&,Vector&);

   void Add(DWORD I, DWORD L, DWORD J, DWORD K, double v)

   {

     DWORD Row = I,

           Col = L * Links[I].Size() * Dim + Find(I,J) * Dim + K;

     Array[Row][Col] += v;

   }

   void Add(DWORD I, double v)

   {

     Right[I] += v;

   }

   DWORD Find(DWORD,DWORD);

   void  Restore(Matrix&);

   void  Set(DWORD,DWORD,double,bool);

   void  Set(DWORD Index1,DWORD Index2,double value)

   {

     DWORD I   = Index1 / Dim,

           L   = Index1 % Dim,

           J   = Index2 / Dim,

           K   = Index2 % Dim,

           Pos = Find(I,J),

           Row = I,

           Col;

     if (Pos == DWORD(-1)) return;

     Col = L * Links[I].Size() * Dim + Find(I,J) * Dim + K;

     Array[Row][Col] = value;

   }

   bool  Get(DWORD Index1,DWORD Index2,double& value)

   {

     DWORD I   = Index1 / Dim,

           L   = Index1 % Dim,

           J   = Index2 / Dim,

           K   = Index2 % Dim,

           Pos = Find(I,J),

           Row = I,

           Col;

     value = 0;

     if (Pos == DWORD(-1)) return false;

     Col = L * Links[I].Size() * Dim + Find(I,J) * Dim + K;

     value = Array[Row][Col];

     return true;

   }

   void  Mul(RVector&,RVector&);

   double  Mul(DWORD,RVector&);

   void  write(ofstream&);

   void  read(ifstream&);

};

class RMatrix

{

  private:

    Vector Buffer;

    DWORD          size;

  public:

    RMatrix(DWORD sz) { size = sz; Buffer.ReSize(size*(size + 1)*0.5); }

   ~RMatrix() {}

    DWORD Size(void) { return size; }

    double& Get(DWORD i,DWORD j) { return Buffer[(2*size + 1 - i)*0.5*i + j - i]; }

};

//************************

#include "smatrix.h"

double Norm(RVector& Left,RVector&  Right)

{

  double Ret = 0;

  for (DWORD i = 0; i < Left.Size(); i++)

   Ret += Left[i] * Right[i];

  return Ret;

}

void RVector::Sub(RVector& Right)

{

  for (DWORD i = 0; i < Size(); i++)

   (*this)[i] -= Right[i];

}

void RVector::Add(RVector& Right)

{

  for (DWORD i = 0; i < Size(); i++)

   (*this)[i] += Right[i];

}

void RVector::Mul(double koff)

{

  for (DWORD i = 0; i < Size(); i++)

   (*this)[i] *= koff;

}

void RVector::Sub(RVector& Right,double koff)

{

  for (DWORD i = 0; i < Size(); i++)

   (*this)[i] -= Right[i]*koff;

}

TSMatrix::TSMatrix(Vector* links, DWORD size, uint dim)

{

  Dim    = dim;

  Links  = links;

  Size   = size;

  Right.ReSize(Dim * Size);

  Array = new Vector[Size];

  for (DWORD i = 0; i < Size; i++)

   Array[i].ReSize(Links[i].Size() * Dim * Dim);

}

void TSMatrix::Add(Matrix& FEMatr,Vector& FE)

{

  double Res;

  DWORD  RRow;

 

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: