Changeset dac8deb in tol for tol_pkg


Ignore:
Timestamp:
Dec 15, 2009, 5:39:55 PM (17 years ago)
Author:
Víctor de Buen <vdebuen@…>
Branches:
1941-docker-image-to-test, devel, master
Children:
8fd1737
Parents:
8642d7e
Message:

Enabling cache for integration methods

git-svn-id: ​https://www.tol-project.org/svn/tolp/trunk@1813 be4846ae-f051-483a-831f-b64e7d08527f

Location:
tol_pkg/FunRn2R
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • tol_pkg/FunRn2R/BaseC2.Cache.tol

    r8642d7e rdac8deb  
    1717  Set _.partial.derivative.1 = Copy(Empty);
    1818  Set _.partial.derivative.2 = Copy(Empty);
     19  Set _.partial.integrate.1 = Copy(Empty);
    1920
    2021  //Returns the cached value of the k-th basic function for an
    … …  
    3738    Real j_ = Min(i,j);
    3839    SubCol(_.partial.derivative.2[i_][j_],[[k]])
     40  };
     41  //Returns the cached value of the first partial integration of k-th basic
     42  //function for an  array of points given as the rows of a matrix
     43  VMatrix partial.integrate.1.v(Real k, VMatrix X, Real i)
     44  {
     45    SubCol(_.partial.integrate.1[i],[[k]])
    3946  };
    4047
    … …  
    6269  };
    6370
     71  //Evaluates the first partial integration of all basic functions, one in
     72  //each returned column, for an  array of points given as the rows of a
     73  //matrix
     74  VMatrix partial.integrate.1.m(VMatrix X, Real i)
     75  {
     76    _.partial.integrate.1[i]
     77  };
    6478  //Some bases are more efficient using cache
    65   Real _build.cache(VMatrix X, Real order)
     79  Real _build.cache(VMatrix X, Real deriv.order, Real integ.order)
    6680  {
    67     VMatrix If(order>=0, { _.function.r :=
    68       _build.function.m(X)
    69     });
    70     Set If(order>=1, { _.partial.derivative.1 :=
     81    VMatrix _.function := _build.function.m(X);
     82    Set If(deriv.order>=1, { _.partial.derivative.1 :=
    7183      For(1, _.n, VMatrix(Real i)
    7284      { _build.partial.derivative.1.m(X,i) })
    7385    });
    74     Set If(order>=2, { _.partial.derivative.2 :=
     86    Set If(deriv.order>=2, { _.partial.derivative.2 :=
    7587      For(1, _.n, Set(Real i)
    7688      {
    … …  
    8193      })
    8294    });
     95    Set If(integ.order>=1, { _.partial.integrate.1 :=
     96      For(1, _.n, VMatrix(Real i)
     97      { _build.partial.integrate.1.m(X,i) })
     98    });
    8399    True
    84100  }

  • tol_pkg/FunRn2R/BaseC2.Eval.tol

    r8642d7e rdac8deb  
    3737  Real upgrade.cache(VMatrix X)
    3838  {
    39     _.base::upgrade.cache(X,0)
     39    _.base::upgrade.cache(X,0,0)
    4040  }
    4141};
    … …  
    6262  Real upgrade.cache(VMatrix X)
    6363  {
    64     _.base::upgrade.cache(X,1)
     64    _.base::upgrade.cache(X,1,0)
    6565  }
    6666};
    … …  
    8989  Real upgrade.cache(VMatrix X)
    9090  {
    91     _.base::upgrade.cache(X,1)
     91    _.base::upgrade.cache(X,2,0)
    9292  }
    9393};
    … …  
    111111  {
    112112    _.base::partial.1ntegrate.1.m(X, _.s)
     113  };
     114  Real upgrade.cache(VMatrix X)
     115  {
     116    _.base::upgrade.cache(X,0,1)
    113117  }
    114118};

  • tol_pkg/FunRn2R/BaseC2.LinComb.tol

    r8642d7e rdac8deb  
    1616  VMatrix _.V;
    1717  VMatrix _.Vi;
     18    Set _.aux = Copy(Empty);
    1819
    1920  ////////////////////////////////////////////////////////////////////////////
    2021  Static Text _.autodoc.member.New = "Creates an instance B2 of "
    2122  "@BaseC2.LinComb as B2 = B1*V";
    22   Static @BaseC2.LinComb New(@BaseC2 B1, VMatrix V, VMatrix Vi)
     23  Static @BaseC2.LinComb New(@BaseC2 base, VMatrix V, VMatrix Vi)
    2324  ////////////////////////////////////////////////////////////////////////////
    2425  {
    25     Real n = B1::_.n;
    26    
     26    Real n = base::_.n;
    2727    @BaseC2.LinComb aux = [[
    28       Real _.n = B1::_.n;
     28      Real _.n = base::_.n;
    2929      Real _.K = VColumns(V);
    3030      @BaseC2 _.base = base;
    … …  
    7979  ////////////////////////////////////////////////////////////////////////////
    8080  {
     81    Set aux = [[
    8182    Set range.K = Range(1,K,1);
     83    Real n = base::_.n;
    8284    Real K1 = base::_.K;
    8385
    84     VMatrix u = Rand(K1*10, K1, -1, 1);
    85 
     86    VMatrix u = Gaussian(K1, n, 0, 1);
     87  //VMatrix u = Eye(K1,n);
     88  //WriteLn("TRACE [@BaseC2.LinComb Compact.K] u:"<<u);
     89    Real base::upgrade.cache(u,0,0);
    8690    VMatrix Pu = Group("ConcatColumns", For(1, K1, VMatrix(Real k)
    8791    {
    8892      base::function.v(k,u)
    8993    }));
    90 
     94  //WriteLn("TRACE [@BaseC2.LinComb Compact.K] Pu:"<<Pu);
    9195    Set Pu.svd = SVD(VMat2Mat(Pu));
    9296
    … …  
    96100    VMatrix Di = Eye(K,K,0,RPow(Mat2VMat(SubRow(Pu.eigenvalue,range.K)),-1));
    97101    VMatrix W = V*Di;
    98     VMatrix Wi = D*Tra(V);
    99     New(base, W, Wi)
     102    VMatrix Wi = D*Tra(V) ]];
     103    @BaseC2.LinComb new = New(base, W, Wi);
     104    Set new::_.aux := aux;
     105    new
    100106  };
    101107
    102108  ////////////////////////////////////////////////////////////////////////////
    103   Real _build.cache(VMatrix X, Real order)
     109  Real _build.cache(VMatrix X, Real deriv.order, Real integ.order)
    104110  ////////////////////////////////////////////////////////////////////////////
    105111  {
    106     Real _.base::upgrade.cache(X,order);
    107     VMatrix If(order>=0, { _.function :=
    108       _.base::function.m(X)*_.V
    109     });
    110     Set If(order>=1, { _.partial.derivative.1 :=
     112    Real _.base::upgrade.cache(X,deriv.order,integ.order);
     113    VMatrix _.function := _.base::function.m(X)*_.V;
     114    Set If(deriv.order>=1, { _.partial.derivative.1 :=
    111115      For(1, _.n, VMatrix(Real i)
    112116      {
    … …  
    114118      })
    115119    });
    116     Set If(order>=2, { _.partial.derivative.2 :=
     120    Set If(deriv.order>=2, { _.partial.derivative.2 :=
    117121      For(1, _.n, Set(Real i)
    118122      {
    … …  
    123127      })
    124128    });
     129    Set If(integ.order>=1, { _.partial.integrate.1 :=
     130      For(1, _.n, VMatrix(Real i)
     131      {
     132        _.base::partial.integrate.1.m(X,i)*_.V
     133      })
     134    });
    125135    True
    126136  }

  • tol_pkg/FunRn2R/BaseC2.Monomial.tol

    r8642d7e rdac8deb  
    99  "functions R^n -> R . Linear independence is ensured since distinct "
    1010  "monomials are allways independent\n";
    11 Class @BaseC2.Monomial : @BaseC2
     11Class @BaseC2.Monomial :  @BaseC2.Cache
    1212//////////////////////////////////////////////////////////////////////////////
    1313{
    … …  
    6565  ////////////////////////////////////////////////////////////////////////////
    6666  {
    67   //WriteLn("TRACE @BaseC2.Monomial::_build.function.2.v");
     67  //WriteLn("TRACE @BaseC2.Monomial::_build.function.v");
    6868    BinGroup("$*", For(1,_.n, VMatrix(Real i)
    6969    {
    70       RPow(SubCol(X,[[i]]),_.degComb[k][i])
     70      Real d = _.degComb[k][i];
     71      If(d==0, Rand(VRows(X),1,1,1),
     72      {
     73      //WriteLn("  _.degComb["<<k+"]["<<i+"]="<<_.degComb[k][i]);
     74        RPow(SubCol(X,[[i]]),_.degComb[k][i])
     75      })
    7176    }))
    7277  };

  • tol_pkg/FunRn2R/BaseC2.tol

    r8642d7e rdac8deb  
    101101  };
    102102  //Some bases are more efficient using cache
    103   Real _build.cache(VMatrix X, Real order) { False };
     103  Real _build.cache(VMatrix X, Real deriv.order, Real integ.order) { False };
    104104
    105105  ////////////////////////////////////////////////////////////////////////////
    … …  
    169169  };
    170170  //Some bases are more efficient using cache
    171   Real upgrade.cache(VMatrix X, Real order)
    172   { _build.cache(X,order) }
     171  Real upgrade.cache(VMatrix X, Real deriv.order, Real integ.order)
     172  { _build.cache(X, deriv.order, integ.order) }
    173173};

  • tol_pkg/FunRn2R/FunC2.tol

    r8642d7e rdac8deb  
    7777  ////////////////////////////////////////////////////////////////////////////
    7878  {
     79    Real _.base::upgrade.cache(X,0,0);
    7980    _.base::function.m(X)*_.linComb
    8081  };
    … …  
    8384  ////////////////////////////////////////////////////////////////////////////
    8485  {
     86    Real _.base::upgrade.cache(X,1,0);
    8587    _.base::partial.derivative.1.m(X,i)*_.linComb
    8688  };
    … …  
    8991  ////////////////////////////////////////////////////////////////////////////
    9092  {
     93    Real _.base::upgrade.cache(X,2,0);
    9194    _.base::partial.derivative.2.m(X,i,j)*_.linComb
     95  };
     96  ////////////////////////////////////////////////////////////////////////////
     97  VMatrix eval.partial.integrate.1.v(VMatrix X, Real i)
     98  ////////////////////////////////////////////////////////////////////////////
     99  {
     100    Real _.base::upgrade.cache(X,1,0);
     101    _.base::partial.integrate.1.m(X,i)*_.linComb
    92102  }
     103
    93104};
    94105

  • tol_pkg/FunRn2R/test/test_0001/test.tol

    r8642d7e rdac8deb  
    4848FunRn2R::@FunC2 f2 = FunRn2R::@FunC2.InBaseC2::New(B2, u2);
    4949
    50 Real B2::upgrade.cache(X,0);
     50Real B2::upgrade.cache(X,0,0);
    5151
    5252VMatrix F2 = f2::eval.function.v(X);
Note: See TracChangeset for help on using the changeset viewer.