예제 #1
0
Polynomial Legendre(unsigned i)
{
    if(i==0)
        return Polynomial({1.0f});
    else if(i==1)
        return Polynomial({0.0f, 1.0f});
    else
        return (Legendre(i-1)*Polynomial({0.0f, 2.0f*(i-1)+1.0f})-Legendre(i-2)*float(i-1))/float(i);
}
예제 #2
0
    void GLL::LagrangeDerivativeMatrix(basics::Matrix& A, const basics::Vector& grid)
    {
      assert( A.rows() == A.cols() && A.rows() == grid.length());

      int N=grid.length();
      for( int i=0;i<N;++i )
        for( int j=0;j<N;++j ) {
          if( i == j )
            A[j][i] = 0;
          else
            A[j][i] = Legendre(grid[i],N-1)/(Legendre(grid[j],N-1)*(grid[i]-grid[j]));
        }
      A[0][0] = -N*(N-1)/4.f;
      A[N-1][N-1] = N*(N-1)/4.f;
    }
예제 #3
0
파일: exeval.c 프로젝트: oleavitt/gem
void eval_legendre(Expr *expr)
{
	expr->l->l->fn(expr->l->l);
	expr->l->r->fn(expr->l->r);
	expr->r->fn(expr->r);
	expr->v.x = Legendre((int)expr->l->l->v.x, (int)expr->l->r->v.x, expr->r->v.x);
}
예제 #4
0
    void GLL::GaussLobattoLegendreWeights(basics::Vector& weight, const basics::Vector& grid)
    {
      assert( grid.length() == weight.length() );

      int N = grid.length();
      for( int i=0;i<N;++i ) {
        Real L=Legendre(grid[i],N-1);
        weight[i] = 2.f/(((Real)N-1)*N*L*L);
      }
    }
예제 #5
0
    void GLL::GaussLobattoLegendreGrid(basics::Vector& grid)
    {
#define TOLERANCE 1.e-15f

      grid[0] = -1.f;
      grid[grid.length()-1] = 1.f; // Lobatto

      if( grid.length() == 2 )
        return;

      basics::Vector GLgrid("Gauss Legendre Grid",grid.length()-1,false);
      GaussLegendreGrid(GLgrid);

      for( int i=1;i<grid.length()-1;i++ ) {
        grid[i] = (GLgrid[i-1]+GLgrid[i])/2.f;
        Real old = 0.f;
        while( fabs(old-grid[i]) > TOLERANCE ) {
          old = grid[i];
          Real L = Legendre(old,grid.length()-1);
          Real Ld = LegendreDerivative(old,grid.length()-1);
          grid[i] += (1.f-old*old)*Ld/(((Real)grid.length()-1.f)*(Real)grid.length()*L);
        }
      }
    }
예제 #6
0
void ShLegendre::Calc(int n_max, double arg, double arg_2)
{
    
    if (_n != n_max || _arg != arg)
    {
        Legendre.resize((n_max+1)*(n_max+1));
        
        Legendre.setZero();
        
        Legendre(0) = 1; // P_0^0
        
        
        // computes the legendre functions P_n^m(arg) for m=n
        // from P_0^0
        // Zotter Diss page 19
        
        for (int n=1; n <= n_max; n++)
        {
            // P_n^m with m=n //correct!!
            Legendre((n+1)*(n+1)-1) = -(2*n-1) * Legendre(n*n-1) * arg_2;
            
            // P_n^m with m=n-1
            Legendre((n+1)*(n+1)-2) = (2*n-1) * arg * Legendre(n*n-1);
        }
        
        
        // rest P_n^m with 3<=n<=n_max and 0 <= m <= n-2
        for (int n=2; n <= n_max; n++)
        {
            for (int m=0; m <= n-2; m++)
            {
                if (m+2 <= n) {
                    Legendre(n*(n+1)+m) = ((2*n-1)*arg*Legendre((n)*(n-1)+m)-(n+m-1)*Legendre((n-2)*(n-1)+m))/(n-m);
                } else
                {
                    Legendre(n*(n+1)+m) = ((2*n-1)*arg*Legendre((n)*(n-1)+m))/(n-m);
                }
                
            }
        }
        
        // mirror coefficients for m<0
        for (int n=1; n <= n_max; n++)
        {
            int n0 = n*(n+1); // index of m=0 coefficients
            
            for (int m=1; m <= n; m++)
            {
                Legendre(n0-m) = Legendre(n0+m);
            }
        }
        
        // std::cout << "Legendre vector size: " << Legendre.size() << std::endl << "Vector: " << std::endl << Legendre << std::endl;
        _arg = arg;
        _n = n_max;
    }
    
}
예제 #7
0
// {{{ linear_algebra()
void linear_algebra(
   GNFS::Polynomial &polynomial, 
   GNFS::Target &target, 
	FactorBase &fb, 
   Matrix &matrix, 
   const std::vector<int> &av, 
   const std::vector<int> &bv)
{

   NTL::ZZ aZ;
   NTL::ZZ bZ;
   NTL::ZZ pZ;
   NTL::ZZ valZ;
   NTL::ZZ numZ;
   int i;
   int j;
   int k;
   int u = polynomial.d*target.t;


   // Initialize sM
   for(j = 0; j <= matrix.sM.NumCols()-1; j++)
   {
      // Initialize row
      for(k = 0; k < matrix.sM.NumCols()-1; k++)
         matrix.sM[k][j] = 0;
      
      // Set the first column
      aZ = av[j];
      bZ = bv[j];
      valZ = aZ + bZ * polynomial.m;
      if(valZ < 0)
      {
         valZ *= -1;
         matrix.sM[0][j] = 1;
      }

      // Set a RFB row 
      i = 0;
      while(i < target.t && valZ != 1)
      {
         pZ = fb.RFB[i];
         if(valZ % pZ == 0)
         {
            if(matrix.sM[1+i][j]==0) matrix.sM[1+i][j]=1;
            else matrix.sM[1+i][j]=0;
            valZ = valZ / pZ;
         } 
         else i++;
      }

      // Set a AFB row 
      valZ = algebraic_norm(polynomial, av[j], bv[j]);
      if(valZ < 0)
         valZ *= -1;
      
      i = 0;
      while(i<u && valZ!=1)
      {
         pZ = fb.AFB[i];
         if(valZ % pZ == 0)
         {
            numZ = fb.AFBr[i];
            //while((aZ + bZ * numZ) % pZ != 0 && i<target.t) // TODO
            while((aZ + bZ * numZ) % pZ != 0) // TODO
            {
               pZ = fb.AFB[++i];
               numZ = fb.AFBr[i];
            }

            if(matrix.sM[1+target.t+i][j]==0) matrix.sM[1+target.t+i][j]=1;
            else matrix.sM[1+target.t+i][j]=0;

            valZ = valZ / pZ;
         }
         else i++;
         
      }

      // Set a QCB row
      for(i=0; i<target.digits; i++)
      {
         numZ = fb.QCB[i];
         valZ = fb.QCBs[i];
         valZ = aZ + bZ * valZ;
         if(Legendre(valZ, numZ) != 1)
         {
            matrix.sM[1+target.t+u+i][j]=1;
         
         }
      }
   }
   
   std::cout << "\tSize: " << matrix.sM.NumRows() << "x" << matrix.sM.NumCols() << std::endl;

   gaussian_elimination(matrix.sM);
   matrix.sfreeCols = get_freecols(matrix.sM);

}