int
reader_read_double_data_file(const char *path,
struct matrix *x,
struct matrix *d)
{
FILE *fd;
matrix_initialize(x, 0, 0);
matrix_initialize(d, 0, 0);
if ((fd = fopen(path, "r")))
{
size_t length;
int c = 1;
char *line = NULL;
while (1)
{
if (getline(&line, &length, fd) == -1)
break;
if (c == 1)
reader_extract_numbers(x, line);
else
reader_extract_numbers(d, line);
c *= -1;
}
return (c != 1) ? 0 : 1;
}
return 0;
}
void
som_initialize(struct som *ann,
som_grid_type grid_type,
clann_size_type input_size,
clann_size_type width)
{
ann->input_size = input_size;
ann->grid.width = width;
ann->learning_rate = 0.1;
ann->const_1 = 1000 / CLANN_LOG(ann->grid.width);
ann->const_2 = 1000;
ann->step = 1;
ann->epoch = 1;
ann->grid.type = grid_type;
switch (ann->grid.type)
{
case SOM_GRID_LINE:
ann->grid.dimension = SOM_GRID_1D;
break;
case SOM_GRID_SQUARE:
ann->grid.dimension = SOM_GRID_2D;
break;
case SOM_GRID_CUBE:
ann->grid.dimension = SOM_GRID_3D;
}
/*
* Compute the number of neurons and initialize weights
*/
ann->grid.n_neurons = CLANN_POW(ann->grid.width, ann->grid.dimension);
matrix_initialize(&ann->grid.indexes,
ann->grid.n_neurons,
ann->grid.dimension);
matrix_initialize(&ann->grid.weights,
ann->grid.n_neurons,
ann->input_size);
matrix_fill_rand(&ann->grid.weights, -1, 1);
/*
* Generate the indexes
*/
clann_size_type count = 0;
clann_real_type *buffer;
buffer = malloc(sizeof(clann_real_type) * ann->grid.dimension);
som_grid_indexes(ann, 0, buffer, &count);
free(buffer);
}
void
kmeans_initialize(struct kmeans *ann,
clann_size_type n_centers,
clann_size_type center_size,
clann_real_type noticeable_change_rate)
{
ann->n_centers = n_centers;
ann->center_size = center_size;
ann->noticeable_change_rate = noticeable_change_rate;
ann->old_centers = NULL;
matrix_initialize(&ann->centers, ann->n_centers, ann->center_size);
matrix_fill_rand(&ann->centers, -1, 1);
}
/*********************************
* Test
********************************/
int main(){
printf("-----------------------------\n");
Matrix* m1 = matrix_Alloc(3,2);
Matrix* m2 = matrix_Alloc(2,4);
matrix_initialize(m1, 2.0);
matrix_initialize(m2, 3.0);
matrix_print(m1);
matrix_print(m2);
//matrix_save(m2, "tests/m3.mat");
//Matrix* res = matrix_kmult(m1,m2);
/*Matrix* res1 = matrix_load( (char *)"tests/m1.mat");
Matrix* res2 = matrix_load( (char *)"tests/m2.mat");
matrix_print(res2);
Matrix* res = matrix_transpose(res2);
matrix_print(res);*/
free(m1);
free(m2);
//main2();
return 0;
}
int
reader_read_data_file(const char *path,
struct matrix *v)
{
FILE *fd;
matrix_initialize(v, 0, 0);
if ((fd = fopen(path, "r")))
{
char *line = NULL;
size_t len;
while (getline(&line, &len, fd) != -1)
reader_extract_numbers(v, line);
return 1;
}
return 0;
}
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void initialize_hardware()
{
#if (ARCH == ARCH_AVR8)
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
wdt_disable();
/* Disable clock division */
clock_prescale_set(clock_div_1);
#elif (ARCH == ARCH_XMEGA)
/* Start the PLL to multiply the 2MHz RC oscillator to 32MHz and switch the CPU core to run from it */
XMEGACLK_StartPLL(CLOCK_SRC_INT_RC2MHZ, 2000000, F_CPU);
XMEGACLK_SetCPUClockSource(CLOCK_SRC_PLL);
/* Start the 32MHz internal RC oscillator and start the DFLL to increase it to 48MHz using the USB SOF as a reference */
XMEGACLK_StartInternalOscillator(CLOCK_SRC_INT_RC32MHZ);
XMEGACLK_StartDFLL(CLOCK_SRC_INT_RC32MHZ, DFLL_REF_INT_USBSOF, F_USB);
PMIC.CTRL = PMIC_LOLVLEN_bm | PMIC_MEDLVLEN_bm | PMIC_HILVLEN_bm;
#endif
matrix_initialize();
USB_Init();
}
int main( int argc , char *argv[] )
{
MRI_IMAGE *inim , *outim ; float *iv ;
int iarg , ii,jj , nreg , ntime , *tau=NULL , rnum ;
NI_element *nelmat=NULL ; char *matname=NULL ;
MTYPE rhomax=0.7 , bmax=0.7 ; int rhonum=7 , bnum=14 ;
char *cgl , *rst ;
matrix X ; vector y ;
float cput ;
reml_collection *rrcol ;
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: 1dREMLfit [option] file.1D\n"
"Least squares fit with REML estimation of the ARMA(1,1) noise.\n"
"\n"
"Options (the first one is mandatory)\n"
"------------------------------------\n"
" -matrix mmm = Read the matrix 'mmm', which should have been\n"
" output from 3dDeconvolve via the '-x1D' option.\n"
" -MAXrho rm = Set the max allowed rho parameter to 'rm' (default=0.7).\n"
" -Nrho nr = Use 'nr' values for the rho parameter (default=7).\n"
" -MAXb bm = Set max allow MA b parameter to 'bm' (default=0.7).\n"
" -Nb nb = Use 'nb' values for the b parameter (default=7).\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
iarg = 1 ;
while( iarg < argc && argv[iarg][0] == '-' ){
/** rho and del params **/
if( strcmp(argv[iarg],"-MAXrho") == 0 ){
rhomax = (MTYPE)strtod(argv[++iarg],NULL) ;
if( rhomax < 0.3 ) rhomax = 0.3 ;
else if( rhomax > 0.9 ) rhomax = 0.9 ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-Nrho") == 0 ){
rhonum = (int)strtod(argv[++iarg],NULL) ;
if( rhonum < 2 ) rhonum = 2 ;
else if( rhonum > 20 ) rhonum = 20 ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-MAXb") == 0 ){
bmax = (MTYPE)strtod(argv[++iarg],NULL) ;
if( bmax < 0.3 ) bmax = 0.3 ;
else if( bmax > 0.9 ) bmax = 0.9 ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-Nb") == 0 ){
bnum = (int)strtod(argv[++iarg],NULL) ;
if( bnum < 2 ) bnum = 2 ;
else if( bnum > 20 ) bnum = 20 ;
iarg++ ; continue ;
}
/** -matrix **/
if( strcmp(argv[iarg],"-matrix") == 0 ){
if( nelmat != NULL ) ERROR_exit("More than 1 -matrix option!");
nelmat = NI_read_element_fromfile( argv[++iarg] ) ; /* read NIML file */
matname = argv[iarg];
if( nelmat == NULL ){ /* try to read as a 1D file */
MRI_IMAGE *nim ; float *nar ;
nim = mri_read_1D(argv[iarg]) ;
if( nim != NULL ){ /* construct a minimal NIML element */
nelmat = NI_new_data_element( "matrix" , nim->nx ) ;
nar = MRI_FLOAT_PTR(nim) ;
for( jj=0 ; jj < nim->ny ; jj++ )
NI_add_column( nelmat , NI_FLOAT , nar + nim->nx*jj ) ;
mri_free(nim) ;
}
}
if( nelmat == NULL || nelmat->type != NI_ELEMENT_TYPE )
ERROR_exit("Can't process -matrix file!");
iarg++ ; continue ;
}
ERROR_exit("Unknown option '%s'",argv[iarg]) ;
}
if( iarg >= argc ) ERROR_exit("No 1D file on command line?!") ;
inim = mri_read_1D( argv[iarg] ) ;
if( inim == NULL ) ERROR_exit("Can't read 1D file %s",argv[iarg]) ;
nreg = nelmat->vec_num ;
ntime = nelmat->vec_len ;
if( ntime != inim->nx )
ERROR_exit("matrix vectors are %d long but input 1D file is %d long",
ntime,inim->nx) ;
cgl = NI_get_attribute( nelmat , "GoodList" ) ;
if( cgl != NULL ){
int Ngoodlist,*goodlist , Nruns,*runs ;
NI_int_array *giar ;
giar = NI_decode_int_list( cgl , ";," ) ;
if( giar == NULL || giar->num < ntime )
ERROR_exit("-matrix 'GoodList' badly formatted?") ;
Ngoodlist = giar->num ; goodlist = giar->ar ;
rst = NI_get_attribute( nelmat , "RunStart" ) ;
if( rst != NULL ){
NI_int_array *riar = NI_decode_int_list( rst , ";,") ;
if( riar == NULL ) ERROR_exit("-matrix 'RunStart' badly formatted?") ;
Nruns = riar->num ; runs = riar->ar ;
} else {
Nruns = 1 ; runs = calloc(sizeof(int),1) ;
}
rnum = 0 ; tau = (int *)malloc(sizeof(int)*ntime) ;
for( ii=0 ; ii < ntime ; ii++ ){
jj = goodlist[ii] ;
for( ; rnum+1 < Nruns && jj >= runs[rnum+1] ; rnum++ ) ; /*nada*/
tau[ii] = jj + 10000*rnum ;
}
}
matrix_initialize( &X ) ;
matrix_create( ntime , nreg , &X ) ;
if( nelmat->vec_typ[0] == NI_FLOAT ){
float *cd ;
for( jj=0 ; jj < nreg ; jj++ ){
cd = (float *)nelmat->vec[jj] ;
for( ii=0 ; ii < ntime ; ii++ ) X.elts[ii][jj] = (MTYPE)cd[ii] ;
}
} else if( nelmat->vec_typ[0] == NI_DOUBLE ){
double *cd ;
for( jj=0 ; jj < nreg ; jj++ ){
cd = (double *)nelmat->vec[jj] ;
for( ii=0 ; ii < ntime ; ii++ ) X.elts[ii][jj] = (MTYPE)cd[ii] ;
}
} else {
ERROR_exit("-matrix file stored will illegal data type!?") ;
}
cput = COX_cpu_time() ;
rrcol = REML_setup( &X , tau , rhonum,rhomax,bnum,bmax ) ;
if( rrcol == NULL ) ERROR_exit("REML setup fails?" ) ;
cput = COX_cpu_time() - cput ;
INFO_message("REML setup: rows=%d cols=%d %d cases CPU=%.2f",
ntime,nreg,rrcol->nset,cput) ;
cput = COX_cpu_time() ;
vector_initialize( &y ) ; vector_create_noinit( ntime , &y ) ;
for( jj=0 ; jj < inim->ny ; jj++ ){
iv = MRI_FLOAT_PTR(inim) + ntime*jj ;
for( ii=0 ; ii < ntime ; ii++ ) y.elts[ii] = (MTYPE)iv[ii] ;
(void)REML_find_best_case( &y , rrcol ) ;
INFO_message(
"Vector #%d: best_rho=%.2f best_b=%.2f best_lam=%.2f best_ssq=%g olsq_ssq=%g",
jj, REML_best_rho, REML_best_bb, REML_best_lam, REML_best_ssq, REML_olsq_ssq ) ;
}
cput = COX_cpu_time() - cput ;
INFO_message("REML fitting: CPU=%.2f",cput) ;
exit(0) ;
}
/*
* Inversion d'une matrice
* A Vérifier !
*/
Matrix* matrix_reverse(Matrix* m){
// Méthode de Gauss
// Allocation de la matrice resultat
Matrix* res = matrix_Alloc(m->r, m->c);
if(res == NULL) {
printf("Error creating matrix !");
return NULL;
}
//Initialise le resultat : res = Id
matrix_initialize(res, 0);
for(int i = 0; i< res->c ; i++){
res->matrix[i][i] = 1;
}
double coeff = 1;
double coeff2 = 1;
double aux1 = 0;
double aux2 = 0;
for(int i = 0 ; i< (m->r)-1 ; i++){
// cas ou le pivot est nul, on permute 2 lignes
if(m->matrix[i][i]==0){
int h = 1;
// Recherche d'un pivot non nulle, il existe car on suppose la matrice inversible
while( i+h < m->r && m->matrix[i+h][i]==0){
h++;
}
if(i+h >= m->r) {
printf("Matrice NON inversible - dansinversion matrice !");
return NULL;
}
//Permutation des lignes
for(int k = i ; k< m->c ; k++){
aux1 = m->matrix[i][k];
m->matrix[i][k] = m->matrix[i+h][k];
m->matrix[i+h][k] = aux1;
// Reapplique sur la matrice résultat
aux2 = res->matrix[i][k];
res->matrix[i][k] = res->matrix[i+h][k];
res->matrix[i+h][k] = aux2;
}
}
// Sans fraction
for(int j = i+1 ; j< m->r; j++){// Pour chaque ligne
coeff = m->matrix[j][i];
//coeff2 = res->matrix[j][i];
for(int k = 0 ; k < m->c; k++){ // On l'applique sur toute la ligne, On est obligé de commencer à 0 pour le resultat ...
m->matrix[j][k] = m->matrix[i][k] * m->matrix[j][k] - coeff * m->matrix[i][k];
// Reapplique sur la matrice résultat
res->matrix[j][k] = m->matrix[i][k] * res->matrix[j][k] - coeff * res->matrix[i][k];
}
}
}
//Maintenant on a une matrice triangulaire supérieur, il n'y a plus qu'à remonter
for(int i = (m->r)-1 ; i > 1 ; i--){// On part de la fin
for(int j = i-1 ; j > 0; j--){// Pour chaque ligne en remontant
m->matrix[j][i] = m->matrix[i][i] * m->matrix[j][i] - coeff * m->matrix[i][i];
coeff = m->matrix[j][i];
//coeff2 = res->matrix[j][i];
for(int k = m->c-1 ; k >= 0; k--){ // On l'applique sur toute la ligne
res->matrix[j][k] = m->matrix[i][k] * res->matrix[j][k] - coeff * res->matrix[i][k];
}
}
}
return res;
}
int
narx_open(struct narx *ann,
const char *file)
{
FILE *fd;
if ((fd = fopen(file, "r")))
{
char *line = NULL;
size_t len;
getline(&line, &len, fd);
if (!strncmp(NARX_FILE_HEADER, line, (4 > len ? len: 4)))
{
struct matrix a, o, w, f;
unsigned int i;
int c = 1;
matrix_initialize(&a, 0, 0);
matrix_initialize(&o, 0, 0);
matrix_initialize(&w, 0, 0);
matrix_initialize(&f, 0, 0);
getline(&line, &len, fd);
reader_extract_numbers(&a, line);
unsigned int arch[a.cols];
for (i = 0; i < a.cols; i++)
arch[i] = (unsigned int) a.values[i];
getline(&line, &len, fd);
reader_extract_numbers(&o, line);
narx_initialize(ann, arch, a.cols, (unsigned int) o.values[1]);
ann->ann.avarage_error = o.values[0];
while (1)
{
if (getline(&line, &len, fd) == -1) break;
if (c == 1)
reader_extract_numbers(&w, line);
else
reader_extract_numbers(&f, line);
c *= -1;
}
if (c == 1)
{
mlp_fill(&ann->ann, &w, &f);
return 1;
}
printf("E. [NARX] Inconsistency in opened file.\n");
}
printf("E. [NARX] Opened file is not a NARX file.\n");
}
else
printf("E. [NARX] Can not open file to read.\n");
return 0;
}
