int main (void) { double **Y = new_square_matrix(n); Y[0][0] = 1; Y[0][1] = 0; Y[0][2] = 0; Y[1][0] = 0; Y[1][1] = 0.2; Y[1][2] = 1; Y[2][0] = 0; Y[2][1] = 1; Y[2][2] = 0; int nz = count_entry(Y,n); int Ti[nz]; int Tj[nz]; double Tx[nz]; matrix_to_triplet(Ti,Tj,Tx,nz,Y,n); int n_row = n; int n_col = n; int * Ap = new int [n_col+1]; int * Ai = new int [nz]; double * Ax = new double [nz]; int status; double Control [UMFPACK_CONTROL]; umfpack_di_defaults (Control) ; status = umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, (int *) NULL); if( status < 0 ) { umfpack_di_report_status (Control, status) ; report_exit("umfpack_zi_triplet_to_col failed\n") ; } double *null = (double *) NULL ; int i ; void *Symbolic, *Numeric ; (void) umfpack_di_symbolic (n, n, Ap, Ai, Ax, &Symbolic, null, null) ; (void) umfpack_di_numeric (Ap, Ai, Ax, Symbolic, &Numeric, null, null) ; umfpack_di_free_symbolic (&Symbolic) ; (void) umfpack_di_solve (UMFPACK_A, Ap, Ai, Ax, v, J, Numeric, null, null) ; umfpack_di_free_numeric (&Numeric) ; for (i = 0 ; i < n ; i++) printf ("v [%d] = %lf\n", i, v[i]) ; delete [] Ap; delete [] Ai; delete [] Ax; return (0) ; }
static long count_entry (char *ent, int top, dev_t last_dev) { long size; if (((top && opt_dereference_arguments) ? stat (ent, &stat_buf) : (*xstat) (ent, &stat_buf)) < 0) { error (0, errno, "%s", path->text); exit_status = 1; return 0; } if (!opt_count_all && stat_buf.st_nlink > 1 && hash_insert (stat_buf.st_ino, stat_buf.st_dev)) return 0; /* Have counted this already. */ if (output_size == size_bytes) size = stat_buf.st_size; else size = ST_NBLOCKS (stat_buf); tot_size += size; if (S_ISDIR (stat_buf.st_mode)) { unsigned pathlen; dev_t dir_dev; char *name_space; char *namep; struct saved_cwd cwd; int through_symlink; struct stat e_buf; dir_dev = stat_buf.st_dev; if (opt_one_file_system && !top && last_dev != dir_dev) return 0; /* Don't enter a new file system. */ #ifndef S_ISDIR # define S_ISDIR(s) 0 #endif /* If we're dereferencing symlinks and we're about to chdir through a symlink, remember the current directory so we can return to it later. In other cases, chdir ("..") works fine. */ through_symlink = (xstat == stat && lstat (ent, &e_buf) == 0 && S_ISLNK (e_buf.st_mode)); if (through_symlink) if (save_cwd (&cwd)) exit (1); if (chdir (ent) < 0) { error (0, errno, _("cannot change to directory %s"), path->text); exit_status = 1; return 0; } errno = 0; name_space = savedir (".", stat_buf.st_size); if (name_space == NULL) { if (errno) { error (0, errno, "%s", path->text); if (through_symlink) { if (restore_cwd (&cwd, "..", path->text)) exit (1); free_cwd (&cwd); } else if (chdir ("..") < 0) error (1, errno, _("cannot change to `..' from directory %s"), path->text); exit_status = 1; return 0; } else error (1, 0, _("virtual memory exhausted")); } /* Remember the current path. */ str_concatc (path, "/"); pathlen = path->length; namep = name_space; while (*namep != 0) { str_concatc (path, namep); size += count_entry (namep, 0, dir_dev); str_trunc (path, pathlen); namep += strlen (namep) + 1; } free (name_space); if (through_symlink) { restore_cwd (&cwd, "..", path->text); free_cwd (&cwd); } else if (chdir ("..") < 0) error (1, errno, _("cannot change to `..' from directory %s"), path->text); str_trunc (path, pathlen - 1); /* Remove the "/" we added. */ if (!opt_summarize_only || top) { if (opt_human_readable) { char buf[LONGEST_HUMAN_READABLE + 1]; printf("%s\t%s\n", human_readable (size, buf, LONGEST_HUMAN_READABLE + 1), path->length > 0 ? path->text : "/"); } else { printf ("%ld\t%s\n", (output_size == size_bytes ? size : convert_blocks (size, output_size)), path->length > 0 ? path->text : "/"); } fflush (stdout); } return opt_separate_dirs ? 0 : size; } else if (opt_all || top) { /* FIXME: make this an option. */ int print_only_dir_size = 0; if (!print_only_dir_size) { if (opt_human_readable) { char buf[LONGEST_HUMAN_READABLE + 1]; printf("%s\t%s\n", human_readable (size, buf, LONGEST_HUMAN_READABLE + 1), path->length > 0 ? path->text : "/"); } else { printf ("%ld\t%s\n", output_size == size_bytes ? size : convert_blocks (size, output_size), path->text); } fflush (stdout); } } return size; }
static void du_files (char **files) { struct saved_cwd cwd; ino_t initial_ino; /* Initial directory's inode. */ dev_t initial_dev; /* Initial directory's device. */ int i; /* Index in FILES. */ if (save_cwd (&cwd)) exit (1); /* Remember the inode and device number of the current directory. */ if (stat (".", &stat_buf)) error (1, errno, _("current directory")); initial_ino = stat_buf.st_ino; initial_dev = stat_buf.st_dev; for (i = 0; files[i]; i++) { char *arg; int s; arg = files[i]; /* Delete final slash in the argument, unless the slash is alone. */ s = strlen (arg) - 1; if (s != 0) { if (arg[s] == '\\') arg[s] = 0; str_copyc (path, arg); } else if (arg[0] == '\\') str_trunc (path, 0); /* Null path for root directory. */ else str_copyc (path, arg); if (!opt_combined_arguments) hash_reset (); count_entry (arg, 1, 0); /* chdir if `count_entry' has changed the working directory. */ if (stat (".", &stat_buf)) error (1, errno, "."); if (stat_buf.st_ino != initial_ino || stat_buf.st_dev != initial_dev) { if (restore_cwd (&cwd, _("starting directory"), NULL)) exit (1); } } if (opt_combined_arguments) { if (opt_human_readable) { char buf[LONGEST_HUMAN_READABLE + 1]; printf("%s\ttotal\n", human_readable (tot_size, buf, LONGEST_HUMAN_READABLE + 1)); } else { printf (_("%ld\ttotal\n"), output_size == size_bytes ? tot_size : convert_blocks (tot_size, output_size == size_kilobytes)); } fflush (stdout); } free_cwd (&cwd); }