template <> void LapHessenberg(
MatrixView<double> A, VectorView<double> Ubeta)
{
TMVAssert(A.iscm());
TMVAssert(A.colsize() == A.rowsize());
TMVAssert(Ubeta.size() == A.rowsize()-1);
TMVAssert(A.ct()==NonConj);
int n = A.rowsize();
int ilo = 1;
int ihi = n;
int lda = A.stepj();
int Lap_info=0;
#ifndef LAPNOWORK
int lwork = n*LAP_BLOCKSIZE;
double* work = LAP_DWork(lwork);
#endif
LAPNAME(dgehrd) (
LAPCM LAPV(n),LAPV(ilo),LAPV(ihi),
LAPP(A.ptr()),LAPV(lda),LAPP(Ubeta.ptr())
LAPWK(work) LAPVWK(lwork) LAPINFO);
#ifdef LAPNOWORK
LAP_Results(Lap_info,"dgehrd");
#else
LAP_Results(Lap_info,int(work[0]),m,n,lwork,"dgehrd");
#endif
}
template <> void LapHessenberg(
MatrixView<std::complex<float> > A,
VectorView<std::complex<float> > Ubeta)
{
TMVAssert(A.iscm());
TMVAssert(A.colsize() >= A.rowsize());
TMVAssert(Ubeta.size() == A.rowsize());
TMVAssert(A.ct()==NonConj);
int n = A.rowsize();
int ilo = 1;
int ihi = n;
int lda = A.stepj();
int Lap_info=0;
#ifndef LAPNOWORK
int lwork = n*LAP_BLOCKSIZE;
std::complex<float>* work = LAP_CWork(lwork);
#endif
LAPNAME(cgehrd) (
LAPCM LAPV(n),LAPV(ilo),LAPV(ihi),
LAPP(A.ptr()),LAPV(lda),LAPP(Ubeta.ptr())
LAPWK(work) LAPVWK(lwork) LAPINFO);
Ubeta.ConjugateSelf();
#ifdef LAPNOWORK
LAP_Results(Lap_info,"cgehrd");
#else
LAP_Results(Lap_info,int(REAL(work[0])),m,n,lwork,"cgehrd");
#endif
}
static void NonBlockHessenberg(
MatrixView<T> A, VectorView<T> Ubeta)
{
#ifdef XDEBUG
cout<<"Start NonBlock Hessenberg Reduction: A = "<<A<<endl;
Matrix<T> A0(A);
#endif
// Decompose A into U H Ut
// H is a Hessenberg Matrix
// U is a Unitary Matrix
// On output, H is stored in the upper-Hessenberg part of A
// U is stored in compact form in the rest of A along with
// the vector Ubeta.
const ptrdiff_t N = A.rowsize();
TMVAssert(A.colsize() == A.rowsize());
TMVAssert(N > 0);
TMVAssert(Ubeta.size() == N-1);
TMVAssert(A.iscm() || A.isrm());
TMVAssert(!Ubeta.isconj());
TMVAssert(Ubeta.step()==1);
// We use Householder reflections to reduce A to the Hessenberg form:
T* Uj = Ubeta.ptr();
T det = 0; // Ignore Householder det calculations
for(ptrdiff_t j=0;j<N-1;++j,++Uj) {
#ifdef TMVFLDEBUG
TMVAssert(Uj >= Ubeta._first);
TMVAssert(Uj < Ubeta._last);
#endif
*Uj = Householder_Reflect(A.subMatrix(j+1,N,j,N),det);
if (*Uj != T(0))
Householder_LMult(A.col(j+2,N),*Uj,A.subMatrix(0,N,j+1,N).adjoint());
}
#ifdef XDEBUG
Matrix<T> U(N,N,T(0));
U.subMatrix(1,N,1,N) = A.subMatrix(1,N,0,N-1);
U.upperTri().setZero();
Vector<T> Ubeta2(N);
Ubeta2.subVector(1,N) = Ubeta;
Ubeta2(0) = T(0);
GetQFromQR(U.view(),Ubeta2);
Matrix<T> H = A;
if (N>2) LowerTriMatrixViewOf(H).offDiag(2).setZero();
Matrix<T> AA = U*H*U.adjoint();
if (Norm(A0-AA) > 0.001*Norm(A0)) {
cerr<<"NonBlock Hessenberg: A = "<<Type(A)<<" "<<A0<<endl;
cerr<<"A = "<<A<<endl;
cerr<<"Ubeta = "<<Ubeta<<endl;
cerr<<"U = "<<U<<endl;
cerr<<"H = "<<H<<endl;
cerr<<"UHUt = "<<AA<<endl;
abort();
}
#endif
}
void StateModel::simulate_initial_state(VectorView eta)const{
if(eta.size() != state_dimension()){
std::ostringstream err;
err << "output vector 'eta' has length " << eta.size()
<< " in StateModel::simulate_initial_state. Expected length "
<< state_dimension();
report_error(err.str());
}
eta = rmvn(initial_state_mean(), initial_state_variance());
}
inline ::Eigen::Map<const ::Eigen::VectorXd, ::Eigen::Unaligned,
::Eigen::InnerStride<::Eigen::Dynamic>>
EigenMap(const VectorView &view) {
return ::Eigen::Map<const ::Eigen::VectorXd,
::Eigen::Unaligned,
::Eigen::InnerStride<::Eigen::Dynamic>>(
view.data(),
view.size(),
::Eigen::InnerStride<::Eigen::Dynamic>(view.stride()));
}
inline
void invnorm2( const VectorView & x ,
const ValueView & r ,
const ValueView & r_inv )
{
Kokkos::parallel_reduce( x.dimension_0() , InvNorm2< VectorView , ValueView >( x , r , r_inv ) );
}
inline
void dot_neg( const VectorView & x ,
const VectorView & y ,
const ValueView & r ,
const ValueView & r_neg )
{
Kokkos::parallel_reduce( x.dimension_0() , DotM< VectorView , ValueView >( x , y , r , r_neg ) );
}
void VectorView::set_to_product(const MatrixView& m, const VectorView& v,
const bool transpose)
{
CBLAS_TRANSPOSE tr;
if (transpose){
tr = CblasTrans;
assert(m.cols() == length());
assert(m.rows() == v.length());
} else {
tr = CblasNoTrans;
assert(m.cols() == v.length());
assert(m.rows() == length());
}
cblas_dgemv(CblasColMajor, tr, m.rows(), m.cols(), 1.0, m.data(),
m.stride(), v.data(), 1, 0.0, data_, 1);
}
double ZGS::increment_log_prior_gradient(const ConstVectorView ¶meters,
VectorView gradient) const {
if (parameters.size() != 1 || gradient.size() != 1) {
report_error(
"Wrong size arguments passed to "
"ZeroMeanGaussianConjSampler::increment_log_prior_gradient.");
}
return log_prior(parameters[0], &gradient[0], nullptr);
}
static inline void Hessenberg(
MatrixView<T> A, VectorView<T> Ubeta)
{
TMVAssert(A.colsize() == A.rowsize());
TMVAssert(Ubeta.size() == A.rowsize()-1);
TMVAssert(A.isrm() || A.iscm());
TMVAssert(A.ct()==NonConj);
TMVAssert(Ubeta.step() == 1);
if (A.rowsize() > 0) {
#ifdef LAP
if (A.iscm())
LapHessenberg(A,Ubeta);
else
#endif
NonLapHessenberg(A,Ubeta);
}
}
double compute_allele_freq(const VectorView snp_genotypes)
{
double macount = 0;
size_t ngenos = 0;
for (size_t i = 0; i < snp_genotypes.length(); ++i){
if (snp_genotypes(i) >= 0){
macount += snp_genotypes(i);
++ngenos;
}
}
return macount / (2.0 * ngenos);
}
void LMAT::Tmult(VectorView lhs, const ConstVectorView &rhs)const {
if(lhs.size()!=3) {
report_error("lhs is the wrong size in LMAT::Tmult");
}
if(rhs.size()!=3) {
report_error("rhs is the wrong size in LMAT::Tmult");
}
lhs[0] = rhs[0];
double phi = phi_->value();
lhs[1] = rhs[0] + phi * rhs[1];
lhs[2] = (1-phi) * rhs[1] + rhs[2];
}
// TODO(stevescott): test
void ASSR::simulate_initial_state(VectorView state0)const {
// First, simulate the initial state of the client state vector.
VectorView client_state(state0, 0, state0.size()-2);
StateSpaceModelBase::simulate_initial_state(client_state);
// Next simulate the initial value of the first latent weekly
// observation.
double mu = StateSpaceModelBase::observation_matrix(0).dot(client_state);
state0[state_dimension() - 2] = rnorm(mu, regression_->sigma());
// Finally, the initial state of the cumulator variable is zero.
state0[state_dimension() - 1] = 0;
}
void MultMV(
const T alpha, const GenDiagMatrix<Ta>& A, const GenVector<Tx>& x,
VectorView<T> y)
// y (+)= alpha * A * x
// yi (+)= alpha * Ai * xi
{
TMVAssert(A.size() == x.size());
TMVAssert(A.size() == y.size());
#ifdef XDEBUG
//cout<<"MultMV: \n";
//cout<<"alpha = "<<alpha<<endl;
//cout<<"A = "<<TMV_Text(A)<<" "<<A<<endl;
//cout<<"x = "<<TMV_Text(x)<<" "<<x<<endl;
//cout<<"y = "<<TMV_Text(y)<<" "<<y<<endl;
Vector<T> y0 = y;
Vector<Tx> x0 = x;
Matrix<Ta> A0 = A;
Vector<T> y2 = alpha*A0*x0;
if (add) y2 += y0;
#endif
ElemMultVV<add>(alpha,A.diag(),x,y);
#ifdef XDEBUG
if (!(Norm(y-y2) <=
0.001*(TMV_ABS(alpha)*Norm(A0)*Norm(x0)+
(add?Norm(y0):TMV_RealType(T)(0))))) {
cerr<<"MultMV: alpha = "<<alpha<<endl;
cerr<<"add = "<<add<<endl;
cerr<<"A = "<<TMV_Text(A)<<" step "<<A.diag().step()<<" "<<A0<<endl;
cerr<<"x = "<<TMV_Text(x)<<" step "<<x.step()<<" "<<x0<<endl;
cerr<<"y = "<<TMV_Text(y)<<" step "<<y.step()<<" "<<y0<<endl;
cerr<<"-> y = "<<y<<endl;
cerr<<"y2 = "<<y2<<endl;
abort();
}
#endif
}
static inline void NonLapHessenberg(
MatrixView<T> A, VectorView<T> Ubeta)
{
TMVAssert(A.rowsize() == A.colsize());
TMVAssert(A.rowsize() > 0);
TMVAssert(Ubeta.size() == A.rowsize()-1);
#if 0
if (A.rowsize() > HESS_BLOCKSIZE)
BlockHessenberg(A,Ubeta,Vbeta,D,E,det);
else
#endif
NonBlockHessenberg(A,Ubeta);
}
/****************************************************************************
*
* StreamInfo1::Configure( )
*
* Set configuration of stream information.
*
****************************************************************************/
bool StreamInfo1::Configure
(
VectorView& sieves, // vector of sieve sizes
std::vector<PMineralInfo1>& minerals, // collection of minerals
double liquidSG // density of liquid phase
)
{
// ensure reasonable number of sieves
if( sieves.size() <= 2 )
goto initFailed;
// ensure reasonable number of minerals
if( minerals.size() < 1 )
goto initFailed;
// set implementation to supplied size distribution
nSize_ = sieves.size();
sizes_.resize( nSize_ );
sizes_ = sieves;
// set implementation to supplied mineral collection
nType_ = static_cast<long>( minerals.size() );
minerals_.clear( );
minerals_.assign( minerals.begin(), minerals.end() );
// should probably check for NULL
// pointer entries in minerals_
// succeeded
return true;
initFailed:
// Initialization failed - object should not be used
return false;
}
void DRSM::increment_expected_gradient(
VectorView gradient, int t, const ConstVectorView &state_error_mean,
const ConstSubMatrix &state_error_variance) {
if (gradient.size() != xdim_ || state_error_mean.size() != xdim_ ||
state_error_variance.nrow() != xdim_ ||
state_error_variance.ncol() != xdim_) {
report_error(
"Wrong size arguments passed to "
"DynamicRegressionStateModel::increment_expected_gradient.");
}
for (int i = 0; i < xdim_; ++i) {
double mean = state_error_mean[i];
double var = state_error_variance(i, i);
double sigsq = DynamicRegressionStateModel::sigsq(i);
;
double tmp = (var + mean * mean) / (sigsq * sigsq) - 1.0 / sigsq;
gradient[i] += .5 * tmp;
}
}
void swap(VectorView<T>& in_oLHS, VectorView<T>& in_oRHS) { in_oLHS.swap(in_oRHS); }
void DynamicRegressionStateModel::simulate_state_error(VectorView eta, int t)const{
check_size(eta.size());
for (int i = 0; i < eta.size(); ++i) {
eta[i] = rnorm(0, coefficient_transition_model_[i]->sigma());
}
}
static void BlockHessenberg(
MatrixView<T> A, VectorView<T> Ubeta)
{
// Much like the block version of Bidiagonalize, we try to maintain
// the operation of several successive Householder matrices in
// a block form, where the net Block Householder is I - YZYt.
//
// But as with the bidiagonlization algorithm (and unlike a simple
// block QR decomposition), we update the matrix from both the left
// and the right, so we also need to keep track of the product
// ZYtm in addition.
//
// The block update at the end of the block loop is
// m' = (I-YZYt) m (I-YZtYt)
//
// The Y matrix is stored in the first K columns of m,
// and the Hessenberg portion of these columns is updated as we go.
// For the right-hand-side update, m -= mYZtYt, the m on the right
// needs to be the full original matrix m, including the original
// versions of these K columns. Therefore, we can't wait until
// the end for this calculation.
//
// Instead, we keep track of mYZt as we progress, so the final update
// is:
//
// m' = (I-YZYt) (m - mYZt Y)
//
// We also need to do this same calculation for each column as we
// progress through the block.
//
const ptrdiff_t N = A.rowsize();
#ifdef XDEBUG
Matrix<T> A0(A);
#endif
TMVAssert(A.rowsize() == A.colsize());
TMVAssert(N > 0);
TMVAssert(Ubeta.size() == N-1);
TMVAssert(!Ubeta.isconj());
TMVAssert(Ubeta.step()==1);
ptrdiff_t ncolmax = MIN(HESS_BLOCKSIZE,N-1);
Matrix<T,RowMajor> mYZt_full(N,ncolmax);
UpperTriMatrix<T,NonUnitDiag|ColMajor> Z_full(ncolmax);
T det(0); // Ignore Householder Determinant calculations
T* Uj = Ubeta.ptr();
for(ptrdiff_t j1=0;j1<N-1;) {
ptrdiff_t j2 = MIN(N-1,j1+HESS_BLOCKSIZE);
ptrdiff_t ncols = j2-j1;
MatrixView<T> mYZt = mYZt_full.subMatrix(0,N-j1,0,ncols);
UpperTriMatrixView<T> Z = Z_full.subTriMatrix(0,ncols);
for(ptrdiff_t j=j1,jj=0;j<j2;++j,++jj,++Uj) { // jj = j-j1
// Update current column of A
//
// m' = (I - YZYt) (m - mYZt Yt)
// A(0:N,j)' = A(0:N,j) - mYZt(0:N,0:j) Y(j,0:j)t
A.col(j,j1+1,N) -= mYZt.Cols(0,j) * A.row(j,0,j).Conjugate();
//
// A(0:N,j)'' = A(0:N,j) - Y Z Yt A(0:N,j)'
//
// Let Y = (L) where L is unit-diagonal, lower-triangular,
// (M) and M is rectangular
//
LowerTriMatrixView<T> L =
LowerTriMatrixViewOf(A.subMatrix(j1+1,j+1,j1,j),UnitDiag);
MatrixView<T> M = A.subMatrix(j+1,N,j1,j);
// Use the last column of Z as temporary storage for Yt A(0:N,j)'
VectorView<T> YtAj = Z.col(jj,0,jj);
YtAj = L.adjoint() * A.col(j,j1+1,j+1);
YtAj += M.adjoint() * A.col(j,j+1,N);
YtAj = Z.subTriMatrix(0,jj) * YtAj;
A.col(j,j1+1,j+1) -= L * YtAj;
A.col(j,j+1,N) -= M * YtAj;
// Do the Householder reflection
VectorView<T> u = A.col(j,j+1,N);
T bu = Householder_Reflect(u,det);
#ifdef TMVFLDEBUG
TMVAssert(Uj >= Ubeta._first);
TMVAssert(Uj < Ubeta._last);
#endif
*Uj = bu;
// Save the top of the u vector, which isn't actually part of u
T& Atemp = *u.cptr();
TMVAssert(IMAG(Atemp) == RealType(T)(0));
RealType(T) Aorig = REAL(Atemp);
Atemp = RealType(T)(1);
// Update Z
VectorView<T> Zj = Z.col(jj,0,jj);
Zj = -bu * M.adjoint() * u;
Zj = Z * Zj;
Z(jj,jj) = -bu;
// Update mYtZt:
//
// mYZt(0:N,j) = m(0:N,0:N) Y(0:N,0:j) Zt(0:j,j)
// = m(0:N,j+1:N) Y(j+1:N,j) Zt(j,j)
// = bu* m(0:N,j+1:N) u
//
mYZt.col(jj) = CONJ(bu) * A.subMatrix(j1,N,j+1,N) * u;
// Restore Aorig, which is actually part of the Hessenberg matrix.
Atemp = Aorig;
}
// Update the rest of the matrix:
// A(j2,j2-1) needs to be temporarily changed to 1 for use in Y
T& Atemp = *(A.ptr() + j2*A.stepi() + (j2-1)*A.stepj());
TMVAssert(IMAG(Atemp) == RealType(T)(0));
RealType(T) Aorig = Atemp;
Atemp = RealType(T)(1);
// m' = (I-YZYt) (m - mYZt Y)
MatrixView<T> m = A.subMatrix(j1,N,j2,N);
ConstMatrixView<T> Y = A.subMatrix(j2+1,N,j1,j2);
m -= mYZt * Y.adjoint();
BlockHouseholder_LMult(Y,Z,m);
// Restore A(j2,j2-1)
Atemp = Aorig;
j1 = j2;
}
#ifdef XDEBUG
Matrix<T> U(N,N,T(0));
U.subMatrix(1,N,1,N) = A.subMatrix(1,N,0,N-1);
U.upperTri().setZero();
U(0,0) = T(1);
Vector<T> Ubeta2(N);
Ubeta2.subVector(1,N) = Ubeta;
Ubeta2(0) = T(0);
GetQFromQR(U.view(),Ubeta2);
Matrix<T> H = A;
if (N>2) LowerTriMatrixViewOf(H).offDiag(2).setZero();
Matrix<T> AA = U*H*U.adjoint();
if (Norm(A0-AA) > 0.001*Norm(A0)) {
cerr<<"NonBlock Hessenberg: A = "<<Type(A)<<" "<<A0<<endl;
cerr<<"A = "<<A<<endl;
cerr<<"Ubeta = "<<Ubeta<<endl;
cerr<<"U = "<<U<<endl;
cerr<<"H = "<<H<<endl;
cerr<<"UHUt = "<<AA<<endl;
Matrix<T,ColMajor> A2 = A0;
Vector<T> Ub2(Ubeta.size());
NonBlockHessenberg(A2.view(),Ub2.view());
cerr<<"cf NonBlock: A -> "<<A2<<endl;
cerr<<"Ubeta = "<<Ub2<<endl;
abort();
}
#endif
}
/****************************************************************************
*
* WhitenCrusher1::Intialize( )
*
* Configure WhitenCrusher1 model.
*
****************************************************************************/
bool WhitenCrusher1::Initialize
(
PStreamInfo1 Config,
const VectorView& ParamVec
)
{
// Test object arguments
if( Config==0 ) goto initFailed;
// Test size of parameter vector
if( ParamVec.size() < 26 ) goto initFailed;
// Set parameters
config_ = Config;
CSS = ParamVec[ 0];
LLen = ParamVec[ 1];
ET = ParamVec[ 2];
LHr = ParamVec[ 3];
MotorPower = ParamVec[ 4];
NoLoadPower = ParamVec[ 5];
a0 = ParamVec[ 6];
a1 = ParamVec[ 7];
a2 = ParamVec[ 8];
a3 = ParamVec[ 9];
a4 = ParamVec[10];
b0 = ParamVec[11];
b1 = ParamVec[12];
b2 = ParamVec[13];
b3 = ParamVec[14];
b4 = ParamVec[15];
b5 = ParamVec[16];
c0 = ParamVec[17];
d0 = ParamVec[18];
d1 = ParamVec[19];
d2 = ParamVec[20];
e0 = ParamVec[21];
e1 = ParamVec[22];
f0 = ParamVec[23];
f1 = ParamVec[24];
f2 = ParamVec[25];
// Retrieve stream model dimensions
nSize_ = config_->nSize();
nType_ = config_->nType();
// Test that product stream is valid
if( Discharge==0 )
goto initFailed;
// Configure Discharge stream
if( !Discharge->SetConfig(config_) )
goto initFailed;
// Resize internal vectors
C_.resize( nSize_ );
T10.resize( nType_ );
nomSize_.resize( nSize_ );
Content_.resize( nSize_ );
BreakFeed_.resize( nSize_ );
BreakProd_.resize( nSize_ );
ModelOutput.resize( 11 );
return true;
initFailed:
return false;
}
// static methods
static double dotproduct(const VectorView &v1,
const VectorView &v2)
{
assert(v1.length() == v2.length());
return cblas_ddot(v1.length(), v1.data_, 1, v2.data_, 1);
}
SpdMatrix outer(const VectorView &v){
SpdMatrix ans(v.size(), 0.0);
ans.add_outer(v);
return ans; }
double RioTintoTS::SPNV3
(
int N,
VectorView X,
VectorView Y,
VectorView& S,
double XX
)
{
double XIXI1 = 0.0;
double DX = 0.0;
double XXI = 0.0;
double YY = 0.0;
double T = 0.0;
// Reverse vectors if X descending order
if( X[N-1] < X[0] )
{
X.reset( X.reverse() );
Y.reset( Y.reverse() );
}
// Find interval containing XX
if( XX < X[0] )
{
// before X[0]
XIXI1 = X[0] - X[1];
DX = (Y[0]-Y[1])/(XIXI1+1e-30) + XIXI1*(S[1]+2*S[0])/6.0;
XXI = XX - X[0];
YY = Y[0] + XXI * ( DX + XXI*S[0] );
}
else if( XX > X[N-1] )
{
// after X[N-1]
XIXI1 = X[N-1] - X[N-2];
DX = (Y[N-1]-Y[N-2])/(XIXI1+1e-30) + XIXI1*(2*S[N-1]+S[N-2])/6.0;
XXI = XX - X[N-1];
YY = Y[N-1] + XXI * ( DX + XXI*S[N-1] );
}
else
{
int i = 0;
int left = 0;
int right = N-1;
int mid = 0;
while( XX>=X[left] && XX<=X[right] )
{
mid = left + (right-left)/2;
if( mid==left )
{
i = left;
break;
}
else if( XX < X[mid] )
{
right = mid;
}
else
{
left = mid;
}
}
// between X[i] and X[i+1]
double x1 = X[i];
double x2 = X[i+1];
double y1 = Y[i];
double y2 = Y[i+1];
XXI = XX - X[i];
XIXI1 = X[i] - X[i+1];
T = 2.0*S[i] + XXI*(S[i]-S[i+1])/(XIXI1+1e-30) + S[i+1];
YY = Y[i] + XXI*(Y[i]-Y[i+1])/(XIXI1+1e-30) + (XX-X[i+1])*T/6.0;
}
return YY;
}
bool CubicSpline::SetSpline( VectorView& X, VectorView& Y, bool logX, bool logY )
{
int i,k;
double p,sig;
// determine element count
N_ = X.size();
// test that X and Y same size
if( N_ < 2 || N_ > 100 || N_ != Y.size() )
goto initFailed;
// dimension structures for N elements
X_.resize( N_ );
Y_.resize( N_ );
Y2_.resize( N_ );
// put values into local X_ and Y_ vectors
if( X[N_-1] < X[0] )
{
// Case 1: X_ values descending
X_ = X.reverse();
Y_ = Y.reverse();
}
else
{
// Caes 2: X_ values ascending
X_ = X;
Y_ = Y;
}
// convert X axis to its log if required
if( logX )
{
logX_ = true;
if( !X_.setLog() )
goto initFailed;
}
// convert Y axis to its log if required
if( logY )
{
logY_ = true;
if( !Y_.setLog() )
goto initFailed;
}
// use natural spline at boundaries
Y2_[0] = u[0] = 0;
Y2_[N_-1] = u[N_-1] = 0;
// decomposition loop - tri-diagonal algorithm
for( i=1; i<(N_-1); i++ )
{
sig = ( X_[i] - X_[i-1] ) / ( X_[i+1] - X_[i-1] );
p = sig * Y2_[i-1] + 2.0;
Y2_[i] = ( sig - 1.0 ) / p;
u[i] = ( Y_[i+1] - Y_[i] ) / ( X_[i+1] - X_[i] )
- ( Y_[i] - Y_[i-1] ) / ( X_[i] - X_[i-1] );
u[i] = ( ( 6.0 * u[i] ) / ( X_[i+1] - X_[i-1] ) - sig * u[i-1] ) / p;
}
// backsubstitition loop - tri-diagonal algorithm
for( k = N_-2; k >= 0; k -- )
{
Y2_[k] = Y2_[k] * Y2_[k+1] + u[k];
}
// SetSpline succeeded
return true;
initFailed:
// Set empty state
SetEmpty( );
// SetSpline failed
return false;
}
void RioTintoTS::SPN3( int N, VectorView X, VectorView Y, VectorView& S )
{
double DI;
double AI;
double AI1;
double CI;
double PI;
double PI1;
double Z;
int i;
int j;
int NM1;
static double C[100];
if( N>2 && N<100 )
{
// Reverse vectors if X descending order
if( X[N-1] < X[0] )
{
X.reset( X.reverse() );
Y.reset( Y.reverse() );
}
// End points
NM1 = N-1;
S[0] = 0;
S[NM1] = 0;
// Initial values
DI = 0.0;
AI = X[1] - X[0];
CI = -AI * S[0];
PI = ( Y[1] - Y[0] ) / ( AI + 1e-30 );
// Form equations and reduce to triangular form
for( i=1; i<NM1; i++ )
{
// Segment width
AI1 = X[i+1] - X[i];
// Diagonal elements
Z = 2.0 * (AI1+AI) - DI;
// Constant term
PI1 = ( Y[i+1] - Y[i] ) / ( AI1 + 1e-30 );
C[i] = ( 6.0*(PI1-PI) - CI ) / ( Z + 1e-30 );
CI = C[i] * AI1;
// Upper daigonal
S[i] = AI1 / ( Z + 1e-30 );
DI = S[i] * AI1;
AI = AI1;
}
// Back substitute
for( j=(NM1-1); j>0; j-- )
{
S[j] = C[j] - S[j]*S[j+1];
}
}
}
EdgeSelector::EdgeSelector(const VectorView &vector) {
SafeCall(igraph_es_vector_copy(ptr(), vector.ptr()));
}
Matrix::Matrix(const VectorView &elements, long int nrow)
: Matrix(elements.cbegin(), elements.cend(), nrow, elements.size() / nrow) {
}
Vector(const VectorView &v) : VectorView(NULL, v.length_mem(), v.length())
{
init();
for (size_t i = 0; i < length_; ++i)
data_[i] = v.data()[i];
}
EdgeSelector EdgeSelector::FromVector(const VectorView &vector) {
static EdgeSelector instance(igraph_ess_vector(vector.ptr()));
return instance;
}
