int main() {
Node *root, *aux;
int size, check = 1, number, temp, num1, num2;
clock_t c2, c1;
float _time;
scanf("%s", input);
transform_input();
printf("(%s)\n", input);
size = strlen(input);
root = make_graph(0, size - 1);
printf("Original Graph:\n");
print_graph(root);
printf("\n");
printf("Start..\n");
c1 = clock();
root = reduce_graph(root, 0);
c2 = clock();
_time = (c2 - c1)*1000/CLOCKS_PER_SEC;
printf("\n\nEnd!\n");
printf("Reduced Graph:\n");
print_graph(root);
printf("\nTempo de redução: %dhs %dmin %dseg %dmiliseg\n\n", (((int) _time)/1000)/3600, ((((int) _time)/1000)%3600)/60, ((((int) _time)/1000)%3600)%60, ((int) _time) - (((int) _time)/1000)*1000);
printf("\n");
return 0;
}
EdgeList generateEdgeList(int argc, char** argv, packed_edge** output){
int log_numverts;
int64_t nedges;
packed_edge* result;
log_numverts = 16; /* In base 2 */
if (argc >= 2) log_numverts = atoi(argv[1]);
make_graph(log_numverts, INT64_C(16) << log_numverts, 1, 2, &nedges, &result);
printf("nedges=%ld before\n",nedges);
//remove loops:
#if rmdup
tic();
packed_edge* end=thrust::remove_if(result, result+nedges, is_loop());
//sort packed_edge twice:
thrust::sort(result,end,pe_less1());
thrust::sort(result,end,pe_less2());
//nedges=(end-result);
//printf("nedges=%d after loop\n",nedges);
//remove duplicates:
end=thrust::unique(result,end);
cudaDeviceSynchronize();
elapsed_time+=toc();
printf("remove dup took %f ms\n", elapsed_time);
//TEMP: reset elapsed time:
elapsed_time=0;
nedges=(end-result);
printf("nedges=%ld after dup\n",nedges);
//
#endif
uusi::EdgeList el=graph500ToEdgeList((const packed_edge*)result,nedges);
*output=result;
return el;
}
void test_dijkstra()
{
// remember to insert edges both ways for an undirected graph
Landscape landscape(5, 5);
for (int yi = 0; yi < landscape.height; yi++) {
for (int xi = 0; xi < landscape.width; xi++) {
QPoint coords = QPoint(xi, yi);
if (xi == 2) {
landscape.setTile(coords, Tile::WATER_TILE);
} else {
landscape.setTile(coords, Tile::GRASS_TILE);
}
std::cout << "+" << landscape.getTile(coords).walkSpeed() << std::endl;
}
}
adjacency_list_t adjacency_list = make_graph(landscape);
std::vector<weight_t> min_distance;
std::vector<vertex_t> previous;
QPoint start(0, 0);
QPoint end(4, 0);
DijkstraComputePaths(landscape.coordsToIndex(start),
adjacency_list, min_distance, previous);
std::cout << "Distance from 0,0 to 11,5: " << min_distance[landscape.coordsToIndex(end)] << std::endl;
std::list<vertex_t> path = DijkstraGetShortestPathTo(landscape.coordsToIndex(end), previous);
std::cout << "Path : ";
std::copy(path.begin(), path.end(), std::ostream_iterator<vertex_t>(std::cout, " "));
std::cout << std::endl;
}
int main(int argc, char* argv[]) {
int log_numverts;
unsigned int start, time_taken;
size_t i;
int64_t nedges, actual_nedges;
int64_t* result;
log_numverts = 16; /* In base GRAPHGEN_INITIATOR_SIZE */
if (argc >= 2) log_numverts = atoi(argv[1]);
/* Start of graph generation timing */
#pragma mta fence
start = mta_get_clock(0);
double initiator[] = {.57, .19, .19, .05};
make_graph(log_numverts, 8. * pow(2., log_numverts), 1, 2, initiator, &nedges, &result);
#pragma mta fence
time_taken = mta_get_clock(start);
/* End of graph generation timing */
actual_nedges = 0;
#pragma mta block schedule
for (i = 0; i < nedges; ++i) if (result[i * 2] != (int64_t)(-1)) ++actual_nedges;
fprintf(stderr, "%" PRIu64 " edge%s generated and permuted in %fs (%f Medges/s)\n", actual_nedges, (actual_nedges == 1 ? "" : "s"), time_taken * mta_clock_period(), 1. * actual_nedges / time_taken * 1.e-6 / mta_clock_period());
free(result);
return 0;
}
int main(int argc, char* argv[]) {
Grappa::init(&argc, &argv);
Grappa::run([]{
LOG(INFO) << "starting...";
tuple_graph tg;
csr_graph unweighted_g;
uint64_t N = (1L<<FLAGS_logN);
uint64_t desired_nnz = FLAGS_nnz_factor * N;
// results output
DictOut resultd;
double time;
/*TODO SEED*/userseed = 10;
TIME(time,
make_graph( FLAGS_logN, desired_nnz, userseed, userseed, &tg.nedge, &tg.edges );
);
LOG(INFO) << "make_graph: " << time;
resultd.add( "make_graph_time", time );
TIME(time,
create_graph_from_edgelist(&tg, &unweighted_g);
);
Node* make_graph(int start, int end){
/*
Recursive function:
It returns the root node
of each subgraph
*/
Node *node;
int last_arg;
char aux_int = 'x';
last_arg = get_last_arg(start, end);
if (input[start] == '(' && input[end] == ')' && end == get_pair(start)) {
node = make_graph(start+1, end-1);
}
else if (input[start] == '[' && input[end] == ']' && end == get_pair(start)) {
node = (Node*) malloc(sizeof(Node));
node->type = '@';
node->left = make_leaf(':');
node->right = make_graph(start+1, end-1);
}
else if (last_arg == start || (input[start] >= 48 && input[start] <=57)) {
if (input[start] >= 48 && input[start] <= 57)
node = make_Nleaf(start,last_arg);
else
node = make_leaf(input[start]);
}
else {
node = (Node*) malloc(sizeof(Node));
node->type = '@';
// if (input[end] == '+' || input[end] == '-'){
// node->left = make_leaf(input[end]);
// node->right = make_graph(start, end-1);
// }
// else {
node->left = make_graph(start, last_arg-1);
node->right = make_graph(last_arg, end);
// }
}
return node;
}
int main(void) {
const unsigned max_size = 1000;
unsigned graph[max_size][2];
struct timeval tv;
if (gettimeofday(&tv, NULL)) {
return 1;
}
unsigned long long t = (unsigned long long)tv.tv_sec * 1000000 + tv.tv_usec;
const int seed = (t >> 32) ^ t;
srand(seed);
unsigned size = rand() % max_size + 1;
for (unsigned i = 0; i < size; ++i) {
graph[i][0] = rand() % (size+1);
graph[i][1] = rand() % (size+1);
}
struct node n1[max_size], n2[max_size];
make_graph(size, graph, n1);
make_graph(size, graph, n2);
schorr_waite(n1);
simple_traverse(n2);
for (unsigned i = 0; i < size; ++i) {
if (graph[i][0] == size) {
assert(n1[i].l == NULL);
assert(n2[i].l == NULL);
} else {
assert(n1[i].l == n1 + graph[i][0]);
assert(n2[i].l == n2 + graph[i][0]);
}
if (graph[i][1] == size) {
assert(n1[i].r == NULL);
assert(n2[i].r == NULL);
} else {
assert(n1[i].r == n1 + graph[i][1]);
assert(n2[i].r == n2 + graph[i][1]);
}
assert(n1[i].m == n2[i].m);
}
return 0;
}
int main(int argc, char ** argv) {
long n_nodes = (argc > 1 ? atol(argv[1]) : 1000);
long n_edges = (argc > 2 ? atol(argv[2]) : 10000);
assert(n_edges >= n_nodes - 1);
assert(n_nodes > 1 || n_edges == 0);
make_graph(n_nodes, n_edges);
myth_create_join_many_ex(0, 0, visit_node, V, 0,
0, 0, sizeof(node), 0,
n_nodes);
printf("OK\n");
return 0;
}
int main(int argc, char* argv[])
{
/* Start the timer */
uglyTime(NULL);
printf("\nQUBIC %.1f: greedy biclustering (compiled "__DATE__" "__TIME__")\n\n", VER);
rows = cols = 0;
/* get the program options defined in get_options.c */
get_options(argc, argv);
/*get the size of input expression matrix*/
get_matrix_size(po->FP);
progress("File %s contains %d genes by %d conditions", po -> FN, rows, cols);
if (rows < 3 || cols < 3)
{
/*neither rows number nor cols number can be too small*/
errAbort("Not enough genes or conditions to make inference");
}
genes = alloc2c(rows, LABEL_LEN);
conds = alloc2c(cols, LABEL_LEN);
/* Read in the gene names and condition names */
read_labels(po -> FP);
/* Read in the expression data */
if (po->IS_DISCRETE)
read_discrete(po -> FP);
else
{
read_continuous(po -> FP);
/* formatting rules */
discretize(addSuffix(po->FN, ".rules"));
}
fclose(po->FP);
/*we can do expansion by activate po->IS_SWITCH*/
if (po->IS_SWITCH)
{
read_and_solve_blocks(po->FB, addSuffix(po->BN, ".expansion"));
}
else
{
/* formatted file */
write_imported(addSuffix(po->FN, ".chars"));
/* the file that stores all blocks */
make_graph(addSuffix(po->FN, ".blocks"));
}/* end of main else */
free(po);
return 0;
}
vector<int> findOrder(int numCourses, vector<pair<int, int> >& prerequisites)
{
vector<int> res;
vector<unordered_set<int> > graph;
graph = make_graph(numCourses, prerequisites);
vector<int> visited(numCourses, 0); //0 unvisited, 1 being visited, 2 visited;
for (int i = 0; i < numCourses; ++i)
{
if (visited[i] == 2) continue;
if (!dfs(graph, visited, res, i)) return {};
}
reverse(res.begin(), res.end());
return res;
}
static void
create_graphs(Dt_t* chans)
{
Dt_t* lp;
Dtlink_t* l1;
Dtlink_t* l2;
channel* cp;
for (l1 = dtflatten (chans); l1; l1 = dtlink(chans,l1)) {
lp = ((chanItem*)l1)->chans;
for (l2 = dtflatten (lp); l2; l2 = dtlink(lp,l2)) {
cp = (channel*)l2;
cp->G = make_graph (cp->cnt);
}
}
}
QVector<QPoint> Landscape::getPath(QPoint start, QPoint end) const
{
std::vector<weight_t> min_distance;
std::vector<vertex_t> previous;
adjacency_list_t adj = make_graph(*this);
DijkstraComputePaths(this->coordsToIndex(start), adj, min_distance, previous);
std::list<vertex_t> path = DijkstraGetShortestPathTo(this->coordsToIndex(end), previous);
if (min_distance[this->coordsToIndex(end)] > 2000000) {
return QVector<QPoint>();
}
QVector<QPoint> retPath;
foreach(vertex_t vx, path) {
retPath.append(this->indexToCoords(vx));
}
int main(int argc, char* argv[]) {
int log_numverts;
double start, time_taken;
int64_t nedges;
packed_edge* result;
log_numverts = 16; /* In base 2 */
if (argc >= 2) log_numverts = atoi(argv[1]);
/* Start of graph generation timing */
start = get_time();
make_graph(log_numverts, INT64_C(16) << log_numverts, 1, 2, &nedges, &result);
time_taken = get_time() - start;
/* End of graph generation timing */
fprintf(stderr, "%" PRIu64 " edge%s generated in %fs (%f Medges/s)\n", nedges, (nedges == 1 ? "" : "s"), time_taken, 1. * nedges / time_taken * 1.e-6);
free(result);
return 0;
}
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
//as the graph node value is int type, we use the node value to index
// the nodes, for non-int value, maybe key_to_index is needed
// also visited flags are accessed by node value
// visited = true does not mean the cycle is detected!!
// after all the adjacent nodes are dfsed, the onpath is set to
// false. then if the adjacent nodes is still onpath but now get
// to be dfsed, cycle is detected!!
//adjacent list is represneted by unordered_set<int>
vector<unordered_set<int>> graph = make_graph(numCourses, prerequisites);
vector<bool> onpath(numCourses, false), visited(numCourses, false);
//loop the vertices to perform DFS
for(int i = 0; i < numCourses; i++)
{
if (!visited[i] && dfs_cycle(graph, i, onpath, visited))
return false;
}
return true;
}
inline std::ostream& write_graphviz(std::ostream& ost,
const std::vector<std::vector<double> >& adj_matrix,
const size_t frequency=0,
const std::vector<std::string>& normal_input={},
const std::vector<std::string>& novel_input={})
{
Graph graph = make_graph(adj_matrix);
for (size_t i=0; i<normal_input.size(); ++i) {
boost::put(boost::vertex_index1, graph,
boost::vertex(i, graph), normal_input[i]);
}
for (size_t i=0; i<novel_input.size(); ++i) {
boost::put(boost::vertex_index2, graph,
boost::vertex(i, graph), novel_input[i]);
}
insert_graphattr(&graph, "frequency", frequency);
boost::write_graphviz(ost, graph,
make_double_writer(boost::get(boost::vertex_index1, graph), "normal",
boost::get(boost::vertex_index2, graph), "novel"),
make_property_writer(boost::get(boost::edge_weight, graph), "weight"),
boost::make_graph_attributes_writer(graph));
return ost;
}
string alienOrder(vector<string>& words) {
if (words.size() == 1) return words[0];
graph g = make_graph(words);
return toposort(g);
}
int main(void) {
Graph g = make_graph();
return 0;
}
int
main (int argc, char **argv)
{
int * restrict has_adj;
int fd;
int64_t desired_nedge;
if (sizeof (int64_t) < 8) {
fprintf (stderr, "No 64-bit support.\n");
return EXIT_FAILURE;
}
if (argc > 1)
get_options (argc, argv);
nvtx_scale = 1L<<SCALE;
init_random ();
desired_nedge = nvtx_scale * edgefactor;
/* Catch a few possible overflows. */
assert (desired_nedge >= nvtx_scale);
assert (desired_nedge >= edgefactor);
if (VERBOSE) fprintf (stderr, "Generating edge list...");
if (use_RMAT) {
nedge = desired_nedge;
IJ = xmalloc_large_ext (nedge * sizeof (*IJ));
rmat_edgelist (IJ, nedge, SCALE, A, B, C);
} else {
make_graph(SCALE, desired_nedge, userseed, userseed, &nedge, (struct packed_edge**)(&IJ));
}
if (VERBOSE) fprintf (stderr, " done.\n");
if (dumpname)
fd = open (dumpname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
else
fd = 1;
if (fd < 0) {
fprintf (stderr, "Cannot open output file : %s\n",
(dumpname? dumpname : "stdout"));
return EXIT_FAILURE;
}
write (fd, IJ, 2 * nedge * sizeof (*IJ));
int buflen = strlen(dumpname) + strlen(".graph") + 1;
char * graphname = (char *) malloc(buflen * sizeof(char));
snprintf(graphname, buflen, "%s.graph", dumpname);
FILE * file = fopen(graphname, "w");
if(!file){
fprintf (stderr, "Cannot open output file : %s\n",
(graphname? graphname : "stdout"));
return EXIT_FAILURE;
}
for (int64_t k = 0; k < nedge; ++k) {
const int64_t i = get_v0_from_edge(&IJ[k]);
const int64_t j = get_v1_from_edge(&IJ[k]);
if (i != j)
fprintf(file, "%" PRId64 " %" PRId64 "\n", i+1, j+1);
}
fclose(file);
//close (fd);
free(graphname);
return EXIT_SUCCESS;
}
void do_client_simulation() {
char buf[256], buf2[256];
int retval;
FILE* f;
sprintf(buf, "%s%s", infile_prefix, CONFIG_FILE);
cc_config.defaults();
read_config_file(true, buf);
log_flags.init();
sprintf(buf, "%s%s", outfile_prefix, "log_flags.xml");
f = fopen(buf, "r");
if (f) {
MIOFILE mf;
mf.init_file(f);
XML_PARSER xp(&mf);
xp.get_tag(); // skip open tag
log_flags.parse(xp);
fclose(f);
}
gstate.add_platform("client simulator");
sprintf(buf, "%s%s", infile_prefix, STATE_FILE_NAME);
if (!boinc_file_exists(buf)) {
fprintf(stderr, "No client state file\n");
exit(1);
}
retval = gstate.parse_state_file_aux(buf);
if (retval) {
fprintf(stderr, "state file parse error %d\n", retval);
exit(1);
}
// if tasks have pending transfers, mark as completed
//
for (unsigned int i=0; i<gstate.results.size(); i++) {
RESULT* rp = gstate.results[i];
if (rp->state() < RESULT_FILES_DOWNLOADED) {
rp->set_state(RESULT_FILES_DOWNLOADED, "init");
} else if (rp->state() == RESULT_FILES_UPLOADING) {
rp->set_state(RESULT_FILES_UPLOADED, "init");
}
}
check_app_config(infile_prefix);
show_app_config();
cc_config.show();
log_flags.show();
sprintf(buf, "%s%s", infile_prefix, GLOBAL_PREFS_FILE_NAME);
sprintf(buf2, "%s%s", infile_prefix, GLOBAL_PREFS_OVERRIDE_FILE);
gstate.read_global_prefs(buf, buf2);
fprintf(index_file,
"<h3>Output files</h3>\n"
"<a href=%s>Summary</a>\n"
"<br><a href=%s>Log file</a>\n",
SUMMARY_FNAME, LOG_FNAME
);
// fill in GPU device nums and OpenCL flags
//
for (int i=0; i<coprocs.n_rsc; i++) {
COPROC& cp = coprocs.coprocs[i];
for (int j=0; j<cp.count; j++) {
cp.device_nums[j] = j;
if (cp.have_opencl) {
cp.instance_has_opencl[j] = true;
}
}
}
set_no_rsc_config();
process_gpu_exclusions();
get_app_params();
if (!include_empty_projects) {
cull_projects();
}
fprintf(summary_file, "--------------------------\n");
int j=0;
for (unsigned int i=0; i<gstate.projects.size(); i++) {
gstate.projects[i]->index = j++;
}
clear_backoff();
gstate.log_show_projects();
gstate.set_ncpus();
work_fetch.init();
//set_initial_rec();
rec_adjust_period = delta;
gstate.request_work_fetch("init");
simulate();
sim_results.compute_figures_of_merit();
sprintf(buf, "%s%s", outfile_prefix, RESULTS_DAT_FNAME);
f = fopen(buf, "w");
sim_results.print(f);
fclose(f);
sprintf(buf, "%s%s", outfile_prefix, RESULTS_TXT_FNAME);
f = fopen(buf, "w");
sim_results.print(f, true);
fclose(f);
fprintf(summary_file,
"Simulation done.\n"
"-------------------------\n"
"Figures of merit:\n"
);
sim_results.print(summary_file, true);
double cpu_time;
boinc_calling_thread_cpu_time(cpu_time);
fprintf(summary_file,
"-------------------------\n"
"Simulator CPU time: %f secs\n"
"-------------------------\n"
"Peak FLOPS: CPU %.2fG GPU %.2fG\n",
cpu_time,
cpu_peak_flops()/1e9,
gpu_peak_flops()/1e9
);
print_project_results(summary_file);
fclose(rec_file);
make_graph("REC", "rec", 0);
}
int main()
{
int inword_toggle=0;
char previous_char='\0';
setlocale(LC_ALL,"hun_HU.iso88592");
txt=fopen("test04.txt","r");
if(txt==0)
{
printf("Error: %d",errno);
return 0;
}
while((actual_char=fgetc(txt))!=EOF)
{
if(qerror()<0)
{
qerror();
return -1;
}
// printf("%c",actual_char);
// printf("\tvalue is=%d\n",actual_char);
if(isalpha(actual_char))
{
letter++;
}
else
{
if(ifspace()==1)
{
space++;
}
if(ifnl()==1)
{
nl++;
}
}
//sets inword_toggle to 1 if at start of word
if((actual_char!=' ' && actual_char!='\n') && isspace(previous_char))
{
word++;
inword_toggle=1;
}
//sets inword_toggle to 0 if at the end of a word
if((actual_char==' ' || actual_char=='\n') && isalnum(previous_char))
{
inword_toggle=0;
// printf("%d\n",wordletternum);
lettersumarrayfiller();
// printf("%d=%d\n",i,letternumsum[i]);
}
//adds one to wordletternum value if still in word or resets counter if not
if(inword_toggle==1)
{
wordletternum++;
}
else
{
wordletternum=0;
}
previous_char=actual_char;
}
lettersumarrayfiller();
fclose(txt);
avrcalc();
term_win_size();
onepercent();
printf("The number of letters: %5d\n",letter);
printf("The number of words: %6d\n",word);
printf("The number of spaces: %5d\n",space);
printf("The number of new lines: %d\n",nl);
printf("\n\n");
/* for(i=0;i<ARRAYSIZE;i++)
{
if(letternumsum[i]!='\0')
{
printf("The number of %d letter words is=%d\n",i,letternumsum[i]);
}
}*/
make_graph();
// printf("terminal width is:%d",term_win_size());
// printf("1 percent is:%.3f\n",onepercent());
// printf("display size is %d\n",display_size());
return 0;
}
int main(int argc, char* argv[]) {
struct timeval currentTime;
gettimeofday(¤tTime, NULL);
int seed = currentTime.tv_sec ^ currentTime.tv_usec;
seed ^= seed >> 12;
seed ^= seed << 25;
seed ^= seed >> 27;
FILE *fout;
if (argc < 2 || argc > 10) {
printError();
}
// define all the variables
int log_numverts = -1;
char * filename = "";
long int numEdges;
double start, time_taken, start_write, time_taken_write;
int64_t nedges;
packed_edge* result;
int binary = 0; // set default to be not binary, normal tsv
numEdges = 16; // default 16
fout = stdout; // default the stdout
int opt;
while(optind < argc) {
if ((opt = getopt(argc, argv, "+e:o:s:b")) != -1) {
switch (opt) {
case 'e':
numEdges = atoi(optarg);
break;
case 'o':
filename = optarg;
fout = fopen(optarg, "wb");
if (fout == NULL) {
fprintf(stderr, "%s -- ", optarg);
perror("fopen for write failed");
exit(1);
}
break;
case 's':
seed = atoi(optarg);
break;
case 'b':
binary = 1;
break;
default:
printError();
break;
}
} else {
if(argv[optind] == NULL) {
printError();
} else {
log_numverts = atoi(argv[optind]); // In base 2
optind++;
}
}
}
if( log_numverts < 0 ) {
printError();
}
//Start of graph generation timing
start = get_time();
make_graph(log_numverts, numEdges << log_numverts, seed, seed, &nedges, &result);
time_taken = get_time() - start;
printf("For 2^%d\n", log_numverts);
printf("\t%f seconds for making graph\n", time_taken);
if (binary == 0) {
// print to the file
start_write = get_time();
for (int i = 0; i < (numEdges << log_numverts); i++) {
fprintf(fout, "%lu\t%lu\n", get_v0_from_edge(result + i), get_v1_from_edge(result + i));
}
time_taken_write = get_time() - start_write;
printf("\t%f seconds for writing ascii version\n", time_taken_write);
} else {
// need to print binary
start_write = get_time();
for (int i = 0; i < (numEdges << log_numverts); i++) {
uint32_t from = get_v0_from_edge(result + i);
uint32_t to = get_v1_from_edge(result + i);
// add the check for not exceed the uint32_t max
fwrite((const void*) & from,sizeof(uint32_t),1,fout);
fwrite((const void*) & to,sizeof(uint32_t),1,fout);
}
time_taken_write = get_time() - start_write;
printf("\t%f seconds for writing binary version\n", time_taken_write);
}
int check_correctness;
check_correctness = fclose(fout);
if (check_correctness == EOF) {
fprintf(stderr, "%s -- ", filename);
perror("fclose failed");
exit(1);
}
return 0;
}
