void caffe_scal<float>(const int N, const float alpha, float *X) {
cblas_sscal(N, alpha, X, 1);
}
void caffe_cpu_scale<float>(const int n, const float alpha, const float *x,
float* y) {
cblas_scopy(n, x, 1, y, 1);
cblas_sscal(n, alpha, y, 1);
}
/**
* @brief Normalizes all FSR scalar fluxes and Track boundary angular
* fluxes to the total fission source (times \f$ \nu \f$).
*/
void VectorizedSolver::normalizeFluxes() {
FP_PRECISION* nu_sigma_f;
FP_PRECISION volume;
FP_PRECISION tot_fission_source;
FP_PRECISION norm_factor;
int size = _num_FSRs * _num_groups * sizeof(FP_PRECISION);
FP_PRECISION* fission_sources = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
/* Compute total fission source for each FSR, energy group */
#pragma omp parallel for private(volume, nu_sigma_f) schedule(guided)
for (int r=0; r < _num_FSRs; r++) {
/* Get pointers to important data structures */
nu_sigma_f = _FSR_materials[r]->getNuSigmaF();
volume = _FSR_volumes[r];
/* Loop over energy group vector lengths */
for (int v=0; v < _num_vector_lengths; v++) {
/* Loop over each energy group within this vector */
#pragma simd vectorlength(VEC_LENGTH)
for (int e=v*VEC_LENGTH; e < (v+1)*VEC_LENGTH; e++)
fission_sources(r,e) = nu_sigma_f[e] * _scalar_flux(r,e);
/* Loop over each energy group within this vector */
#pragma simd vectorlength(VEC_LENGTH)
for (int e=v*VEC_LENGTH; e < (v+1)*VEC_LENGTH; e++)
fission_sources(r,e) *= volume;
}
}
/* Compute the total fission source */
size = _num_FSRs * _num_groups;
#ifdef SINGLE
tot_fission_source = cblas_sasum(size, fission_sources, 1);
#else
tot_fission_source = cblas_dasum(size, fission_sources, 1);
#endif
/* Deallocate memory for fission source array */
MM_FREE(fission_sources);
/* Compute the normalization factor */
norm_factor = 1.0 / tot_fission_source;
log_printf(DEBUG, "Tot. Fiss. Src. = %f, Normalization factor = %f",
tot_fission_source, norm_factor);
/* Normalize the FSR scalar fluxes */
#ifdef SINGLE
cblas_sscal(size, norm_factor, _scalar_flux, 1);
cblas_sscal(size, norm_factor, _old_scalar_flux, 1);
#else
cblas_dscal(size, norm_factor, _scalar_flux, 1);
cblas_dscal(size, norm_factor, _old_scalar_flux, 1);
#endif
/* Normalize the Track angular boundary fluxes */
size = 2 * _tot_num_tracks * _num_polar * _num_groups;
#ifdef SINGLE
cblas_sscal(size, norm_factor, _boundary_flux, 1);
#else
cblas_dscal(size, norm_factor, _boundary_flux, 1);
#endif
return;
}
void LLC::Encode_with_max_pooling(const float* const data, const uint32_t dim,
const uint32_t num_frame,
float* const code) const
{
if (data == NULL || dim != dim_ || num_frame <= 0)
{
cerr << "ERROR in input data" << endl;
exit(-1);
}
if (!has_setup_)
{
cerr << "ERROR: Must call SetUp() before." << endl;
exit(-1);
}
vl_uint32* index = (vl_uint32*) vl_malloc(
sizeof(vl_uint32) * num_knn_ * num_frame);
memset(index, 0, num_knn_ * num_frame);
float* dist(NULL);
vl_kdforest_query_with_array(kdforest_model_, index, num_knn_, num_frame,
dist, data);
// start to encode
const uint32_t len_code = num_base_;
memset(code, 0, sizeof(float) * len_code);
const uint32_t len_z = dim_ * num_knn_;
const uint32_t len_C = num_knn_ * num_knn_;
const uint32_t len_b = num_knn_;
float* z = (float*) malloc(sizeof(float) * len_z);
float* C = (float*) malloc(sizeof(float) * len_C);
float* b = (float*) malloc(sizeof(float) * len_b);
memset(z, 0, sizeof(float) * len_z);
memset(C, 0, sizeof(float) * len_C);
memset(b, 0, sizeof(float) * len_b);
double sum(0);
const float* base = base_.get();
for (uint32_t i = 0; i < num_frame; i++)
{
uint32_t tmp_ind;
// z = B_i - 1 * x_i'
for (uint32_t n = 0; n < num_knn_; n++)
{
tmp_ind = (uint32_t) index[i * num_knn_ + n];
memcpy(z + n * dim_, base + tmp_ind * dim_, sizeof(float) * dim_);
cblas_saxpy(dim_, -1.0f, data + i * dim_, 1, z + n * dim_, 1);
}
// C = z * z', i.e. covariance matrix
for (uint32_t m = 0; m < num_knn_; ++m)
for (uint32_t n = m; n < num_knn_; ++n)
{
float sum = cblas_sdot(dim_, z + m * dim_, 1, z + n * dim_, 1);
C[m * num_knn_ + n] = sum;
C[n * num_knn_ + m] = sum;
}
sum = 0;
for (uint32_t m = 0; m < num_knn_; m++)
sum += C[m * num_knn_ + m];
sum = sum * beta_;
for (uint32_t m = 0; m < num_knn_; m++)
C[m * num_knn_ + m] += sum;
for (uint32_t m = 0; m < num_knn_; m++)
b[m] = 1;
// solve
{
char upper_triangle = 'U';
int INFO;
int int_one = 1;
const int num_knn = (int) num_knn_;
sposv(&upper_triangle, &num_knn, &int_one, C, &num_knn, b, &num_knn,
&INFO);
}
sum = 0;
for (uint32_t m = 0; m < num_knn_; m++)
sum += b[m];
cblas_sscal(num_knn_, 1.0 / sum, b, 1);
for (uint32_t m = 0; m < num_knn_; m++)
{
tmp_ind = (uint32_t) index[i * num_knn_ + m];
if (code[tmp_ind] < b[m])
code[tmp_ind] = b[m];
}
}
free(index);
free(z);
free(C);
free(b);
}
void
test_scal (void) {
const double flteps = 1e-4, dbleps = 1e-6;
{
int N = 1;
float alpha = 0.0f;
float X[] = { 0.651f };
int incX = -1;
float expected[] = { 0.651f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 112)");
}
};
};
{
int N = 1;
float alpha = 0.1f;
float X[] = { 0.651f };
int incX = -1;
float expected[] = { 0.651f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 113)");
}
};
};
{
int N = 1;
float alpha = 1.0f;
float X[] = { 0.651f };
int incX = -1;
float expected[] = { 0.651f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 114)");
}
};
};
{
int N = 1;
double alpha = 0;
double X[] = { 0.686 };
int incX = -1;
double expected[] = { 0.686 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 115)");
}
};
};
{
int N = 1;
double alpha = 0.1;
double X[] = { 0.686 };
int incX = -1;
double expected[] = { 0.686 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 116)");
}
};
};
{
int N = 1;
double alpha = 1;
double X[] = { 0.686 };
int incX = -1;
double expected[] = { 0.686 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 117)");
}
};
};
{
int N = 1;
float alpha[2] = {0.0f, 0.0f};
float X[] = { 0.986f, -0.775f };
int incX = -1;
float expected[] = { 0.986f, -0.775f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 118) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 118) imag");
};
};
};
{
int N = 1;
float alpha[2] = {0.1f, 0.0f};
float X[] = { 0.986f, -0.775f };
int incX = -1;
float expected[] = { 0.986f, -0.775f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 119) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 119) imag");
};
};
};
{
int N = 1;
float alpha[2] = {1.0f, 0.0f};
float X[] = { 0.986f, -0.775f };
int incX = -1;
float expected[] = { 0.986f, -0.775f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 120) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 120) imag");
};
};
};
{
int N = 1;
float alpha[2] = {0.0f, 0.1f};
float X[] = { 0.986f, -0.775f };
int incX = -1;
float expected[] = { 0.986f, -0.775f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 121) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 121) imag");
};
};
};
{
int N = 1;
float alpha[2] = {0.1f, 0.2f};
float X[] = { 0.986f, -0.775f };
int incX = -1;
float expected[] = { 0.986f, -0.775f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 122) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 122) imag");
};
};
};
{
int N = 1;
float alpha[2] = {1.0f, 0.3f};
float X[] = { 0.986f, -0.775f };
int incX = -1;
float expected[] = { 0.986f, -0.775f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 123) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 123) imag");
};
};
};
{
int N = 1;
double alpha[2] = {0, 0};
double X[] = { 0.454, -0.478 };
int incX = -1;
double expected[] = { 0.454, -0.478 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 124) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 124) imag");
};
};
};
{
int N = 1;
double alpha[2] = {0.1, 0};
double X[] = { 0.454, -0.478 };
int incX = -1;
double expected[] = { 0.454, -0.478 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 125) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 125) imag");
};
};
};
{
int N = 1;
double alpha[2] = {1, 0};
double X[] = { 0.454, -0.478 };
int incX = -1;
double expected[] = { 0.454, -0.478 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 126) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 126) imag");
};
};
};
{
int N = 1;
double alpha[2] = {0, 0.1};
double X[] = { 0.454, -0.478 };
int incX = -1;
double expected[] = { 0.454, -0.478 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 127) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 127) imag");
};
};
};
{
int N = 1;
double alpha[2] = {0.1, 0.2};
double X[] = { 0.454, -0.478 };
int incX = -1;
double expected[] = { 0.454, -0.478 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 128) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 128) imag");
};
};
};
{
int N = 1;
double alpha[2] = {1, 0.3};
double X[] = { 0.454, -0.478 };
int incX = -1;
double expected[] = { 0.454, -0.478 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 129) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 129) imag");
};
};
};
{
int N = 2;
float alpha = 0.0f;
float X[] = { 0.389f, -0.236f };
int incX = 1;
float expected[] = { 0.0f, -0.0f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 130)");
}
};
};
{
int N = 2;
float alpha = 0.1f;
float X[] = { 0.389f, -0.236f };
int incX = 1;
float expected[] = { 0.0389f, -0.0236f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 131)");
}
};
};
{
int N = 2;
float alpha = 1.0f;
float X[] = { 0.389f, -0.236f };
int incX = 1;
float expected[] = { 0.389f, -0.236f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 132)");
}
};
};
{
int N = 2;
double alpha = 0;
double X[] = { -0.429, -0.183 };
int incX = 1;
double expected[] = { -0.0, -0.0 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 133)");
}
};
};
{
int N = 2;
double alpha = 0.1;
double X[] = { -0.429, -0.183 };
int incX = 1;
double expected[] = { -0.0429, -0.0183 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 134)");
}
};
};
{
int N = 2;
double alpha = 1;
double X[] = { -0.429, -0.183 };
int incX = 1;
double expected[] = { -0.429, -0.183 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 135)");
}
};
};
{
int N = 2;
float alpha[2] = {0.0f, 0.0f};
float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
int incX = 1;
float expected[] = { -0.0f, 0.0f, 0.0f, 0.0f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 136) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 136) imag");
};
};
};
{
int N = 2;
float alpha[2] = {0.1f, 0.0f};
float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
int incX = 1;
float expected[] = { -0.0603f, 0.0239f, 0.0339f, -0.058f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 137) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 137) imag");
};
};
};
{
int N = 2;
float alpha[2] = {1.0f, 0.0f};
float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
int incX = 1;
float expected[] = { -0.603f, 0.239f, 0.339f, -0.58f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 138) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 138) imag");
};
};
};
{
int N = 2;
float alpha[2] = {0.0f, 0.1f};
float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
int incX = 1;
float expected[] = { -0.0239f, -0.0603f, 0.058f, 0.0339f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 139) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 139) imag");
};
};
};
{
int N = 2;
float alpha[2] = {0.1f, 0.2f};
float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
int incX = 1;
float expected[] = { -0.1081f, -0.0967f, 0.1499f, 0.0098f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 140) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 140) imag");
};
};
};
{
int N = 2;
float alpha[2] = {1.0f, 0.3f};
float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
int incX = 1;
float expected[] = { -0.6747f, 0.0581f, 0.513f, -0.4783f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 141) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 141) imag");
};
};
};
{
int N = 2;
double alpha[2] = {0, 0};
double X[] = { -0.956, 0.613, 0.443, 0.503 };
int incX = 1;
double expected[] = { -0.0, 0.0, 0.0, 0.0 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 142) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 142) imag");
};
};
};
{
int N = 2;
double alpha[2] = {0.1, 0};
double X[] = { -0.956, 0.613, 0.443, 0.503 };
int incX = 1;
double expected[] = { -0.0956, 0.0613, 0.0443, 0.0503 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 143) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 143) imag");
};
};
};
{
int N = 2;
double alpha[2] = {1, 0};
double X[] = { -0.956, 0.613, 0.443, 0.503 };
int incX = 1;
double expected[] = { -0.956, 0.613, 0.443, 0.503 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 144) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 144) imag");
};
};
};
{
int N = 2;
double alpha[2] = {0, 0.1};
double X[] = { -0.956, 0.613, 0.443, 0.503 };
int incX = 1;
double expected[] = { -0.0613, -0.0956, -0.0503, 0.0443 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 145) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 145) imag");
};
};
};
{
int N = 2;
double alpha[2] = {0.1, 0.2};
double X[] = { -0.956, 0.613, 0.443, 0.503 };
int incX = 1;
double expected[] = { -0.2182, -0.1299, -0.0563, 0.1389 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 146) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 146) imag");
};
};
};
{
int N = 2;
double alpha[2] = {1, 0.3};
double X[] = { -0.956, 0.613, 0.443, 0.503 };
int incX = 1;
double expected[] = { -1.1399, 0.3262, 0.2921, 0.6359 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 147) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 147) imag");
};
};
};
{
int N = 2;
float alpha = 0.0f;
float X[] = { 0.629f, -0.419f };
int incX = -1;
float expected[] = { 0.629f, -0.419f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 148)");
}
};
};
{
int N = 2;
float alpha = 0.1f;
float X[] = { 0.629f, -0.419f };
int incX = -1;
float expected[] = { 0.629f, -0.419f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 149)");
}
};
};
{
int N = 2;
float alpha = 1.0f;
float X[] = { 0.629f, -0.419f };
int incX = -1;
float expected[] = { 0.629f, -0.419f };
cblas_sscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], flteps, "sscal(case 150)");
}
};
};
{
int N = 2;
double alpha = 0;
double X[] = { 0.398, -0.656 };
int incX = -1;
double expected[] = { 0.398, -0.656 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 151)");
}
};
};
{
int N = 2;
double alpha = 0.1;
double X[] = { 0.398, -0.656 };
int incX = -1;
double expected[] = { 0.398, -0.656 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 152)");
}
};
};
{
int N = 2;
double alpha = 1;
double X[] = { 0.398, -0.656 };
int incX = -1;
double expected[] = { 0.398, -0.656 };
cblas_dscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 153)");
}
};
};
{
int N = 2;
float alpha[2] = {0.0f, 0.0f};
float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
int incX = -1;
float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 154) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 154) imag");
};
};
};
{
int N = 2;
float alpha[2] = {0.1f, 0.0f};
float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
int incX = -1;
float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 155) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 155) imag");
};
};
};
{
int N = 2;
float alpha[2] = {1.0f, 0.0f};
float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
int incX = -1;
float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 156) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 156) imag");
};
};
};
{
int N = 2;
float alpha[2] = {0.0f, 0.1f};
float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
int incX = -1;
float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 157) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 157) imag");
};
};
};
{
int N = 2;
float alpha[2] = {0.1f, 0.2f};
float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
int incX = -1;
float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 158) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 158) imag");
};
};
};
{
int N = 2;
float alpha[2] = {1.0f, 0.3f};
float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
int incX = -1;
float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
cblas_cscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 159) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 159) imag");
};
};
};
{
int N = 2;
double alpha[2] = {0, 0};
double X[] = { 0.521, -0.811, 0.556, -0.147 };
int incX = -1;
double expected[] = { 0.521, -0.811, 0.556, -0.147 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 160) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 160) imag");
};
};
};
{
int N = 2;
double alpha[2] = {0.1, 0};
double X[] = { 0.521, -0.811, 0.556, -0.147 };
int incX = -1;
double expected[] = { 0.521, -0.811, 0.556, -0.147 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 161) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 161) imag");
};
};
};
{
int N = 2;
double alpha[2] = {1, 0};
double X[] = { 0.521, -0.811, 0.556, -0.147 };
int incX = -1;
double expected[] = { 0.521, -0.811, 0.556, -0.147 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 162) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 162) imag");
};
};
};
{
int N = 2;
double alpha[2] = {0, 0.1};
double X[] = { 0.521, -0.811, 0.556, -0.147 };
int incX = -1;
double expected[] = { 0.521, -0.811, 0.556, -0.147 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 163) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 163) imag");
};
};
};
{
int N = 2;
double alpha[2] = {0.1, 0.2};
double X[] = { 0.521, -0.811, 0.556, -0.147 };
int incX = -1;
double expected[] = { 0.521, -0.811, 0.556, -0.147 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 164) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 164) imag");
};
};
};
{
int N = 2;
double alpha[2] = {1, 0.3};
double X[] = { 0.521, -0.811, 0.556, -0.147 };
int incX = -1;
double expected[] = { 0.521, -0.811, 0.556, -0.147 };
cblas_zscal(N, alpha, X, incX);
{
int i;
for (i = 0; i < 2; i++) {
gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 165) real");
gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 165) imag");
};
};
};
}
void DSift::Extract(const float* gray_img, const uint32_t width,
const uint32_t height, vector<VlDsiftKeypoint>* frames,
vector<float>* descrs, uint32_t* dim)
{
if (frames != NULL)
frames->clear();
if (descrs == NULL || dim == NULL)
{
cerr << "NULL pointer for descriptors and dim" << endl;
exit(-1);
}
descrs->clear();
*dim = 0;
const uint32_t max_sz = *(std::max_element(sizes_.begin(), sizes_.end()));
const uint32_t len_img = width * height;
if (!has_setup_)
SetUp(width, height);
else
{
if (width != width_ || height != height_)
{
cerr << "ERROR: Image size not matching!" << endl;
exit(-1);
}
}
for (size_t i = 0; i < sizes_.size(); ++i)
{
const uint32_t sz = sizes_[i];
const int off = std::floor(1.5 * (max_sz - sz));
vl_dsift_set_bounds(dsift_model_, bound_minx_ + std::max(0, off),
bound_miny_ + std::max(0, off),
std::min((int) width - 1, bound_maxx_),
std::min((int) height - 1, bound_maxy_));
VlDsiftDescriptorGeometry geom;
geom.numBinX = DEFAULT_NUM_BIN_X;
geom.numBinY = DEFAULT_NUM_BIN_Y;
geom.numBinT = DEFAULT_NUM_BIN_T;
geom.binSizeX = sz;
geom.binSizeY = sz;
vl_dsift_set_geometry(dsift_model_, &geom);
/*
{
int stepX;
int stepY;
int minX;
int minY;
int maxX;
int maxY;
vl_bool useFlatWindow;
int numFrames = vl_dsift_get_keypoint_num(dsift_model_);
int descrSize = vl_dsift_get_descriptor_size(dsift_model_);
VlDsiftDescriptorGeometry g = *vl_dsift_get_geometry(dsift_model_);
vl_dsift_get_steps(dsift_model_, &stepY, &stepX);
vl_dsift_get_bounds(dsift_model_, &minY, &minX, &maxY, &maxX);
useFlatWindow = vl_dsift_get_flat_window(dsift_model_);
printf(
"vl_dsift: bounds: [minX,minY,maxX,maxY] = [%d, %d, %d, %d]\n",
minX + 1, minY + 1, maxX + 1, maxY + 1);
printf("vl_dsift: subsampling steps: stepX=%d, stepY=%d\n", stepX,
stepY);
printf(
"vl_dsift: num bins: [numBinT, numBinX, numBinY] = [%d, %d, %d]\n",
g.numBinT, g.numBinX, g.numBinY);
printf("vl_dsift: descriptor size: %d\n", descrSize);
printf("vl_dsift: bin sizes: [binSizeX, binSizeY] = [%d, %d]\n",
g.binSizeX, g.binSizeY);
printf("vl_dsift: flat window: %s\n", VL_YESNO(useFlatWindow));
printf("vl_dsift: window size: %g\n",
vl_dsift_get_window_size(dsift_model_));
printf("vl_dsift: num of features: %d\n", numFrames);
}
*/
const float sigma = 1.0 * sz / magnif_;
float* smooth_img = (float*) malloc(sizeof(float) * len_img);
memset(smooth_img, 0, sizeof(float) * len_img);
vl_imsmooth_f(smooth_img, width, gray_img, width, height, width, sigma,
sigma);
vl_dsift_process(dsift_model_, smooth_img);
free(smooth_img);
const int num_key_pts = vl_dsift_get_keypoint_num(dsift_model_);
const VlDsiftKeypoint* key_points = vl_dsift_get_keypoints(dsift_model_);
*dim = vl_dsift_get_descriptor_size(dsift_model_);
const float* features = vl_dsift_get_descriptors(dsift_model_);
float* f = (float*) malloc(sizeof(float) * num_key_pts * (*dim));
cblas_scopy(num_key_pts * (*dim), features, 1, f, 1);
cblas_sscal(num_key_pts * (*dim), 512.0f, f, 1);
for (uint32_t d = 0; d < num_key_pts; ++d)
{
const float norm = (key_points + d)->norm;
if (norm < contr_thrd_)
{
// remove low contrast
memset(f + d * (*dim), 0, sizeof(float) * (*dim));
}
else
{
for (uint32_t j = d * (*dim); j < (d + 1) * (*dim); ++j)
{
float tmp = VL_MIN(f[j], 255.0);
if (!float_desc_)
tmp = (int) tmp;
f[j] = tmp;
}
}
}
if (i == 0)
{
if (frames != NULL)
frames->reserve(num_key_pts * sizes_.size());
descrs->reserve(num_key_pts * sizes_.size() * (*dim));
}
if (frames != NULL)
frames->insert(frames->end(), key_points, key_points + num_key_pts);
descrs->insert(descrs->end(), f, f + num_key_pts * (*dim));
free(f);
}
}
inline void Matrix<float>::operator*=(float value)
{
cblas_sscal(shape().prod(), value, _data, 1);
}
void HostVector<float>::Scale(const float alpha) {
cblas_sscal(this->size_, alpha, this->vec_, 1);
}
void caffe_scal<float>(const int N, const float alpha, float *X) {
cblas_sscal(N, alpha, X, 1);
//std::copy(X, X + N, std::ostream_iterator<float>(std::cout, "\t"));
}
// In addition, MKL comes with an additional function axpby that is not present
// in standard blas. We will simply use a two-step (inefficient, of course) way
// to mimic that.
inline void cblas_saxpby(const int N, const float alpha, const float* X,
const int incX, const float beta, float* Y,
const int incY) {
cblas_sscal(N, beta, Y, incY);
cblas_saxpy(N, alpha, X, incX, Y, incY);
}
VALUE rb_blas_xscal_mod(int argc, VALUE *argv, VALUE self)
{
Matrix *dx;
int incx;
int n;
float da_f;
double da_d;
float da_c[2];
double da_z[2];
//char error_msg[64];
VALUE da_value, n_value, incx_value;
rb_scan_args(argc, argv, "12", &da_value, &incx_value, &n_value);
Data_Get_Struct(self, Matrix, dx);
if(incx_value == Qnil)
incx = 1;
else
incx = NUM2INT(incx_value);
if(n_value == Qnil)
n = dx->nrows;
else
n = NUM2INT(n_value);
if(dx == NULL || dx->ncols != 1)
{ //sprintf(error_msg, "Self is not a Vector");
rb_raise(rb_eRuntimeError, "Self is not a Vector");
}
switch(dx->data_type)
{
case Single_t: //s
if(da_value == Qnil)
da_f = (float) 1.0;
else
da_f = (float) NUM2DBL(da_value);
cblas_sscal(n , da_f, (float *)dx->data, incx );
break;
case Double_t: //d
if(da_value == Qnil)
da_d = (double) 1.0;
else
da_d = NUM2DBL(da_value);
cblas_dscal(n , da_d, (double *)dx->data, incx );
break;
case Complex_t: //c
if(da_value == Qnil)
{
da_c[0] = (float) 1.0;
da_c[1] = (float) 0.0;
}
else
{
da_c[0] = (float) NUM2DBL(rb_funcall( rb_intern("Complex"), rb_intern("real"), 1, da_value) );
da_c[1] = (float) NUM2DBL(rb_funcall(rb_intern("Complex"), rb_intern("image"), 1, da_value ) );
}
cblas_cscal(n , da_c, dx->data, incx );
break;
case Double_Complex_t: //z
if(da_value == Qnil)
{
da_z[0] = (double) 1.0;
da_z[1] = (double) 0.0;
}
else
{
da_z[0] = NUM2DBL(rb_funcall( rb_intern("Complex"), rb_intern("real"), 1, da_value) );
da_z[1] = NUM2DBL(rb_funcall(rb_intern("Complex"), rb_intern("image"), 1, da_value ) );
}
cblas_zscal(n , da_z, dx->data, incx );
break;
default:
//sprintf(error_msg, "Invalid data_type (%d) in Matrix", dx->data_type);
rb_raise(rb_eRuntimeError, "Invalid data_type (%d) in Matrix", dx->data_type);
break; //Never reaches here.
}
return self;
}
int CORE_ststrf(int M, int N, int IB, int NB,
float *U, int LDU,
float *A, int LDA,
float *L, int LDL,
int *IPIV,
float *WORK, int LDWORK,
int *INFO)
{
static float zzero = 0.0;
static float mzone =-1.0;
float alpha;
int i, j, ii, sb;
int im, ip;
/* Check input arguments */
*INFO = 0;
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (IB < 0) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDU < max(1,NB)) && (NB > 0)) {
coreblas_error(6, "Illegal value of LDU");
return -6;
}
if ((LDA < max(1,M)) && (M > 0)) {
coreblas_error(8, "Illegal value of LDA");
return -8;
}
if ((LDL < max(1,IB)) && (IB > 0)) {
coreblas_error(10, "Illegal value of LDL");
return -10;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
/* Set L to 0 */
memset(L, 0, LDL*N*sizeof(float));
ip = 0;
for (ii = 0; ii < N; ii += IB) {
sb = min(N-ii, IB);
for (i = 0; i < sb; i++) {
im = cblas_isamax(M, &A[LDA*(ii+i)], 1);
IPIV[ip] = ii+i+1;
if (fabsf(A[LDA*(ii+i)+im]) > fabsf(U[LDU*(ii+i)+ii+i])) {
/*
* Swap behind.
*/
cblas_sswap(i, &L[LDL*ii+i], LDL, &WORK[im], LDWORK );
/*
* Swap ahead.
*/
cblas_sswap(sb-i, &U[LDU*(ii+i)+ii+i], LDU, &A[LDA*(ii+i)+im], LDA );
/*
* Set IPIV.
*/
IPIV[ip] = NB + im + 1;
for (j = 0; j < i; j++) {
A[LDA*(ii+j)+im] = zzero;
}
}
if ((*INFO == 0) && (fabsf(A[LDA*(ii+i)+im]) == zzero)
&& (fabsf(U[LDU*(ii+i)+ii+i]) == zzero)) {
*INFO = ii+i+1;
}
alpha = ((float)1. / U[LDU*(ii+i)+ii+i]);
cblas_sscal(M, (alpha), &A[LDA*(ii+i)], 1);
cblas_scopy(M, &A[LDA*(ii+i)], 1, &WORK[LDWORK*i], 1);
cblas_sger(
CblasColMajor, M, sb-i-1,
(mzone), &A[LDA*(ii+i)], 1,
&U[LDU*(ii+i+1)+ii+i], LDU,
&A[LDA*(ii+i+1)], LDA );
ip = ip+1;
}
/*
* Apply the subpanel to the rest of the panel.
*/
if(ii+i < N) {
for(j = ii; j < ii+sb; j++) {
if (IPIV[j] <= NB) {
IPIV[j] = IPIV[j] - ii;
}
}
CORE_sssssm(
NB, N-(ii+sb), M, N-(ii+sb), sb, sb,
&U[LDU*(ii+sb)+ii], LDU,
&A[LDA*(ii+sb)], LDA,
&L[LDL*ii], LDL,
WORK, LDWORK, &IPIV[ii]);
for(j = ii; j < ii+sb; j++) {
if (IPIV[j] <= NB) {
IPIV[j] = IPIV[j] + ii;
}
}
}
}
return PLASMA_SUCCESS;
}
DLLEXPORT void s_scale(const blasint n, const float alpha, float x[]) {
cblas_sscal(n, alpha, x, 1);
}
void STARPU_SSCAL(int N, float alpha, float *X, int incX)
{
cblas_sscal(N, alpha, X, incX);
}
void CpuDevice<float>::Axpby(float alpha, const Values<float> &x, float beta, Values<float> *y) {
// TODO(robertsdionne): Figure out why clang thinks cblas_saxpby is an undefined symbol.
cblas_sscal(y->width, beta, y->values.data(), 1);
cblas_saxpy(x.width, alpha, x.values.data(), 1, y->values.data(), 1);
}
