void test_with (VP &v1, VP &v2, MP &m1) const {
{
// Rows and columns
initialize_matrix (m1);
for (int i = 0; i < N; ++ i) {
v1 = ublas::row (m1, i);
std::cout << "row (m, " << i << ") = " << v1 << std::endl;
v1 = ublas::column (m1, i);
std::cout << "column (m, " << i << ") = " << v1 << std::endl;
}
// Outer product
initialize_vector (v1);
initialize_vector (v2);
m1 = ublas::outer_prod (v1, v2);
std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
// Matrix vector product
initialize_matrix (m1);
initialize_vector (v1);
v2 = ublas::prod (m1, v1);
std::cout << "prod (m1, v1) = " << v2 << std::endl;
v2 = ublas::prod (v1, m1);
std::cout << "prod (v1, m1) = " << v2 << std::endl;
}
}
bool GLView::scr2world_z0(Vector2<double>& pos, Vector2<int> const& scr) const {
push_matrix();
initialize_matrix();
set_perspective_matrix();
double model[16], proj[16];
int view[4];
glGetDoublev(GL_MODELVIEW_MATRIX, model);
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetIntegerv(GL_VIEWPORT, view);
Vector3<double> v; // マウス座標に対応するカメラのznear面上のワールド座標
gluUnProject(GLdouble(scr.x), GLdouble(scr.y), 0.0, model, proj, view, &v.x, &v.y, &v.z);
// 透視射影の場合（正射影の場合は単純に(v.x, v.y)）
if ((0.0<v.z && v.z<eye_.z) || (eye_.z<v.z && v.z<0.0)) {
// 視線の先がz=0平面に交わる場合
double const denom = eye_.z-v.z;
pos.set((eye_.z*v.x-v.z*eye_.x)/denom, (eye_.z*v.y-v.z*eye_.y)/denom);
pop_matrix();
return true;
} else {
// 交わらない場合
pos.set(v.x-eye_.x, v.y-eye_.y);
pop_matrix();
return false;
}
}
void LinearSolver::initialize(const BC_SET * bcs)
{
if (bcs) {
if (! allowReinitialization_ ) throw ATC_Error("LinearSolver: reinitialization not allowed");
//if (! bcs_ ) throw ATC_Error("LinearSolver: adding constraints after constructing without constraints is not allowed");
// shallow --> deep copy
if (! bcs_ ) { // constraintHandlerType_ == NO_CONSTRAINTS
if (matrixModified_) {
throw ATC_Error("LinearSolver: adding constraints after constructing without constraints is not allowed if matrix has been modified");
}
else {
matrixCopy_ = *matrixSparse_;
matrixSparse_ = &matrixCopy_;
constraintHandlerType_ = -1;
setup();
}
}
bcs_ = bcs;
initializedMatrix_ = false;
initializedInverse_ = false;
if (matrixModified_) {
matrixCopy_ = matrixOriginal_;
matrixSparse_ = &matrixCopy_;
}
}
initialize_matrix();
initialize_inverse();
initialize_rhs();
initialized_ = true;
}
int main()
{
int size = SIZE;
int *first, *result;
monitor *m;
first = make_square_matrix(size);
result = make_square_matrix(size);
initialize_matrix(first, size);
NOTIFY(print_matrix(first, size, size));
m = monitor_init(SELF);
monitor_start(m);
multiply_matrix_symm_transp(first, result, size);
monitor_end(m);
monitor_print_stats(m, VERBOSE);
NOTIFY(print_matrix(result, size, size));
NOTIFY(verify_matrix(first, result, size));
monitor_free(m);
return 0;
}
void operator () (int runs, safe_tag) const {
try {
static M m1 (N, N), m2 (N, N), m3 (N, N);
initialize_matrix (m1);
initialize_matrix (m2);
boost::timer t;
for (int i = 0; i < runs; ++ i) {
m3 = - (m1 + m2);
// sink_matrix (m3);
}
footer<value_type> () (0, 2 * N * N, runs, t.elapsed ());
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
}
void operator () (int runs, fast_tag) const {
try {
static M m1 (N, N), m2 (N, N), m3 (N, N);
initialize_matrix (m1);
initialize_matrix (m2);
boost::timer t;
for (int i = 0; i < runs; ++ i) {
m3.assign (ublas::prod (m1, m2));
// sink_matrix (m3);
}
footer<value_type> () (N * N * N, N * N * (N - 1), runs, t.elapsed ());
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
}
graph_memory_model<T, matrix>(size_t fixed_matrix_size) : matrix_size(fixed_matrix_size)
{
if(fixed_matrix_size < 2) // minimum to get one arc into graph
{
throw std::invalid_argument("matrix must be minimum 2 rows / cols strong!");
}
initialize_matrix();
}
int inverse_matrix (MATRIX const *m, MATRIX *n)
/*****************************************************************************
******************************************************************************/
{
if (!M_SQUARE (*m))
{
printf ("ERROR (inverse_matrix): MATRIX must be square!\n");
print_matrix ("MATRIX:", m);
n->cols=0; n->rows=0;
return -1;
}
else
{
float det;
int res;
res = determinant (m,&det);
if (res == -1)
{
printf ("ERROR (inverse_matrix): singular MATRIX!\n");
print_matrix ("MATRIX:", m);
return -1;
}
else
{
initialize_matrix (n, MROWS (*m), MCOLS (*m));
if (MROWS (*m) == 1)
{
MDATA (*n, 0, 0) = 1 / det ;
}
else if (MROWS (*m) == 2)
{
MDATA (*n, 0, 0) = MDATA (*m, 1, 1) / det ;
MDATA (*n, 0, 1) = -MDATA (*m, 0, 1) / det ;
MDATA (*n, 1, 0) = -MDATA (*m, 1, 0) / det ;
MDATA (*n, 1, 1) = MDATA (*m, 0, 0) / det ;
}
else
{
MDATA (*n, 0, 0) = cross_product (m, 1, 1, 2, 2) / det ;
MDATA (*n, 0, 1) = -cross_product (m, 0, 1, 2, 2) / det ;
MDATA (*n, 0, 2) = cross_product (m, 0, 1, 1, 2) / det ;
MDATA (*n, 1, 0) = -cross_product (m, 1, 0, 2, 2) / det ;
MDATA (*n, 1, 1) = cross_product (m, 0, 0, 2, 2) / det ;
MDATA (*n, 1, 2) = -cross_product (m, 0, 0, 1, 2) / det ;
MDATA (*n, 2, 0) = cross_product (m, 1, 0, 2, 1) / det ;
MDATA (*n, 2, 1) = -cross_product (m, 0, 0, 2, 1) / det ;
MDATA (*n, 2, 2) = cross_product (m, 0, 0, 1, 1) / det ;
}
}
}
return 1;
}
void operator () (int runs, fast_tag) const {
try {
static M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
mr3 (m3, ublas::range (0, N), ublas::range (0, N));
initialize_matrix (mr1);
initialize_matrix (mr2);
boost::timer t;
for (int i = 0; i < runs; ++ i) {
mr3.assign (ublas::prod (mr1, mr2));
// sink_matrix (mr3);
}
footer<value_type> () (N * N * N, N * N * (N - 1), runs, t.elapsed ());
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
catch (...) {
std::cout << "unknown exception" << std::endl;
}
}
void operator () (VP &v1, VP &v2, MP &m1) const {
try {
// Rows and columns
initialize_matrix (m1, ublas::lower_tag ());
for (int i = 0; i < N; ++ i) {
v2 = ublas::row (m1, i);
std::cout << "row (m, " << i << ") = " << v2 << std::endl;
v2 = ublas::column (m1, i);
std::cout << "column (m, " << i << ") = " << v2 << std::endl;
}
// Outer product
initialize_vector (v1);
initialize_vector (v2);
v1 (0) = 0;
v1 (N - 1) = 0;
v2 (0) = 0;
v2 (N - 1) = 0;
m1 = ublas::outer_prod (v1, v2);
std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
// Matrix vector product
initialize_matrix (m1, ublas::lower_tag ());
initialize_vector (v1);
v2 = ublas::prod (m1, v1);
std::cout << "prod (m1, v1) = " << v2 << std::endl;
v2 = ublas::prod (v1, m1);
std::cout << "prod (v1, m1) = " << v2 << std::endl;
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
catch (...) {
std::cout << "unknown exception" << std::endl;
}
}
int main(void)
{
// Structs for timing data.
struct rusage before, after;
double ti_multiply=0.0;
// Seed random number generator.
srand(time(NULL));
// Initalize matrixes. Change values here for different size matrices.
MATRIX* m1 = malloc(sizeof(MATRIX));
MATRIX* m2 = malloc(sizeof(MATRIX));
initialize_matrix(10,10,m1);
initialize_matrix(10,10,m2);
MATRIX* m3 = malloc(sizeof(MATRIX));
// Calculate time while multiplying.
getrusage(RUSAGE_SELF, &before);
strassen_mult(m1,m2,m3);
getrusage(RUSAGE_SELF, &after);
ti_multiply = calculate(&before, &after);
// Print out matrices to stdout. Comment this section out for large matrices.
print_matrix(m1);
print_matrix(m2);
print_matrix(m3);
// Print out computation time.
printf("\nTime Spent (in sec): %f\n", (ti_multiply));
// Free matrices when done with them.
free_matrix(m1);
free_matrix(m2);
free_matrix(m3);
}
void master(int nproc) {
int size = nproc;
int** result_matrix = NULL;
result_matrix = initialize_matrix(result_matrix, size, size);
for (int i = 0; i < nproc; i++) {
MPI_Send(&size, 1, MPI_INT, i + 1, i + 1, MPI_COMM_WORLD);
int* vector_a = new int[size];
int* vector_b = new int[size];
for (int k = 0; k < size; k++) {
vector_a[k] = matrix_a[k][i];
vector_a[k] = matrix_a[k][i];
vector_a[k] = matrix_a[k][i];
}
print_vector_with_message(vector_a, size, "-------------MASTER VECTOR A-----------");
for (int k = 0; k < size; k++) {
vector_b[k] = matrix_b[i][k];
vector_b[k] = matrix_b[i][k];
vector_b[k] = matrix_b[i][k];
}
print_vector_with_message(vector_b, size, "-------------MASTER VECTOR B-----------");
MPI_Send(vector_a, size, MPI_INT, i + 1, i + 1, MPI_COMM_WORLD);
MPI_Send(vector_b, size, MPI_INT, i + 1, i + 1, MPI_COMM_WORLD);
}
for (int p = 0; p < nproc; p++) {
int index = 0;
int* matrix_temp_1d = new int[size * size];
MPI_Recv(matrix_temp_1d, size * size, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUSES_IGNORE);
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
result_matrix[i][j] += matrix_temp_1d[index++];
}
}
}
print_matrix_with_message(result_matrix, size, size, "---------RESULT--------");
}
void operator () (int runs, safe_tag) const {
try {
static M m (N, N);
static V v1 (N), v2 (N);
initialize_matrix (m);
initialize_vector (v1);
boost::timer t;
for (int i = 0; i < runs; ++ i) {
v2 = ublas::prod (m, v1);
// sink_vector (v2);
}
footer<value_type> () (N * N, N * (N - 1), runs, t.elapsed ());
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
}
void operator () (int runs, fast_tag) const {
try {
static M m (N, N);
ublas::matrix_range<M> mr (m, ublas::range (0, N), ublas::range (0, N));
static V v1 (N), v2 (N);
ublas::vector_range<V> vr1 (v1, ublas::range (0, N)),
vr2 (v2, ublas::range (0, N));
initialize_matrix (mr);
initialize_vector (vr1);
boost::timer t;
for (int i = 0; i < runs; ++ i) {
vr2.assign (ublas::prod (mr, vr1));
// sink_vector (vr2);
}
footer<value_type> () (N * N, N * (N - 1), runs, t.elapsed ());
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
}
void LinearSolver::eigen_system( DENS_MAT & eigenvalues, DENS_MAT & eigenvectors, const DENS_MAT * M) /* const */
{
initialize_matrix(); // no inverse needed
const DENS_MAT * Kp = NULL;
const DENS_MAT * Mp =M;
DENS_MAT MM;
DENS_MAT KM;
if (constraintHandlerType_ == CONDENSE_CONSTRAINTS) {
Kp = &matrixFreeFree_;
if (M) {
DENS_MAT MfreeFixed; // not used
M->row_partition(freeSet_,MM,MfreeFixed);
Mp = &MM;
}
}
else {
if (matrixDense_.nRows() == 0) matrixDense_ =matrixSparse_->dense_copy();
Kp = &matrixDense_;
}
if (!M) {
MM.identity(Kp->nRows());
Mp = &MM;
}
DENS_MAT eVecs, eVals;
eVecs = eigensystem(*Kp,*Mp,eVals);
eigenvalues.reset(nVariables_,1);
eigenvectors.reset(nVariables_,nVariables_);
set<int>::const_iterator itr;
for (int i = 0; i < Kp->nRows(); i++) { // ordering is by energy not node
eigenvalues(i,0) = eVals(i,0);
int j = 0;
for (itr = freeSet_.begin(); itr != freeSet_.end(); itr++,j++) {
int jj = *itr;
eigenvectors(jj,i) = eVecs(j,i); // transpose
}
}
}
void slave(int slave_rank) {
int slave_size = 0;
MPI_Recv(&slave_size, 1, MPI_INT, 0, slave_rank, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
int* vector_a = new int[slave_size];
int* vector_b = new int[slave_size];
MPI_Recv(vector_a, slave_size, MPI_INT, 0, slave_rank, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(vector_b, slave_size, MPI_INT, 0, slave_rank, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
int** matrix_c_temp = NULL;
matrix_c_temp = initialize_matrix(matrix_c_temp, slave_size, slave_size);
for (int k = 0; k < slave_size; k++) {
for (int q = 0; q < slave_size; q++) {
matrix_c_temp[k][q] = vector_a[k] * vector_b[q];
}
}
int* matrix_c_temp_1d = new int[slave_size * slave_size];
int index = 0;
for (int k = 0; k < slave_size; k++) {
for (int q = 0; q < slave_size; q++) {
matrix_c_temp_1d[index++] = matrix_c_temp[k][q];
}
}
int offset = 0;
MPI_Send(matrix_c_temp_1d + offset, index, MPI_INT, 0, slave_rank, MPI_COMM_WORLD);
delete[] matrix_c_temp_1d;
delete[] vector_a;
delete[] vector_b;
}
int xplor_read(char *filename)
/*
READ XPLOR DATA MATRIX
GWV: April 2009; adjusted for funny Intel Mac problems; adjust HEADER and FOOTER defs for other platforms
*/
{
FILE *fp;
int i, n;
long pos;
int vdw, flag, junk1, junk2;
int nasq; // MIND THAT THIS IS A FORTRAN INTEGER IN xplor-nih/source/mmdisg.f on line 51:
// INTEGER VALPTR, NSLCT, NMETR, BUNIT, LENGTH
printf ("DEBUG: nmv.xplor_read %s\n", filename);
// OPEN BINARY FILE
fp = fopen(filename, "rb");
if (fp==NULL) {
printf("Error: opening file %s\n", filename);
printf("... Bailing out ...\n");
exit(1);
}
printf("Reading at pos: %ld\n", ftell(fp));
fread(&flag, (size_t) sizeof(int), (size_t) 1, fp);
// READ NATOMS SQUARED
printf("Reading at pos: %ld\n", ftell(fp));
// fread(&nasq, (size_t) sizeof(nasq), (size_t) 1, fp); # sanders latest code
fread(&nasq, (size_t) sizeof(int), (size_t) 1, fp);
// READ JUNK
fread(&junk1, (size_t) sizeof(int), (size_t) 1, fp);
fread(&junk2, (size_t) sizeof(int), (size_t) 1, fp);
printf("DEBUG: int flag: %d\n", flag);
printf("DEBUG: int nasq: %d\n", nasq);
printf("DEBUG: int junk1: %d\n", junk1);
printf("DEBUG: int junk2: %d\n", junk2);
if (nasq < 4){
printf("Error xplor_read: too small value nasq (%d); probable error with file %s\n", nasq, filename);
printf("... Bailing out ...\n");
exit(1);
}
natoms = (int) sqrt(nasq);
printf("natoms> %d\n", natoms);
/** Inserted extra check when having problems reading the file and this code found a million+ atoms that were then allocated in a squared matrix ;-)*/
if (natoms > 999999){
printf("Error xplor_read: too large number of atoms %d\n", natoms);
exit(1);
}
printf("DEBUG: INITIALIZE MATRIX\n");
initialize_matrix();
printf("DEBUG: Read the matrix\n");
for (i=0; i<natoms; i++) {
// Read n atom floats
// printf("Starting at pos: %ld\n", ftell(fp));
n = (int) fread(dist_mtrx[i], (size_t) sizeof(float), (size_t) natoms, fp);
// printf("Ending at pos: %ld\n", ftell(fp));
// printf(">i,n %d %d\n", i, n);
if (n != natoms) {
if (feof(fp)) {
fprintf(stderr, "End of file found\n");
} else {
fprintf(stderr, "Read error\n");
}
printf(">i,n %d %d\n", i, n);
printf("Error xplor_read: only %d values while reading row %d\n", n, i);
printf("... Bailing out ...\n");
exit(1);
}
// for(j=0;j<10;j++)
// printf("i,j,d %d %d> %10.3e\n", i, j, dist_mtrx[i][j]);
// for(j=natoms-10;j<natoms;j++)
// printf("%d %d> %10.3e\n", i, j, dist_mtrx[i][j]);
// Read a footer after every row
fread(&junk1, (size_t) sizeof(int), (size_t) 1, fp);
fread(&junk2, (size_t) sizeof(int), (size_t) 1, fp);
}
printf("DEBUG: read final completion code indicator of XPLOR\n");
n = fread(&vdw, (size_t) sizeof(int), (size_t) 1, fp);
printf ("vdw> %d\n", vdw);
if (vdw != -1) {
printf("Error: xplor_read: VDW flag is set to %d.\n",vdw);
printf("... Bailing out ...\n");
exit(1);
}
printf("DEBUG: CLOSE THE FILE\n");
fclose(fp);
return natoms;
}
void test_expression_with (MP &m1, MP &m2, MP &m3) const {
value_type t;
// Default Construct
default_construct<MP>::test ();
// Copy and swap
initialize_matrix (m1);
initialize_matrix (m2);
m1 = m2;
std::cout << "m1 = m2 = " << m1 << std::endl;
m1.assign_temporary (m2);
std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
m1.swap (m2);
std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
// Zero assignment
m1 = ublas::zero_matrix<> (m1.size1 (), m1.size2 ());
std::cout << "m1.zero_matrix = " << m1 << std::endl;
m1 = m2;
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
// Project range and slice
initialize_matrix (m1);
initialize_matrix (m2);
project (m1, ublas::range(0,1),ublas::range(0,1)) = project (m2, ublas::range(0,1),ublas::range(0,1));
project (m1, ublas::range(0,1),ublas::range(0,1)) = project (m2, ublas::slice(0,1,1),ublas::slice(0,1,1));
project (m1, ublas::slice(2,-1,2),ublas::slice(2,-1,2)) = project (m2, ublas::slice(0,1,2),ublas::slice(0,1,2));
project (m1, ublas::slice(2,-1,2),ublas::slice(2,-1,2)) = project (m2, ublas::range(0,2),ublas::range(0,2));
std::cout << "m1 = range/slice " << m1 << std::endl;
#endif
// Unary matrix operations resulting in a matrix
initialize_matrix (m1);
m2 = - m1;
std::cout << "- m1 = " << m2 << std::endl;
m2 = ublas::conj (m1);
std::cout << "conj (m1) = " << m2 << std::endl;
// Binary matrix operations resulting in a matrix
initialize_matrix (m1);
initialize_matrix (m2);
m3 = m1 + m2;
std::cout << "m1 + m2 = " << m3 << std::endl;
m3 = m1 - m2;
std::cout << "m1 - m2 = " << m3 << std::endl;
m3 = ublas::element_prod (m1, m2);
std::cout << "element_prod (m1, m2) = " << m3 << std::endl;
// Scaling a matrix
t = N;
initialize_matrix (m1);
m2 = value_type (1.) * m1;
std::cout << "1. * m1 = " << m2 << std::endl;
m2 = t * m1;
std::cout << "N * m1 = " << m2 << std::endl;
initialize_matrix (m1);
m2 = m1 * value_type (1.);
std::cout << "m1 * 1. = " << m2 << std::endl;
m2 = m1 * t;
std::cout << "m1 * N = " << m2 << std::endl;
m2 = m1 / value_type (2.);
std::cout << "m1 / 2. = " << m2 << std::endl;
m2 = m1 / t;
std::cout << "m1 / N = " << m2 << std::endl;
// Some assignments
initialize_matrix (m1);
initialize_matrix (m2);
m2 += m1;
std::cout << "m2 += m1 = " << m2 << std::endl;
m2 -= m1;
std::cout << "m2 -= m1 = " << m2 << std::endl;
m2 = m2 + m1;
std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
m2 = m2 - m1;
std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
m1 *= value_type (1.);
std::cout << "m1 *= 1. = " << m1 << std::endl;
m1 *= t;
std::cout << "m1 *= N = " << m1 << std::endl;
// Transpose
initialize_matrix (m1);
m2 = ublas::trans (m1);
std::cout << "trans (m1) = " << m2 << std::endl;
// Hermitean
initialize_matrix (m1);
m2 = ublas::herm (m1);
std::cout << "herm (m1) = " << m2 << std::endl;
// Matrix multiplication
initialize_matrix (m1);
initialize_matrix (m2);
m3 = ublas::prod (m1, m2);
std::cout << "prod (m1, m2) = " << m3 << std::endl;
}
int main(int argc, char *argv[]) {
FILE *FptrNumDocs;
ENVIRONMENT env;
char *model_data_dir;
char pathbuf[BUFSIZ];
char *col_label_file;
int write_matlab;
int col_labels_from_file;
int rows, columns;
MODEL_PARAMS model_params;
MODEL_INFO model_info;
env.word_array = NULL;
env.word_tree = NULL;
if ( argc != 17 ) usage_and_exit( argv[0], 1 );
if ( strcmp( argv[1], "-mdir" ) != 0 ) usage_and_exit( argv[0], 1 );
model_data_dir = argv[2];
if ( strcmp( argv[3], "-matlab" ) != 0 ) usage_and_exit( argv[0], 1 );
write_matlab = atoi( argv[4] );
if ( strcmp( argv[5], "-precontext" ) != 0 ) usage_and_exit( argv[0], 1 );
pre_context_size = atoi( argv[6] );
if ( strcmp( argv[7], "-postcontext" ) != 0 ) usage_and_exit( argv[0], 1 );
post_context_size = atoi( argv[8] );
if ( strcmp( argv[9], "-rows" ) != 0 ) usage_and_exit( argv[0], 1 );
rows = atoi( argv[10] );
if ( strcmp( argv[11], "-columns" ) != 0 ) usage_and_exit( argv[0], 1 );
columns = atoi( argv[12] );
if ( strcmp( argv[13], "-col_labels_from_file" ) != 0 ) usage_and_exit( argv[0], 1 );
col_labels_from_file = atoi( argv[14] );
if ( strcmp( argv[15], "-col_label_file" ) != 0 ) usage_and_exit( argv[0], 1 );
col_label_file = argv[16];
fprintf( stderr, "model data dir is \"%s\".\n", model_data_dir );
/** Read in current model params **/
sprintf( pathbuf, "%s/%s", model_data_dir, MODEL_PARAMS_BIN_FILE );
if ( !read_model_params( pathbuf, &model_params )) {
die( "count_wordvec.c: couldn't read model data file\n" );
}
sprintf( pathbuf, "%s/%s", model_data_dir, MODEL_INFO_BIN_FILE );
if ( !read_model_info( pathbuf, &model_info )) {
die( "count_wordvec.c: couldn't read model info file\n" );
}
if (model_params.rows < rows) {
rows = model_params.rows;
} else {
model_params.rows = rows;
}
printf("count_wordvec.c: looking for %d rows\n", rows);
printf("which had better match %d\n", model_params.rows);
model_info.columns = columns;
model_info.col_labels_from_file = col_labels_from_file;
model_info.pre_context_size = pre_context_size;
model_info.post_context_size = post_context_size;
model_info.blocksize = BLOCKSIZE;
model_info.start_columns = START_COLUMNS;
message( "Reading the dictionary... ");
if( !read_dictionary( &(env.word_array), &(env.word_tree), model_data_dir ))
die( "count_wordvec.c: Can't read the dictionary.\n");
/*** read number of ducuments from file ***/
sprintf( pathbuf, "%s/%s", model_data_dir, FNUM_FILE );
if ( !my_fopen( &FptrNumDocs, pathbuf, "r" ))
die( "couldn't open filenames file" );
if( !fscanf( FptrNumDocs, "%d", &numDocs ))
die( "can't read numDocs" );
if( !my_fclose( &FptrNumDocs ))
die( "couldn't close numDocs file" );
/*****/
/* Set some initial values in the matrix, arrays etc. */
if( !initialize_row_indices( env.word_array, &(env.row_indices),
rows ))
die( "Couldn't initialize row indices.\n");
if( !initialize_column_indices( env.word_array, &(env.col_indices),
columns, col_labels_from_file, col_label_file, &(env.word_tree) ))
die( "Couldn't initialize column indices.\n");
/* Allocate memory and set everything to zero.
Defined in matrix.h */
if( !initialize_matrix( (MATRIX_TYPE***) &(env.matrix), rows, columns))
die( "Can't initialize matrix.\n");
/* Go through the wordlist, applying process_region to all regions. */
fprintf( stderr, "model data dir is \"%s\".\n", model_data_dir );
fprintf( stderr, "count_wordvec.c: about to call process_wordlist\n" );
if( !process_wordlist( is_target, advance_target,
set_region_in, set_region_out,
process_region , &env, model_data_dir))
die( "Couldn't process wordlist.\n");
/* Perform some conversion on the matrix.
E.g. some kind of normalization. We traditionally take the square root
of all entries. */
if( !transform_matrix( (MATRIX_TYPE **) (env.matrix), rows, columns))
die( "Couldn't transform matrix.\n");
/* Write the co-occurrence matrix. */
message( "Writing the co-occurrence matrix.\n");
if( !write_matrix_svd((MATRIX_TYPE **) (env.matrix),
rows, columns, model_data_dir ))
die( "count_wordvec.c: couldn't write co-occurrence "
"matrix in SVD input format.\n" );
if ( write_matlab ) {
if ( !write_matrix_matlab( (MATRIX_TYPE **)(env.matrix),
rows, columns, model_data_dir ))
die( "count_wordvec.c: couldn't write co-occurrence "
"matrix in Matlab input format.\n" );
}
sprintf( pathbuf, "%s/%s", model_data_dir, MODEL_PARAMS_BIN_FILE );
if ( !write_model_params( pathbuf, &model_params )) {
die( "count_wordvec.c: couldn't write model params file\n" );
}
sprintf( pathbuf, "%s/%s", model_data_dir, MODEL_INFO_BIN_FILE );
if ( !write_model_info( pathbuf, &model_info )) {
die( "count_wordvec.c: couldn't write model info file\n" );
}
exit( EXIT_SUCCESS);
}
graph_memory_model<T, matrix>() : matrix_size(default_matrix_size)
{
initialize_matrix();
}
string longestPalindrome(string s)
{
int n = s.length();
if(s == "")
{
return s;
}
int **matrix = new int*[n];
for(int i = 0; i < n; i++)
{
matrix[i] = new int[n];
}
initialize_matrix(matrix, n);
for(int i = 0; i < n; i++)
{
matrix[i][i] = 1;
}
int curr_length = 0;
int max_length = 0;
int start = 0;
int last = 0;
for(int j = 1; j < n ; j++)
{
curr_length = j+1;
for(int i = 0; i+j < n; i++)
{
if(s[i] == s[i + j] && (matrix[i+1][i + j - 1] == 1 || matrix[i+1][i + j -1] == -1))
{
if(max_length < curr_length)
{
cout << endl << "i:" << i << "\t" << "i+j :"<< i+j;
start = i;
last = i + j;
max_length = curr_length;
}
matrix[i][i+j] = 1;
}
else
{
matrix[i][i+j] = 0;
}
// }
}
}
/*for(int val = start; val <= last ; val++)
{
cout << s[val];
}*/
//print_matrix(matrix, n);
//cout << endl << max_length;
return s.substr(start,(last - start + 1));
}
void test_with (MP &m1, MP &m2, MP &m3) const {
{
value_type t;
// Default Construct
default_construct<MP>::test ();
// Copy and swap
initialize_matrix (m1);
initialize_matrix (m2);
m1 = m2;
std::cout << "m1 = m2 = " << m1 << std::endl;
m1.assign_temporary (m2);
std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
m1.swap (m2);
std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
// Unary matrix operations resulting in a matrix
initialize_matrix (m1);
m2 = - m1;
std::cout << "- m1 = " << m2 << std::endl;
m2 = ublas::conj (m1);
std::cout << "conj (m1) = " << m2 << std::endl;
// Binary matrix operations resulting in a matrix
initialize_matrix (m1);
initialize_matrix (m2);
m3 = m1 + m2;
std::cout << "m1 + m2 = " << m3 << std::endl;
m3 = m1 - m2;
std::cout << "m1 - m2 = " << m3 << std::endl;
// Scaling a matrix
t = N;
initialize_matrix (m1);
m2 = value_type (1.) * m1;
std::cout << "1. * m1 = " << m2 << std::endl;
m2 = t * m1;
std::cout << "N * m1 = " << m2 << std::endl;
initialize_matrix (m1);
m2 = m1 * value_type (1.);
std::cout << "m1 * 1. = " << m2 << std::endl;
m2 = m1 * t;
std::cout << "m1 * N = " << m2 << std::endl;
// Some assignments
initialize_matrix (m1);
initialize_matrix (m2);
m2 += m1;
std::cout << "m2 += m1 = " << m2 << std::endl;
m2 -= m1;
std::cout << "m2 -= m1 = " << m2 << std::endl;
m2 = m2 + m1;
std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
m2 = m2 - m1;
std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
m1 *= value_type (1.);
std::cout << "m1 *= 1. = " << m1 << std::endl;
m1 *= t;
std::cout << "m1 *= N = " << m1 << std::endl;
// Transpose
initialize_matrix (m1);
// Transpose of a triangular isn't triangular of the same kind
std::cout << "trans (m1) = " << ublas::trans (m1) << std::endl;
// Hermitian
initialize_matrix (m1);
// Hermitian of a triangular isn't hermitian of the same kind
std::cout << "herm (m1) = " << ublas::herm (m1) << std::endl;
// Matrix multiplication
initialize_matrix (m1);
initialize_matrix (m2);
m3 = ublas::prod (m1, m2);
std::cout << "prod (m1, m2) = " << m3 << std::endl;
}
}
int main(int argc, char *argv[])
{
int ret;
int choice;
int i, j;
float Ts=0.002;
float T;
float vm=0.05; //mean speed
matrix xd, xd_dot, J;
float q0[5], q_final[5];
float p0[3];
float p1[3];
DUNIT *unit;
unsigned short motor[NUM_MOTORS];
unsigned char sensor[NUM_SENSORS];
pSM = (SM*) mbuff_alloc(NAME_OF_MEMORY, sizeof(SM));
if(pSM == NULL) {
perror("mbuff_alloc failed");
return -1;
}
// Header = 1,;
// Step = 2,
motor[0] = 0;
motor[1] = 0;
motor[2] = 2100;
motor[3] = 4200;
motor[4] = -2500;
motor[5] = 0;
motor[6] = 18100;
motor[7] = -2100;
motor[8] = 1000;
motor[9] = 6200;
motor[10] = 0;
motor[11] = 0;
motor[12] = -2100;
motor[13] = -4180;
motor[14] = 2500;
motor[15] = 0;
motor[16] = -18810;
motor[17] = 2000;
motor[18] = -1000;
motor[19] = -6200;
motor[20] = 2100;
motor[21] = 60;
motor[22] = 60;
sensor[0] = 'R';
sensor[1] = 'R';
sensor[2] = 'R';
sensor[3] = 'R';
unit = (DUNIT*)&(pSM->Data.IntDat);
ret = send_commands(motor, sensor, unit);
pSM->VarIF.ResRep = 0;
pSM->VarIF.Mode = IDLE;
pSM->VarIF.InterruptSend = TRUE;
//watch return
readret(unit);
//desired final configuration
//q_final[0]=PI*3/5;
//q_final[1]=PI/3;
//q_final[2]=PI/6;
//q_final[3]=-PI/4;
//q_final[4]=0;
//evaluate_position(q_final, p1);
q0[4]=0;
open_hand (motor, sensor, unit);
while (1)
{
//present position
read_positions(unit, motor);
robot2DH (&motor[16], q0);
evaluate_position(q0, p0);
printf("\nPresent position: (%f,%f,%f)\n",p0[0],p0[1],p0[2]);
//select desired position
choice=select_desired_position (p1);
if (choice==-1) break;
if (choice==1) close_hand (motor, sensor, unit);
if (choice==2) open_hand (motor, sensor, unit);
printf("\nDesired final position: (%f,%f,%f)\n",p1[0],p1[1],p1[2]);
//execution time
T=evaluate_execution_time (p0, p1, vm);
//initializing matrixes
initialize_matrix (&xd, T/Ts+1, 3);
initialize_matrix (&xd_dot, T/Ts+1, 3);
initialize_matrix (&J, 3, 5);
//evaluate desired trajectory
trajectory_left_arm (Ts, T, p0, p1, &xd, &xd_dot);
//inverse kinematics
inverse_kinematics (Ts, T, &xd, &xd_dot, unit);
}
//close_hand (motor, sensor, unit);
free(xd.vector);
free(xd_dot.vector);
free(J.vector);
//free memory
mbuff_free(NAME_OF_MEMORY, (void*)pSM);
return 0;
}
void LinearSolver::greens_function(int I, VECTOR & G_I)
{
SPAR_MAT * A = NULL;
initialize_matrix();
initialize_inverse();
G_I.reset(nVariables_);
VECTOR & x = G_I;
if (solverType_ == ITERATIVE_SOLVE_SYMMETRIC) {
DENS_VEC b(nVariables_); b = 0.0; b(I) = 1.0;
if (parallel_) {
A = new PAR_SPAR_MAT(LammpsInterface::instance()->world(), *matrixSparse_);
}
else {
A = new SPAR_MAT(*matrixSparse_);
}
const DIAG_MAT & PC = matrixDiagonal_;
int niter = maxIterations_;
double tol = tol_;
int convergence = CG(*A, x, b, PC, niter, tol);
if (convergence>0) {
stringstream ss;
ss << "CG greens_function solve did not converge,";
ss << " iterations: " << niter;
ss << " residual: " << tol;
throw ATC_Error(ss.str());
}
}
else if (solverType_ == ITERATIVE_SOLVE) {
DENS_VEC b(nVariables_); b = 0.0; b(I) = 1.0;
// VECTOR & bb = b;
if (parallel_) {
A = new PAR_SPAR_MAT(LammpsInterface::instance()->world(), *matrixSparse_);
}
else {
A = new SPAR_MAT(*matrixSparse_);
}
// const DENS_MAT A = matrixSparse_->dense_copy();
const DIAG_MAT & PC = matrixDiagonal_;
int iterations = maxIterations_;
int restarts = maxRestarts_;
double tol = tol_;
DENS_MAT H(maxRestarts_+1, maxRestarts_);
DENS_VEC xx(nVariables_);
int convergence = GMRES(*A, xx, b, PC, H, restarts, iterations, tol);
if (convergence>0) {
stringstream ss;
ss << "GMRES greens_function solve did not converge,";
ss << " iterations: " << iterations;
ss << " residual: " << tol;
throw ATC_Error(ss.str());
}
x.copy(xx.ptr(),xx.nRows());
}
else {
const DENS_MAT & invA = matrixInverse_;
if (constraintHandlerType_ == CONDENSE_CONSTRAINTS) {
set<int>::const_iterator itr;
for (itr = fixedSet_.begin(); itr != fixedSet_.end(); itr++) {
int ii = *itr;
x(ii) = 0;
}
itr = freeSet_.find(I);
if (itr !=freeSet_.end() ) {
int j = freeGlobalToCondensedMap_[I];
int i = 0;
for (itr = freeSet_.begin(); itr != freeSet_.end(); itr++,i++) {
int ii = *itr;
x(ii) = invA(j,i);
}
}
}
else {
for (int i = 0; i < nVariables_; ++i) x(i) = invA(I,i);
}
}
delete A;
}
static int computeMatrixLMSOpt(TAsoc *cp_ass, int cnt, Tsc *estimacion) {
int i;
float LMETRICA2;
float X1[MAXLASERPOINTS], Y1[MAXLASERPOINTS];
float X2[MAXLASERPOINTS],Y2[MAXLASERPOINTS];
float X2Y2[MAXLASERPOINTS],X1X2[MAXLASERPOINTS];
float X1Y2[MAXLASERPOINTS], Y1X2[MAXLASERPOINTS];
float Y1Y2[MAXLASERPOINTS];
float K[MAXLASERPOINTS], DS[MAXLASERPOINTS];
float DsD[MAXLASERPOINTS], X2DsD[MAXLASERPOINTS], Y2DsD[MAXLASERPOINTS];
float Bs[MAXLASERPOINTS], BsD[MAXLASERPOINTS];
float A1, A2, A3, B1, B2, B3, C1, C2, C3, D1, D2, D3;
MATRIX matA,invMatA;
VECTOR vecB,vecSol;
A1=0;A2=0;A3=0;B1=0;B2=0;B3=0;
C1=0;C2=0;C3=0;D1=0;D2=0;D3=0;
LMETRICA2=params.LMET*params.LMET;
for (i=0; i<cnt; i++){
X1[i]=cp_ass[i].nx*cp_ass[i].nx;
Y1[i]=cp_ass[i].ny*cp_ass[i].ny;
X2[i]=cp_ass[i].rx*cp_ass[i].rx;
Y2[i]=cp_ass[i].ry*cp_ass[i].ry;
X2Y2[i]=cp_ass[i].rx*cp_ass[i].ry;
X1X2[i]=cp_ass[i].nx*cp_ass[i].rx;
X1Y2[i]=cp_ass[i].nx*cp_ass[i].ry;
Y1X2[i]=cp_ass[i].ny*cp_ass[i].rx;
Y1Y2[i]=cp_ass[i].ny*cp_ass[i].ry;
K[i]=X2[i]+Y2[i] + LMETRICA2;
DS[i]=Y1Y2[i] + X1X2[i];
DsD[i]=DS[i]/K[i];
X2DsD[i]=cp_ass[i].rx*DsD[i];
Y2DsD[i]=cp_ass[i].ry*DsD[i];
Bs[i]=X1Y2[i]-Y1X2[i];
BsD[i]=Bs[i]/K[i];
A1=A1 + (1-Y2[i]/K[i]);
B1=B1 + X2Y2[i]/K[i];
C1=C1 + (-cp_ass[i].ny + Y2DsD[i]);
D1=D1 + (cp_ass[i].nx - cp_ass[i].rx -cp_ass[i].ry*BsD[i]);
A2=B1;
B2=B2 + (1-X2[i]/K[i]);
C2=C2 + (cp_ass[i].nx-X2DsD[i]);
D2=D2 + (cp_ass[i].ny -cp_ass[i].ry +cp_ass[i].rx*BsD[i]);
A3=C1;
B3=C2;
C3=C3 + (X1[i] + Y1[i] - DS[i]*DS[i]/K[i]);
D3=D3 + (Bs[i]*(-1+DsD[i]));
}
initialize_matrix(&matA,3,3);
MDATA(matA,0,0)=A1; MDATA(matA,0,1)=B1; MDATA(matA,0,2)=C1;
MDATA(matA,1,0)=A2; MDATA(matA,1,1)=B2; MDATA(matA,1,2)=C2;
MDATA(matA,2,0)=A3; MDATA(matA,2,1)=B3; MDATA(matA,2,2)=C3;
if (inverse_matrix (&matA, &invMatA)==-1)
return -1;
#ifdef INTMATSM_DEB
print_matrix("inverted matrix", &invMatA);
#endif
initialize_vector(&vecB,3);
VDATA(vecB,0)=D1; VDATA(vecB,1)=D2; VDATA(vecB,2)=D3;
multiply_matrix_vector (&invMatA, &vecB, &vecSol);
estimacion->x=-VDATA(vecSol,0);
estimacion->y=-VDATA(vecSol,1);
estimacion->tita=-VDATA(vecSol,2);
return 1;
}
int main(){
printf("HOWDY lets multiply\n");
FILE* inA=fopen("inputA.txt","r"); //open files for reading and writing
FILE* inB=fopen("inputB.txt", "r");// r is read
FILE* outC= fopen("outputC.txt", "w");//w is write
int a_rows, a_columns, b_rows, b_columns;
fscanf(inA,"%d %d",&a_rows,&a_columns); // get number of rows and columns of A and B
fscanf(inB,"%d %d",&b_rows,&b_columns);
if (a_columns!=b_rows){//make sure we can multiply the matricies
printf("Err, matrix A columns not equal to matrix B rows");
return 0;
}
int c_rows=a_rows;
int c_columns=b_columns;
float** A=initialize_matrix(a_rows,a_columns);//initialize A
float** B=initialize_matrix(b_rows,b_columns);//initialize B
float temp;
int i=0; //populate A
for (i;i<a_rows;++i){
int j=0;
for(j;j<a_columns;++j){
fscanf(inA,"%f",&temp); //get single value from file
A[i][j]=temp;//store it in A
}
}
printf("Matrix A\n\n"); //show A to user
print_matrix(A,a_rows,a_columns);
i=0; //populate B
for (i;i<b_rows;++i){
int j=0;
for(j;j<b_columns;++j){
fscanf(inB,"%f",&temp); //get single value from file
B[i][j]=temp;//store it in A
}
}
printf("Matrix B\n\n"); //show B to user
print_matrix(B,b_rows,b_columns);
float** C=matrix_multiply(A,B,a_rows,a_columns,b_rows,b_columns); //Multiplies matrix, mallocs for C must delete later
printf("Matrix C=A*B\n\n"); //show C to user
print_matrix(C,c_rows,c_columns);
fprintf(outC,"%d %d\n",c_rows,c_columns);//write C rows and columns to output file
i=0;
for (i;i<c_rows;++i){
int j=0;
for (j;j<c_columns;++j){
fprintf(outC,"%f ",(float)C[i][j]); //write C values
}
}
char* _buf=NULL;
size_t _buf_size=256;
printf("input any char to exit\n");
getline(&_buf,&_buf_size,stdin); // keep window open in debugger
return 0;
}
void operator () (MP &m1, MP &m2, MP &m3) const {
try {
value_type t;
// Copy and swap
initialize_matrix (m1);
initialize_matrix (m2);
m1 = m2;
std::cout << "m1 = m2 = " << m1 << std::endl;
m1.assign_temporary (m2);
std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
m1.swap (m2);
std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
// Unary matrix operations resulting in a matrix
initialize_matrix (m1);
m2 = - m1;
std::cout << "- m1 = " << m2 << std::endl;
m2 = ublas::conj (m1);
std::cout << "conj (m1) = " << m2 << std::endl;
// Binary matrix operations resulting in a matrix
initialize_matrix (m1);
initialize_matrix (m2);
m3 = m1 + m2;
std::cout << "m1 + m2 = " << m3 << std::endl;
m3 = m1 - m2;
std::cout << "m1 - m2 = " << m3 << std::endl;
// Scaling a matrix
t = N;
initialize_matrix (m1);
m2 = value_type (1.) * m1;
std::cout << "1. * m1 = " << m2 << std::endl;
m2 = t * m1;
std::cout << "N * m1 = " << m2 << std::endl;
initialize_matrix (m1);
m2 = m1 * value_type (1.);
std::cout << "m1 * 1. = " << m2 << std::endl;
m2 = m1 * t;
std::cout << "m1 * N = " << m2 << std::endl;
// Some assignments
initialize_matrix (m1);
initialize_matrix (m2);
#ifdef BOOST_UBLAS_USE_ET
m2 += m1;
std::cout << "m2 += m1 = " << m2 << std::endl;
m2 -= m1;
std::cout << "m2 -= m1 = " << m2 << std::endl;
#else
m2 = m2 + m1;
std::cout << "m2 += m1 = " << m2 << std::endl;
m2 = m2 - m1;
std::cout << "m2 -= m1 = " << m2 << std::endl;
#endif
m1 *= value_type (1.);
std::cout << "m1 *= 1. = " << m1 << std::endl;
m1 *= t;
std::cout << "m1 *= N = " << m1 << std::endl;
// Transpose
initialize_matrix (m1);
m2 = ublas::trans (m1);
std::cout << "trans (m1) = " << m2 << std::endl;
// Hermitean
initialize_matrix (m1);
m2 = ublas::herm (m1);
std::cout << "herm (m1) = " << m2 << std::endl;
// Matrix multiplication
initialize_matrix (m1);
initialize_matrix (m2);
m3 = ublas::prod (m1, m2);
std::cout << "prod (m1, m2) = " << m3 << std::endl;
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
catch (...) {
std::cout << "unknown exception" << std::endl;
}
}
BOOST_UBLAS_INLINE
void initialize_matrix (M &m) {
typedef typename M::orientation_category orientation_category;
initialize_matrix (m, orientation_category ());
}
int main(int argc, char **argv) {
MPI_Init(&argc, &argv);
int rank, nprocs;
// Initialize the MPI, get the size and the rank.
if (argc < 2) {
printf("Must supply option for Matrix Size, eg: naive.exe 1000 \n");
return -1;
}
int matrix_size;
if (sscanf(argv[1], "%d", &matrix_size) != 1) {
printf("Invalid command line argument: '%s'\n", argv[1] );
return 1;
}
// int matrix_size = atoi(argv[1]);
struct timeval total_start;
struct timeval total_finish;
gettimeofday(&total_start,NULL);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
int row_size = matrix_size / nprocs;
double *matrix_a, *matrix_b, *result_matrix, *tempR, *tempS, *tempX;
matrix_a = (double *) malloc(matrix_size * (row_size) * sizeof(double)) ;
matrix_b = (double *) malloc(matrix_size * (row_size) * sizeof(double)) ;
result_matrix = (double *) malloc(matrix_size * (row_size) * sizeof(double)) ;
tempR = (double *) malloc(matrix_size * (row_size) * sizeof(double)) ;
initialize_matrix_slice(matrix_a, matrix_b, result_matrix, matrix_size,row_size, rank);
// step 1
int i, j ;
int step ;
if (DEBUG) {
printf("%d\tr = %d\n", rank, row_size);
}
double validate_result ;
double diff ;
double *current_result;
tempS = matrix_b;
for (step = 0 ; step < nprocs; step++) {
if (rank%2 == 0 ) {
Ring_Send(tempS, row_size * matrix_size) ;
Ring_Recv(tempR, row_size * matrix_size) ;
} else {
Ring_Recv(tempR, row_size * matrix_size) ;
Ring_Send(tempS, row_size * matrix_size) ;
}
slice_matrix_multiply(matrix_a,tempS, result_matrix, matrix_size, row_size, rank, nprocs, step) ;
tempX = tempS;
tempS = tempR;
tempR = tempX;
}
if (DEBUG) {
print_matrix_slice(matrix_a, matrix_b, result_matrix, matrix_size, row_size, rank);
}
gettimeofday(&total_finish,NULL);
if (rank ==(nprocs-1) ) {
printf("RANK,CompleteTime,row_size, matrix_size\n" ) ;
}
printf("%d,%.8f,%d, %d\n", rank, get_time_diff(&total_start, &total_finish),row_size, matrix_size ) ;
return 1;
double *verify_matrix_a, *verify_matrix_b, *verify_result_matrix, *global_current_result ;
for (i=0; i < row_size; i++){
for (j=0; j < matrix_size; j++){
current_result = result_matrix + i * matrix_size + j;
validate_result = get_validated_result( GLOBAL_I(i,rank,row_size) , j , matrix_size);
diff = *current_result - validate_result ; // *global_current_result ;
if (diff != 0.0) {
printf(" (%.4f == %.4f) => diff = %.4f ", *current_result, validate_result, diff );
}
}
}
gettimeofday(&total_start,NULL);
verify_matrix_a = (double *) malloc(matrix_size * (matrix_size) * sizeof(double)) ;
verify_matrix_b = (double *) malloc(matrix_size * (matrix_size) * sizeof(double)) ;
verify_result_matrix = (double *) malloc(matrix_size * (matrix_size) * sizeof(double)) ;
initialize_matrix(verify_matrix_a, verify_matrix_b, verify_result_matrix, matrix_size);
best_matrix_multiply(verify_matrix_a, verify_matrix_b, verify_result_matrix, matrix_size);
if (DEBUG && (rank ==0) ) {
print_matrix_slice(verify_matrix_a, verify_matrix_b, verify_result_matrix, matrix_size, matrix_size,rank);
}
for (i=0; i < row_size; i++){
for (j=0; j < matrix_size; j++){
current_result = result_matrix + i * matrix_size + j;
global_current_result = verify_result_matrix + GLOBAL_I(i,rank,row_size) * matrix_size + j;
diff = *current_result - *global_current_result ;
// if (diff != 0.0) {
// printf(" (%.4f == %.4f) => diff = %.4f ", *current_result, *global_current_result, diff );
// }
}
}
gettimeofday(&total_finish,NULL);
printf("RANK%d,Naive,%.8f\n", rank, get_time_diff(&total_start, &total_finish) ) ;
MPI_Finalize();
return 1;
}
void test_blas_2<V, M, N>::test () {
{
V v1 (N), v2 (N);
M m (N, N);
// _t_mv
initialize_vector (v1);
initialize_matrix (m);
ublas::blas_2::tmv (v1, m);
std::cout << "tmv (v1, m) = " << v1 << std::endl;
initialize_vector (v1);
initialize_matrix (m);
ublas::blas_2::tmv (v1, ublas::trans (m));
std::cout << "tmv (v1, trans (m)) = " << v1 << std::endl;
#ifdef USE_STD_COMPLEX
initialize_vector (v1);
initialize_matrix (m);
ublas::blas_2::tmv (v1, ublas::herm (m));
std::cout << "tmv (v1, herm (m)) = " << v1 << std::endl;
#endif
// _t_sv
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m, ublas::lower_tag ());
ublas::blas_2::tsv (v1, m, ublas::lower_tag ());
std::cout << "tsv (v1, m) = " << v1 << " " << ublas::prod (m, v1) - v2 << std::endl;
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m, ublas::upper_tag ());
ublas::blas_2::tsv (v1, ublas::trans (m), ublas::lower_tag ());
std::cout << "tsv (v1, trans (m)) = " << v1 << " " << ublas::prod (ublas::trans (m), v1) - v2 << std::endl;
#ifdef USE_STD_COMPLEX
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m, ublas::upper_tag ());
ublas::blas_2::tsv (v1, ublas::herm (m), ublas::lower_tag ());
std::cout << "tsv (v1, herm (m)) = " << v1 << " " << ublas::prod (ublas::herm (m), v1) - v2 << std::endl;
#endif
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m, ublas::upper_tag ());
ublas::blas_2::tsv (v1, m, ublas::upper_tag ());
std::cout << "tsv (v1, m) = " << v1 << " " << ublas::prod (m, v1) - v2 << std::endl;
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m, ublas::lower_tag ());
ublas::blas_2::tsv (v1, ublas::trans (m), ublas::upper_tag ());
std::cout << "tsv (v1, trans (m)) = " << v1 << " " << ublas::prod (ublas::trans (m), v1) - v2 << std::endl;
#ifdef USE_STD_COMPLEX
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m, ublas::lower_tag ());
ublas::blas_2::tsv (v1, ublas::herm (m), ublas::upper_tag ());
std::cout << "tsv (v1, herm (m)) = " << v1 << " " << ublas::prod (ublas::herm (m), v1) - v2 << std::endl;
#endif
// _g_mv
// _s_mv
// _h_mv
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m);
ublas::blas_2::gmv (v1, value_type (1), value_type (1), m, v2);
std::cout << "gmv (v1, 1, 1, m, v2) = " << v1 << std::endl;
ublas::blas_2::gmv (v1, value_type (1), value_type (1), ublas::trans (m), v2);
std::cout << "gmv (v1, 1, 1, trans (m), v2) = " << v1 << std::endl;
#ifdef USE_STD_COMPLEX
ublas::blas_2::gmv (v1, value_type (1), value_type (1), ublas::herm (m), v2);
std::cout << "gmv (v1, 1, 1, herm (m), v2) = " << v1 << std::endl;
#endif
// _g_r
// _g_ru
// _g_rc
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m);
ublas::blas_2::gr (m, value_type (1), v1, v2);
std::cout << "gr (m, 1, v1, v2) = " << m << std::endl;
ublas::blas_2::gr (m, value_type (1), v1, ublas::conj (v2));
std::cout << "gr (m, 1, v1, conj (v2)) = " << m << std::endl;
// _s_r
initialize_vector (v1);
initialize_matrix (m);
ublas::blas_2::sr (m, value_type (1), v1);
std::cout << "sr (m, 1, v1) = " << m << std::endl;
#ifdef USE_STD_COMPLEX
// _h_r
initialize_vector (v1);
initialize_matrix (m);
ublas::blas_2::hr (m, value_type (1), v1);
std::cout << "hr (m, 1, v1) = " << m << std::endl;
#endif
// _s_r2
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m);
ublas::blas_2::sr2 (m, value_type (1), v1, v2);
std::cout << "sr2 (m, 1, v1, v2) = " << m << std::endl;
#ifdef USE_STD_COMPLEX
// _h_r2
initialize_vector (v1);
initialize_vector (v2);
initialize_matrix (m);
ublas::blas_2::hr2 (m, value_type (1), v1, v2);
std::cout << "hr2 (m, 1, v1, v2) = " << m << std::endl;
#endif
}
}
