int mdt_feature_aligned_residue_pair_add( struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, int protein1, int protein2, gboolean asymmetric, mdt_cb_feature_aligned_residue_pair getbin, void *data, mdt_cb_free freefunc, GError **err) { char *fullname; struct mdt_feature_aligned_residue_pair *feat; int nfeat; if (!check_protein_pair(protein1, protein2, "Aligned residue pair", err)) { return -1; } feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_ALIGNED_RESIDUE_PAIR, data, freefunc)->u.aligned_residue_pair); feat->protein1 = protein1; feat->protein2 = protein2; feat->getbin = getbin; fullname = g_strdup_printf("%s of proteins (%d,%d)", name, protein1, protein2); mod_mdt_libfeature_register(&mlib->base, nfeat, fullname, precalc_type, protein2 == 1 ? MOD_MDTP_AB : MOD_MDTP_AC, MOD_MDTS_RESIDUE_PAIR, asymmetric, 0); g_free(fullname); return nfeat; }
int mdt_feature_protein_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, int protein, mdt_cb_feature_protein getbin, void *data, mdt_cb_free freefunc, GError **err) { GString *fullname; struct mdt_feature_protein *feat; mod_mdt_protein mdt_protein; int nfeat; if (!check_protein(protein, "Protein", &mdt_protein, err)) { return -1; } feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_PROTEIN, data, freefunc)->u.protein); feat->protein = protein; feat->getbin = getbin; fullname = g_string_new(name); g_string_append_printf(fullname, " of protein %d", protein); mod_mdt_libfeature_register(&mlib->base, nfeat, fullname->str, precalc_type, mdt_protein, MOD_MDTS_PROTEIN, FALSE, 0); g_string_free(fullname, TRUE); return nfeat; }
int mdt_feature_protein_pair_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, int protein1, int protein2, mdt_cb_feature_protein_pair getbin, void *data, mdt_cb_free freefunc, GError **err) { char *fullname; struct mdt_feature_protein_pair *feat; int nfeat; if (!check_protein_pair(protein1, protein2, "Protein pair", err)) { return -1; } feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_PROTEIN_PAIR, data, freefunc)->u.protein_pair); feat->protein1 = protein1; feat->protein2 = protein2; feat->getbin = getbin; fullname = g_strdup_printf("%s of proteins (%d,%d)", name, protein1, protein2); mod_mdt_libfeature_register(&mlib->base, nfeat, fullname, precalc_type, protein2 == 1 ? MOD_MDTP_AB : MOD_MDTP_AC, MOD_MDTS_PROTEIN, FALSE, 0); g_free(fullname); return nfeat; }
void node(const osmium::Node& node) { if (m_cfg.add_untagged_nodes || !node.tags().empty()) { gdalcpp::Feature feature{m_layer_point, m_factory.create_point(node)}; feature.set_field("id", double(node.id())); add_feature(feature, node); } }
void way(const osmium::Way& way) { try { gdalcpp::Feature feature{m_layer_linestring, m_factory.create_linestring(way)}; feature.set_field("id", int32_t(way.id())); add_feature(feature, way); } catch (const osmium::geometry_error&) { std::cerr << "Ignoring illegal geometry for way " << way.id() << ".\n"; } }
void t_hdr_supported::add_features(const list<string> &l) { if (l.empty()) return; for (list<string>::const_iterator i = l.begin(); i != l.end(); i++) { add_feature(*i); } populated = true; }
void area(const osmium::Area& area) { try { gdalcpp::Feature feature{m_layer_multipolygon, m_factory.create_multipolygon(area)}; feature.set_field("id", int32_t(area.id())); add_feature(feature, area); } catch (const osmium::geometry_error&) { std::cerr << "Ignoring illegal geometry for area " << area.id() << " created from " << (area.from_way() ? "way" : "relation") << " with id=" << area.orig_id() << ".\n"; } }
int mdt_feature_angle_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, mdt_cb_feature_bond getbin, void *data, mdt_cb_free freefunc) { struct mdt_feature_bond *feat; int nfeat; feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_BOND, data, freefunc)->u.bond); feat->type = MDT_BOND_TYPE_ANGLE; feat->getbin = getbin; mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type, MOD_MDTP_A, MOD_MDTS_ANGLE, FALSE, 0); return nfeat; }
int mdt_feature_tuple_pair_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, mdt_cb_feature_tuple_pair getbin, void *data, mdt_cb_free freefunc) { struct mdt_feature_tuple_pair *feat; int nfeat; feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_TUPLE_PAIR, data, freefunc)->u.tuple_pair); feat->getbin = getbin; mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type, MOD_MDTP_A, MOD_MDTS_TUPLE_PAIR, TRUE, 0); return nfeat; }
int mdt_feature_atom_pair_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, gboolean asymmetric, mdt_cb_feature_atom_pair getbin, void *data, mdt_cb_free freefunc) { struct mdt_feature_atom_pair *feat; int nfeat; feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_ATOM_PAIR, data, freefunc)->u.atom_pair); feat->getbin = getbin; mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type, MOD_MDTP_A, MOD_MDTS_ATOM_PAIR, asymmetric, 0); mdt_feature_add_needed_file(mlib, nfeat, MOD_MDTF_STRUCTURE); return nfeat; }
int mdt_feature_residue_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, int protein, int delta, int align_delta, gboolean pos2, int bin_seq_outrange, mdt_cb_feature_residue getbin, void *data, mdt_cb_free freefunc, GError **err) { GString *fullname; struct mdt_feature_residue *feat; mod_mdt_protein mdt_protein; int nfeat; if (!check_protein(protein, "Residue", &mdt_protein, err)) { return -1; } feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_RESIDUE, data, freefunc)->u.residue); feat->protein = protein; feat->delta = delta; feat->align_delta = align_delta; feat->pos2 = pos2; feat->bin_seq_outrange = bin_seq_outrange; feat->getbin = getbin; fullname = g_string_new(name); g_string_append_printf(fullname, " of protein %d", protein); if (pos2) { g_string_append(fullname, " at pos2"); } if (delta != 0) { g_string_append_printf(fullname, ", at delta %d", delta); } if (align_delta != 0) { g_string_append_printf(fullname, ", at alignment delta %d", align_delta); } mod_mdt_libfeature_register(&mlib->base, nfeat, fullname->str, precalc_type, mdt_protein, pos2 ? MOD_MDTS_RESIDUE_PAIR : MOD_MDTS_RESIDUE, FALSE, 0); g_string_free(fullname, TRUE); return nfeat; }
int mdt_feature_group_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, int ifeat1, int ifeat2, mdt_cb_feature_group getbin, void *data, mdt_cb_free freefunc, GError **err) { struct mdt_feature_group *feat; int nfeat; if (!check_feature(ifeat1, mlib, 1, err) || !check_feature(ifeat2, mlib, 2, err)) { return -1; } feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_GROUP, data, freefunc)->u.group); feat->ifeat1 = ifeat1; feat->ifeat2 = ifeat2; feat->getbin = getbin; mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type, MOD_MDTP_A, MOD_MDTS_PROTEIN, FALSE, 0); return nfeat; }
static int merge_hwe (struct hwentry * dst, struct hwentry * src) { merge_str(vendor); merge_str(product); merge_str(revision); merge_str(uid_attribute); merge_str(features); merge_str(hwhandler); merge_str(selector); merge_str(checker_name); merge_str(prio_name); merge_str(prio_args); merge_str(alias_prefix); merge_str(bl_product); merge_num(pgpolicy); merge_num(pgfailback); merge_num(rr_weight); merge_num(no_path_retry); merge_num(minio); merge_num(minio_rq); merge_num(pg_timeout); merge_num(flush_on_last_del); merge_num(fast_io_fail); merge_num(dev_loss); merge_num(user_friendly_names); merge_num(retain_hwhandler); merge_num(detect_prio); /* * Make sure features is consistent with * no_path_retry */ if (dst->no_path_retry == NO_PATH_RETRY_FAIL) remove_feature(&dst->features, "queue_if_no_path"); else if (dst->no_path_retry != NO_PATH_RETRY_UNDEF) add_feature(&dst->features, "queue_if_no_path"); return 0; }
layer_t *avg_pooling(layer_t *target, int factor) { layer_t *result_layer = init_layer(); for (int stack = 0; stack < target->size; stack += 1) { int result_size = (target->feature[stack]->size)/factor; image_t *result = init_image2D(result_size); for(int i = 0; i < result_size; i += 1) { for(int j = 0; j < result_size; j += 1) { float sum = 0; for(int m = 0; m < factor; m += 1) { for(int n = 0; n < factor; n += 1) { sum += target->feature[stack]->element[0][i*target->feature[stack]->size*factor+j*factor+m*target->feature[stack]->size+n]; } } result->element[0][i*result->size+j] = sum / (target->feature[stack]->size * target->feature[stack]->size); } } add_feature(result_layer, result); } return result_layer; }
void FeatureMap :: read_from_file( string filename ){ ifstream input_file( filename.c_str() ); size_t num_features; input_file >> num_features; for ( size_t i = 0; i < num_features; i++ ){ pair<float, float> ctr; input_file >> ctr.first >> ctr.second; string shape_name; input_file >> shape_name; pair<int, int> size; input_file >> size.first >> size.second; size_t feature_size; input_file >> feature_size; vector<float> feature(feature_size); for( size_t j = 0; j < feature_size; j++ ){ input_file >> feature[j]; } int label; input_file >> label; add_feature( ctr, name_to_shape(shape_name), size, feature, label ); } }
int mdt_feature_residue_pair_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, int protein, gboolean asymmetric, mdt_cb_feature_residue_pair getbin, void *data, mdt_cb_free freefunc, GError **err) { struct mdt_feature_residue_pair *feat; mod_mdt_protein mdt_protein; int nfeat; if (!check_protein(protein, "Residue pair", &mdt_protein, err)) { return -1; } feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_RESIDUE_PAIR, data, freefunc)->u.residue_pair); feat->protein = protein; feat->getbin = getbin; mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type, mdt_protein, MOD_MDTS_RESIDUE_PAIR, asymmetric, 0); return nfeat; }
int mdt_feature_tuple_add(struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type, gboolean pos2, mdt_cb_feature_tuple getbin, void *data, mdt_cb_free freefunc) { GString *fullname; struct mdt_feature_tuple *feat; int nfeat; feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_TUPLE, data, freefunc)->u.tuple); feat->pos2 = pos2; feat->getbin = getbin; fullname = g_string_new(name); if (pos2) { g_string_append(fullname, " at pos2"); } mod_mdt_libfeature_register(&mlib->base, nfeat, fullname->str, precalc_type, MOD_MDTP_A, pos2 ? MOD_MDTS_TUPLE_PAIR : MOD_MDTS_TUPLE, FALSE, 0); g_string_free(fullname, TRUE); return nfeat; }
static void setup_tun_net(char *arg) { struct device *dev; struct net_info *net_info = malloc(sizeof(*net_info)); int ipfd; u32 ip = INADDR_ANY; bool bridging = false; char tapif[IFNAMSIZ], *p; struct virtio_net_config conf; net_info->tunfd = get_tun_device(tapif); dev = new_device("net", VIRTIO_ID_NET); dev->priv = net_info; add_virtqueue(dev, VIRTQUEUE_NUM, net_input); add_virtqueue(dev, VIRTQUEUE_NUM, net_output); ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); if (ipfd < 0) err(1, "opening IP socket"); if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) { arg += strlen(BRIDGE_PFX); bridging = true; } p = strchr(arg, ':'); if (p) { str2mac(p+1, conf.mac); add_feature(dev, VIRTIO_NET_F_MAC); *p = '\0'; } if (bridging) add_to_bridge(ipfd, tapif, arg); else ip = str2ip(arg); configure_device(ipfd, tapif, ip); add_feature(dev, VIRTIO_NET_F_CSUM); add_feature(dev, VIRTIO_NET_F_GUEST_CSUM); add_feature(dev, VIRTIO_NET_F_GUEST_TSO4); add_feature(dev, VIRTIO_NET_F_GUEST_TSO6); add_feature(dev, VIRTIO_NET_F_GUEST_ECN); add_feature(dev, VIRTIO_NET_F_HOST_TSO4); add_feature(dev, VIRTIO_NET_F_HOST_TSO6); add_feature(dev, VIRTIO_NET_F_HOST_ECN); add_feature(dev, VIRTIO_RING_F_INDIRECT_DESC); set_config(dev, sizeof(conf), &conf); close(ipfd); devices.device_num++; if (bridging) verbose("device %u: tun %s attached to bridge: %s\n", devices.device_num, tapif, arg); else verbose("device %u: tun %s: %s\n", devices.device_num, tapif, arg); }
/** Fill the features DArray for [from][to cell */ void fill_features(Hashmap *featuremap, DArray *farr, int from, int to, FeaturedSentence sentence) { char buffer[255]; if (from != to && to != 0) { Word pword_w = (Word) DArray_get(sentence->words, from); Word cword_w = (Word) DArray_get(sentence->words, to); join(buffer, 2, pword_w->form, pword_w->postag); add_feature(pword_ppos, buffer, featuremap, farr); add_feature(pword, pword_w->form, featuremap, farr); add_feature(ppos, pword_w->postag, featuremap, farr); join(buffer, 2, cword_w->form, cword_w->postag); add_feature(cword_cpos, buffer, featuremap, farr); add_feature(cword, cword_w->form, featuremap, farr); add_feature(cpos, cword_w->postag, featuremap, farr); join(buffer, 4, pword_w->form, pword_w->postag, cword_w->form, cword_w->postag); add_feature(pword_ppos_cword_cpos, buffer, featuremap, farr); join(buffer, 3, pword_w->postag, cword_w->form, cword_w->postag); add_feature(ppos_cword_cpos, buffer, featuremap, farr); join(buffer, 3, pword_w->form, pword_w->postag, cword_w->postag); add_feature(pword_ppos_cpos, buffer, featuremap, farr); join(buffer, 3, pword_w->form, pword_w->postag, cword_w->form); add_feature(pword_ppos_cword, buffer, featuremap, farr); join(buffer, 2, pword_w->form, cword_w->form); add_feature(pword_cword, buffer, featuremap, farr); join(buffer, 2, pword_w->postag, cword_w->postag); add_feature(ppos_cpos, buffer, featuremap, farr); /* char* pposP1_v; char* pposM1_v; char* cposM1_v; char* cposP1_v; if (from == DArray_count(sentence->words) - 1 ) pposP1_v = STOP; else pposP1_v = (char*)DArray_get(sentence->postags, from+1); if (from == 0 ) pposM1_v = START; else pposM1_v = (char*)DArray_get(sentence->postags, from-1); if (to == 0 ) cposM1_v = START; else cposM1_v = (char*)DArray_get(sentence->postags, to-1); if (to == sentence->length - 1 ) cposP1_v = STOP; else cposP1_v = (char*)DArray_get(sentence->postags, to+1); join(buffer, 4, ppos_v, pposP1_v, cposM1_v,cpos_v); add_feature(ppos_pposP1_cposM1_cpos, buffer, featuremap,farr); join(buffer, 4, pposM1_v, ppos_v, cposM1_v,cpos_v); add_feature(pposM1_ppos_cposM1_cpos, buffer, featuremap,farr); join(buffer, 4, ppos_v, pposP1_v, cpos_v,cposP1_v); add_feature(ppos_pposP1_cpos_cposP1, buffer, featuremap,farr); join(buffer, 4, pposM1_v, ppos_v, cpos_v,cposP1_v); add_feature(pposM1_ppos_cpos_cposP1, buffer, featuremap,farr); int left_context, right_context; if (from < to){ left_context = from; right_context = to; }else{ left_context = to; right_context = from; } for(int j = left_context + 1; j < right_context;j++){ join(buffer, 3, DArray_get(sentence->postags, left_context), DArray_get(sentence->postags, j), DArray_get(sentence->postags, right_context)); add_feature(ppos_bpos_cpos, buffer, featuremap, farr); } * */ } }
void scan_image(SDL_Surface* image) { predict_cascade_t* cascade = load_adaboost("adaboost_test2.txt"); features_array_t* features = alloc_features_array(); Uint32 red_pixel = SDL_MapRGB(image->format, 0, 255, 0); for (int i = 0; i < 162336; ++i) { feature_t f; f.i = f.j = f.w = f.h = f.charac = f.value = -1; add_feature(f, features); } const int padding = 2; for (int scale = 24; scale < 100; scale *= 1.25) { for (int i = 0; i < image->w - scale; i += padding) { for (int j = 0; j < image->h - scale; j += padding) { SDL_Surface* sub_window = extract_image(image, i, j, scale, scale); convert_to_greyscale(sub_window); //if (scale != 24) { sub_window = scale_surface(sub_window, 24, 24); //} integral_image_t* integral_image = alloc_integral_image(sub_window->w, sub_window->h); convert_to_integral_image(sub_window, integral_image); SDL_FreeSurface(sub_window); int k = 0; cascade_t layer; printf("\n=============================\n\n"); printf("x=%d y=%d\n", i, j); while (k < cascade->nb_layers) { compute_cascade_features(features, cascade->layers[k], integral_image); layer.nb_features = cascade->layers[k]->T; layer.alphas = cascade->layers[k]->alphas; layer.thresholds = cascade->layers[k]->thresholds; layer.parities = cascade->layers[k]->parities; layer.features = cascade->layers[k]->features; layer.strong_threshold = cascade->layers[k]->strong_threshold; if (!strong_classify(features, &layer)) { printf("non face layer=%d\n", k); break; } ++k; } free_integral_image(integral_image); if (k == cascade->nb_layers) { printf("---------------------------------------------------------detected\n"); for (int x = i; x < i + scale; ++x) { putpixel(image, x, j, red_pixel); } for (int y = j; y < j + scale; ++y) { putpixel(image, i, y, red_pixel); } for (int x = i; x < i + scale; ++x) { putpixel(image, x, j + scale, red_pixel); } for (int y = j; y < j + scale; ++y) { putpixel(image, i + scale, y, red_pixel); } } } } } SDL_SaveBMP(image, "../SDL/detection.bmp"); free_features_array(features); free_predict_cascade(cascade); }
/*L:195 * Our network is a Host<->Guest network. This can either use bridging or * routing, but the principle is the same: it uses the "tun" device to inject * packets into the Host as if they came in from a normal network card. We * just shunt packets between the Guest and the tun device. */ static void setup_tun_net(char *arg) { struct device *dev; struct net_info *net_info = malloc(sizeof(*net_info)); int ipfd; u32 ip = INADDR_ANY; bool bridging = false; char tapif[IFNAMSIZ], *p; struct virtio_net_config conf; net_info->tunfd = get_tun_device(tapif); /* First we create a new network device. */ dev = new_device("net", VIRTIO_ID_NET); dev->priv = net_info; /* Network devices need a recv and a send queue, just like console. */ add_virtqueue(dev, VIRTQUEUE_NUM, net_input); add_virtqueue(dev, VIRTQUEUE_NUM, net_output); /* * We need a socket to perform the magic network ioctls to bring up the * tap interface, connect to the bridge etc. Any socket will do! */ ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); if (ipfd < 0) err(1, "opening IP socket"); /* If the command line was --tunnet=bridge:<name> do bridging. */ if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) { arg += strlen(BRIDGE_PFX); bridging = true; } /* A mac address may follow the bridge name or IP address */ p = strchr(arg, ':'); if (p) { str2mac(p+1, conf.mac); add_feature(dev, VIRTIO_NET_F_MAC); *p = '\0'; } /* arg is now either an IP address or a bridge name */ if (bridging) add_to_bridge(ipfd, tapif, arg); else ip = str2ip(arg); /* Set up the tun device. */ configure_device(ipfd, tapif, ip); /* Expect Guest to handle everything except UFO */ add_feature(dev, VIRTIO_NET_F_CSUM); add_feature(dev, VIRTIO_NET_F_GUEST_CSUM); add_feature(dev, VIRTIO_NET_F_GUEST_TSO4); add_feature(dev, VIRTIO_NET_F_GUEST_TSO6); add_feature(dev, VIRTIO_NET_F_GUEST_ECN); add_feature(dev, VIRTIO_NET_F_HOST_TSO4); add_feature(dev, VIRTIO_NET_F_HOST_TSO6); add_feature(dev, VIRTIO_NET_F_HOST_ECN); /* We handle indirect ring entries */ add_feature(dev, VIRTIO_RING_F_INDIRECT_DESC); set_config(dev, sizeof(conf), &conf); /* We don't need the socket any more; setup is done. */ close(ipfd); devices.device_num++; if (bridging) verbose("device %u: tun %s attached to bridge: %s\n", devices.device_num, tapif, arg); else verbose("device %u: tun %s: %s\n", devices.device_num, tapif, arg); }
int main(int argc, char *argv[]) { boolean print_parse = FALSE; boolean print_expanded = FALSE; char *arg; char *source_name = NULL; char *output_name = NULL; FILE *file; add_header_handler("module", set_module); add_header_handler("library", set_library); add_header_handler(NULL, end_of_headers); init_sym_table(); init_feature(); init_info(); init_expand(); init_compile(); #ifdef MACOS add_feature(symbol("macos")); # ifndef SHLB argc = ccommand( &argv ); # endif #endif while ((arg = *++argv) != NULL) { if (arg[0] == '-') { switch (arg[1]) { case 'd': if (arg[2] == '\0') { print_parse = TRUE; print_expanded = TRUE; } else { char *ptr; for (ptr = arg+2; *ptr != '\0'; ptr++) { switch (*ptr) { case 'p': print_parse = TRUE; break; case 'e': print_expanded = TRUE; break; default: fprintf(stderr, "Invalid thing to print: ``%c''\n", *ptr); usage(); } } } break; case 'o': if (output_name != NULL) { fprintf(stderr, "-o can only be used once.\n"); usage(); } else if (arg[2] != '\0') output_name = arg+2; else if (*++argv == NULL) { fprintf(stderr, "-o must be followed by the output " "file name.\n"); usage(); } else output_name = *argv; break; case 'l': if (LibraryName != NULL) { fprintf(stderr, "-l can only be used once.\n"); usage(); } if (arg[2] != '\0') LibraryName = symbol(arg+2); else if (*++argv == NULL) { fprintf(stderr, "-l must be followed by the library " "name.\n"); usage(); } else LibraryName = symbol(*argv); break; case 'q': GiveWarnings = FALSE; break; case 'D': if (arg[2] != '\0') add_feature(symbol(arg + 2)); else if (*++argv == NULL) { fprintf(stderr, "-D must be followed by the feature to define.\n"); usage(); } else add_feature(symbol(*argv)); break; case 'U': if (arg[2] != '\0') remove_feature(symbol(arg + 2)); else if (*++argv == NULL) { fprintf(stderr, "-U must be followed by the feature " "to undefine.\n"); usage(); } else remove_feature(symbol(*argv)); break; default: fprintf(stderr, "Invalid flag: ``%s''\n", arg); usage(); } } else if (source_name != NULL) { fprintf(stderr, "Too many files\n"); usage(); } else source_name = arg; } if (source_name == NULL) usage(); yyin = fopen(source_name, "rb"); if (yyin == NULL) { /* Try the same filename but in the current directory */ /* Start ptr at the null termination, and work backwards to a path separator. */ char *ptr = source_name + strlen(source_name); for ( ; ptr != source_name; ptr--) { if (*ptr == '/' || *ptr == '\\') { /* We're pointing at the path separator, which is too far */ ptr++; break; } } /* If ptr is a different string than source_name, and it isn't the empty string... */ if (ptr != source_name && *ptr != 0) { yyin = fopen(ptr, "rb"); } if (yyin == NULL) { perror(source_name); exit(1); } } current_file = source_name; yyparse(); if (print_parse) { printf("================ Original Parse Tree ================\n"); print_body(Program, 0); } if (nerrors != 0) exit(1); /* Do the various source-to-source expansions. */ expand(Program); if (print_expanded) { printf("================ Expanded Parse Tree ================\n"); print_body(Program, 0); } if (nerrors != 0) exit(1); /* Run environment analysis */ environment_analysis(Program); if (nerrors != 0) exit(1); if (output_name == NULL) output_name = make_output_name(source_name, ".dbc"); if (strcmp(output_name, "-") == 0) file = stdout; else file = fopen(output_name, "wb"); if (file == NULL) { perror(output_name); exit(1); } dump_setup_output(source_name, file); /* Generate code. */ compile(Program); dump_finalize_output(); fclose(file); exit(0); return 0; }
int main() { int i; printf("==== Initial status ====\n"); image_t *test_cimage1 = init_image2D(5); for(i = 0; i < test_cimage1->size*test_cimage1->size; i += 1) { if (i%2) test_cimage1->element[0][i] = i; else test_cimage1->element[0][i] = -i; } image_t *test_cimage2 = init_image2D(5); for(i = 0; i < test_cimage2->size*test_cimage2->size; i += 1) { if (i%2) test_cimage2->element[0][i] = i; else test_cimage2->element[0][i] = -i; } kernel_t *test_kernel1 = init_kernel2D(3); for(i = 0; i < test_kernel1->size*test_kernel1->size; i += 1) { test_kernel1->element[0][i] = (i%3)+1; } kernel_t *test_kernel2 = init_kernel2D(3); for(i = 0; i < test_kernel2->size*test_kernel2->size; i += 1) { test_kernel2->element[0][i] = -1; } printf("Images:\n"); layer_t *input_layer = init_layer(); add_feature(input_layer, test_cimage1); add_feature(input_layer, test_cimage2); printlayer(input_layer); printf("Kernels:\n"); layer_t *kernel_layer = init_layer(); add_feature(kernel_layer, test_kernel1); add_feature(kernel_layer, test_kernel2); printlayer(kernel_layer); printf("\n"); printf("==== Test convolution ====\n"); printf("Convolution2D:\n"); layer_t *result_clayer = convolution2D(input_layer, kernel_layer); printlayer(result_clayer); printf("\n"); printf("==== Test activator function ====\n"); layer_t *result_alayer = activator(result_clayer, relu); printlayer(result_alayer); printf("\n"); printf("==== Test pooling ====\n"); printf("Max Pooling:\n"); layer_t *result_player = max_pooling(result_alayer, 3); printlayer(result_player); printf("Avg Pooling:\n"); result_player = avg_pooling(result_alayer, 3); printlayer(result_player); printf("Min Pooling:\n"); result_player = min_pooling(result_alayer, 3); printlayer(result_player); printf("=== Test image3D ===\n"); image_t *image3d = init_image3D(3, 3); image3d->element[0][1] = 1; image3d->element[1][1] = 2; image3d->element[2][1] = 3; printmap(image3d); return 0; }