C1AffineSet<MatrixType,Policies>::C1AffineSet(const VectorType& x, const MatrixType& B, const VectorType& r, ScalarType t) : SetType( x+B*r, VectorType(x.dimension()), MatrixType::Identity(x.dimension()), MatrixType(x.dimension(),x.dimension()), t), C0BaseSet(x, B, r), C1BaseSet(x.dimension()) {}
Pped2Set<MatrixType>::Pped2Set(const VectorType& the_x) : m_x(the_x), m_r(the_x.dimension()), m_r0(the_x.dimension()), m_B(MatrixType::Identity(the_x.dimension())), m_C(MatrixType::Identity(the_x.dimension())) { m_r.clear(); split(m_x,m_r0); }
typename SumLNorm<VectorType, MatrixType>::ScalarType SumLNorm<VectorType, MatrixType>::operator()(const VectorType &x) const { ScalarType s(0.0); for(int i=0; i<x.dimension(); i++) s += capd::abs(x[i]); return s; }
typename EuclLNorm<VectorType, MatrixType>::ScalarType EuclLNorm<VectorType, MatrixType>::operator()(const VectorType &x) const { ScalarType s(0.); for(int i=0;i<x.dimension();++i) s += power(x[i], 2); return sqrt(nonnegativePart(s)); }
typename MatrixType::ScalarType::BoundType OdeNum<MatrixType>::quadEscTime(const VectorType& x,const VectorType& y,int& dir) { VectorType firstCoef=ode.f(x); VectorType remainder1=ode.f(y); VectorType remainder2=ode.df(y)*ode.f(y)/2; TimeDoubleton<Real> the_linEscTime = OdeNum<MatrixType>::linEscTime(x[0],remainder1[0],y[0]); TimeDoubleton<Real> the_quadEscTime = OdeNum<MatrixType>::quadEscTime(x[0],firstCoef[0],remainder2[0],y[0]); Real result = capd::min( capd::max(the_linEscTime.left,the_quadEscTime.left), capd::max(the_linEscTime.right,the_quadEscTime.right) ); dir=0; for(int i=1;i<x.dimension();++i) { TimeDoubleton<Real> the_linEscTime=OdeNum<MatrixType>::linEscTime(x[i],remainder1[i],y[i]); TimeDoubleton<Real> the_quadEscTime=OdeNum<MatrixType>::quadEscTime(x[i],firstCoef[i],remainder2[i],y[i]); Real escTime = capd::min( capd::max(the_linEscTime.left,the_quadEscTime.left), capd::max(the_linEscTime.right,the_quadEscTime.right) ); if( escTime < result ) { result = escTime; dir=i; } } return result; }
typename MaxNorm<VectorType, MatrixType>::ScalarType MaxNorm<VectorType, MatrixType>::operator()(const VectorType &x) const { ScalarType s(0.); for(int i=0;i<x.dimension();i++) { s = capd::max(s, capd::abs(x[i])); } return s; }
std::vector<typename SetType::VectorType> getCorners(const SetType & set) { typedef typename SetType::VectorType VectorType; std::vector<VectorType> cor; VectorType v = set.get_r(); corners(v, set.get_r(), 0, v.dimension(), cor); for(typename std::vector<VectorType>::iterator it = cor.begin(); it != cor.end(); ++it){ *it = set.get_x() + set.get_C() * set.get_r0() + set.get_B() * *it; } return cor; }
VectorType conjVector(const VectorType & v){ VectorType result(v.dimension()); typename VectorType::const_iterator b = v.begin(), e = v.end(); typename VectorType::iterator r = result.begin(); while(b!=e){ *r = conj(*b); ++r; ++b; } return result; }
typename OdeNum<MatrixType>::VectorType OdeNum<MatrixType>::enclosureGuaranteeingBounds( const VectorType &x, int *found ) { ScalarType trial_step = ScalarType(-0.2,1.2)*step; int dim = x.dimension(); VectorType y(dim), z(dim), Small(dim); ScalarType h = ScalarType(0,1)*step; Real multf=1.5; *found=0; int counter=0,limit=10; for(int i=0;i<dim;i++) Small[i] = ScalarType(-1,1) * 1e-15; z = x + trial_step*ode.f(x); z += Small; // to be sure that z has noempty interior while((!(*found)) && (counter<limit)) { counter++; y = x + h*ode.f(z); *found=1; for(int i=0;i<dim;i++) { if(!(y[i].subsetInterior(z[i]))) { *found = 0; z[i] = y[i]; ScalarType s; z[i].split(s); s = multf*s; z[i] += s; } } } if(!(*found)) { //status="enclosureGuaranteeingBounds - loop limit exceeded"; diagBadEnlcosure(x); } return y; }
typename DiffInclusionLN<MapT, DynSysT>::VectorType DiffInclusionLN<MapT, DynSysT>::perturbations(const VectorType& x){ VectorType W_1 = dynamicalSystemEnclosure(x); VectorType W_2 = diffInclusionEnclosure(x); MatrixType J = m_diffIncl.getVectorField()[W_2]; VectorType deltha = m_diffIncl.perturbations(W_2); ScalarType C = right((*m_norm)(deltha)); ScalarType l = right((*m_norm)(J)); ScalarType D = (l.contains(0.0))? C*getStep() : (C*(exp(l*getStep())-1))/l; VectorType result(x.dimension()); for(int i=0; i< result.dimension(); ++i) result[i] = ScalarType(-D.rightBound(), D.rightBound()); return result; }
typename MatrixType::ScalarType::BoundType OdeNum<MatrixType>::linEscTime(const VectorType& x,const VectorType& y,int& dir) { VectorType remainder=ode.f(y); TimeDoubleton<Real> the_linEscTime=OdeNum<MatrixType>::linEscTime(x[0],remainder[0],y[0]); Real result=capd::min(the_linEscTime.left,the_linEscTime.right); dir=0; for(int i=1;i<x.dimension();i++) { the_linEscTime=OdeNum<MatrixType>::linEscTime(x[i],remainder[i],y[i]); Real escTime=capd::min(the_linEscTime.left,the_linEscTime.right); if( escTime < result ) { result = escTime; dir=i; } } return result; }
ResultType matrixByVector(const MatrixType& m,const VectorType& u){ ResultType result(m.numberOfRows(),true); if(m.numberOfColumns()!=u.dimension()) throw std::range_error("operator Matrix*Vector: incompatible dimensions"); typename ResultType::iterator b=result.begin(), e=result.end(); typename MatrixType::const_iterator i = m.begin(); while(b!=e) { typename ResultType::ScalarType x = chomp::TypeTraits<typename ResultType::ScalarType>::zero(); typename VectorType::const_iterator bv=u.begin(), be=u.end(); while(bv!=be) { x += (*bv) * (*i); ++bv; ++i; } *b=x; ++b; } return result; }
void OdeNum<MatrixType>::diagBadEnlcosure(const VectorType &x) const { std::ofstream raport("raport.ecl",std::ios::app); raport << "-------------------------\n"; raport << "x=" << x << "\n"; raport << "step=" << step << "\n"; raport << "f(x)=" << ode.f(x) << "\n"; int dim = x.dimension(); ScalarType trial_step = ScalarType(-0.2,1.2) * step; int diag=0; VectorType max_r = trial_step*ode.f(x); VectorType Ye = x+max_r; raport << "Ye=" << Ye << "\n"; raport << "diam Ye=" ; for(int i=0; i<dim; i++) raport << rightBound(capd::abs(diam(Ye[i]))) << " " ; raport << "\n"; MatrixType dv = ode.df(x+max_r); capd::vectalg::MaxNorm<VectorType,MatrixType> maxN; ScalarType L = maxN(dv); if (!(step*L < 1)) { diag=1; raport << "hL > 1 \n"; } raport << "hL=" << step*L << "\n"; Real *diamvect = new Real[dim]; Real *dfabs = new Real[dim*dim]; if (!diag) { int i; for(i=0;i<dim; i++) diamvect[i] = rightBound(capd::abs(diam(Ye[i]))); for(i=0;i<dim; i++) for(int j=0; j<dim; j++) dfabs[i*dim+j]= rightBound(capd::abs(dv[i][j])); for(i=0;i<dim;i++) { Real t=0; for(int j=0;j<dim;j++) t += dfabs[i*dim+j]*diamvect[j]; t *= 2.5* rightBound(capd::abs(step)); if(t > diamvect[i]) { diag=2; raport << "5/2 h Dfi/Dxj diam(Ye_j)=t" << t << " > diam(Ye_i)= " << diamvect[i] << " ; i=" << i << "\n"; } }// i-loop } // if(!diag) if(!diag) { diag=3; raport << "unknown reason \n" ; } delete [] diamvect; delete [] dfabs; }
C0FlowballSet<MatrixType>::C0FlowballSet(const VectorType& x, const ScalarType& r, const NormType& aNorm, ScalarType t) : C0Set<MatrixType>(intervalBall(x,r),VectorType(x.dimension()),t), m_x(x),m_r(r),m_n(aNorm.clone()) {}