static void *matrix_new(t_symbol *s, int argc, t_atom *argv)
{
t_matrix *x = (t_matrix *)pd_new(matrix_class);
int row, col;
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("matrix"), gensym(""));
outlet_new(&x->x_obj, 0);
x->atombuffer = 0;
x->x_canvas = canvas_getcurrent();
switch (argc) {
case 0:
row = col = 0;
break;
case 1:
if (argv->a_type == A_SYMBOL) {
matrix_read(x, argv->a_w.w_symbol);
return(x);
}
row = col = atom_getfloat(argv);
break;
default:
row = atom_getfloat(argv++);
col = atom_getfloat(argv++);
}
if(row*col) {
adjustsize(x, row, col);
matrix_set(x, 0);
}
return (x);
}
void game_init(int argc, char *argv[]) {
game_delay = (DELAY_MIN+DELAY_MAX)/2;
stat = STAT_EDITING;
running = true;
int c;
int x = 0;
int y = 0;
const char *path = NULL;
while ((c = getopt(argc, argv, "hp:x:y:s:")) != -1) {
switch (c) {
case 'p': path = optarg; break;
case 'x': x = atoi(optarg); break;
case 'y': y = atoi(optarg); break;
case 's': game_delay = DELAY_MAX - (atoi(optarg) - 1)*10; break;
case 'h':
usage(argv[0]);
exit(-1);
break;
}
}
if (path) matrix_read(path, x, y);
else matrix_init();
initscr();
noecho();
cbreak();
main_window = newwin(ROWS, COLS*2, 0, 0);
panel_window = newwin(ROWS, COLS, 0, COLS*2+1);
nodelay(main_window, true);
nodelay(panel_window, true);
panel_draw();
}
void select_method (char **argv) {
int x = 1;
if (x==1)
matrix_read(argv[3], atoi(argv[2]));
else if(!x)
list_read(argv[3]);
else
exit(1);
}
matrix* matrix_transpose(matrix* m) {
matrix* mat_out = matrix_zero(m->n_cols, m->n_rows);
int i_row, i_col;
for (i_row = 0; i_row < m->n_rows; i_row++) {
for (i_col = 0; i_col < m->n_cols; i_col++) {
matrix_write(mat_out, i_col, i_row, matrix_read(m, i_row, i_col));
}
}
return mat_out;
}
void find_SP (char *path, int s, int size) {
//table_node * T = initialize_data(size);
s--;
int * array = matrix_read(path, size);
int i,j,k;
int T[size];
for (i=0;i<size;i++)
T[i] = -1;
T[s] = 0;
struct head_ptr * Q = malloc(sizeof(struct head_ptr));
Q->next = Q->last = malloc(sizeof(struct queue_node));
// Queuing the first node onto the queue
Q->next->v_no = s;
Q->next->next = NULL;
Q->last = Q->next;
// Main BFS algo for shortest unweighted path
while (Q->next) //while Q->next is not NULL
{
int vertex_no = dequeue(Q);
/* Enter code for checking the adjacency method */
/* for (all vertex w adjacent to vertex_no && T[w].distance == -1)
{
T[w].distance = T[s].distance+1;
queue(Q,w);
}
*/
for (j=0;j<size;j++)
{
if (array[vertex_no][j]==1 && T[j] == -1 )
{
T[j] = T[vertex_no] + 1;
queue(Q,j);
}
}
}
}
void master(char *a_fname, char *b_fname, char *out_fname) {
Matrix a = matrix_read(a_fname);
Matrix b = matrix_read(b_fname);
if (a.width != a.height || b.width != b.height || a.width != b.width) {
printf("Invalid inputs. Both matricies must be nxn. A was %dx%d. B was"
" %dx%d", a.height, a.width, b.height, b.width);
MPI_Abort(MPI_COMM_WORLD, -1);
}
MPI_Bcast(&(a.width), 1, MPI_INT, 0, MPI_COMM_WORLD);
Matrix result = matrix_malloc(a.width, b.width);
matrix_init(&result);
MPI_matrix_multiply(&result, &a, &b, a.width, 0, MPI_COMM_WORLD);
matrix_write(out_fname, result);
if (result.width <= 20)
matrix_print(result);
free(result.data);
free(a.data);
free(b.data);
}
int main()
{
long process_time;
matrix_read(MATRICES_FILE, h_mat1, h_mat2, &n);
fprintf(stderr, "Starting hard work.\n");
process_time = matrix_mult_cpu_naive(h_mat1, h_mat2, h_out, n);
fprintf(stderr, "Finished CPU naïve in %ld milliseconds\n", process_time);
fprintf(stderr, "\n");
process_time = matrix_mult_cpu_cache(h_mat1, h_mat2, h_out, n);
fprintf(stderr, "Finished CPU with use of cache in %ld milliseconds\n", process_time);
fprintf(stderr, "\n");
matrix_mult_gpu(h_mat1, h_mat2, h_out, n);
return 0;
}
int main(int argc, char *argv[])
{
const char*filename = "jtest.caf";
const char*myname=argv[0];
observe_signals ();
struct recorder d;
ambix_matrix_t*matrix=NULL;
int32_t order = -1;
d.buffer_frames = 4096;
d.minimal_frames = 32;
d.channels = 2;
d.timer_seconds = -1.0;
d.timer_counter = 0;
d.sample_format = AMBIX_SAMPLEFORMAT_FLOAT32;
d.file_format = AMBIX_BASIC;
int c;
while((c = getopt(argc, argv, "hVx:X:O:b:fhm:n:t:")) != -1) {
switch(c) {
case 'x':
d.e_channels = (int) strtol(optarg, NULL, 0);
d.file_format = AMBIX_EXTENDED;
break;
case 'X':
matrix=matrix_read(optarg, matrix);
if(!matrix) {
eprintf("%s: couldn't read matrix-file '%s'\n", myname, optarg);
FAILURE;
}
d.file_format = AMBIX_EXTENDED;
break;
case 'O':
order = (uint32_t) strtol(optarg, NULL, 0);
break;
case 'b':
d.buffer_frames = (int) strtol(optarg, NULL, 0);
break;
#if 0
case 'f':
d.file_format = (int) strtol(optarg, NULL, 0);
break;
#endif
case 'V':
version (myname);
break;
case 'h':
usage (myname);
break;
case 'm':
d.minimal_frames = (int) strtol(optarg, NULL, 0);
break;
case 't':
d.timer_seconds = (float) strtod(optarg, NULL);
break;
default:
eprintf("%s: illegal option, %c\n", myname, c);
usage (myname);
break;
}
}
if(optind == argc - 1) {
filename=argv[optind];
} else {
eprintf("opening default file '%s'\n", filename);
//usage (myname);
}
/* Allocate channel based data. */
if(matrix) {
if(order<0) {
d.a_channels = matrix->cols;
} else {
if(ambix_order2channels(order) != matrix->rows) {
eprintf("%s: ambisonics order:%d cannot use [%dx%d] adaptor matrix.\n", myname, order, matrix->rows, matrix->cols);
FAILURE;
}
d.a_channels = matrix->cols;
}
} else {
if(order<0)
order=1;
d.a_channels=ambix_order2channels(order);
}
switch(d.file_format) {
case AMBIX_BASIC:
//d.a_channels;
d.e_channels=0;
break;
case AMBIX_EXTENDED:
//d.a_channels;
//d.e_channels;
break;
case AMBIX_NONE: default:
d.a_channels=0;
//d.e_channels;
}
d.channels = d.a_channels+d.e_channels;
if(d.channels < 1) {
eprintf("%s: illegal number of channels: %d\n", myname, d.channels);
FAILURE;
}
d.in = (float**)xmalloc(d.channels * sizeof(float *));
d.input_port = (jack_port_t**)xmalloc(d.channels * sizeof(jack_port_t *));
/* Connect to JACK. */
jack_client_t *client = jack_client_unique_("ambix-jrecord");
jack_set_error_function(jack_client_minimal_error_handler);
jack_on_shutdown(client, jack_client_minimal_shutdown_handler, 0);
jack_set_process_callback(client, process, &d);
d.sample_rate = jack_get_sample_rate(client);
/* Setup timer. */
if(d.timer_seconds < 0.0) {
d.timer_frames = -1;
} else {
d.timer_frames = d.timer_seconds * d.sample_rate;
}
/* Create sound file. */
ambix_info_t sfinfo;
memset(&sfinfo, 0, sizeof(sfinfo));
sfinfo.samplerate = (int) d.sample_rate;
sfinfo.frames = 0;
sfinfo.fileformat = d.file_format;
sfinfo.ambichannels = d.a_channels;
sfinfo.extrachannels = d.e_channels;
d.sound_file = ambix_open(filename, AMBIX_WRITE, &sfinfo);
if(matrix) {
ambix_err_t aerr = ambix_set_adaptormatrix(d.sound_file, matrix);
if(AMBIX_ERR_SUCCESS != aerr) {
eprintf("setting [%dx%d] matrix returned %d.\n", matrix->rows, matrix->cols, aerr);
FAILURE;
}
}
/* Allocate buffers. */
d.buffer_samples = d.buffer_frames * d.channels;
d.buffer_bytes = d.buffer_samples * sizeof(float);
d.a_buffer = (float32_t*)xmalloc(d.buffer_frames * d.a_channels * sizeof(float32_t));
d.e_buffer = (float32_t*)xmalloc(d.buffer_frames * d.e_channels * sizeof(float32_t));
d.d_buffer = (float*)xmalloc(d.buffer_bytes);
d.j_buffer = (float*)xmalloc(d.buffer_bytes);
d.u_buffer = (float*)xmalloc(d.buffer_bytes);
d.ring_buffer = jack_ringbuffer_create(d.buffer_bytes);
/* Create communication pipe. */
xpipe(d.pipe);
/* Start disk thread. */
pthread_create (&(d.disk_thread),
NULL,
disk_thread_procedure,
&d);
/* Create input ports and activate client. */
#if 0
jack_port_make_standard(client, d.input_port, d.channels, false);
jack_client_activate(client);
#else
do {
int i=0, a, e;
const char*format=(sfinfo.fileformat == AMBIX_BASIC)?"ACN_%d":"ambisonics_%d";
const int a_offset=(sfinfo.fileformat == AMBIX_BASIC)?0:1;
for(a=0; a<d.a_channels; a++) {
d.input_port[i] = _jack_port_register(client, JackPortIsInput, format, a+a_offset);
i++;
}
for(e=0; e<d.e_channels; e++) {
d.input_port[i] = _jack_port_register(client, JackPortIsInput, "in_%d", e+1);
i++;
}
} while(0);
if(jack_activate(client)) {
eprintf("jack_activate() failed\n");
FAILURE;
}
#endif
/* Wait for disk thread to end, which it does when it reaches the
end of the file or is interrupted. */
pthread_join(d.disk_thread, NULL);
/* Close sound file, free ring buffer, close JACK connection, close
pipe, free data buffers, indicate success. */
jack_client_close(client);
ambix_close(d.sound_file);
jack_ringbuffer_free(d.ring_buffer);
close(d.pipe[0]);
close(d.pipe[1]);
free(d.a_buffer);
free(d.e_buffer);
free(d.d_buffer);
free(d.j_buffer);
free(d.u_buffer);
free(d.in);
free(d.input_port);
if(matrix)ambix_matrix_destroy(matrix);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
char *rws_eg_seg, *outpics_dir, str[400], *desc;
unsigned char pixval;
static unsigned char *pic;
int mode, iarg, i, ii, iis, iie, j, jj, jjs, jje;
float *buf, *p, *pe, aval;
float minval=9999.9, maxval=-9999.9, range, a=0.0, b=0.0, maxabs, c;
int rw, rh;
int pw, ph;
if(argc < 4)
usage("<rwfile_in[rwfile_in...]> <rws|eg|seg> <outpics_dir>");
rws_eg_seg = argv[argc - 2];
outpics_dir = argv[argc - 1];
if(!strcmp(rws_eg_seg, "rws"))
mode = RWS;
else if(!strcmp(rws_eg_seg, "eg"))
mode = EG;
else if(!strcmp(rws_eg_seg, "seg"))
mode = SEG;
else
fatalerr("the rws|eg|seg arg must be rws, eg, or seg", (char *)NULL,
(char *)NULL);
if(mode != SEG) {
for(iarg = 1; iarg < argc - 2; iarg++) {
matrix_read(argv[iarg], &desc, &rh, &rw, &buf);
free(desc);
for(pe = (p = buf) + rw*rh; p < pe; p++) {
aval = *p;
if(iarg == 1 && p == buf)
minval = maxval = aval;
else if(aval < minval)
minval = aval;
else if(aval > maxval)
maxval = aval;
}
free(buf);
}
if(mode == EG) {
range = maxval - minval;
if(range > 0.) {
a = -255. / range;
b = 255. * maxval / range;
}
else {
a = 0.;
b = 128.;
}
}
else {
maxabs = fabs((double)minval);
if((c = fabs((double)maxval)) > maxabs)
maxabs = c;
if(maxabs > 0.) {
a = 255. / maxabs;
b = 0.;
}
else {
a = 0.;
b = 128.;
}
}
}
for(iarg = 1; iarg < argc - 2; iarg++) {
matrix_read(argv[iarg], &desc, &rh, &rw, &buf);
free(desc);
pw = PWS * rw;
ph = PWS * rh;
malloc_uchar(&pic, pw*ph, "rwpics pic");
for(i = iis = 0, iie = PWS, p = buf; i < rh; i++, iis += PWS,
iie += PWS)
for(j = jjs = 0, jje = PWS; j < rw; j++, jjs += PWS, jje += PWS,
p++) {
aval = *p;
if(mode == EG)
pixval = a * aval + b + .5;
else if(mode == SEG)
pixval = (aval < 0. ? 255 : 0);
else
pixval = a * fabs((double)aval) + b + .5;
for(ii = iis; ii < iie; ii++)
for(jj = jjs; jj < jje; jj++)
pic[ii*pw+jj] = pixval;
}
free(buf);
sprintf(str, "%s/%s_%s.pct", outpics_dir, lastcomp(argv[iarg]),
rws_eg_seg);
write_ihdr_std(pic, pw, ph, 8, str);
free(pic);
}
return 0;
}
BOOL ASENSOR::Open( BOOL reset )
{
BOOL ok;
STRING file;
char *path;
int step,i;
if( STR_null(ObjectName) )
{
ASENSOR_errorf("ASENSOR::Open() Sensor name not set.\n");
return(FALSE);
}
for( ok=TRUE,step=ASENSOR_OPEN_CONFIGURATION; ((step <= ASENSOR_OPEN_VARIABLES) && ok); step++ )
{
switch( step )
{
case ASENSOR_OPEN_CONFIGURATION :
strncpy(file,STR_stringf("%s.CFG",ObjectName),STRLEN);
if( (path=FILE_Calibration(file)) == NULL )
{
ASENSOR_errorf("ASENSOR::Open() Cannot find configuration file: %s\n",file);
ok = FALSE;
break;
}
strncpy(file,path,STRLEN);
ok = ConfigLoad(file);
break;
case ASENSOR_OPEN_CALIBRATION :
// Default identity calibration matrix for sensor.
Calibration = I(DAQ_ChannelCount);
if( !CalibrationFlags[ASENSOR_CALIBRATION_MTX] )
{
break;
}
strncpy(file,STR_stringf("%s.MTX",ObjectName),STRLEN);
if( (path=FILE_Calibration(file)) == NULL )
{
ASENSOR_errorf("ASENSOR::Open() Cannot find calibration file: %s\n",file);
ok = FALSE;
break;
}
strncpy(file,path,STRLEN);
if( !matrix_read(file,Calibration) )
{
ASENSOR_errorf("ASENSOR::Open() Cannot load calibration file: %s\n",file);
ok = FALSE;
break;
}
// For some reason the ATI DAQ F/T sensor calibration matrix must be transposed.
if( DeviceType == ASENSOR_DEVICE_DAQFT )
{
Calibration.transpose();
}
break;
case ASENSOR_OPEN_GAIN :
Gain.dim(1,DAQ_ChannelCount);
Gain.ones();
if( !CalibrationFlags[ASENSOR_CALIBRATION_GAIN] )
{
break;
}
strncpy(file,STR_stringf("%s.K",ObjectName),STRLEN);
if( (path=FILE_Calibration(file)) == NULL )
{
ASENSOR_errorf("ASENSOR::Open() Cannot find gain file: %s\n",file);
ok = FALSE;
break;
}
strncpy(file,path,STRLEN);
if( !matrix_read(file,Gain) )
{
ASENSOR_errorf("ASENSOR::Open() Cannot load gain file: %s\n",file);
ok = FALSE;
break;
}
MakeColumnVector(Gain);
// For some reason the ATI DAQ F/T sensor gains must be inverted.
if( DeviceType == ASENSOR_DEVICE_DAQFT )
{
for( i=1; (i <= DAQ_ChannelCount); i++ )
{
if( Gain(1,i) != 0.0 )
{
Gain(1,i) = 1.0 / Gain(1,i);
}
}
}
break;
case ASENSOR_OPEN_BIAS :
BiasVolts.dim(1,DAQ_ChannelCount);
BiasVolts.zeros();
if( !CalibrationFlags[ASENSOR_CALIBRATION_BIAS] )
{
break;
}
strncpy(file,STR_stringf("%s.B",ObjectName),STRLEN);
if( (path=FILE_Calibration(file)) == NULL )
{
ASENSOR_errorf("ASENSOR::Open() Cannot find bias file: %s\n",file);
ok = FALSE;
break;
}
strncpy(file,path,STRLEN);
if( !matrix_read(file,BiasVolts) )
{
ASENSOR_errorf("ASENSOR::Open() Cannot load bias file: %s\n",file);
ok = FALSE;
break;
}
strncpy(BiasFile,file,STRLEN);
strncpy(BiasHistoryFile,STR_stringf("%sH",file),STRLEN);
MakeColumnVector(BiasVolts);
//disp(BiasVolts);
break;
case ASENSOR_OPEN_VARIABLES :
SensorVolts.dim(1,DAQ_ChannelCount);
SensorValues.dim(1,DAQ_ChannelCount);
for( i=0; (i < DAQ_ChannelCount); i++ )
{
BiasData[i] = new DATAPROC(STR_stringf("%s[%i]",ObjectName,i),BiasPoints,DATAPROC_FLAG_CIRCULAR);
if( VoltPoints > 0 )
{
VoltData[i] = new DATAPROC(STR_stringf("%s[%i]",ObjectName,i),VoltPoints,DATAPROC_FLAG_CIRCULAR);
}
}
if( WindowSize > 0 )
{
Window = new WINFIT(ObjectName,WindowSize,DAQ_ChannelCount);
}
break;
}
STR_printf(ok,ASENSOR_debugf,ASENSOR_errorf,"ASENSOR::Open() %s[%d] %s.\n",ASENSOR_OpenText[step],step,STR_OkFailed(ok));
}
if( ok )
{
OpenFlag = TRUE;
if( reset )
{
BiasResetAnterograde();
}
}
return(ok);
}
