static void custom_unix_test(void) { void *array; bool ok; /* "linux" is replaced by "1" in .template so we use "Linux" */ dr_fprintf(STDERR, " testing custom Linux alloc...."); array = dr_raw_mem_alloc(PAGE_SIZE, DR_MEMPROT_READ | DR_MEMPROT_WRITE, NULL); if (array == NULL) dr_fprintf(STDERR, "error: unable to mmap\n"); write_array(array); # ifdef LINUX array = dr_raw_mremap(array, PAGE_SIZE, PAGE_SIZE*2, MREMAP_MAYMOVE, NULL); if ((ptr_int_t)array <= 0 && (ptr_int_t)array >= -PAGE_SIZE) dr_fprintf(STDERR, "error: unable to mremap\n"); write_array(array); # endif ok = dr_raw_mem_free(array, PAGE_SIZE*2); if (!ok) dr_fprintf(STDERR, "error: failed to munmap\n"); # ifdef LINUX array = dr_raw_brk(0); if (array == NULL) dr_fprintf(STDERR, "error: unable to query brk\n"); # endif dr_fprintf(STDERR, "success\n"); }
static void autonumber(FlexBuffer *buffer, const Token& t) { const AttributeRec *id = t.LookupAttr(SGMLName::intern("ID", 1)); const AttributeRec *type = t.LookupAttr(SGMLName::intern("Type", 1)); const AttributeRec *initial = t.LookupAttr(SGMLName::intern("Initial", 1)); const AttributeRec *delta = t.LookupAttr(SGMLName::intern("Delta", 1)); const AttributeRec *reset = t.LookupAttr(SGMLName::intern("Reset", 1)); const AttributeRec *counter = t.LookupAttr(SGMLName::intern("Counter", 1)); if(!id) throw(Unexpected("Autonumber: missing ID attribute")); if(!type) throw(Unexpected("Autonumber: missing Type attribute")); if(!initial) throw(Unexpected("Autonumber: missing Initial attribute")); if(!delta) throw(Unexpected("Autonumber: missing Delta attribute")); if(!reset) throw(Unexpected("Autonumber: missing Reset attribute")); if(!counter) throw(Unexpected("Autonumber: missing Counter attribute")); buffer->writeStr(id->getAttrValueString()); buffer->writeStr(" = autonumber[\""); buffer->writeStr(type->getAttrValueString()); buffer->writeStr("\", \""); buffer->writeStr(initial->getAttrValueString()); buffer->writeStr("\", \""); buffer->writeStr(delta->getAttrValueString()); buffer->writeStr("\", "); write_array(buffer, counter->getAttrValueString(), 1); buffer->writeStr(", "); write_array(buffer, reset->getAttrValueString(), 1); buffer->writeStr("]\n\n"); }
void Wf_return::write(string & indent, ostream & os) { // int is_complex; // Array2 <doublevar> amp;//!< ln( |psi| ), grad ln( |psi| ), grad^2 |psi|/|psi| // Array2 <doublevar> phase; //!< phase and derivatives // Array2 <dcomplex> cvals; //!< (null), grad ln(|psi|), grad^2 psi/psi for os << indent << "nfunc " << amp.GetDim(0) << " nst " << amp.GetDim(1) << endl; os << indent << "is_complex " << is_complex << endl; os << indent << "amp "; write_array(os, amp) ; os << indent << "phase "; write_array(os, phase) ; os << indent << "cvals "; write_array(os, cvals) ; }
static int write_value(int fd, NODE *val) { int code, len; if (val->type == Node_var_array) { code = htonl(2); if (write(fd, & code, sizeof(code)) != sizeof(code)) return -1; return write_array(fd, val); } if ((val->flags & NUMBER) != 0) { code = htonl(1); if (write(fd, & code, sizeof(code)) != sizeof(code)) return -1; if (write(fd, & val->numbr, sizeof(val->numbr)) != sizeof(val->numbr)) return -1; } else { code = 0; if (write(fd, & code, sizeof(code)) != sizeof(code)) return -1; len = htonl(val->stlen); if (write(fd, & len, sizeof(len)) != sizeof(len)) return -1; if (write(fd, val->stptr, val->stlen) != val->stlen) return -1; } return 0; }
static awk_value_t * do_writea(int nargs, awk_value_t *result) { awk_value_t filename, array; int fd = -1; uint32_t major = MAJOR; uint32_t minor = MINOR; assert(result != NULL); make_number(0.0, result); if (do_lint && nargs > 2) lintwarn(ext_id, _("writea: called with too many arguments")); if (nargs < 2) goto out; /* directory is first arg, array to dump is second */ if (! get_argument(0, AWK_STRING, & filename)) { fprintf(stderr, _("do_writea: argument 0 is not a string\n")); errno = EINVAL; goto done1; } if (! get_argument(1, AWK_ARRAY, & array)) { fprintf(stderr, _("do_writea: argument 1 is not an array\n")); errno = EINVAL; goto done1; } /* open the file, if error, set ERRNO and return */ fd = creat(filename.str_value.str, 0600); if (fd < 0) goto done1; if (write(fd, MAGIC, strlen(MAGIC)) != strlen(MAGIC)) goto done1; major = htonl(major); if (write(fd, & major, sizeof(major)) != sizeof(major)) goto done1; minor = htonl(minor); if (write(fd, & minor, sizeof(minor)) != sizeof(minor)) goto done1; if (write_array(fd, array.array_cookie)) { make_number(1.0, result); goto done0; } done1: update_ERRNO_int(errno); unlink(filename.str_value.str); done0: close(fd); out: return result; }
void JsonValue::write(std::string &json) const { switch (type) { case Type::null: json += "null"; break; case Type::object: write_object(json); break; case Type::array: write_array(json); break; case Type::string: write_string(value_string, json); break; case Type::number: write_number(json); break; case Type::boolean: json += value_boolean ? "true" : "false"; break; case Type::undefined: break; } }
static void write_value(io::stream& e, const void* object, const bsreq* req, int level) { if(req->type == number_type) { auto value = req->get(object); e << value; } else if(req->type == text_type) { auto value = (const char*)req->get(object); e << "\"" << value << "\""; } else if(req->reference) { auto value = (const void*)req->get(object); write_key(e, value, req->type); } else if(req->isenum) { auto value = req->get(object); auto pd = bsdata::find(req->type); if(pd) write_key(e, pd->get(value), req->type); else e << value; } else { if(level > 0) e << "("; auto count = 0; for(auto f = req->type; *f; f++) { if(count) e << ", "; write_array(e, object, f, level + 1); count++; } if(level > 0) e << ")"; } }
static awk_bool_t write_value(int fd, awk_value_t *val) { uint32_t code, len; if (val->val_type == AWK_ARRAY) { code = htonl(2); if (write(fd, & code, sizeof(code)) != sizeof(code)) return awk_false; return write_array(fd, val->array_cookie); } if (val->val_type == AWK_NUMBER) { code = htonl(1); if (write(fd, & code, sizeof(code)) != sizeof(code)) return awk_false; if (write(fd, & val->num_value, sizeof(val->num_value)) != sizeof(val->num_value)) return awk_false; } else { code = 0; if (write(fd, & code, sizeof(code)) != sizeof(code)) return awk_false; len = htonl(val->str_value.len); if (write(fd, & len, sizeof(len)) != sizeof(len)) return awk_false; if (write(fd, val->str_value.str, val->str_value.len) != (ssize_t) val->str_value.len) return awk_false; } return awk_true; }
static size_t write_compact_array(json_t* array, stream_t* stream) { size_t bytes = 0; assert(json_is_array(array)); json_t* header = build_compact_array_header(array); uint8_t tag = BSER_TAG_COMPACT_ARRAY; if (stream->write(stream, &tag, SIZE_U8) == SIZE_U8) { size_t header_bytes = write_array(header, stream); if (header_bytes > 0) { size_t array_length = json_array_size(array); json_t* array_length_node = json_integer(array_length); size_t integer_size = write_integer(array_length_node, stream); if (integer_size > 0) { size_t written = write_compact_objects(array, header, stream); if (written > 0) { bytes = SIZE_U8 + header_bytes + integer_size + written; } } json_decref(array_length_node); } } json_decref(header); return bytes; }
char *save_gene_for_phase_and_front(int pi /* population index */, const char *save_prefix, int phase, int front_index) { static char gene_save_name[255]; double *gene = genes[pi]; double *fitness = fitness_matrix + FITNESS_INDEX(pi); sprintf(gene_save_name, "p%d-f%dgene.bin", phase, front_index); add_to_script(gene_save_name, phase, fitness); sprintf(gene_save_name, "%s/p%d-f%dgene.bin", save_prefix, phase, front_index); mprintf(1, "individOnFront[{phase -> %d, frontIndex -> %d}] -> \n", phase, front_index + 1); assert(FITNESS_COUNT == 2); mprintf(1, "\t{fitness -> {%lf, %lf}, age -> %d, layer -> %d, meetsGoal -> %s, geneFilename -> \"%s\"", fitness[0], fitness[1], ages[pi], LAYER_OF_INDIV(pi), is_goal_fitness(fitness) ? "True" : "False", gene_save_name); #ifdef PRINT_GENE_CHAR mprintf(1, ", gene -> { %lf" , gene[0]); int i; for (i = 1; i < GENE_COUNT; i++) mprintf(0, ", %lf", gene[i]); mprintf(0, "} "); #endif mprintf(0, "}\n"); write_array(gene_save_name, GENE_COUNT, gene); return gene_save_name; }
pfs::error_code ubjson_ostream<OStreamType, JsonType>::write_json (json_type const & j, bool with_prefix) { switch (j.type()) { case data_type::null: _os << UBJSON_CHAR_NULL; break; case data_type::boolean: _os << (j.boolean_data() ? UBJSON_CHAR_TRUE : UBJSON_CHAR_FALSE); break; case data_type::integer: return write_integer(j.integer_data(), with_prefix); case data_type::real: return write_real(j.real_data(), with_prefix); case data_type::string: return write_string(j.string_data(), with_prefix); case data_type::array: return write_array(j); case data_type::object: return write_object(j); } return pfs::error_code(); }
BinaryOutputStream& BinaryOutputStream::write_record( Numeric::float64* data, int nbr ) { begin_record(); write_array(data, nbr); end_record(); return *this; }
int avro_schema_to_json(const avro_schema_t schema, avro_writer_t out) { check_param(EINVAL, is_avro_schema(schema), "schema"); check_param(EINVAL, out, "writer"); int rval; if (is_avro_primitive(schema)) { check(rval, avro_write_str(out, "{\"type\":\"")); } switch (avro_typeof(schema)) { case AVRO_STRING: check(rval, avro_write_str(out, "string")); break; case AVRO_BYTES: check(rval, avro_write_str(out, "bytes")); break; case AVRO_INT32: check(rval, avro_write_str(out, "int")); break; case AVRO_INT64: check(rval, avro_write_str(out, "long")); break; case AVRO_FLOAT: check(rval, avro_write_str(out, "float")); break; case AVRO_DOUBLE: check(rval, avro_write_str(out, "double")); break; case AVRO_BOOLEAN: check(rval, avro_write_str(out, "boolean")); break; case AVRO_NULL: check(rval, avro_write_str(out, "null")); break; case AVRO_RECORD: return write_record(out, avro_schema_to_record(schema)); case AVRO_ENUM: return write_enum(out, avro_schema_to_enum(schema)); case AVRO_FIXED: return write_fixed(out, avro_schema_to_fixed(schema)); case AVRO_MAP: return write_map(out, avro_schema_to_map(schema)); case AVRO_ARRAY: return write_array(out, avro_schema_to_array(schema)); case AVRO_UNION: return write_union(out, avro_schema_to_union(schema)); case AVRO_LINK: return write_link(out, avro_schema_to_link(schema)); } if (is_avro_primitive(schema)) { return avro_write_str(out, "\"}"); } avro_set_error("Unknown schema type"); return EINVAL; }
int main(int argc, char **argv) { if (argc < 3) { printf("usage: jpg2hdr outfile.hdr infile.jpg\n"); } write_array(argv[1], argv[2]); }
int main(int argc, char* argv[]) { A2 A = create_array(); write_array(A); std::cout << ((read_array(A) == 1) ? "ok" : "error") << std::endl; std::cout << ((A.rsum(N - 1) == 1) ? "ok" : "error") << std::endl; std::cout << ((A.csum(M - 1) == 1) ? "ok" : "error") << std::endl; return 0; } // main
void write_device_array(const char *filename, T *data, int n) { T *host_array = new T[n]; if(cudaMemcpy(host_array, data, n*sizeof(T), cudaMemcpyDeviceToHost) != cudaSuccess) { BOOST_LOG_TRIVIAL(error) << "Error copying data from device to host."; exit(4); } write_array(filename, host_array, n); delete []host_array; }
static NODE * do_writea(int nargs) { NODE *file, *array; int ret; int fd; uint32_t major = MAJOR; uint32_t minor = MINOR; if (do_lint && get_curfunc_arg_count() > 2) lintwarn("writea: called with too many arguments"); /* directory is first arg, array to dump is second */ file = get_scalar_argument(0, FALSE); array = get_array_argument(1, FALSE); /* open the file, if error, set ERRNO and return */ (void) force_string(file); fd = creat(file->stptr, 0600); if (fd < 0) { goto done1; } if (write(fd, MAGIC, strlen(MAGIC)) != strlen(MAGIC)) goto done1; major = htonl(major); if (write(fd, & major, sizeof(major)) != sizeof(major)) goto done1; minor = htonl(minor); if (write(fd, & minor, sizeof(minor)) != sizeof(minor)) goto done1; ret = write_array(fd, array); if (ret != 0) goto done1; ret = 0; goto done0; done1: ret = -1; update_ERRNO(); unlink(file->stptr); done0: close(fd); /* Set the return value */ return make_number((AWKNUM) ret); }
/* WARNING i#262: if you use the cmake binary package, ctest is built * without a GNU_STACK section, which causes the linux kernel to set * the READ_IMPLIES_EXEC personality flag, which is propagated to * children and causes all mmaps to be +x, breaking all these tests * that check for mmapped memory to be +rw or +r! */ static void global_test(void) { char *array; uint prot; dr_fprintf(STDERR, " testing global memory alloc..."); array = dr_global_alloc(SIZE); write_array(array); dr_query_memory((const byte *)array, NULL, NULL, &prot); if (prot != get_os_mem_prot(DR_MEMPROT_READ|DR_MEMPROT_WRITE)) dr_fprintf(STDERR, "[error: prot %d doesn't match rw] ", prot); dr_global_free(array, SIZE); dr_fprintf(STDERR, "success\n"); }
static size_t write_json(json_t* json, stream_t* stream) { switch (json_typeof(json)) { case JSON_OBJECT: return write_object(json, stream); case JSON_ARRAY: return write_array(json, stream); case JSON_STRING: return write_string(json, stream); case JSON_INTEGER: return write_integer(json, stream); case JSON_REAL: return write_real(json, stream); case JSON_TRUE: return write_true(json, stream); case JSON_FALSE: return write_false(json, stream); case JSON_NULL: return write_null(json, stream); default: return 0; } }
void write_fields(io::stream& e, const void* object, const bsreq* req, const bsreq* skip = 0) { auto count = 0; for(auto f = req; *f; f++) { if(skip && skip == f) continue; if(isempthy(object, req)) continue; if(count > 0) e << " "; e << req->id; e << "("; write_array(e, object, req, 0); e << ")"; count++; } e << "\r\n"; }
static void write_attr(FlexBuffer *f_buffer, const AttributeRec *arec) { f_buffer->writeStr( SGMLName::lookup( arec->getAttrName() ) ); f_buffer->writeStr( ":\t" ); const char *val = arec->getAttrValueString(); /* NAMES, NUMBERS convert to arrays for stylesheet lang. */ if(arec->getAttrType() == SGMLName::TOKEN && strchr(val, ' ')){ write_array(f_buffer, val, 0); }else{ /* NASTY HACK! * The stylesheet internal language requires some feature * values to be quoted, and some not. It _seems_ that * quoting anything that doesn't start with a digit will * satisfy the constraints. This is highly artificial! * * Now for the exception that proves the hack! * TRUE and FALSE... * * One more to add to the heap, * if an attribute value is being referenced */ int quotes = !isdigit(val[0]) && strcmp(val, "TRUE") != 0 && strcmp(val, "FALSE") != 0 && val[0] != '@'; if(quotes) f_buffer->writeStr( "\"" ); f_buffer->writeStr( val ); if(quotes) f_buffer->writeStr( "\"" ); } }
static void nonheap_test(void) { uint prot; char *array = dr_nonheap_alloc(SIZE, DR_MEMPROT_READ|DR_MEMPROT_WRITE|DR_MEMPROT_EXEC); dr_fprintf(STDERR, " testing nonheap memory alloc..."); write_array(array); dr_query_memory((const byte *)array, NULL, NULL, &prot); if (prot != get_os_mem_prot((DR_MEMPROT_READ|DR_MEMPROT_WRITE|DR_MEMPROT_EXEC))) dr_fprintf(STDERR, "[error: prot %d doesn't match rwx] ", prot); dr_memory_protect(array, SIZE, DR_MEMPROT_NONE); dr_query_memory((const byte *)array, NULL, NULL, &prot); if (prot != get_os_mem_prot(DR_MEMPROT_NONE)) dr_fprintf(STDERR, "[error: prot %d doesn't match none] ", prot); dr_memory_protect(array, SIZE, DR_MEMPROT_READ); dr_query_memory((const byte *)array, NULL, NULL, &prot); if (prot != get_os_mem_prot(DR_MEMPROT_READ)) dr_fprintf(STDERR, "[error: prot %d doesn't match r] ", prot); if (dr_safe_write(array, 1, (const void *) &prot, NULL)) dr_fprintf(STDERR, "[error: should not be writable] "); dr_nonheap_free(array, SIZE); dr_fprintf(STDERR, "success\n"); }
static void raw_alloc_test(void) { uint prot; char *array = PREFERRED_ADDR; dr_mem_info_t info; bool res; dr_fprintf(STDERR, " testing raw memory alloc..."); res = dr_raw_mem_alloc(PAGE_SIZE, DR_MEMPROT_READ | DR_MEMPROT_WRITE, array) != NULL; if (!res) { dr_fprintf(STDERR, "[error: fail to alloc at "PFX"]\n", array); return; } write_array(array); dr_query_memory((const byte *)array, NULL, NULL, &prot); if (prot != get_os_mem_prot(DR_MEMPROT_READ|DR_MEMPROT_WRITE)) dr_fprintf(STDERR, "[error: prot %d doesn't match rw]\n", prot); dr_raw_mem_free(array, PAGE_SIZE); dr_query_memory_ex((const byte *)array, &info); if (info.prot != DR_MEMPROT_NONE) dr_fprintf(STDERR, "[error: prot %d doesn't match none]\n", info.prot); dr_fprintf(STDERR, "success\n"); }
static void raw_alloc_test(void) { uint prot; char *array, *preferred; dr_mem_info_t info; bool res; dr_fprintf(STDERR, " testing raw memory alloc..."); /* Find a free region of memory without inadvertently "preloading" it. * First probe by allocating 2x the platform allocation alignment unit. */ array = dr_raw_mem_alloc(HINT_ALLOC_SIZE, DR_MEMPROT_READ | DR_MEMPROT_WRITE, NULL); /* Then select the second half as the preferred address for the allocation test. */ preferred = (void *)((ptr_uint_t)array + HINT_OFFSET); /* Free the probe allocation. */ dr_raw_mem_free(array, HINT_ALLOC_SIZE); array = preferred; /* Now `array` is guaranteed to be available. */ res = dr_raw_mem_alloc(PAGE_SIZE, DR_MEMPROT_READ | DR_MEMPROT_WRITE, array) != NULL; if (!res) { dr_fprintf(STDERR, "[error: fail to alloc at "PFX"]\n", array); return; } write_array(array); dr_query_memory((const byte *)array, NULL, NULL, &prot); if (prot != get_os_mem_prot(DR_MEMPROT_READ|DR_MEMPROT_WRITE)) dr_fprintf(STDERR, "[error: prot %d doesn't match rw]\n", prot); dr_raw_mem_free(array, PAGE_SIZE); dr_query_memory_ex((const byte *)array, &info); if (info.prot != DR_MEMPROT_NONE) dr_fprintf(STDERR, "[error: prot %d doesn't match none]\n", info.prot); dr_fprintf(STDERR, "success\n"); }
static void custom_windows_test(void) { void *array; MEMORY_BASIC_INFORMATION mbi; bool ok; dr_fprintf(STDERR, " testing custom windows alloc...."); array = dr_custom_alloc(NULL, DR_ALLOC_NON_HEAP | DR_ALLOC_NON_DR | DR_ALLOC_RESERVE_ONLY, PAGE_SIZE*2, DR_MEMPROT_NONE, NULL); if (array == NULL) dr_fprintf(STDERR, "error: unable to reserve\n"); if (dr_virtual_query(array, &mbi, sizeof(mbi)) != sizeof(mbi)) dr_fprintf(STDERR, "error: unable to query prot\n"); /* 0 is sometimes returned (see VirtualQuery docs) */ if (mbi.Protect != PAGE_NOACCESS && mbi.Protect != 0) dr_fprintf(STDERR, "error: wrong reserve prot %x\n", mbi.Protect); if (mbi.State != MEM_RESERVE) dr_fprintf(STDERR, "error: memory wasn't reserved\n"); array = dr_custom_alloc(NULL, DR_ALLOC_NON_HEAP | DR_ALLOC_NON_DR | DR_ALLOC_COMMIT_ONLY | DR_ALLOC_FIXED_LOCATION, PAGE_SIZE, DR_MEMPROT_READ | DR_MEMPROT_WRITE, array); if (array == NULL) dr_fprintf(STDERR, "error: unable to commit\n"); if (dr_virtual_query(array, &mbi, sizeof(mbi)) != sizeof(mbi)) dr_fprintf(STDERR, "error: unable to query prot\n"); if (mbi.Protect != PAGE_READWRITE) dr_fprintf(STDERR, "error: wrong commit prot %x\n", mbi.Protect); if (mbi.State != MEM_COMMIT || mbi.RegionSize != PAGE_SIZE) dr_fprintf(STDERR, "error: memory wasn't committed\n"); write_array(array); ok = dr_custom_free(NULL, DR_ALLOC_NON_HEAP | DR_ALLOC_NON_DR | DR_ALLOC_COMMIT_ONLY, array, PAGE_SIZE); if (!ok) dr_fprintf(STDERR, "error: failed to de-commit\n"); if (dr_virtual_query(array, &mbi, sizeof(mbi)) != sizeof(mbi)) dr_fprintf(STDERR, "error: unable to query prot\n"); /* 0 is sometimes returned (see VirtualQuery docs) */ if (mbi.Protect != PAGE_NOACCESS && mbi.Protect != 0) dr_fprintf(STDERR, "error: wrong decommit prot %x\n", mbi.Protect); if (mbi.State != MEM_RESERVE) dr_fprintf(STDERR, "error: memory wasn't de-committed %x\n", mbi.State); ok = dr_custom_free(NULL, DR_ALLOC_NON_HEAP | DR_ALLOC_NON_DR | DR_ALLOC_RESERVE_ONLY, array, PAGE_SIZE*2); if (!ok) dr_fprintf(STDERR, "error: failed to un-reserve\n"); if (dr_virtual_query(array, &mbi, sizeof(mbi)) != sizeof(mbi)) dr_fprintf(STDERR, "error: unable to query prot\n"); /* 0 is sometimes returned (see VirtualQuery docs) */ if (mbi.Protect != PAGE_NOACCESS && mbi.Protect != 0) dr_fprintf(STDERR, "error: wrong unreserve prot %x\n", mbi.Protect); if (mbi.State != MEM_FREE) dr_fprintf(STDERR, "error: memory wasn't un-reserved\n"); dr_fprintf(STDERR, "success\n"); }
static void custom_test(void) { void *drcontext = dr_get_current_drcontext(); void *array; size_t size; uint prot; dr_fprintf(STDERR, " testing custom memory alloc...."); /* test global */ array = dr_custom_alloc(NULL, 0, SIZE, 0, NULL); write_array(array); dr_custom_free(NULL, 0, array, SIZE); array = dr_custom_alloc(NULL, DR_ALLOC_CACHE_REACHABLE, SIZE, 0, NULL); ASSERT(reachable_from_client(array)); write_array(array); dr_custom_free(NULL, DR_ALLOC_CACHE_REACHABLE, array, SIZE); /* test thread-local */ array = dr_custom_alloc(drcontext, DR_ALLOC_THREAD_PRIVATE, SIZE, 0, NULL); write_array(array); dr_custom_free(drcontext, DR_ALLOC_THREAD_PRIVATE, array, SIZE); array = dr_custom_alloc(drcontext, DR_ALLOC_THREAD_PRIVATE|DR_ALLOC_CACHE_REACHABLE, SIZE, 0, NULL); ASSERT(reachable_from_client(array)); write_array(array); dr_custom_free(drcontext, DR_ALLOC_THREAD_PRIVATE|DR_ALLOC_CACHE_REACHABLE, array, SIZE); /* test non-heap */ array = dr_custom_alloc(NULL, DR_ALLOC_NON_HEAP, PAGE_SIZE, DR_MEMPROT_READ|DR_MEMPROT_WRITE, NULL); write_array(array); dr_custom_free(NULL, DR_ALLOC_NON_HEAP, array, PAGE_SIZE); array = dr_custom_alloc(NULL, DR_ALLOC_NON_HEAP|DR_ALLOC_FIXED_LOCATION, PAGE_SIZE, DR_MEMPROT_READ|DR_MEMPROT_WRITE, PREFERRED_ADDR); ASSERT(array == (void *)PREFERRED_ADDR); write_array(array); dr_custom_free(NULL, DR_ALLOC_NON_HEAP|DR_ALLOC_FIXED_LOCATION, array, PAGE_SIZE); array = dr_custom_alloc(NULL, DR_ALLOC_NON_HEAP|DR_ALLOC_CACHE_REACHABLE, PAGE_SIZE, DR_MEMPROT_READ|DR_MEMPROT_WRITE, NULL); ASSERT(reachable_from_client(array)); write_array(array); dr_custom_free(NULL, DR_ALLOC_NON_HEAP|DR_ALLOC_CACHE_REACHABLE, array, PAGE_SIZE); array = dr_custom_alloc(NULL, DR_ALLOC_NON_HEAP|DR_ALLOC_LOW_2GB, PAGE_SIZE, DR_MEMPROT_READ|DR_MEMPROT_WRITE, NULL); #ifdef X64 ASSERT((ptr_uint_t)array < 0x80000000); #endif write_array(array); dr_custom_free(NULL, DR_ALLOC_NON_HEAP|DR_ALLOC_LOW_2GB, array, PAGE_SIZE); array = dr_custom_alloc(NULL, DR_ALLOC_NON_HEAP|DR_ALLOC_NON_DR, PAGE_SIZE, DR_MEMPROT_READ|DR_MEMPROT_WRITE, NULL); write_array(array); dr_custom_free(NULL, DR_ALLOC_NON_HEAP|DR_ALLOC_NON_DR, array, PAGE_SIZE); array = dr_custom_alloc(NULL, DR_ALLOC_NON_HEAP, PAGE_SIZE, DR_MEMPROT_READ|DR_MEMPROT_WRITE|DR_MEMPROT_EXEC, NULL); ASSERT(dr_query_memory((byte *)array, NULL, &size, &prot) && size == PAGE_SIZE && prot == (DR_MEMPROT_READ|DR_MEMPROT_WRITE| DR_MEMPROT_EXEC)); write_array(array); dr_custom_free(NULL, DR_ALLOC_NON_HEAP, array, PAGE_SIZE); dr_fprintf(STDERR, "success\n"); }
///////////////////////////////////////////////////////////////////////////////////////////// //int main(int argc, char *argv[ ]) //{ int main(void) { sortingindex = 0; if((fpp = fopen(INPUT_FILE, "r")) == NULL) { printf("Cannot open 'parameter_file'.\n"); } for(j = 0; j < 11; j++) { if(fscanf(fpp, "%lf", &tmp) != EOF) { my_array[j] = tmp; } else { printf("Not enough data in 'input_parameter'!"); } } fclose(fpp); In_n= (int) my_array[0]; In_vect_n= (int) my_array[1]; Out_n= (int) my_array[2]; Mf_n= (int) my_array[3]; training_data_n= (int) my_array[4]; checking_data_n= (int) my_array[5]; epoch_n= (int) my_array[6]; step_size=my_array[7]; increase_rate=my_array[8]; decrease_rate=my_array[9]; threshold = my_array[10]; Rule_n = (int)pow((double)Mf_n, (double)In_n); //number of rules Node_n = In_n + In_n*Mf_n + 3*Rule_n + In_n*Rule_n + Out_n; /* allocate matrices and memories */ int trnnumcheck[training_data_n + 1]; int trnnumchecku[training_data_n + 1]; for(i=0; i<training_data_n +1; i++) { trnnumcheck[i]=0; trnnumchecku[i]=0; } diff =(double **)create_matrix(Out_n, training_data_n, sizeof(double)); double chkvar[checking_data_n]; double cdavg[checking_data_n]; double chkvar_un[checking_data_n]; double cdavg_un[checking_data_n]; target = calloc(Out_n, sizeof(double)); de_out = calloc(Out_n, sizeof(double)); node_p = (NODE_T **)create_array(Node_n, sizeof(NODE_T *)); config = (int **)create_matrix(Node_n, Node_n, sizeof(int)); training_data_matrix = (double **)create_matrix(training_data_n, In_n*In_vect_n + Out_n, sizeof(double)); if(checking_data_n > 0) { checking_data_matrix = (double **)create_matrix(checking_data_n, In_n*In_vect_n +Out_n, sizeof(double)); checking_data_matrix_un = (double **)create_matrix(checking_data_n, Out_n, sizeof(double)); chk_output = (double **)create_matrix(checking_data_n, Out_n, sizeof(double)); } layer_1_to_4_output = (COMPLEX_T **)create_matrix(training_data_n, In_n*Mf_n + 3*Rule_n, sizeof(COMPLEX_T)); trn_rmse_error = calloc(epoch_n, sizeof(double)); trnNMSE = calloc(epoch_n, sizeof(double)); chk_rmse_error = calloc(epoch_n, sizeof(double)); kalman_parameter = (double **)create_matrix(Out_n ,(In_n*In_vect_n + 1)*Rule_n, sizeof(double)); kalman_data = (double **)create_matrix(Out_n ,(In_n*In_vect_n + 1)*Rule_n, sizeof(double)); step_size_array = calloc(epoch_n, sizeof(double)); ancfis_output = (double **)create_matrix(training_data_n , Out_n, sizeof(double)); trn_error =calloc(Out_n +1, sizeof(double)); chk_error_n = calloc(Out_n +1, sizeof(double));// changing size for adding new error measures chk_error_un = calloc(Out_n +1, sizeof(double));// changing size for adding new error measures trn_datapair_error = calloc(training_data_n, sizeof(double)); trn_datapair_error_sorted = (double **)create_matrix(2,training_data_n, sizeof(double)); NMSE = calloc(Out_n, sizeof(double)); NDEI = calloc(Out_n, sizeof(double)); unNMSE = calloc(Out_n, sizeof(double)); unNDEI = calloc(Out_n, sizeof(double)); //Build Matrix of 0 nd 1 to show the connected nodes gen_config(In_n, Mf_n,Out_n, config);//gen_config.c //With the above matrix, build ANCFIS connected nodes build_ancfis(config); //datastru.c //Find total number of nodes in layer 1 and 5 parameter_n = set_parameter_mode(); //datastru.c parameter_array = calloc(parameter_n, sizeof(double)); initpara(TRAIN_DATA_FILE, training_data_n, In_n, In_vect_n+1, Mf_n); // initpara.c // after this step, the parameters (they are present in layer 1 and layer 5 only) are assigned a random initial value // using some basic algebra and these value are then stored in "para.ini" get_parameter(node_p,Node_n,INIT_PARA_FILE); //input.c // after this step, the initial random values of the parametrs are read from "oara.ini" and assigned to the appropriate nodes in the node structure by accessing their para list. //Get training and testing data get_data(TRAIN_DATA_FILE, training_data_n, training_data_matrix); //input.c // after this step, the training input data is read from the "data.trn" fle and stroed in the training data matrix. get_data(CHECK_DATA_FILE, checking_data_n, checking_data_matrix); //input.c // after the above step, the checking data is read from the "data.chk" file and then stored in the checking data matrix. for(i=0; i< Out_n; i++) { for(j=0; j<training_data_n; j++) { trnavg = trnavg + training_data_matrix[j][(i+1)*In_vect_n +i]; } } trnavg = trnavg /(Out_n * training_data_n); for(i=0; i< Out_n; i++) { for(j=0; j<training_data_n; j++) { temp = training_data_matrix[j][(i+1)*In_vect_n +i]- trnavg; temp = temp*temp; trnvariance = trnvariance + temp; } } trnvariance = trnvariance /((Out_n * training_data_n)-1); temp = 0.0; for(i=0; i< Out_n; i++) { for(j=0; j< checking_data_n; j++) { chkavg = chkavg + checking_data_matrix[j][(i+1)*In_vect_n +i]; } } chkavg = chkavg /(Out_n * checking_data_n); for(i=0; i< Out_n; i++) { for(j=0; j<checking_data_n; j++) { temp = checking_data_matrix[j][(i+1)*In_vect_n +i]- chkavg; temp = temp*temp; chkvariance = chkvariance + temp; } } chkvariance = chkvariance /((Out_n * checking_data_n)-1); printf("epochs \t trn error \t tst error\n"); printf("------ \t --------- \t ---------\n"); //printf("not entering the epoch loop and the i loop yoyoyo\n"); /************** for(ep_n = 0; ep_n < epoch_n; ep_n++) { //step_size_pointer= &step_size; //printf("epoch numbernumber %d \n", ep_n); //step_size_array[ep_n] = step_size_pointer; step_size_array[ep_n] = step_size; // after the above step, the updated stepsize at the end of the last loop is stored in the step_size_array. // this will keep happening every time we start en epoch and hence at the end of the loop, step_size_array will // have a list of all the updated step sizes. Since this is a offline version, step sizes are updated only // at the end of an epoch. for(m = 0; m < Out_n; m++) { //printf("m loop number %d \n", m); for(j = 0; j < training_data_n; j++) { //printf("j loop number %d \n", j); //copy the input vector(s) to input node(s) put_input_data(node_p,j, training_data_matrix); //input.c // after this(above) step, the input data is transferred frm the training data matrix to the "node" structure. //printf("testing \n"); //printf("reeeetesting \n"); target[m] = training_data_matrix[j][(m+1)*In_vect_n+m]; // *** // this step assigns the value of the "m"th output of "j" th trainig data pair to target. //printf("testing \n"); //forward pass, get node outputs from layer 1 to layer 4 calculate_output(In_n, In_n + In_n*Mf_n + 3*Rule_n - 1, j); //forward.c // after this step, output of nodes in layer 1 to 4 is calculated. Please note that when this happens for the first // time, i.e. when ep_n=0, our network parametrs are already initialized. thus, it is possible to get the // output of each node using the function definitios proposed in forward.c. After first epoch, our parametrs get // updated and this output is then calculated using teh new parameters. The essential point to note here is that // we can always calculate the output of each node since we have already initialized our parameters. //printf("testing \n"); //put outputs of layer 1 to 4 into layer_1_to_4_output for(k = 0; k < Mf_n*In_n + 3*Rule_n; k++) { //printf("testing \n"); layer_1_to_4_output[j][k] = *node_p[k + In_n]->value; } // the above loop simply puts the values of nodes from layer 1 to layer 4 in the layer_1_to_4_output matrix. //identify layer 5 params using LSE (Kalman filter) //printf("testing \n"); get_kalman_data(kalman_data, target); //kalman.c // this function call finds out the values of O4iXnl .. these are basically the coefficients // of the kalman parametrs for a given training data pair //puts them in kalman_data matrix. // this kalman_data matrix has In_n number of rows and number of columns equal to number of parametrs that are // responsible for determining each output... as stated above, the outputs are actually the coefficients of the // parameters. //printf("testing \n"); //calculate Kalman parameters kalman(ep_n, j+(m*training_data_n), m, kalman_data, kalman_parameter,target); //kalman.c // this function call evaluates kalman parametrs for a given output, for a given epoch.. that is it takes the epoch // number from us, takes the info about how many times has kalman been invoked before, also takes in the // output number(row number) for whihc the parametrs are to be found out... it also takes kalman_data and reads // from it to estimate the kalman parameters... it also takes target .. and stores the output in the mth row of // kalman_parameter. //printf("testing \n"); } // let me tell u what the abopve loop is doing.. after observing closely, it is easy to see that in the above loop, // for a given output node, one by one, all the training data are taken inside the ANCFIS structure, outputs // are calculated from one to 4, then a recursive kalman filetr is used to identify the kalman // parametrs corresponding to the output node.. these kalman parameters are updated after every tarining data pair // and finally at the end of all the training data, we have an estimate for the kalman parametrs corresponding to // the output node. } // thus, at the of the above loop, the kalman parametrs for all the output nodes are evaluated... // now, we are ready to actually calculate the outputs.. plase remember that, all this while, the actual // values of the parametrs of nodes in layer 1 and layer 5 are the ones that were randomly initialized. for(j = 0; j < training_data_n; j++) { //printf("testing 1\n"); put_input_data(node_p,j, training_data_matrix); //input.c //printf("testing 2 \n"); for(k = 0; k < Mf_n*In_n + 3*Rule_n; k++) { *node_p[k + In_n]->value = layer_1_to_4_output[j][k]; } // u must be able to see that in the above two loops, each time, whatever output we got for a given training // datta pair, it was safely stored in layer_1_to_4 array...and each time, the value on the actual nodes in the // structure got changed.. due to new incoming training data pair..this was periodic with period trainingdata_n.. // that is for each output node, we got the same results for a given training dat aapir.. that is the node values // were independent of m. Now, for a given traing data pair, we are getting those value back in the actual node // node structure from that laye blh blah matrix.. //printf("testing 3\n"); put_kalman_parameter(Out_n,kalman_parameter); //kalman.c // using this function call, we are placing the setimated value of the layer 5 parametrs in the node structure // by accessing each node and its parameter list. // Do forward pass for L5 and L6 calculate_output(In_n + In_n*Mf_n + 3*Rule_n, Node_n, j); //forward.c // for a given value of the training data pair, this function calculates the output of layer 5 and layer 6 nodes // and places them in the node structure. calculate_root(training_data_matrix,diff,j,node_p); //debug.c // this function call calculates the square of the erro between the predicted value of an output node and the // corresponding actual value in the training data matrix..(actual output) and stores it in diff. // this call performs the above action for a given training data pair and for all output nodes. // Do backward pass and calculate all error rate for each node calculate_de_do(j,Out_n,target,ancfis_output); //backward.c // calculates de_do for each node fora given training data pair update_de_dp(j); //de_dp.c // updates de_do for each node.... } // thus at the end of this loop, estimated outputs for all the training data are calculated..also back propogatin // is done and de_dp for all the nodes is updated. //printf("testing 1\n"); calculate_trn_err(diff,trn_error,trn_datapair_error,training_data_n); //debug.c //printf("testing 2 \n"); //training_error_measure(target,ancfis_output,diff, training_data_n, trn_error,out_n); //trn_err.c trn_rmse_error[ep_n] = trn_error[Out_n]; printf("%3d \t %.11f \n", ep_n+1, trn_error[Out_n]); //Find RMSE of testing error /************************************* if(checking_data_n != 0) { printf("testing 3 \n"); epoch_checking_error(checking_data_matrix, checking_data_n, chk_error, training_data_n, chk_output, ep_n); //chk_err.c writes to tracking.txt printf("testing 4 \n"); chk_rmse_error[ep_n] = chk_error[Out_n]; for (i=0; i<Out_n; i++) //printf("%3d \t %.11f \t %.11f\n", ep_n+1, trn_error[i], chk_error[i]); printf("%3d \t %.11f \n", ep_n+1, trn_error[i]); //printf("%.11f\t %.11f\n", trn_error[Out_n],chk_error[Out_n]); printf("%.11f\t %.11f\n", trn_error[Out_n]); write_result(ep_n+1,Out_n,trn_error,chk_error); //debug.c writes to result.txt } else { for (i=0; i<Out_n; i++) printf("%4d \t %.11f\n", ep_n+1, trn_error[i]); } ***************************/ /** //Find minimum training error and its epoch-number if(trn_rmse_error[ep_n] < min_trn_RMSE) { min_trn_RMSE_epoch = ep_n +1; min_trn_RMSE = trn_rmse_error[ep_n]; record_parameter(parameter_array); } if(ep_n < epoch_n-1) { //update parameters in 1st layer (Using VNCSA) update_parameter(1, step_size); //new_para.c //update stepsize update_step_size(trn_rmse_error, ep_n, &step_size, decrease_rate, increase_rate); //stepsize.c } } ***/ //////////////////////////////////////////////////////////// fppp = (FILE *)open_file("status.txt", "w"); fpppp = (FILE *)open_file("trn.txt", "w"); ep_n=0; do { //step_size_pointer= &step_size; printf("epoch numbernumber %d \n", ep_n+1); //step_size_array[ep_n] = step_size_pointer; step_size_array[ep_n] = step_size; // after the above step, the updated stepsize at the end of the last loop is stored in the step_size_array. // this will keep happening every time we start en epoch and hence at the end of the loop, step_size_array will // have a list of all the updated step sizes. Since this is a offline version, step sizes are updated only // at the end of an epoch. for(m = 0; m < Out_n; m++) { //printf("m loop number %d \n", m); for(j = 0; j < training_data_n; j++) { //printf("j loop number %d \n", j); //copy the input vector(s) to input node(s) put_input_data(node_p,j, training_data_matrix); //input.c // after this(above) step, the input data is transferred frm the training data matrix to the "node" structure. //printf("testing \n"); //printf("reeeetesting \n"); target[m] = training_data_matrix[j][(m+1)*In_vect_n+m]; // *** // this step assigns the value of the "m"th output of "j" th trainig data pair to target. //printf("testing \n"); //forward pass, get node outputs from layer 1 to layer 4 calculate_output(In_n, In_n + In_n*Mf_n + 3*Rule_n, j); //forward.c // after this step, output of nodes in layer 1 to 4 is calculated. Please note that when this happens for the first // time, i.e. when ep_n=0, our network parametrs are already initialized. thus, it is possible to get the // output of each node using the function definitios proposed in forward.c. After first epoch, our parametrs get // updated and this output is then calculated using teh new parameters. The essential point to note here is that // we can always calculate the output of each node since we have already initialized our parameters. //printf("testing \n"); //put outputs of layer 1 to 4 into layer_1_to_4_output for(k = 0; k < Mf_n*In_n + 3*Rule_n; k++) { //printf("testing \n"); layer_1_to_4_output[j][k] = *node_p[k + In_n]->value; //fprintf(fppp, "%lf \t %lf \t \n", (layer_1_to_4_output[j][k]).real, (layer_1_to_4_output[j][k]).imag); } // the above loop simply puts the values of nodes from layer 1 to layer 4 in the layer_1_to_4_output matrix. //identify layer 5 params using LSE (Kalman filter) //printf("testing \n"); get_kalman_data(kalman_data, target); //kalman.c // this function call finds out the values of O4iXnl .. these are basically the coefficients // of the kalman parametrs for a given training data pair //puts them in kalman_data matrix. // this kalman_data matrix has In_n number of rows and number of columns equal to number of parametrs that are // responsible for determining each output... as stated above, the outputs are actually the coefficients of the // parameters. //printf("testing \n"); //calculate Kalman parameters kalman(ep_n, j+(m*training_data_n), m, kalman_data, kalman_parameter,target); //kalman.c // this function call evaluates kalman parametrs for a given output, for a given epoch.. that is it takes the epoch // number from us, takes the info about how many times has kalman been invoked before, also takes in the // output number(row number) for whihc the parametrs are to be found out... it also takes kalman_data and reads // from it to estimate the kalman parameters... it also takes target .. and stores the output in the mth row of // kalman_parameter. //printf("testing \n"); } // let me tell u what the abopve loop is doing.. after observing closely, it is easy to see that in the above loop, // for a given output node, one by one, all the training data are taken inside the ANCFIS structure, outputs // are calculated from one to 4, then a recursive kalman filetr is used to identify the kalman // parametrs corresponding to the output node.. these kalman parameters are updated after every tarining data pair // and finally at the end of all the training data, we have an estimate for the kalman parametrs corresponding to // the output node. } // thus, at the of the above loop, the kalman parametrs for all the output nodes are evaluated... // now, we are ready to actually calculate the outputs.. plase remember that, all this while, the actual // values of the parametrs of nodes in layer 1 and layer 5 are the ones that were randomly initialized. for(j = 0; j < training_data_n; j++) { //printf("testing 1\n"); put_input_data(node_p,j, training_data_matrix); //input.c //printf("testing 2 \n"); for(k = 0; k < Mf_n*In_n + 3*Rule_n; k++) { *node_p[k + In_n]->value = layer_1_to_4_output[j][k]; /*if(ep_n==1) { fprintf(fppp, "%d.\t %lf \t + \t i%lf \n", k, (layer_1_to_4_output[j][k]).real,(layer_1_to_4_output[j][k]).imag); }*/ } // u must be able to see that in the above two loops, each time, whatever output we got for a given training // datta pair, it was safely stored in layer_1_to_4 array...and each time, the value on the actual nodes in the // structure got changed.. due to new incoming training data pair..this was periodic with period trainingdata_n.. // that is for each output node, we got the same results for a given training dat aapir.. that is the node values // were independent of m. Now, for a given traing data pair, we are getting those value back in the actual node // node structure from that laye blh blah matrix.. //printf("testing 3\n"); put_kalman_parameter(Out_n,kalman_parameter); //kalman.c //printf("hihahahha \n"); // using this function call, we are placing the setimated value of the layer 5 parametrs in the node structure // by accessing each node and its parameter list. // Do forward pass for L5 and L6 calculate_output(In_n + In_n*Mf_n + 3*Rule_n, Node_n, j); //forward.c // for a given value of the training data pair, this function calculates the output of layer 5 and layer 6 nodes // and places them in the node structure. //printf("hihahahha no 2 \n"); calculate_root(training_data_matrix,diff,j,node_p); //debug.c // this function call calculates the square of the erro between the predicted value of an output node and the // corresponding actual value in the training data matrix..(actual output) and stores it in diff. // this call performs the above action for a given training data pair and for all output nodes. // Do backward pass and calculate all error rate for each node calculate_de_do(j,Out_n,target,ancfis_output); //backward.c //printf("hihahahha no 3 \n"); // calculates de_do for each node fora given training data pair update_de_dp(j); //de_dp.c // updates de_do for each node.... } // thus at the end of this loop, estimated outputs for all the training data are calculated..also back propogatin // is done and de_dp for all the nodes is updated. //printf("testing 1\n"); calculate_trn_err(diff,trn_error, trn_datapair_error, training_data_n); //debug.c //printf("testing 2 \n"); //training_error_measure(target,ancfis_output,diff, training_data_n, trn_error,out_n); //trn_err.c trn_rmse_error[ep_n] = trn_error[Out_n]; trnNMSE[ep_n] = trn_rmse_error[ep_n]*trn_rmse_error[ep_n]/trnvariance; fprintf(fppp, "epoch number is %d \t trn RMSE is %.11f \t trn NMSE is %lf \t \n", ep_n + 1, trn_rmse_error[ep_n], trnNMSE[ep_n]); //fprintf(fpppp, "\n"); fprintf(fpppp, "epoch number is %d \t trn RMSE is %.11f \t trn NMSE is %lf \t \n", ep_n + 1, trn_rmse_error[ep_n], trnNMSE[ep_n]); printf("trn RMSE is \t %lf \n", trn_rmse_error[ep_n]); printf("trn NMSE is \t %lf \n", trnNMSE[ep_n]); for(i=0; i<training_data_n; i++) { trn_datapair_error_sorted[0][i]=trn_datapair_error[i]; trn_datapair_error_sorted[1][i]= i+1; } for(j=1; j<training_data_n; j++) { for(i=0; i<training_data_n-j; i++) { if(trn_datapair_error_sorted[0][i]>trn_datapair_error_sorted[0][i+1]) { sorting=trn_datapair_error_sorted[0][i+1]; trn_datapair_error_sorted[0][i+1]=trn_datapair_error_sorted[0][i]; trn_datapair_error_sorted[0][i]=sorting; sortingindex = sorting=trn_datapair_error_sorted[1][i+1]; trn_datapair_error_sorted[1][i+1]=trn_datapair_error_sorted[1][i]; trn_datapair_error_sorted[1][i]=sortingindex; } } } for(j=0; j<training_data_n; j++) { fprintf(fppp, "\n"); fprintf(fppp, "training data pair sorted number \t %d \n", j+1); fprintf(fppp, "training data pair original number \t %d \n", (int)(trn_datapair_error_sorted[1][j])); fprintf(fppp, "training data pair sorted error in RMSE is \t %lf \n",trn_datapair_error_sorted[0][j]); fprintf(fpppp, "%d \t", (int)(trn_datapair_error_sorted[1][j])); complexsum = complex(0.0, 0.0); fprintf(fppp,"Normalized layer 3 outputs are as follows \n"); for(k= In_n*Mf_n + Rule_n; k< In_n*Mf_n + 2*Rule_n; k++) { fprintf(fppp, "%d.\t %lf + i%lf \t %lf < %lf \n", k, (layer_1_to_4_output[j][k]).real,(layer_1_to_4_output[j][k]).imag, c_abs(layer_1_to_4_output[j][k]), c_phase(layer_1_to_4_output[j][k])*180/PI); complexsum = c_add(complexsum, layer_1_to_4_output[j][k]); } fprintf(fppp, "Sum of the outputs of layer 3 is \t %lf+i%lf \t %lf<%lf \n", complexsum.real, complexsum.imag, c_abs(complexsum), c_phase(complexsum)*180/PI); complexsum = complex(0.0, 0.0); fprintf(fppp,"dot producted layer 4 outputs are as follows \n"); for(k=In_n*Mf_n + 2*Rule_n; k< In_n*Mf_n + 3*Rule_n; k++) { fprintf(fppp, "%d.\t %lf + i%lf \t %lf < %lf \n", k, (layer_1_to_4_output[j][k]).real,(layer_1_to_4_output[j][k]).imag, c_abs(layer_1_to_4_output[j][k]), c_phase(layer_1_to_4_output[j][k])*180/PI); complexsum = c_add(complexsum, layer_1_to_4_output[j][k]); } fprintf(fppp, "sum of the outputs of layer 4 is \t %lf +i%lf \t %lf<%lf \n", complexsum.real, complexsum.imag, c_abs(complexsum), c_phase(complexsum)*180/PI); if(j> training_data_n -6 ) { trnnumcheck[(int)(trn_datapair_error_sorted[1][j])]= trnnumcheck[(int)(trn_datapair_error_sorted[1][j])] +1; } if(j<5 ) { trnnumchecku[(int)(trn_datapair_error_sorted[1][j])]= trnnumchecku[(int)(trn_datapair_error_sorted[1][j])] +1; } } fprintf(fpppp, "\n"); //Find RMSE of testing error /******************************************************************************** if(checking_data_n != 0) { printf("testing 3 \n"); epoch_checking_error(checking_data_matrix, checking_data_n, chk_error, training_data_n, chk_output, ep_n); //chk_err.c writes to tracking.txt printf("testing 4 \n"); chk_rmse_error[ep_n] = chk_error[Out_n]; for (i=0; i<Out_n; i++) printf("%3d \t %.11f \t %.11f\n", ep_n+1, trn_error[i], chk_error[i]); printf("%.11f\t %.11f\n", trn_error[Out_n],chk_error[Out_n]); write_result(ep_n+1,Out_n,trn_error,chk_error); //debug.c writes to result.txt } else { for (i=0; i<Out_n; i++) printf("%4d \t %.11f\n", ep_n+1, trn_error[i]); } **************************************************************************************/ // check whether the current training RMSE is less than the threhold and store its epch number and parametrs if(trn_rmse_error[ep_n] < min_trn_RMSE) { min_trn_RMSE_epoch = ep_n +1; min_trn_RMSE = trn_rmse_error[ep_n]; min_trnNMSE = trnNMSE[ep_n]; record_parameter(parameter_array); } if(ep_n < epoch_n-1) { //update parameters in 1st layer (Using VNCSA) update_parameter(1, step_size); //new_para.c //update stepsize update_step_size(trn_rmse_error, ep_n, &step_size, decrease_rate, increase_rate); //stepsize.c } ep_n++; } while((trnNMSE[ep_n -1]>= threshold) && (ep_n <= epoch_n -1)); for(i=1; i<=training_data_n; i++) { fprintf(fpppp, "%d \t %d \n", i, trnnumcheck[i]); } for(i=1; i<=training_data_n; i++) { fprintf(fpppp, "%d \t %d \n", i, trnnumchecku[i]); } if(trnNMSE[ep_n -1]< threshold) { fprintf(fppp, "\n"); fprintf(fppp, "We have gone below the threshold value \n"); fprintf(fppp, "the epoch number in which this happened is %d \n", min_trn_RMSE_epoch); } else { fprintf(fppp, "\n"); fprintf(fppp, "We exhausted the available epochs and threshold was not broken :( \n"); fprintf(fppp, "the epoch number which yielded minimum training RMSE is %d \n", min_trn_RMSE_epoch); } fclose(fppp); fclose(fpppp); double *minmaxc; minmaxc= (double *)calloc(2*In_n, sizeof(double)); if((fpp = fopen("minmax.txt", "r")) == NULL) { printf("Cannot open 'parameter_file'.\n"); } for(j = 0; j < 2*In_n; j++) { if(fscanf(fpp, "%lf", &tmp) != EOF) { minmaxc[j] = tmp; } else { printf("Not enough data in 'input_parameter'!"); } } fclose(fpp); ////////////////////////////////////////////////////////////// restore_parameter(parameter_array); //output.c write_parameter(FINA_PARA_FILE); //output.c write_array(trnNMSE, epoch_n, TRAIN_ERR_FILE); //lib.c if (checking_data_n != 0) { //printf("testing 3 \n"); epoch_checking_error(checking_data_matrix, checking_data_n, chk_error_n, chk_error_un, training_data_n, chk_output, ep_n -1, minmaxc); //chk_err.c writes to tracking.txt //printf("testing 4 \n"); //chk_rmse_error[ep_n] = chk_error[Out_n]; min_chk_RMSE_n = chk_error_n[Out_n]; printf(" initial checking RMSE is %lf \n ", min_chk_RMSE_n); min_chk_RMSE_un = chk_error_un[Out_n]; //for (i=0; i<Out_n; i++) //printf("%3d \t %.11f \t %.11f\n", ep_n+1, trn_error[i], chk_error[i]); //printf("%3d \t %.11f \n", ep_n+1, trn_error[i]); //printf("%.11f\t %.11f\n", trn_error[Out_n],chk_error[Out_n]); //printf("%.11f\t \n", trn_error[Out_n]); //write_result(min_trn_RMSE_epoch ,Out_n,trn_rmse_error,chk_error); //debug.c writes to result.txt about the epoch number at which the stopping was done and the corresponding training RMSE and checking RMSE } //write_array(chk_rmse_error, epoch_n, CHECK_ERR_FILE); //lib.c //} write_array(step_size_array, epoch_n, STEP_SIZE_FILE); //lib.c /************************************************************************** min_chk_RMSE = chk_rmse_error[epoch_n -1]; min_chk_RMSE_epoch = epoch_n -1; for(j=0; j< epoch_n; j++) { if(chk_rmse_error[j]< min_chk_RMSE) { min_chk_RMSE = chk_rmse_error[j]; min_chk_RMSE_epoch = j; } } *************************************************************************/ /************************************************************** double minmaxc[2*In_n]; if((fpp = fopen("minmax.txt", "r")) == NULL) { printf("Cannot open 'parameter_file'.\n"); } for(j = 0; j < 2*In_n; j++) { if(fscanf(fpp, "%lf", &tmp) != EOF) { minmaxc[j] = tmp; } else { printf("Not enough data in 'input_parameter'!"); } } fclose(fpp); ***************************************************************************/ for(k=0; k< Out_n; k++) { for(j=0; j< checking_data_n; j++) { checking_data_matrix_un[j][k]= (checking_data_matrix[j][(k+1)*In_vect_n +k])* (minmaxc[(2*k) +1] - minmaxc[2*k]) + minmaxc[2*k]; } } // the following code calculates the cdavg_un and checking datat average bothe un normalized for(k=0; k< Out_n; k++) { for(j=0; j< checking_data_n; j++) { checking_data_average_un = checking_data_average_un + checking_data_matrix_un[j][k]; } cdavg_un[k]=checking_data_average_un/checking_data_n; checking_data_average_un_temp=checking_data_average_un_temp+checking_data_average_un; checking_data_average_un=0; } checking_data_average_un = checking_data_average_un_temp/(Out_n*checking_data_n); printf("%lf is the checking datat average non normalized\n", checking_data_average_un); // the following code calcuates the chkvar_un un normalized for(k=0; k< Out_n; k++) { for(j=0; j< checking_data_n; j++) { temp= temp + (checking_data_matrix_un[j][k] - cdavg_un[k])*(checking_data_matrix_un[j][k] - cdavg_un[k]); } chkvar_un[k]=temp/(checking_data_n-1); //checking_variance_un = checking_variance_un + temp; temp=0; } temp =0.0; // the following code cacluates the un normalized checking varinace for(j=0; j< checking_data_n; j++) { for(k=0; k< Out_n; k++) { temp = checking_data_matrix_un[j][k] - checking_data_average_un; temp = temp*temp; checking_variance_un = checking_variance_un + temp; } } checking_variance_un = checking_variance_un/((Out_n*checking_data_n)-1); printf("%lf is the checking variance non normalized \n", checking_variance_un); temp =0.0; checking_data_average_n=0.0; checking_data_average_n_temp=0.0; // the following code calculates the cdavg and checking data average both normalized for(k=0; k< Out_n; k++) { for(j=0; j< checking_data_n; j++) { checking_data_average_n = checking_data_average_n + checking_data_matrix[j][(k+1)*In_vect_n +k]; } cdavg[k]=checking_data_average_n/checking_data_n; checking_data_average_n_temp=checking_data_average_n_temp+checking_data_average_n; checking_data_average_n=0; } checking_data_average_n = checking_data_average_n_temp/(Out_n*checking_data_n); printf("%lf is the checking datat average normalized\n", checking_data_average_n); temp =0.0; checking_variance_n =0.0; // the following code cacluates the normalized checking varinace for(j=0; j< checking_data_n; j++) { for(k=0; k< Out_n; k++) { temp = checking_data_matrix[j][(k+1)*In_vect_n +k] - checking_data_average_n; temp = temp*temp; checking_variance_n = checking_variance_n + temp; } } checking_variance_n = checking_variance_n/((Out_n*checking_data_n)-1); temp = 0.0; printf("%lf is the checking variance normalized \n", checking_variance_n); // the following code calcuatres the normalized chkvar[k] temp=0.0; for(k=0; k< Out_n; k++) { for(j=0; j< checking_data_n; j++) { temp= temp + (checking_data_matrix[j][(k+1)*In_vect_n +k] - cdavg[k])*(checking_data_matrix[j][(k+1)*In_vect_n +k] - cdavg[k]); } chkvar[k]=temp/(checking_data_n-1); //checking_variance_n = checking_variance_n + temp; temp=0; } NMSE_un = min_chk_RMSE_un * min_chk_RMSE_un / checking_variance_un; NMSE_n = min_chk_RMSE_n * min_chk_RMSE_n / checking_variance_n; NMSE_n2 = min_chk_RMSE_n * min_chk_RMSE_n / chkvariance; NDEI_un = sqrt(NMSE_un); NDEI_n = sqrt(NMSE_n); for(k=0;k<Out_n;k++) { NMSE[k]=chk_error_n[k]*chk_error_n[k]/chkvar[k]; NDEI[k]=sqrt(NMSE[k]); unNMSE[k]=chk_error_un[k]*chk_error_un[k]/chkvar_un[k]; unNDEI[k]=sqrt(unNMSE[k]); } write_result(min_trn_RMSE_epoch ,Out_n,trn_rmse_error,chk_error_un, chk_error_n, NDEI_un, NMSE_un, NDEI_n, NMSE_n, NMSE, NDEI, unNMSE, unNDEI); //debug.c writes to result.txt about the epoch number at which the stopping was done and the corresponding training RMSE and checking RMSE printf("Minimum training RMSE is \t %f \t \n",min_trn_RMSE); printf("Minimum training RMSE epoch is \t %d \n",min_trn_RMSE_epoch); printf("Minimum training NMSE is \t %f \t \n",min_trnNMSE); //printf("Minimum training RMSE epoch is \t %d \n",min_trnNMSE_epoch); //printf("Minimum training RMSE is \t %f \t \n",min_trn_RMSE); //printf("Minimum training RMSE epoch is \t %d \n",min_trn_RMSE_epoch); printf("%f \t is the checking RMSE non normalized\n",min_chk_RMSE_un); printf("%f \t is the checking RMSE normalized\n",min_chk_RMSE_n); //printf("%f \t is the checking RMSE normalized22222222 \n",min_chk_RMSE_n2); printf(" checking NMSE non normlized is %f \t NDEI non normalized is %f \n",NMSE_un, NDEI_un); printf("checking NMSE normalized is %f \t NDEI normalized is %f \n",NMSE_n, NDEI_n); printf("checking NMSE2 normalized is %f \n",NMSE_n2); printf("traning data variance is %f \n",trnvariance); return(0);
static int write_image_internal (char *file, SLang_Array_Type *at, int color_type, void (*write_fun)(png_struct *, png_byte *p, SLindex_Type, png_byte *), int flip) { FILE *fp; Png_Type *p = NULL; png_struct *png; png_info *info; SLindex_Type width, height; png_byte **image_pointers; int bit_depth; int status = -1; png_byte *tmpbuf; bit_depth = 8; height = at->dims[0]; width = at->dims[1]; if (NULL == (image_pointers = allocate_image_pointers (height, (png_byte *)at->data, width * at->sizeof_type, flip))) return -1; if (NULL == (tmpbuf = (png_byte *)SLmalloc (4*width))) { free_image_pointers (image_pointers); return -1; } if (NULL == (fp = fopen (file, "wb"))) { (void)SLerrno_set_errno (errno); SLang_verror (SL_Open_Error, "Unable to open %s", file); goto return_error; } if (NULL == (p = alloc_png_type ('w'))) goto return_error; p->fp = fp; if (NULL == (p->png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL))) { SLang_verror (SL_Open_Error, "png_create_write_struct failed"); goto return_error; } png = p->png; if (NULL == (p->info = png_create_info_struct (png))) { SLang_verror (SL_Open_Error, "png_create_info_struct failed"); goto return_error; } info = p->info; if (setjmp(png_jmpbuf(png))) { SLang_verror (SL_Write_Error, "PNG I/O error"); goto return_error; } png_init_io(png, fp); png_set_IHDR (png, info, width, height, bit_depth, color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); png_write_info(png, info); if (-1 == write_array (png, image_pointers, height, width, write_fun, tmpbuf)) goto return_error; png_write_end(png, NULL); if (EOF == fclose (p->fp)) { SLang_verror (SL_Write_Error, "Error closing %s", file); SLerrno_set_errno (errno); } else status = 0; p->fp = NULL; /* drop */ return_error: if (tmpbuf != NULL) SLfree ((char *) tmpbuf); free_image_pointers (image_pointers); if (p != NULL) free_png_type (p); return status; }
void plist_to_bin(plist_t plist, char **plist_bin, uint32_t * length) { GPtrArray *objects = NULL; GHashTable *ref_table = NULL; struct serialize_s ser_s; uint8_t offset_size = 0; uint8_t dict_param_size = 0; uint64_t num_objects = 0; uint64_t root_object = 0; uint64_t offset_table_index = 0; GByteArray *bplist_buff = NULL; uint64_t i = 0; uint8_t *buff = NULL; uint64_t *offsets = NULL; uint8_t pad[6] = { 0, 0, 0, 0, 0, 0 }; uint8_t trailer[BPLIST_TRL_SIZE]; //for string glong len = 0; int type = 0; glong items_read = 0; glong items_written = 0; GError *error = NULL; gunichar2 *unicodestr = NULL; //check for valid input if (!plist || !plist_bin || *plist_bin || !length) return; //list of objects objects = g_ptr_array_new(); //hashtable to write only once same nodes ref_table = g_hash_table_new(plist_data_hash, plist_data_compare); //serialize plist ser_s.objects = objects; ser_s.ref_table = ref_table; serialize_plist(plist, &ser_s); //now stream to output buffer offset_size = 0; //unknown yet dict_param_size = get_needed_bytes(objects->len); num_objects = objects->len; root_object = 0; //root is first in list offset_table_index = 0; //unknown yet //setup a dynamic bytes array to store bplist in bplist_buff = g_byte_array_new(); //set magic number and version g_byte_array_append(bplist_buff, BPLIST_MAGIC, BPLIST_MAGIC_SIZE); g_byte_array_append(bplist_buff, BPLIST_VERSION, BPLIST_VERSION_SIZE); //write objects and table offsets = (uint64_t *) malloc(num_objects * sizeof(uint64_t)); for (i = 0; i < num_objects; i++) { plist_data_t data = plist_get_data(g_ptr_array_index(objects, i)); offsets[i] = bplist_buff->len; switch (data->type) { case PLIST_BOOLEAN: buff = (uint8_t *) malloc(sizeof(uint8_t)); buff[0] = data->boolval ? BPLIST_TRUE : BPLIST_FALSE; g_byte_array_append(bplist_buff, buff, sizeof(uint8_t)); free(buff); break; case PLIST_UINT: write_int(bplist_buff, data->intval); break; case PLIST_REAL: write_real(bplist_buff, data->realval); break; case PLIST_KEY: case PLIST_STRING: len = strlen(data->strval); if ( is_ascii_string(data->strval, len) ) { write_string(bplist_buff, data->strval); } else { unicodestr = g_utf8_to_utf16(data->strval, len, &items_read, &items_written, &error); write_unicode(bplist_buff, unicodestr, items_written); g_free(unicodestr); } break; case PLIST_DATA: write_data(bplist_buff, data->buff, data->length); case PLIST_ARRAY: write_array(bplist_buff, g_ptr_array_index(objects, i), ref_table, dict_param_size); break; case PLIST_DICT: write_dict(bplist_buff, g_ptr_array_index(objects, i), ref_table, dict_param_size); break; case PLIST_DATE: write_date(bplist_buff, data->timeval.tv_sec + (double) data->timeval.tv_usec / G_USEC_PER_SEC); break; default: break; } } //free intermediate objects g_hash_table_foreach_remove(ref_table, free_index, NULL); g_ptr_array_free(objects, TRUE); g_hash_table_destroy(ref_table); //write offsets offset_size = get_needed_bytes(bplist_buff->len); offset_table_index = bplist_buff->len; for (i = 0; i < num_objects; i++) { uint8_t *offsetbuff = (uint8_t *) malloc(offset_size); #if G_BYTE_ORDER == G_BIG_ENDIAN offsets[i] = offsets[i] << ((sizeof(uint64_t) - offset_size) * 8); #endif memcpy(offsetbuff, &offsets[i], offset_size); byte_convert(offsetbuff, offset_size); g_byte_array_append(bplist_buff, offsetbuff, offset_size); free(offsetbuff); } //experimental pad to reflect apple's files g_byte_array_append(bplist_buff, pad, 6); //setup trailer num_objects = GUINT64_FROM_BE(num_objects); root_object = GUINT64_FROM_BE(root_object); offset_table_index = GUINT64_FROM_BE(offset_table_index); memcpy(trailer + BPLIST_TRL_OFFSIZE_IDX, &offset_size, sizeof(uint8_t)); memcpy(trailer + BPLIST_TRL_PARMSIZE_IDX, &dict_param_size, sizeof(uint8_t)); memcpy(trailer + BPLIST_TRL_NUMOBJ_IDX, &num_objects, sizeof(uint64_t)); memcpy(trailer + BPLIST_TRL_ROOTOBJ_IDX, &root_object, sizeof(uint64_t)); memcpy(trailer + BPLIST_TRL_OFFTAB_IDX, &offset_table_index, sizeof(uint64_t)); g_byte_array_append(bplist_buff, trailer, BPLIST_TRL_SIZE); //duplicate buffer *plist_bin = (char *) malloc(bplist_buff->len); memcpy(*plist_bin, bplist_buff->data, bplist_buff->len); *length = bplist_buff->len; g_byte_array_free(bplist_buff, TRUE); free(offsets); }
static int write_datum(avro_writer_t writer, const avro_encoding_t * enc, avro_schema_t writers_schema, avro_datum_t datum) { if (is_avro_schema(writers_schema) && is_avro_link(writers_schema)) { return write_datum(writer, enc, (avro_schema_to_link(writers_schema))->to, datum); } switch (avro_typeof(datum)) { case AVRO_NULL: return enc->write_null(writer); case AVRO_BOOLEAN: return enc->write_boolean(writer, avro_datum_to_boolean(datum)->i); case AVRO_STRING: return enc->write_string(writer, avro_datum_to_string(datum)->s); case AVRO_BYTES: return enc->write_bytes(writer, avro_datum_to_bytes(datum)->bytes, avro_datum_to_bytes(datum)->size); case AVRO_INT32: case AVRO_INT64:{ int64_t val = avro_typeof(datum) == AVRO_INT32 ? avro_datum_to_int32(datum)->i32 : avro_datum_to_int64(datum)->i64; if (is_avro_schema(writers_schema)) { /* handle promotion */ if (is_avro_float(writers_schema)) { return enc->write_float(writer, (float)val); } else if (is_avro_double(writers_schema)) { return enc->write_double(writer, (double)val); } } return enc->write_long(writer, val); } case AVRO_FLOAT:{ float val = avro_datum_to_float(datum)->f; if (is_avro_schema(writers_schema) && is_avro_double(writers_schema)) { /* handle promotion */ return enc->write_double(writer, (double)val); } return enc->write_float(writer, val); } case AVRO_DOUBLE: return enc->write_double(writer, avro_datum_to_double(datum)->d); case AVRO_RECORD: return write_record(writer, enc, avro_schema_to_record(writers_schema), datum); case AVRO_ENUM: return write_enum(writer, enc, avro_schema_to_enum(writers_schema), avro_datum_to_enum(datum)); case AVRO_FIXED: return avro_write(writer, avro_datum_to_fixed(datum)->bytes, avro_datum_to_fixed(datum)->size); case AVRO_MAP: return write_map(writer, enc, avro_schema_to_map(writers_schema), avro_datum_to_map(datum)); case AVRO_ARRAY: return write_array(writer, enc, avro_schema_to_array(writers_schema), avro_datum_to_array(datum)); case AVRO_UNION: return write_union(writer, enc, avro_schema_to_union(writers_schema), avro_datum_to_union(datum)); case AVRO_LINK: break; } return 0; }