void Force_iid_model::update(arma::colvec& Y,const arma::colvec3& force, const arma::colvec3& torque) {
features(contact) = gaussian_step_function_positive(arma::norm(force),0.9,1,beta);
features(up) = gaussian_step_function_positive(force(0),limits[contact].lower,limits[contact].upper,var[contact]); //+
features(down) = gaussian_step_function_negative(force(0),limits[down].lower,limits[down].upper,var[down]); //-
features(left) = gaussian_step_function_negative(force(1),limits[left].lower,limits[left].upper,var[left]); // -
features(right) = gaussian_step_function_positive(force(1),limits[right].lower,limits[right].upper,var[right]); // +
features(push) = gaussian_step_function_negative(force(2),limits[push].lower,limits[push].upper,var[push]); //-
//contact,up,down,left,right,push
features_simple(0) = features(contact);
features_simple(1) = arma::max(features(arma::span(1,4)));
if(type == FULL) {
Y.resize(6);
Y(contact) = features(contact);
Y(up) = features(up);
Y(down) = features(down);
Y(left) = features(left);
Y(right) = features(right);
Y(push) = features(push);
} else {
Y.resize(2);
Y(0) = features_simple(0);
Y(1) = features_simple(1);
}
}
// [[Rcpp::export]]
double ksFastTestStatistic(arma::colvec y, arma::colvec z){
uvec trt = find( z == 1 );
uvec ctrl = find( z == 0 );
vec yT = y.elem(trt);
vec yC = y.elem(ctrl);
// assuming no missing vals yT = yT[!is.na(yT)];
double nX = yT.n_rows; //length(yT);
double nY = yC.n_rows;
double n = nX * nY/(nX + nY);
colvec w = join_cols(yT, yC); // c(yT,yC)
uvec orderedw = sort_index(w); //order(w)
int totalN = nX + nY;
colvec d(totalN);
d.fill(1/nX);
d.elem( find( orderedw > nX ) ).fill(-1/nY);
// d = cumsum(Rcpp::ifelse(orderedw <= nX, 1/nX, -1/nY));
colvec F = cumsum(d);
// check for ties
vec uniqF = unique(w);
vec out = F;
if ( uniqF.n_elem < totalN ){
//uvec nonzerodiffs = find( diff(sort(F)) != 0 );
vec Fnonzerodiffs = F.elem( find( diff(sort(F)) != 0 ) );
vec out = Fnonzerodiffs; // I dont know why I cant use join_cols (Fnonzerodiffs,F(totalN-1))
out.insert_rows(1,F(totalN-1)); // z <- z[c(which(diff(sort(w)) != 0), n.x + n.y)]
}
// return(max(abs(out)));
return(max(abs(out)));
}
double get_xi_sqr(arma::colvec &x, arma::mat &post_sigma, arma::colvec &post_mu){
arma::mat v = x.t()*post_sigma*x;
arma::mat xmu = x.t()*post_mu;
std::cout << "x.t()*post_sigma*x = " << std::endl;
v.print();
std::cout << "x.t()*post_mu = " << std::endl;
xmu.print();
return as_scalar(v) + as_scalar(xmu)*as_scalar(xmu);
}
bool CamAruco2DObservationModel::hasClearLineOfSight(const ompl::base::State *state, const arma::colvec& landmark )
{
using namespace arma;
colvec xVec = state->as<SE2BeliefSpace::StateType>()->getArmaData();
colvec robot_to_landmark_ray = landmark.subvec(1,2) - xVec.subvec(0,1);
double distance = norm(robot_to_landmark_ray,2);
int steps = std::floor(distance/ompl::magic::ONE_STEP_DISTANCE_FOR_VISIBILITY);
ompl::base::State *tempState = this->si_->allocState();
for(int i=1 ; i < steps; i++)
{
double newX = xVec(0) + i*robot_to_landmark_ray(0)/steps;
double newY = xVec(1) + i*robot_to_landmark_ray(1)/steps;
tempState->as<SE2BeliefSpace::StateType>()->setXYYaw(newX, newY,0);
if(!this->si_->isValid(tempState))
{
return false;
}
}
si_->freeState(tempState);
return true;
}
void CamAruco2DObservationModel::calculateRangeBearingToLandmark(const ompl::base::State *state, const arma::colvec& landmark, double& range, double& bearing)
{
using namespace arma;
colvec xVec = state->as<SE2BeliefSpace::StateType>()->getArmaData();
colvec diff = landmark.subvec(1,2) - xVec.subvec(0,1);
//norm is the 2nd Holder norm, i.e. the Euclidean norm
double distance = norm(diff,2);
double robot_landmark_ray = atan2(diff[1],diff[0]) ;
double delta_theta = robot_landmark_ray - xVec[2];
//if(distance < 0.1)
//{
// OMPL_INFORM("Aruco: Range: %f bearing: %f", distance, delta_theta);
//}
FIRMUtils::normalizeAngleToPiRange(delta_theta);
range = distance;
bearing = delta_theta;
}
// //' Self-concordant Taylor approximation logstar function
// //'
// //' Minus log and its first \code{der} derivatives, on \code{eps < x < M}, with
// //' fourth order Taylor series approximation to the left of \code{eps} and to the right of \code{M}
// //'
// //' @param x column vector of observations
// //' @param eps lower tolerance
// //' @param M maximum value
// //' @param der derivative, either 0, 1 or 2.
// //'
// //' @return a matrix with \eqn{der+1} columns containing values
arma::mat mllog(arma::colvec x, double eps, double M, int der=0){
if(!(der==0 || der==1 || der==2)){
Rcpp::stop("Only first two derivatives and log functions implemented");
}
if(eps > M){
Rcpp::stop("Thresholds out of order");
}
//Coefficients for 4th order Taylor approx below eps
arma::vec coefs(5);
arma::vec Coefs(5);
coefs(0) = -log(eps);
Coefs(0) = -log(M);
for(int i=1; i<5; i++){
coefs(i) = R_pow(-eps,-i)/(double)i;
Coefs(i) = R_pow(-M,-i)/(double)i;
}
arma::uvec lo = find(x < eps);
arma::uvec hi = find(x > M);
//Function value
arma::vec f(x.size());
f = -log(x);
f(lo) = h(x(lo)-eps, coefs);
f(hi) = h(x(hi)-M, Coefs);
if(der < 1){
return f;
}
//First derivative
arma::vec fp(x.size());
fp = -1.0/x;
fp(lo) = hp(x(lo)-eps, eps);
fp(hi) = hp(x(hi)-M, M);
if(der < 2){
return join_rows(f, fp);
}
//Second derivative
arma::vec fpp(x.size());
fpp = pow(x,-2);
fpp(lo) = hpp(x(lo)-eps, eps);
fpp(hi) = hpp(x(hi)-M, M);
return join_rows(join_rows(f,fp),fpp);
}
arma::colvec computeBetaJ_cpp(arma::colvec y, arma::mat X, int j, int m, int adjFinSample) {
int bigT = X.n_rows;
int numThrow = ceil((double)m / 2);
if (adjFinSample == 0) numThrow = m ;
mat XSparse; colvec ySparse;
XSparse.zeros(bigT - numThrow, X.n_cols); ySparse.zeros(bigT - numThrow);
if (j < 2) {
XSparse.rows(0, bigT - numThrow - 1) = X.rows(numThrow, bigT - 1);
ySparse.rows(0, bigT - numThrow - 1) = y.rows(numThrow, bigT - 1);
} else {
XSparse.rows(0, j - 2) = X.rows(0, j - 2); ySparse.rows(0, j - 2) = y.rows(0, j - 2);
XSparse.rows(j - 1, bigT - numThrow - 1) = X.rows(j + numThrow - 1, bigT - 1);
ySparse.rows(j - 1, bigT - numThrow - 1) = y.rows(j + numThrow - 1, bigT - 1);
}
colvec beta = runOLSFast_cpp(ySparse, XSparse);
return(beta);
}
void GMM::expection(arma::colvec& x) const{
x.zeros();
for(std::size_t k = 0; k < K;k++){
x += Means[k] * pi(k);
}
}
void CheckActivationCorrect(const arma::colvec input, const arma::colvec target)
{
// Test the activation function using a single value as input.
for (size_t i = 0; i < target.n_elem; i++)
{
BOOST_REQUIRE_CLOSE(ActivationFunction::fn(input.at(i)),
target.at(i), 1e-3);
}
// Test the activation function using the entire vector as input.
arma::colvec activations;
ActivationFunction::fn(input, activations);
for (size_t i = 0; i < activations.n_elem; i++)
{
BOOST_REQUIRE_CLOSE(activations.at(i), target.at(i), 1e-3);
}
}
void CheckDerivativeCorrect(const arma::colvec input, const arma::colvec target)
{
// Test the calculation of the derivatives using a single value as input.
for (size_t i = 0; i < target.n_elem; i++)
{
BOOST_REQUIRE_CLOSE(ActivationFunction::deriv(input.at(i)),
target.at(i), 1e-3);
}
// Test the calculation of the derivatives using the entire vector as input.
arma::colvec derivatives;
ActivationFunction::deriv(input, derivatives);
for (size_t i = 0; i < derivatives.n_elem; i++)
{
BOOST_REQUIRE_CLOSE(derivatives.at(i), target.at(i), 1e-3);
}
}
//[[Rcpp::export]]
double computeSStat_cpp(arma::colvec beta, arma::mat invS, arma::colvec y, arma::mat X,
int j, int m) {
mat newX = X.rows(j - 1, j + m - 2); colvec newY = y.rows(j - 1, j + m - 2);
mat A = trans(newX) * invS * (newY - newX * beta);
mat V = trans(newX) * invS * newX;
mat S = trans(A) * inv(V) * A;
double s = S(0, 0);
return(s);
}
double nLL2(arma::colvec par, arma::colvec Data, int Nf) {
double failcomp=0.0,suscomp=0.0;
arma::colvec F=Data.rows(0,Nf-1);
for(int i=0; i<Nf; i++) {
failcomp=failcomp+R::dlnorm(F(i),par(0),par(1),1);
}
failcomp=-failcomp;
int Nd=Data.n_rows;
arma::colvec S;
if(Nd>Nf) {
S=Data.rows(Nf,Nd-1);
for(int i=0; i<(Nd-Nf); i++) {
suscomp=suscomp+R::plnorm(S(i),par(0),par(1),0,1);
}
}
double negLL=failcomp-suscomp;
return negLL;
}
//--------------------------------------------------------------------------------------------------
double Krigidx( const arma::colvec& KF,
const arma::colvec& comb,
const arma::mat& X,
const arma::cube& Gamma ) {
int k;
int n = X.n_rows;
int c = comb.size();
double S;
arma::mat W = arma::ones( n, n );
for ( k = 0; k < c; k++ ) {
W = W % Gamma.slice( comb( k ) - 1 );
}
S = as_scalar( KF.t() * W * KF );
return S;
}
int classify(double xi, arma::mat &sigma, arma::mat &sigma_inv, arma::colvec &x, arma::colvec &mu){
arma::mat sigma_t_inv = get_post_sigma_inv(xi, x, sigma_inv);
arma::mat sigma_t = sigma_t_inv.i();
arma::colvec mu_t;
int s = 0;
mu_t = get_post_mu(x, sigma_inv, sigma_t, mu, s);
double log_0 = log(sigmoid(xi)) - xi/2 - lambda(xi)*xi*xi - 0.5*as_scalar(mu.t()*sigma_inv*mu) + 0.5*as_scalar(mu_t.t()*sigma_t.t()*mu_t) + 0.5*log(det(sigma_t)/det(sigma));
s = 1;
mu_t = get_post_mu(x, sigma_inv, sigma_t, mu, s);
double log_1 = log(sigmoid(xi)) - xi/2 - lambda(xi)*xi*xi - 0.5*as_scalar(mu.t()*sigma_inv*mu) + 0.5*as_scalar(mu_t.t()*sigma_t.t()*mu_t) + 0.5*log(det(sigma_t)/det(sigma));
if(log_1 > log_0) return 1;
else return 0;
}
void CheckInverseCorrect(const arma::colvec input)
{
// Test the calculation of the inverse using a single value as input.
for (size_t i = 0; i < input.n_elem; i++)
{
BOOST_REQUIRE_CLOSE(ActivationFunction::inv(ActivationFunction::fn(
input.at(i))), input.at(i), 1e-3);
}
// Test the calculation of the inverse using the entire vector as input.
arma::colvec activations;
ActivationFunction::fn(input, activations);
ActivationFunction::inv(activations, activations);
for (size_t i = 0; i < input.n_elem; i++)
{
BOOST_REQUIRE_CLOSE(activations.at(i), input.at(i), 1e-3);
}
}
arma::mat computeCovMatForAndrews_cpp(arma::colvec u, int breakDate) {
int bigT = u.n_rows;
int m = bigT - breakDate;
mat totSum =zeros(m, m);
for (int j = 0; j < (breakDate + 1); j++) {
colvec uUsed = u.rows(j, j + m - 1);
totSum = totSum + uUsed * trans(uUsed);
}
mat Sigma = totSum / (breakDate + 1);
return(Sigma);
}
/*
* Implementation of the PReLU activation function test. The function
* is implemented as PReLU layer in the file perametric_relu.hpp
*
* @param input Input data used for evaluating the PReLU activation
* function.
* @param target Target data used to evaluate the PReLU activation.
*/
void CheckPReLUActivationCorrect(const arma::colvec input,
const arma::colvec target)
{
PReLU<> prelu;
// Test the activation function using the entire vector as input.
arma::colvec activations;
prelu.Forward(std::move(input), std::move(activations));
for (size_t i = 0; i < activations.n_elem; i++)
{
BOOST_REQUIRE_CLOSE(activations.at(i), target.at(i), 1e-3);
}
}
arma::colvec computeTestStatDistribution_cpp(arma::colvec y, arma::mat X, int breakDate,
int m, int adjFinSample, arma::mat invS) {
int bigT = X.n_rows;
colvec sJ = zeros(breakDate - m + 1);
for (int j = 0; j < (breakDate - m + 1); j++) {
colvec betaJ = computeBetaJ_cpp(y.rows(0, bigT - 1 - m), X.rows(0, bigT - 1 - m),
j + 1, m, adjFinSample);
sJ(j) = computeSStat_cpp(betaJ, invS, y, X, j + 1, m);
// if (j == 44) {
// Rcout << "betaJ = "<< betaJ << "sJ(j) = " << sJ(j) << endl;
// }
}
return(sJ);
}
int CamAruco2DObservationModel::findCorrespondingLandmark(const ompl::base::State *state, const arma::colvec &observedLandmark, arma::colvec &candidateObservation)
{
using namespace arma;
int landmarkID = observedLandmark[0];
double maxLikelihood = -1.0;
double candidatelandmarkRange =0, candidatelandmarkBearing = 0;
int candidateIndx = -1;
for(unsigned int i = 0; i < landmarks_.size() ; i++)
{
if(landmarks_[i](0) == landmarkID)
{
double landmarkRange =0, landmarkBearing = 0;
// get range and bearing to landmark
this->calculateRangeBearingToLandmark(state, landmarks_[i], landmarkRange,landmarkBearing);
arma::colvec prediction;
prediction<<landmarkRange<<landmarkBearing<<endr;
// calculate the likelihood
double lkhd = getDataAssociationLikelihood(observedLandmark.subvec(1,2), prediction);
if(lkhd > maxLikelihood)
{
candidateIndx = i;
maxLikelihood = lkhd;
candidatelandmarkRange = landmarkRange;
candidatelandmarkBearing = landmarkBearing;
}
}
}
assert(candidateIndx >= 0 && "Candidate index cannot be negative");
// The observation is id, range, bearing, orientation of the landmark
candidateObservation<<landmarkID<<candidatelandmarkRange<<candidatelandmarkBearing<<landmarks_[candidateIndx][3]<<endr;
assert(candidateIndx>=0);
return candidateIndx;
}
double weight_pow_dist( const arma::colvec& x,
const arma::colvec& y,
const arma::colvec& w,
const arma::colvec& p ) {
double d = 0.0;
if ( x.size() > 0 && x.size() == y.size() && y.size() == w.size() && w.size() == p.size() ) {
int i, n;
n = x.size();
#pragma omp parallel for shared( w, x, y, p ) private( i ) reduction(+:d)
for( i = 0; i < n; i++ ) {
d += w(i) * std::pow( std::abs( x(i) - y(i) ), p(i) );
}
}
return d;
}
/*
* Implementation of the PReLU activation function derivative test.
* The function is implemented as PReLU layer in the file
* perametric_relu.hpp
*
* @param input Input data used for evaluating the PReLU activation
* function.
* @param target Target data used to evaluate the PReLU activation.
*/
void CheckPReLUDerivativeCorrect(const arma::colvec input,
const arma::colvec target)
{
PReLU<> prelu;
// Test the calculation of the derivatives using the entire vector as input.
arma::colvec derivatives;
// This error vector will be set to 1 to get the derivatives.
arma::colvec error = arma::ones<arma::colvec>(input.n_elem);
prelu.Backward(std::move(input), std::move(error), std::move(derivatives));
for (size_t i = 0; i < derivatives.n_elem; i++)
{
BOOST_REQUIRE_CLOSE(derivatives.at(i), target.at(i), 1e-3);
}
}
// mvrGaussian_density evaluates the PDF of the multivariate Gaussian distribution
// plase note this function returns the un-logged PDF to avoid infinite values
// [[Rcpp::export]]
double mvrGaussian_pdf(arma::colvec x, arma::colvec mu, arma::mat sigma){
//define constants
int k = x.size();
double twoPi = 2 * M_PI;
double out;
double rootTerm;
rootTerm = 1 / sqrt(pow(twoPi,k) * det(sigma));
arma::mat AexpTerm;
AexpTerm = exp(-0.5 * arma::trans(x - mu) * inv(sigma) * (x - mu));
double expTerm;
expTerm = AexpTerm(0,0);
out = rootTerm * expTerm;
return(out);
}
//--------------------------------------------------------------------------------------------------
double Krigvar( const arma::colvec& KF,
const arma::cube& Gamma ) {
int i;
int n = Gamma.n_rows;
int m = Gamma.n_slices;
double Var;
arma::mat V = arma::ones( n, n );
for( i = 0; i < m; i++ ) {
V = V % ( arma::ones( n, n ) + Gamma.slice( i ) );
}
V = V - arma::ones( n, n );
Var = as_scalar( KF.t() * V * KF );
return Var;
}
//[[Rcpp::export]]
List gibbsNG(arma::colvec x, int N){
int n= x.size();
arma::mat theta(N,2);
double mi=0, phi=1; /* chutes iniciais */
double a=1, b=1; /* valores para os hiperparâmetros da a priori */
double m=0, v=1;
for(int i=0; i<N; i++)
{
double A = a + 0.5*n ;
double B=0;
for(int j=0; j<n; j++){ B += pow( (x(j,0)-mi) ,2) ; }
B = b + 0.5*B;
phi=R::rgamma(A,1/B); /* atualiza phi com base em A e B */
double V = 1/( (n*phi) + (1/v) );
double M = V*( (m/v) + sum(x)*phi );
mi = R::rnorm(M,V);
theta(i,0)=mi;
theta(i,1)=phi;
}
List saida;
saida["cadeias"]=theta;
return saida;
}
//--------------------------------------------------------------------------------------------------
double linear_kernel( const arma::colvec& x, const arma::colvec& y, const double& alpha ) {
return as_scalar( alpha * x.t() * y );
}
void Peg_distance_model::print(const arma::colvec& Y) const{
Y.print("Y");
}
arma::mat get_post_sigma_inv(double xi, arma::colvec &x, arma::mat &sigma_inv){
std::cout << "x*x.t()" << std::endl;
(x*x.t()).print();
return sigma_inv + 2*std::abs(lambda(xi))*(x*x.t());
}
//' Compute ego/alter edge coordinates considering alter's size and aspect ratio
//'
//' Given a graph, vertices' positions and sizes, calculates the absolute positions
//' of the endpoints of the edges considering the plot's aspect ratio.
//'
//' @param graph A square matrix of size \eqn{n}. Adjacency matrix.
//' @param toa Integer vector of size \eqn{n}. Times of adoption.
//' @param x Numeric vector of size \eqn{n}. x-coordinta of vertices.
//' @param y Numeric vector of size \eqn{n}. y-coordinta of vertices.
//' @param vertex_cex Numeric vector of size \eqn{n}. Vertices' sizes in terms
//' of the x-axis (see \code{\link{symbols}}).
//' @param undirected Logical scalar. Whether the graph is undirected or not.
//' @param no_contemporary Logical scalar. Whether to return (compute) edges'
//' coordiantes for vertices with the same time of adoption (see details).
//' @param dev Numeric vector of size 2. Height and width of the device (see details).
//' @param ran Numeric vector of size 2. Range of the x and y axis (see details).
//' @param curved Logical vector.
//' @return A numeric matrix of size \eqn{m\times 5}{m * 5} with the following
//' columns:
//' \item{x0, y0}{Edge origin}
//' \item{x1, y1}{Edge target}
//' \item{alpha}{Relative angle between \code{(x0,y0)} and \code{(x1,y1)} in terms
//' of radians}
//' With \eqn{m} as the number of resulting edges.
//' @details
//'
//' In order to make the plot's visualization more appealing, this function provides
//' a straight forward way of computing the tips of the edges considering the
//' aspect ratio of the axes range. In particular, the following corrections are
//' made at the moment of calculating the egdes coords:
//'
//' \itemize{
//' \item{Instead of using the actual distance between ego and alter, a relative
//' one is calculated as follows
//' \deqn{d'=\left[(x_0-x_1)^2 + (y_0' - y_1')^2\right]^\frac{1}{2}}{d'=sqrt[(x0-x1)^2 + (y0'-y1')^2]}
//' where \eqn{%
//' y_i'=y_i\times\frac{\max x - \min x}{\max y - \min y} }{%
//' yi' = yi * [max(x) - min(x)]/[max(y) - min(y)]}
//' }
//' \item{Then, for the relative elevation angle, \code{alpha}, the relative distance \eqn{d'}
//' is used, \eqn{\alpha'=\arccos\left( (x_0 - x_1)/d' \right)}{\alpha' = acos[ (x0 - x1)/d' ]}}
//' \item{Finally, the edge's endpoint's (alter) coordinates are computed as follows: %
//' \deqn{%
//' x_1' = x_1 + \cos(\alpha')\times v_1}{%
//' x1' = x1 + cos(\alpha') * v1
//' }
//' \deqn{%
//' y_1' = y_1 -+ \sin(\alpha')\times v_1 \times\frac{\max y - \min y}{\max x - \min x} }{%
//' y1' = y1 -+ sin(\alpha')*[max(y) - min(y)]/[max(x) - min(x)]
//' }
//' Where \eqn{v_1}{v1} is alter's size in terms of the x-axis, and the sign of
//' the second term in \eqn{y_1'}{y1'} is negative iff \eqn{y_0 < y_1}{y0<y1}.
//' }
//' }
//'
//' The same process (with sign inverted) is applied to the edge starting piont.
//' The resulting values, \eqn{x_1',y_1'}{x1',y1'} can be used with the function
//' \code{\link{arrows}}. This is the workhorse function used in \code{\link{plot_threshold}}.
//'
//' The \code{dev} argument provides a reference to rescale the plot accordingly
//' to the device, and former, considering the size of the margins as well (this
//' can be easily fetched via \code{par("pin")}, plot area in inches).
//'
//' On the other hand, \code{ran} provides a reference for the adjustment
//' according to the range of the data, this is \code{range(x)[2] - range(x)[1]}
//' and \code{range(y)[2] - range(y)[1]} respectively.
//'
//' @keywords misc dplot
//' @examples
//' # --------------------------------------------------------------------------
//' data(medInnovationsDiffNet)
//' library(sna)
//'
//' # Computing coordinates
//' set.seed(79)
//' coords <- sna::gplot(as.matrix(medInnovationsDiffNet$graph[[1]]))
//'
//' # Getting edge coordinates
//' vcex <- rep(1.5, nnodes(medInnovationsDiffNet))
//' ecoords <- edges_coords(
//' medInnovationsDiffNet$graph[[1]],
//' diffnet.toa(medInnovationsDiffNet),
//' x = coords[,1], y = coords[,2],
//' vertex_cex = vcex,
//' dev = par("pin")
//' )
//'
//' ecoords <- as.data.frame(ecoords)
//'
//' # Plotting
//' symbols(coords[,1], coords[,2], circles=vcex,
//' inches=FALSE, xaxs="i", yaxs="i")
//'
//' with(ecoords, arrows(x0,y0,x1,y1, length=.1))
//' @export
// [[Rcpp::export]]
NumericMatrix edges_coords(
const arma::sp_mat & graph,
const arma::colvec & toa,
const arma::colvec & x,
const arma::colvec & y,
const arma::colvec & vertex_cex,
bool undirected=true,
bool no_contemporary=true,
NumericVector dev = NumericVector::create(),
NumericVector ran = NumericVector::create(),
LogicalVector curved = LogicalVector::create()
) {
// The output matrix has the following
// - x0 and y0
// - x1 and y1
// - alpha
std::vector< double > x0;
std::vector< double > y0;
std::vector< double > x1;
std::vector< double > y1;
std::vector< double > alpha;
// Rescaling the vertex sizes
arma::colvec vertex_size(vertex_cex);
// If yexpand is too small, just throw an error
if (ran.length() == 0) {
ran = NumericVector::create(2);
ran[0] = x.max() - x.min();
ran[1] = y.max() - y.min();
}
// Expansion factor for y
double yexpand = 1.0;
if ( ran[1] > 1e-5 ) yexpand = ran[1]/ran[0];
// Adjusting for device size
if (dev.length() == 0)
dev = NumericVector::create(2,1.0);
// Curved?
if (curved.length() == 0)
curved = LogicalVector::create(graph.n_nonzero, true);
yexpand = yexpand * (dev[0]/dev[1]);
for(arma::sp_mat::const_iterator it = graph.begin(); it != graph.end(); ++it) {
int i = it.row();
int j = it.col();
// Checking conditions
if (undirected && (i < j)) continue;
if (no_contemporary && (toa(i)==toa(j)) ) continue;
// Computing angle
double a = atan2((y(j) - y(i))/yexpand, x(j) - x(i));
alpha.push_back(a);
// Adding the xs and the ys
x0.push_back(x.at(i) + cos(a)*vertex_size.at(i));
x1.push_back(x.at(j) - cos(a)*vertex_size.at(j));
// The formula needs an extra help to figure out the ys
y0.push_back(y.at(i) + sin(a)*vertex_size.at(i)*yexpand);
y1.push_back(y.at(j) - sin(a)*vertex_size.at(j)*yexpand);
}
// Building up the output
int e = x0.size();
NumericMatrix out(e,5);
for(int i=0; i<e; ++i) {
out(i,0) = x0[i];
out(i,1) = y0[i];
out(i,2) = x1[i];
out(i,3) = y1[i];
out(i,4) = alpha[i];
}
colnames(out) = CharacterVector::create("x0", "y0", "x1", "y1", "alpha");
return out;
}
// [[Rcpp::export]]
List vertices_coords(
const arma::colvec & x,
const arma::colvec & y,
const arma::colvec & size,
const arma::colvec & nsides,
const arma::colvec & rot,
NumericVector dev = NumericVector::create(),
NumericVector ran = NumericVector::create()
) {
// Checking sizes
if (x.n_rows != y.n_rows) stop("-x- and -y- lengths do not coincide.");
if (x.n_rows != size.n_rows) stop("-x- and -size- lengths do not coincide.");
if (x.n_rows != nsides.n_rows) stop("-x- and -nsides- lengths do not coincide.");
if (x.n_rows != rot.n_rows) stop("-x- and -rot- lengths do not coincide.");
List out(x.n_rows);
// If yexpand is too small, just throw an error
if (ran.length() == 0) {
ran = NumericVector::create(2);
ran[0] = x.max() - x.min();
ran[1] = y.max() - y.min();
}
// Expansion factor for y
double yexpand = 1.0;
if ( ran[1] > 1e-5 ) yexpand = ran[1]/ran[0];
// Adjusting for device size
if (dev.length() == 0)
dev = NumericVector::create(2,1.0);
yexpand = yexpand * (dev[0]/dev[1]);
for (unsigned i=0;i<x.n_rows;++i) {
// Getting inner degrees
double alpha = PI - ((nsides(i) - 2.0)*PI)/nsides(i);
double beta = (PI - 2.0*PI/nsides(i))/2.0;
// Getting step size
double size_adj = 2.0*cos(beta)*size(i);
// Suboutput and first coordinate
arma::mat coords(nsides(i),2);
coords(0,0) = x(i) + size(i)*cos(beta + PI + rot(i));
coords(0,1) = y(i) + size(i)*sin(beta + PI + rot(i))*yexpand;
double ALPHA = rot(i);
for (int j=1; j<nsides(i); ++j) {
coords(j,0) = coords(j-1,0) + size_adj*cos(ALPHA);
coords(j,1) = coords(j-1,1) + size_adj*sin(ALPHA)*yexpand;
ALPHA += alpha;
}
// Assigning element
out[i] = coords;
}
return out;
}
//--------------------------------------------------------------------------------------------------
double polynomial_kernel( const arma::colvec& x, const arma::colvec& y,
const double& alpha, const double& beta, const double& n ) {
return pow( as_scalar( alpha * x.t() * y ) + beta, n );
}
