// m=m-m*v*v'
void sub_m_v_vT(mat &m, const vec &v)
{
vec v2(m.rows());
double tmp, *v2p;
const double *vp;
int i, j;
it_assert(v.size() == m.cols(), "sub_m_v_vT()");
v2p = v2._data();
for (i = 0; i < m.rows(); i++) {
tmp = 0.0;
vp = v._data();
for (j = 0; j < m.cols(); j++)
tmp += *(vp++) * m._elem(i, j);
*(v2p++) = tmp;
}
v2p = v2._data();
for (i = 0; i < m.rows(); i++) {
vp = v._data();
for (j = 0; j < m.cols(); j++)
m._elem(i, j) -= *v2p * *(vp++);
v2p++;
}
}
// fonction retournant le produit d'une matrice et d'un vecteur
vec Calculs::produit(mat MM, vec V)
{
VV.resize(MM.size());
for(kk=0;kk<MM.size();kk++)
{
som = 0;
for(ll=0;ll<V.size();ll++)
{
som = som+MM[kk][ll]*V[ll];
}
VV[kk] = som;
}
return VV;
}
inline void update_WtA(mat & WtA, const mat & W, const mat & W1, const mat & H2, const mat & A)
{
// compute WtA = (W[:, 0:k-1], W1)^T (A - W[, k:end] H2^T)
if (H2.empty())
update_WtA(WtA, W, W1, A);
else
{
int k = W.n_cols - H2.n_cols;
//std::cout << "1.3" << std::endl;
//A.print("A = ");
//(W.cols(k, W.n_cols-1) * H2.t()).print("W[, k:] = ");
update_WtA(WtA, W.cols(0, k-1), W1, A - W.cols(k, W.n_cols-1) * H2.t());
}
}
//! get gravity and body acc. components of the window
//! @param[in] &window reference to the window
//! @param[out] &gravity reference to the gravity comp. extracted from the window
//! @param[out] &body reference to the body acc. comp. extracted from the window
void Classifier::analyzeWindow(mat &window, mat &gravity, mat &body)
{
// perform median filtering to reduce the noise
int n = 3;
mat clean_window = window.t();
medianFilter(clean_window, n);
clean_window = clean_window.t();
// discriminate between gravity and body acc. components
mat tempgr = clean_window.t();
gravity = ChebyshevFilter(tempgr);
gravity = gravity.t();
body = clean_window - gravity;
}
// convertion
void mat2Blob(mat& mA, shared_ptr<Blob>& out, int c, int h, int w) {
int n = mA.n_rows;
assert(mA.n_cols == c*h*w);
mA = mA.t();
if (out) {
out.reset();
}
out.reset(new Blob(n, c, h, w));
for (int i = 0; i < n; ++i) {
(*out)[i] = cube(mA.colptr(i), h, w, c);
}
return;
}
double Jastrow::getRatio(const int &particleNum, const mat &rNew, const mat &rOld){
double argument = 0;
double fNew = 0;
double fOld = 0;
double r12 = 0;
for (int i = 0; i < particleNum; i++){
r12Vec = rNew.row(particleNum) - rNew.row(i);
r12 = sqrt(r12Vec(0)*r12Vec(0) + r12Vec(1)*r12Vec(1) + r12Vec(2)*r12Vec(2));
fNew = f(r12, particleNum, i);
r12Vec = rOld.row(particleNum) - rOld.row(i);
r12 = sqrt(r12Vec(0)*r12Vec(0) + r12Vec(1)*r12Vec(1) + r12Vec(2)*r12Vec(2));
fOld = f(r12, particleNum, i);
argument += fNew - fOld;
}
for (int i = particleNum + 1; i < nParticles; i++){
r12Vec = rNew.row(particleNum) - rNew.row(i);
r12 = sqrt(r12Vec(0)*r12Vec(0) + r12Vec(1)*r12Vec(1) + r12Vec(2)*r12Vec(2));
fNew = f(r12, particleNum, i);
r12Vec = rOld.row(particleNum) - rOld.row(i);
r12 = sqrt(r12Vec(0)*r12Vec(0) + r12Vec(1)*r12Vec(1) + r12Vec(2)*r12Vec(2));
fOld = f(r12, particleNum, i);
argument += fNew - fOld;
}
return exp(argument);
}
//used for both spheric and hybrid multilateration
static
bool generate_meas(vec &meas, const bvec &method, const mat &bs_pos, const vec &ms_pos)
{
unsigned int method_len = length(method);
unsigned int nb_bs = bs_pos.cols();
bool column = true;
if(3 == nb_bs) {
nb_bs = bs_pos.rows();
column = false;
}
if((nb_bs < method_len) || (3 != length(ms_pos))) {
return false;
}
meas.set_size(method_len);
vec pos(3);
vec pos_ref(3);
pos_ref = column ? bs_pos.get_col(0) : bs_pos.get_row(0);
for(unsigned int k = 0; k < method_len; ++k) {
if(bin(1) == method[k]) { /* hyperbolic */
pos = column ? bs_pos.get_col(k + 1) : bs_pos.get_row(k + 1);
meas[k] = get_dist(pos, ms_pos) - get_dist(pos_ref, ms_pos);
}
else { /* spherical */
pos = column ? bs_pos.get_col(k) : bs_pos.get_row(k);
meas[k] = get_dist(pos, ms_pos);
}
}
return true;
}
virtual Vec4f vertex(int iface, int nthvert) {
Vec2f uv = m_model->uv(iface, nthvert);
varying_uv.set_col(nthvert, uv);
varying_nrm.set_col(nthvert, proj<3>(m_invModelMat*embed<4>(m_model->normal(iface, nthvert), 0.f)));
Vec3f unScaledVert = m_model->vert(iface, nthvert);
Vec3f scaledVert=Vec3f(unScaledVert[0]*m_localScaling[0],
unScaledVert[1]*m_localScaling[1],
unScaledVert[2]*m_localScaling[2]);
Vec4f gl_Vertex = m_projectionMat*m_modelView1*embed<4>(scaledVert);
varying_tri.set_col(nthvert, gl_Vertex);
Vec4f gl_VertexLightView = m_projectionMat*m_lightModelView*embed<4>(scaledVert);
varying_tri_light_view.set_col(nthvert, gl_VertexLightView);
return gl_Vertex;
}
mat bb_shift_relative(mat bb,pair<double,double>shift)
{
bb.row(1) = bb.row(1)+(bb.row(3)-bb.row(1)+1)*shift.first;
bb.row(2) = bb.row(2)+(bb.row(4)-bb.row(2)+1)*shift.second;
bb.row(3) = bb.row(3)+(bb.row(3)-bb.row(1)+1)*shift.first;
bb.row(4) = bb.row(4)+(bb.row(4)-bb.row(2)+1)*shift.second;
}
void updateStateThread() {
while(0 == lcm1.handle()) {
x0.at(0,0) = current_state.position[0]/1000.0;
x0.at(3,0) = current_state.position[1]/1000.0;
x0.at(6,0) = -(current_state.position[2]/1000.0 + simu_height) + better_height;
x0.at(1,0) = current_state.velocity[0];
x0.at(4,0) = current_state.velocity[1];
x0.at(7,0) = -current_state.velocity[2];
accumu_err_x = accumu_err_x + x0.at(0,0) * dT;
accumu_err_y = accumu_err_y + x0.at(3,0) * dT;
accumu_err_z = accumu_err_z + x0.at(6,0) * dT;
x0.at(2,0) = accumu_err_x;
x0.at(5,0) = accumu_err_y;
x0.at(8,0) = accumu_err_z;
usleep(5e4);
// cout <<__LINE__<<endl;
}
}
void forward_substitution(const mat &L, int p, const vec &b, vec &x)
{
assert( L.rows() == L.cols() && L.cols() == b.size() && b.size() == x.size() && p <= L.rows()/2 );
int n = L.rows(), i, j;
x=b;
for (j=0;j<n;j++) {
x(j)/=L(j,j);
for (i=j+1;i<MIN(j+p+1,n);i++) {
x(i)-=L(i,j)*x(j);
}
}
}
mat backslash(const mat &A, const mat &B)
{
mat ls_solve(const mat &A, const mat &b);
mat ls_solve_od(const mat &A, const mat &b);
int m=A.rows(), n=A.cols();
if (m == n)
return ls_solve(A,B);
else if (m > n)
return ls_solve_od(A,B);
//it_error("Cannot solve under-determined linear equation systems!");
return vec(0);
}
//Beregning av enkeltderiverte til orbitalene
rowvec3 Wavefunction::Gradient(const mat &r, const int number_particle, const int &Orbital_number, double alpha, int atom_nr)
{
double Sum_I_Eksponenten = 0;
rowvec3 Gradienten;
Gradienten(0)=0; Gradienten(1)=0; Gradienten(2)=0;
for (int k = 0; k < dimension; k++)
{
Sum_I_Eksponenten += (r(number_particle, k) - R(atom_nr, k)) * (r(number_particle, k) - R(atom_nr, k));
}
Sum_I_Eksponenten = sqrt(Sum_I_Eksponenten);
if (Orbital_number == 0)
{
Gradienten = -(alpha * (r.row(number_particle)-R.row(atom_nr)) / Sum_I_Eksponenten) * exp(-alpha*Sum_I_Eksponenten);
}
if (Orbital_number == 1)
{
Gradienten = (alpha*(r.row(number_particle) - R.row(atom_nr))*(alpha*Sum_I_Eksponenten-4) / (4*Sum_I_Eksponenten)) * exp(-alpha*Sum_I_Eksponenten/2);
}
if (Orbital_number == 2)
{
Gradienten(0) = -alpha*(r(number_particle, 0)-R(atom_nr, 0)) * (r(number_particle ,0)-R(atom_nr, 0)) + 2*Sum_I_Eksponenten;
Gradienten(1) = -alpha*(r(number_particle, 0)-R(atom_nr,0)) * (r(number_particle ,1)-R(atom_nr,1));
Gradienten(2) = -alpha*(r(number_particle, 0)-R(atom_nr,0)) * (r(number_particle ,2)-R(atom_nr,2));
Gradienten = Gradienten * exp(-alpha*Sum_I_Eksponenten / 2) / (2*Sum_I_Eksponenten);
}
if (Orbital_number == 3)
{
Gradienten(0) = -alpha*(r(number_particle, 1)-R(atom_nr,1)) * (r(number_particle ,0)-R(atom_nr, 0));
Gradienten(1) = -alpha*(r(number_particle, 1)-R(atom_nr,1)) * (r(number_particle ,1)-R(atom_nr,1)) + 2*Sum_I_Eksponenten;
Gradienten(2) = -alpha*(r(number_particle, 1)-R(atom_nr,1)) * (r(number_particle ,2)-R(atom_nr,2));
Gradienten = Gradienten * exp(-alpha*Sum_I_Eksponenten / 2) / (2*Sum_I_Eksponenten);
}
if (Orbital_number == 4)
{
Gradienten(0) = -alpha*(r(number_particle, 2)-R(atom_nr,2)) * (r(number_particle ,0)-R(atom_nr, 0));
Gradienten(1) = -alpha*(r(number_particle, 2)-R(atom_nr,2)) * (r(number_particle ,1)-R(atom_nr,1));
Gradienten(2) = -alpha*(r(number_particle, 1)-R(atom_nr,1)) * (r(number_particle ,2)-R(atom_nr,2)) + 2*Sum_I_Eksponenten;
Gradienten = Gradienten * exp(-alpha*Sum_I_Eksponenten / 2) / (2*Sum_I_Eksponenten);
}
return Gradienten;
}
void randselect(mat X, mat y, int n, mat &outX, mat &outy) {
std::vector<int> indeces;
for (int i = 0; i < (int)X.n_rows; i++) {
indeces.push_back(i);
}
random_shuffle(indeces.begin(), indeces.end());
mat _X_ = X;
mat _y_ = y;
outX = mat(n, X.n_cols);
outy = mat(n, 1);
for (int i = 0; i < n; i++) {
outX.row(i) = _X_.row(indeces[i]);
outy.row(i) = _y_.row(indeces[i]);
}
}
mat mul(mat &A, mat &B) //A: m*n, B: n*p
{
mat C(A.size(), vec(B[0].size())); //C: m:p
for (int i = 0; i < A.size(); i++)
{
for (int k = 0; k < B.size(); k++)
{
for (int j = 0; j < B[0].size(); j++)
{
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % M;
}
}
}
return C;
}
mat pow(mat A, ll n)
{
mat B(A.size(),vec(A.size()));
for(int i=0;i<A.size();i++)
{
B[i][i]=1ll;
}
while(n>0)
{
if(n&1)B = mul(B,A);
A = mul(A,A);
n >>= 1;
}
return B;
}
mat mul(mat &A,mat &B)
{
mat C(A.size(),vec(B[0].size()));
for(int i=0;i<A.size();i++)
{
for(int k=0;k<B.size();k++)
{
for(int j=0;j<B[0].size();j++)
{
C[i][j]=(C[i][j]+A[i][k]*B[k][j])%MOD;
}
}
}
return C;
}
mat pow(mat A, LL n)
{
int i, j;
mat B(A.size(), vec(A.size()));
for(i = 0; i < A.size(); i++)
B[i][i] = 1;
while(n > 0)
{
if(n&1)
B = mul(B, A);
A = mul(A, A);
n = n >> 1;
}
return B;
}
mat FMRLasso::GenoStd(mat& geno)
{
assert(geno.n_rows == mN);
assert(geno.n_cols == mP);
double q;
for ( unsigned int j = 0; j < mP; j++)
{
q = sum(geno.col(j)) / (2.0 * mN); // BE CAREFUL FOR A VECTOR 0 INDEX
//cout << q << endl;
geno.col(j) = (geno.col(j) - 2.0 * q) / sqrt(2.0 * q * (1.0 - q));
}
return geno;
}
void ConstantCF::covarianceGradient(mat& grad, const int parameterNumber, const mat& X) const
{
assert(parameterNumber == 0);
Transform* t = getTransform(parameterNumber);
double gradientTransform = t->gradientTransform(getParameter(parameterNumber));
switch(parameterNumber)
{
case 0 :
{
grad = gradientTransform * ones(X.rows(), X.rows());
}
}
}
void tlin::traduceD(const mat &m, SuperMatrix *&A)
{
int rows = m.rows(), cols = m.cols();
if (!A)
allocD(A, rows, cols);
int lda;
double *Avalues = 0;
readDN(A, lda, Avalues);
assert(A->nrow == rows && A->ncol == cols && lda == rows);
memcpy(Avalues, m.values(), rows * cols * sizeof(double));
}
void SeqOls::useObservations(mat X, mat Y // A n x p matrix with n responses,
// one response per row
) {
if (X.size() != Y.size()) {
cout << " The predictor/response matrices should have the same size";
cout << endl;
}
n = X.n_rows;
p = X.n_cols;
X = join_rows(X, ones(n, 1));
P = inv((X.t()) * X);
B = P * (X.t() * Y);
G = inv(B.rows(0, p - 1));
}
//' C++ Wrapper to Check Stability of Two-sided Matching
//'
//' This function checks if a given matching is stable for a particular set of
//' preferences. This function provides an R wrapper for the C++ backend. Users
//' should not call this function directly and instead use
//' \code{\link{galeShapley.checkStability}}.
//'
//' @param proposerUtils is a matrix with cardinal utilities of the proposing
//' side of the market. If there are \code{n} proposers and \code{m} reviewers,
//' then this matrix will be of dimension \code{m} by \code{n}. The
//' \code{i,j}th element refers to the payoff that individual \code{j} receives
//' from being matched to individual \code{i}.
//' @param reviewerUtils is a matrix with cardinal utilities of the courted side
//' of the market. If there are \code{n} proposers and \code{m} reviewers, then
//' this matrix will be of dimension \code{n} by \code{m}. The \code{i,j}th
//' element refers to the payoff that individual \code{j} receives from being
//' matched to individual \code{i}.
//' @param proposals is a matrix that contains the number of the reviewer that a
//' given proposer is matched to: the first row contains the number of the
//' reviewer that is matched with the first proposer (using C++ indexing), the
//' second row contains the id of the reviewer that is matched with the second
//' proposer, etc. The column dimension accommodates proposers with multiple
//' slots.
//' @param engagements is a matrix that contains the number of the proposer that
//' a given reviewer is matched to (using C++ indexing). The column dimension
//' accommodates reviewers with multiple slots.
//' @return true if the matching is stable, false otherwise
// [[Rcpp::export]]
bool cpp_wrapper_galeshapley_check_stability(mat proposerUtils, mat reviewerUtils, umat proposals, umat engagements) {
// number of workers
const int M = proposerUtils.n_cols;
// number of firms
const int N = proposerUtils.n_rows;
// number of slots per firm
const int slotsReviewers = engagements.n_cols;
// number of slots per worker
const int slotsProposers = proposals.n_cols;
// more jobs than workers (add utility from being unmatched to firms' preferences)
if(N*slotsReviewers>M*slotsProposers) {
reviewerUtils.insert_rows(M, 1);
reviewerUtils.row(M).fill(-1e10);
}
// more workers than jobs (add utility from being unmatched to workers' preferences)
if(M*slotsProposers>N*slotsReviewers) {
proposerUtils.insert_rows(N, 1);
proposerUtils.row(N).fill(-1e10);
}
// loop over workers
for(int wX=0; wX<M; wX++) {
// loop over firms
for(int fX=0; fX<N; fX++) {
// loop over multiple "slots" at the same worker
for(int swX=0;swX<slotsProposers;swX++) {
// loop over multiple slots at the same firm
for(int sfX=0;sfX<slotsReviewers;sfX++) {
// check if wX and fX would rather be matched with each other than with their actual matches
if(reviewerUtils(wX, fX) > reviewerUtils(engagements(fX, sfX), fX) && proposerUtils(fX, wX) > proposerUtils(proposals(wX, swX), wX)) {
::Rf_warning("matching is not stable; worker %d would rather be matched to firm %d and vice versa.\n", wX, fX);
return false;
}
}
}
}
}
return true;
}
void add_vector(float * a, mat b, int dim){
petuum::RowAccessor row_acc;
b.Get(0, &row_acc);
const petuum::DenseRow<float>& r = row_acc.Get<petuum::DenseRow<float> >();
for(int i=0;i<dim;i++)
a[i]+=r[i];
}
// Maximum Down-Sampling
mat maxDownSample(mat source, int stride, mat& retnMask){
dbg_assert(source.n_rows == source.n_cols);
dbg_assert(stride <= source.n_rows);
dbg_assert((source.n_rows % stride) == 0);
int source_size = source.n_rows;
int result_size = source_size / stride;
mat result = zeros<mat>(result_size, result_size);
retnMask = zeros<mat>(source_size, source_size);
for(int row=0; row < result_size; row++){
for(int col=0; col < result_size; col++){
int row_start = row * stride;
int col_start = col * stride;
uword retn_row;
uword retn_col;
result(row, col) = source.submat(
row_start,
col_start,
row_start + stride - 1,
col_start + stride - 1
).max(retn_row, retn_col);
retnMask(retn_row + row_start,
retn_col + col_start) = 1;
}
}
return(result);
}
///
/// \brief PLSData::Discriminate
/// \param data
/// \param labels
/// \return
/// Perform PLS-DA
bool PLSData::Discriminate(const mat &data, const mat &labels)
{
//data (usually, but not necessarly spectra) is X
//labels are Y;
if (labels.n_rows != data.n_cols) return false;
mat X_loadings, Y_loadings, X_scores, Y_scores, coefficients, percent_variance, fitted;
bool success = Vespucci::Math::DimensionReduction::plsregress(data.t(), labels, labels.n_cols,
X_loadings, Y_loadings,
X_scores, Y_scores,
coefficients, percent_variance,
fitted);
mat residuals = fitted - labels;
if (success){
AddMetadata("Type", "Calibration");
AddMetadata("Components calculated", QString::number(labels.n_cols));
AddMatrix("Percent Variance", percent_variance);
AddMatrix("Predictor Loadings", X_loadings);
AddMatrix("Response Loadings", Y_loadings);
AddMatrix("Predictor Scores", X_scores);
AddMatrix("Response Scores", Y_scores);
AddMatrix("Coefficients", coefficients);
AddMatrix("Fitted Data", fitted);
AddMatrix("Residuals", residuals);
}
return success;
}
// операции над обычными матрицами
vec operator * (const mat & a, const vec & b)
{
vec res(b.size());
for (size_t i = 0; i < a.size(); ++i)
res[i] = a[i] * b;
return res;
}
double scoreFunc(vec &f_q, vector<unsigned> &a_indices, mat &Ws){
vec g_a = zeros<vec>(f_q.n_rows);
for (auto i : a_indices) {
g_a += Ws.col(i);
}
return norm_dot(g_a, f_q);
}
void load(mat &x, mat &y) {
std::ifstream input("/home/joseph/C/data/house.dat", std::ios::in);
std::string line;
if (input.is_open()) {
x = mat(datasize, n);
y = mat(datasize, o);
y.zeros();
for (; std::getline(input, line) ;) {
if (strcmp(line.substr(0, 5).c_str(), "@data") == 0) {
cout << "reading data..." << endl;
break;
}
}
for (uint32_t i = 0 ; i < datasize ; ++i) {
for (int j = 0 ; j < n ; ++j) {
double xi = 0;
char c;
input >> xi;
if (j == 0) xi /= (7322564.0 / 10.0);
x(i, j) = xi;
// read ,
input >> c;
}
double val = 0;
input >> val;
y(i, 0) = val / scale;
}
}
mat MaxPoolLayer::forwardprop(const mat& pa) {
a = mat(pa.n_rows, outputsize * nfilter, arma::fill::zeros);
images = cube(inputheight + 2*padding, inputwidth + 2*padding, pa.n_rows);
indexes = mat(pa.n_rows, outputsize*2);
for (uint32_t i = 0 ; i < pa.n_rows ; ++i) {
// reshape input sample
mat sample = pa.row(i);
for (int j = 0 ; j < pnfilter ; ++j) {
const mat img = toimage(pa, j, inputwidth, inputheight);
images.slice(i) = addzeropadding(img);
#ifdef HAVE_OPENMP
#pragma omp parallel for default(none) shared(j,i) if (nfilter >= 16)
#endif
for (int k = 0 ; k < nfilter ; ++k) {
mat partialoutput;
mat index;
maxpool(images.slice(i), partialoutput, index);
a.submat(i, k*outputsize, i, (k+1)*outputsize-1) += partialoutput;
indexes.submat(i, 0, i, outputsize*2-1) = index;
}
}
}
return funcop(a, actfunc.act);
}