C1AffineSet<MatrixType,Policies>::C1AffineSet(const C0BaseSet & c0part, const C1BaseSet& c1part, ScalarType t)
: SetType(
VectorType(c0part),
VectorType(c0part.dimension()),
MatrixType(c1part),
MatrixType(c0part.dimension(),c0part.dimension()),
t),
C0BaseSet(c0part),
C1BaseSet(c1part)
{}
VectorType
NativeArrayToMappedVector(Datum inDatum, bool inNeedMutableClone) {
typedef typename VectorType::Scalar Scalar;
ArrayType* array = reinterpret_cast<ArrayType*>(
madlib_DatumGetArrayTypeP(inDatum));
size_t arraySize = ARR_NDIM(array) == 1
? ARR_DIMS(array)[0]
: ARR_DIMS(array)[0] * ARR_DIMS(array)[1];
if (!(ARR_NDIM(array) == 1
|| (ARR_NDIM(array) == 2
&& (ARR_DIMS(array)[0] == 1 || ARR_DIMS(array)[1] == 1)))) {
std::stringstream errorMsg;
errorMsg << "Invalid type conversion to matrix. Expected one-"
"dimensional array but got " << ARR_NDIM(array)
<< " dimensions.";
throw std::invalid_argument(errorMsg.str());
}
Scalar* origData = reinterpret_cast<Scalar*>(ARR_DATA_PTR(array));
Scalar* data;
if (inNeedMutableClone) {
data = reinterpret_cast<Scalar*>(
defaultAllocator().allocate<dbal::FunctionContext, dbal::DoNotZero,
dbal::ThrowBadAlloc>(sizeof(Scalar) * arraySize));
std::copy(origData, origData + arraySize, data);
} else {
data = reinterpret_cast<Scalar*>(ARR_DATA_PTR(array));
}
return VectorType(data, arraySize);
}
VectorImport( const Teuchos::RCP<const Teuchos::Comm<int> > & arg_comm ,
const CommMessageType & arg_recv_msg ,
const CommMessageType & arg_send_msg ,
const CommIdentType & arg_send_nodeid ,
const unsigned arg_count_owned ,
const unsigned arg_count_receive )
: recv_msg( arg_recv_msg )
, send_msg( arg_send_msg )
, send_nodeid( arg_send_nodeid )
, send_buffer()
, host_send_buffer()
, host_recv_buffer()
, comm( arg_comm )
, count_owned( arg_count_owned )
, count_receive( arg_count_receive )
{
if ( ! ReceiveInPlace ) {
host_recv_buffer = HostVectorType("recv_buffer",count_receive);
}
unsigned send_count = 0 ;
for ( unsigned i = 0 ; i < send_msg.dimension_0() ; ++i ) { send_count += send_msg(i,1); }
send_buffer = VectorType("send_buffer",send_count);
host_send_buffer = Kokkos::create_mirror_view( send_buffer );
}
VectorType CrossProduct(const VectorType & a, const VectorType & b)
{
// Area of the parallelogram *sic* created by two vectors.
const auto x = (a.Y * b.Z) - (a.Z * b.Y);
const auto y = (a.Z * b.X) - (a.X * b.Z);
const auto z = (a.X * b.Y) - (a.Y * b.X);
return VectorType(x, y, z);
}
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())
{}
void C0FlowballSet<MatrixType>::move(capd::dynsys::DynSys<MatrixType> &dynsys, C0FlowballSet &result) const
{
VectorType s(m_x.dimension());
VectorType vi = VectorType(*this);
result.m_r = m_r*dynsys.Lipschitz(this->getCurrentTime(),vi,*m_n);
VectorType y = dynsys.Phi(this->getCurrentTime(),m_x);
split(y,s);
s += dynsys.Remainder(this->getCurrentTime(),m_x,vi);
result.m_x = y;
result.m_r += (*m_n)(s);
result.setCurrentTime(this->getCurrentTime()+dynsys.getStep());
result.setLastEnclosure(vi);
}
void InclRect2Set<MatrixType>::move(DiffIncl & diffIncl, InclRect2Set<MatrixType>& result) const {
VectorType x = VectorType(*this);
//computation of an unperturbed trajectory
BaseSet::move(diffIncl.getDynamicalSystem(), result);
//computation of the influence of the perturbations
VectorType Deltha = diffIncl.perturbations(x);
// Rearrangements
x = midVector( result.m_x + Deltha);
VectorType dr = result.m_x + Deltha - x;
MatrixType BT = Transpose(result.m_B);
result.m_r = result.m_r + BT * dr;
result.m_x = x;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
VectorType TriangleOps::computeNormal(DREAM3D::SurfaceMesh::Vert_t& n0, DREAM3D::SurfaceMesh::Vert_t& n1, DREAM3D::SurfaceMesh::Vert_t& n2)
{
double vert0[3];
double vert1[3];
double vert2[3];
double u[3];
double w[3];
double normal[3];
vert0[0] = static_cast<float>(n0.pos[0]);
vert0[1] = static_cast<float>(n0.pos[1]);
vert0[2] = static_cast<float>(n0.pos[2]);
vert1[0] = static_cast<float>(n1.pos[0]);
vert1[1] = static_cast<float>(n1.pos[1]);
vert1[2] = static_cast<float>(n1.pos[2]);
vert2[0] = static_cast<float>(n2.pos[0]);
vert2[1] = static_cast<float>(n2.pos[1]);
vert2[2] = static_cast<float>(n2.pos[2]);
//
// Compute the normal
u[0] = vert1[0] - vert0[0];
u[1] = vert1[1] - vert0[1];
u[2] = vert1[2] - vert0[2];
w[0] = vert2[0] - vert0[0];
w[1] = vert2[1] - vert0[1];
w[2] = vert2[2] - vert0[2];
MatrixMath::CrossProduct(u, w, normal);
MatrixMath::Normalize3x1(normal);
return VectorType(normal[0], normal[1], normal[2]);
}
void TSymbolTable::insertBuiltIn(ESymbolLevel level, TOperator op, const char *ext, const TType *rvalue, const char *name,
const TType *ptype1, const TType *ptype2, const TType *ptype3, const TType *ptype4, const TType *ptype5)
{
if (ptype1->getBasicType() == EbtGSampler2D)
{
insertUnmangledBuiltIn(name);
bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtFloat, 4) : rvalue, name, TCache::getType(EbtSampler2D), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISampler2D), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSampler2D), ptype2, ptype3, ptype4, ptype5);
}
else if (ptype1->getBasicType() == EbtGSampler3D)
{
insertUnmangledBuiltIn(name);
bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtFloat, 4) : rvalue, name, TCache::getType(EbtSampler3D), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISampler3D), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSampler3D), ptype2, ptype3, ptype4, ptype5);
}
else if (ptype1->getBasicType() == EbtGSamplerCube)
{
insertUnmangledBuiltIn(name);
bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtFloat, 4) : rvalue, name, TCache::getType(EbtSamplerCube), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISamplerCube), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSamplerCube), ptype2, ptype3, ptype4, ptype5);
}
else if (ptype1->getBasicType() == EbtGSampler2DArray)
{
insertUnmangledBuiltIn(name);
bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtFloat, 4) : rvalue, name, TCache::getType(EbtSampler2DArray), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISampler2DArray), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSampler2DArray), ptype2, ptype3, ptype4, ptype5);
}
else if (IsGenType(rvalue) || IsGenType(ptype1) || IsGenType(ptype2) || IsGenType(ptype3))
{
ASSERT(!ptype4 && !ptype5);
insertUnmangledBuiltIn(name);
insertBuiltIn(level, op, ext, SpecificType(rvalue, 1), name, SpecificType(ptype1, 1), SpecificType(ptype2, 1), SpecificType(ptype3, 1));
insertBuiltIn(level, op, ext, SpecificType(rvalue, 2), name, SpecificType(ptype1, 2), SpecificType(ptype2, 2), SpecificType(ptype3, 2));
insertBuiltIn(level, op, ext, SpecificType(rvalue, 3), name, SpecificType(ptype1, 3), SpecificType(ptype2, 3), SpecificType(ptype3, 3));
insertBuiltIn(level, op, ext, SpecificType(rvalue, 4), name, SpecificType(ptype1, 4), SpecificType(ptype2, 4), SpecificType(ptype3, 4));
}
else if (IsVecType(rvalue) || IsVecType(ptype1) || IsVecType(ptype2) || IsVecType(ptype3))
{
ASSERT(!ptype4 && !ptype5);
insertUnmangledBuiltIn(name);
insertBuiltIn(level, op, ext, VectorType(rvalue, 2), name, VectorType(ptype1, 2), VectorType(ptype2, 2), VectorType(ptype3, 2));
insertBuiltIn(level, op, ext, VectorType(rvalue, 3), name, VectorType(ptype1, 3), VectorType(ptype2, 3), VectorType(ptype3, 3));
insertBuiltIn(level, op, ext, VectorType(rvalue, 4), name, VectorType(ptype1, 4), VectorType(ptype2, 4), VectorType(ptype3, 4));
}
else
{
TFunction *function = new TFunction(NewPoolTString(name), rvalue, op, ext);
function->addParameter(TConstParameter(ptype1));
if (ptype2)
{
function->addParameter(TConstParameter(ptype2));
}
if (ptype3)
{
function->addParameter(TConstParameter(ptype3));
}
if (ptype4)
{
function->addParameter(TConstParameter(ptype4));
}
if (ptype5)
{
function->addParameter(TConstParameter(ptype5));
}
ASSERT(hasUnmangledBuiltIn(name));
insert(level, function);
}
}
void TSymbolTable::insertBuiltIn(ESymbolLevel level, TOperator op, const char *ext, TType *rvalue, const char *name,
TType *ptype1, TType *ptype2, TType *ptype3, TType *ptype4, TType *ptype5)
{
if (ptype1->getBasicType() == EbtGSampler2D)
{
bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2D), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2D), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2D), ptype2, ptype3, ptype4, ptype5);
}
else if (ptype1->getBasicType() == EbtGSampler3D)
{
bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler3D), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler3D), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler3D), ptype2, ptype3, ptype4, ptype5);
}
else if (ptype1->getBasicType() == EbtGSamplerCube)
{
bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSamplerCube), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISamplerCube), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSamplerCube), ptype2, ptype3, ptype4, ptype5);
}
else if (ptype1->getBasicType() == EbtGSampler2DArray)
{
bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2DArray), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2DArray), ptype2, ptype3, ptype4, ptype5);
insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2DArray), ptype2, ptype3, ptype4, ptype5);
}
else if (IsGenType(rvalue) || IsGenType(ptype1) || IsGenType(ptype2) || IsGenType(ptype3))
{
ASSERT(!ptype4 && !ptype5);
insertBuiltIn(level, op, ext, SpecificType(rvalue, 1), name, SpecificType(ptype1, 1), SpecificType(ptype2, 1), SpecificType(ptype3, 1));
insertBuiltIn(level, op, ext, SpecificType(rvalue, 2), name, SpecificType(ptype1, 2), SpecificType(ptype2, 2), SpecificType(ptype3, 2));
insertBuiltIn(level, op, ext, SpecificType(rvalue, 3), name, SpecificType(ptype1, 3), SpecificType(ptype2, 3), SpecificType(ptype3, 3));
insertBuiltIn(level, op, ext, SpecificType(rvalue, 4), name, SpecificType(ptype1, 4), SpecificType(ptype2, 4), SpecificType(ptype3, 4));
}
else if (IsVecType(rvalue) || IsVecType(ptype1) || IsVecType(ptype2) || IsVecType(ptype3))
{
ASSERT(!ptype4 && !ptype5);
insertBuiltIn(level, op, ext, VectorType(rvalue, 2), name, VectorType(ptype1, 2), VectorType(ptype2, 2), VectorType(ptype3, 2));
insertBuiltIn(level, op, ext, VectorType(rvalue, 3), name, VectorType(ptype1, 3), VectorType(ptype2, 3), VectorType(ptype3, 3));
insertBuiltIn(level, op, ext, VectorType(rvalue, 4), name, VectorType(ptype1, 4), VectorType(ptype2, 4), VectorType(ptype3, 4));
}
else
{
TFunction *function = new TFunction(NewPoolTString(name), *rvalue, op, ext);
TParameter param1 = {0, ptype1};
function->addParameter(param1);
if (ptype2)
{
TParameter param2 = {0, ptype2};
function->addParameter(param2);
}
if (ptype3)
{
TParameter param3 = {0, ptype3};
function->addParameter(param3);
}
if (ptype4)
{
TParameter param4 = {0, ptype4};
function->addParameter(param4);
}
if (ptype5)
{
TParameter param5 = {0, ptype5};
function->addParameter(param5);
}
insert(level, function);
}
}
typename GaussianProcess<TScalarType>::MatrixType GaussianProcess<TScalarType>::InvertKernelMatrix(const typename GaussianProcess<TScalarType>::MatrixType &K,
typename GaussianProcess<TScalarType>::InversionMethod inv_method = GaussianProcess<TScalarType>::FullPivotLU,
bool stable) const{
// compute core matrix
if(debug){
std::cout << "GaussianProcess::InvertKernelMatrix: inverting kernel matrix... ";
std::cout.flush();
}
typename GaussianProcess<TScalarType>::MatrixType core;
switch(inv_method){
// standard method: fast but not that accurate
// Uses the LU decomposition with full pivoting for the inversion
case FullPivotLU:{
if(debug) std::cout << " (inversion method: FullPivotLU) " << std::flush;
try{
if(stable){
core = K.inverse();
}
else{
if(debug) std::cout << " (using lapack) " << std::flush;
core = lapack::lu_invert<TScalarType>(K);
}
}
catch(lapack::LAPACKException& e){
core = K.inverse();
}
}
break;
// very accurate and very slow method, use it for small problems
// Uses the two-sided Jacobi SVD decomposition
case JacobiSVD:{
if(debug) std::cout << " (inversion method: JacobiSVD) " << std::flush;
Eigen::JacobiSVD<MatrixType> jacobisvd(K, Eigen::ComputeThinU | Eigen::ComputeThinV);
if((jacobisvd.singularValues().real().array() < 0).any() && debug){
std::cout << "GaussianProcess::InvertKernelMatrix: warning: there are negative eigenvalues.";
std::cout.flush();
}
core = jacobisvd.matrixV() * VectorType(1/jacobisvd.singularValues().array()).asDiagonal() * jacobisvd.matrixU().transpose();
}
break;
// accurate method and faster than Jacobi SVD.
// Uses the bidiagonal divide and conquer SVD
case BDCSVD:{
if(debug) std::cout << " (inversion method: BDCSVD) " << std::flush;
#ifdef EIGEN_BDCSVD_H
Eigen::BDCSVD<MatrixType> bdcsvd(K, Eigen::ComputeThinU | Eigen::ComputeThinV);
if((bdcsvd.singularValues().real().array() < 0).any() && debug){
std::cout << "GaussianProcess::InvertKernelMatrix: warning: there are negative eigenvalues.";
std::cout.flush();
}
core = bdcsvd.matrixV() * VectorType(1/bdcsvd.singularValues().array()).asDiagonal() * bdcsvd.matrixU().transpose();
#else
// this is checked, since BDCSVD is currently not in the newest release
throw std::string("GaussianProcess::InvertKernelMatrix: BDCSVD is not supported by the provided Eigen library.");
#endif
}
break;
// faster than the SVD method but less stable
// computes the eigenvalues/eigenvectors of selfadjoint matrices
case SelfAdjointEigenSolver:{
if(debug) std::cout << " (inversion method: SelfAdjointEigenSolver) " << std::flush;
try{
core = lapack::chol_invert<TScalarType>(K);
}
catch(lapack::LAPACKException& e){
Eigen::SelfAdjointEigenSolver<MatrixType> es;
es.compute(K);
VectorType eigenValues = es.eigenvalues().reverse();
MatrixType eigenVectors = es.eigenvectors().rowwise().reverse();
if((eigenValues.real().array() < 0).any() && debug){
std::cout << "GaussianProcess::InvertKernelMatrix: warning: there are negative eigenvalues.";
std::cout.flush();
}
core = eigenVectors * VectorType(1/eigenValues.array()).asDiagonal() * eigenVectors.transpose();
}
}
break;
}
if(debug) std::cout << "[done]" << std::endl;
return core;
}
void C1AffineSet<MatrixType, Policies>::move(DynSysType & dynsys, C1AffineSet& result) const
{
// important: here we assume that m_r contains zero
// this is assured by each constructor and each step of this algorithm
const size_type dim = m_x.dimension();
VectorType y(dim), rem(dim), enc(dim);
MatrixType jacPhi(dim,dim), jacEnc(dim,dim), jacRem(dim,dim);
MatrixType B(dim,dim), Q(dim,dim);
VectorType xx = VectorType(*this);
// the following function can throw an exception leaving output parameters in an inconsistent state
// do not overwrite parameters of the set until we are sure that they are computed correctly
dynsys.encloseC1Map(this->getCurrentTime(),
this->m_x, xx, // input parameters
y, rem, enc, // C^0 output
jacPhi, jacRem, jacEnc // C^1 output
);
result.m_x = y + rem;
B = result.m_B = jacPhi * m_B;
// ---------- C^0 - part -----------------
// here we compute enclosure of the image after one iteration of the map/flow
result.m_currentSet = result.m_x + result.m_B*this->m_r;
// here we compute representation for the new set
// xx is unnecessary now
split(result.m_x, xx);
// we assume that Policies provides algorithms for computation
// of B, its inverse invB and updates
this->Policies::computeBinvB(result.m_B,result.m_invB,this->m_r);
// eventually we compute new representation of r
result.m_r = (result.m_invB * B) * m_r + result.m_invB * xx;
// ---------- C^1 - part -----------------
MatrixType J = jacPhi + jacRem;
result.m_D = J*this->m_D;
B = result.m_Bjac = J*this->m_Bjac;
// here we compute enclosure of the image after one iteration of the map/flow
result.m_currentMatrix = J*this->m_currentMatrix;
intersection(result.m_currentMatrix,result.m_D + result.m_Bjac*m_R,result.m_currentMatrix);
// here we compute representation for the new set
// jacRem is unnecessary now
split(result.m_D, jacRem);
// we assume that Policies provides algorithms for computation
// of B, its inverse invB and updates
this->Policies::computeBinvB(result.m_Bjac,result.m_invBjac,this->m_R);
// eventually we compute new representation of r
result.m_R = (result.m_invBjac * B) * m_R + result.m_invBjac * jacRem;
result.setCurrentTime(this->getCurrentTime()+dynsys.getStep());
result.setLastEnclosure(enc);
result.setLastMatrixEnclosure(jacEnc);
}
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())
{}
// CRTP
VectorType difference(const MyType& other) const
{
return VectorType(elements[0] - other.x(), elements[1] - other.y());
}
VectorType Normalize(const VectorType & v, const NumberType length)
{
return VectorType(v.X / length, v.Y / length, v.Z / length);
}
VectorType Normalize(const VectorType & v)
{
const auto vLength = Length(v);
return VectorType(v.X / vLength, v.Y / vLength, v.Z / vLength);
}
