void SkFontDescriptor::serialize(SkWStream* stream) { stream->writePackedUInt(fStyle); write_string(stream, fFamilyName, kFontFamilyName); write_string(stream, fFullName, kFullName); write_string(stream, fPostscriptName, kPostscriptName); if (fFontData.get()) { if (fFontData->getIndex()) { write_uint(stream, fFontData->getIndex(), kFontIndex); } if (fFontData->getAxisCount()) { write_uint(stream, fFontData->getAxisCount(), kFontAxes); for (int i = 0; i < fFontData->getAxisCount(); ++i) { stream->writePackedUInt(fFontData->getAxis()[i]); } } } stream->writePackedUInt(kSentinel); if (fFontData.get() && fFontData->hasStream()) { SkAutoTDelete<SkStreamAsset> fontData(fFontData->detachStream()); size_t length = fontData->getLength(); stream->writePackedUInt(length); stream->writeStream(fontData, length); } else { stream->writePackedUInt(0); } }
size_t StartMessage::serialize(unsigned char *write_buffer){ size_t len = getSize(); write_uint(write_buffer, 0, &len); write_uint(write_buffer, 4, &_msg_type); write_uint(write_buffer, 8, &_client_id); return len; }
static bool write_range( char **string, size_t *length, unsigned int start, unsigned int end, bool first) { return IF_(!first, write_string(string, length, ",")) && write_uint(string, length, start) && IF_(end > start, write_string(string, length, "-") && write_uint(string, length, end)); }
size_t PerspectiveMessage::serialize(unsigned char *write_buffer) { size_t len = getSize(); write_uint(write_buffer, 0, &len); write_uint(write_buffer, 4, &_msg_type); write_uint(write_buffer, 8, &_client_id); write_float(write_buffer, 12, &_perspective._fov); write_float(write_buffer, 16, &_perspective._aspect); write_float(write_buffer, 20, &_perspective._near); write_float(write_buffer, 24, &_perspective._far); return len; }
size_t TouchEventMessage::serialize(unsigned char *write_buffer) { size_t len = getSize(); write_uint(write_buffer, 0, &len); write_uint(write_buffer, 4, &_msg_type); write_uint(write_buffer, 8, &_client_id); write_uchar(write_buffer, 12, &_touch_event._event_type); write_float(write_buffer, 13, &_touch_event._x1); write_float(write_buffer, 17, &_touch_event._y1); write_float(write_buffer, 21, &_touch_event._x2); write_float(write_buffer, 25, &_touch_event._y2); return len; }
void lbm_write_state_binary(FILE * handle, const LbmState * lbm_state) { size_t i; write_uint(handle, lbm_state->lx); write_uint(handle, lbm_state->ly); size_t nodes = lbm_state->lx * lbm_state->ly; for(i = 0; i < Q; ++i) write_n_doubles(handle, lbm_state->f[i], nodes); for(i = 0; i < Q; ++i) write_n_doubles(handle, lbm_state->f_next[i], nodes); }
static inline void write_format_pos(uintmax_t nbr, t_pfflags *flags, char *buff, int *index) { int n; n = init(nbr, flags) - 1; if (!FT_BIT_VAL(flags->flg, FTPF_ZERO_PADDING)) while (++n < flags->nformat) buff[++*index] = ' '; if ((nbr || FT_BIT_VAL(flags->flg, FTPF_FORCE_PREFIX_)) && FT_BIT_VAL(flags->flg, FTPF_PREFIX)) { if ((flags->base == 8) || (flags->base == 16)) buff[++*index] = '0'; else write_base(buff, index, flags); if (flags->base == 16) buff[++*index] = (FT_BIT_VAL(flags->flg, FTPF_HEX_UPCASE) ? 'X' : 'x'); } if (FT_BIT_VAL(flags->flg, FTPF_ZERO_PADDING)) while (++n < flags->nformat) buff[++*index] = '0'; write_uint(nbr, buff, flags, index); }
/* Test writing single values of various types to board's global memory. * The test passes if we read back what we wrote. */ void test_small_writes (ssize_t f) { unsigned char uc; unsigned short us; unsigned int ui; unsigned long int uli; write_uchar (f, 0, 0, 19); uc = read_uchar (f, 0, 0); assert (uc == 19); write_ushort (f, 0, 0, 13); us = read_ushort(f, 0, 0); assert (us == 13); write_ulong (f, 0, 0, 0x3037383633352030); uli = read_ulong (f, 0, 0); assert (uli == 0x3037383633352030); write_uint (f, 0, 0, 18987983); ui = read_uint (f, 0, 0); assert (ui == 18987983); printf ("test_small_writes PASSED\n"); }
void MyEeprom::writeUInt (uint16_t l, uint16_t relative_address) { if (rotateEeprom == true) { write_uint(l, relative_address); } else { simple_write_uint(l, relative_address); } }
size_t CameraMessage::serialize(unsigned char *write_buffer) { /* 长度,类型,id,内容 */ size_t len = getSize(); write_uint(write_buffer, 0, &len); write_uint(write_buffer, 4, &_msg_type); write_uint(write_buffer, 8, &_client_id); write_float(write_buffer, 12, &_camera._eyex); write_float(write_buffer, 16, &_camera._eyey); write_float(write_buffer, 20, &_camera._eyez); write_float(write_buffer, 24, &_camera._centerx); write_float(write_buffer, 28, &_camera._centery); write_float(write_buffer, 32, &_camera._centerz); write_float(write_buffer, 36, &_camera._upx); write_float(write_buffer, 40, &_camera._upy); write_float(write_buffer, 44, &_camera._upz); return len; }
int double_correlation_write_data_to_file(const double_correlation* self, const char * filename, bool binary){ FILE* fp=0; fp=fopen(filename, "w"); if (!fp) { return 1; } for (unsigned int i=0; i<self->hierarchy_depth; i++) { for (unsigned int j=0; j<self->tau_lin+1; j++) { write_double(fp,self->A[i][j],self->dim_A,binary); } } if (!self->autocorrelation){ for (unsigned int i=0; i<self->hierarchy_depth; i++) { for (unsigned int j=0; j<self->tau_lin+1; j++) { write_double(fp,self->B[i][j],self->dim_B,binary); } } } for (unsigned int i=0; i<self->n_result; i++) { write_double(fp,self->result[i],self->dim_corr,binary); } write_uint(fp,self->n_sweeps,self->n_result ,binary); write_uint(fp,self->n_vals ,self->hierarchy_depth,binary); write_uint(fp,self->newest ,self->hierarchy_depth,binary); write_double(fp,self->A_accumulated_average ,self->dim_A,binary); write_double(fp,self->A_accumulated_variance,self->dim_A,binary); if (!self->autocorrelation){ write_double(fp,self->B_accumulated_average ,self->dim_B,binary); write_double(fp,self->B_accumulated_variance,self->dim_B,binary); } write_uint(fp,&(self->n_data),1,binary); write_uint(fp,&(self->t ),1,binary); write_double(fp,&(self->last_update),1,binary); fclose(fp); return 0; }
void write(adt_type& tok_str, token tok) { if (tok.kind == tk_err) { write_str(tok_str, "<error token>"); } else if (tok.kind == tk_eof) { write_str(tok_str, "<end of file>"); } else if (tok.kind == tk_special) { write(tok_str, tok.special_id); } else if (tok.kind == tk_uint) { write_char(tok_str, '#'); write_uint(tok_str, tok.uint_val); } else { fox_assert(tok.kind == tk_name && "invalid token kind"); write_str(tok_str, tok.str_val); } }
void Model::save(std::ostream & ofs) { // write a signature into the file char chunk[16]; if (full) { strncpy(chunk, SEGMENTOR_MODEL_FULL, 16); } else { strncpy(chunk, SEGMENTOR_MODEL_MINIMAL, 16); } ofs.write(chunk, 16); if (full) { ofs.write(reinterpret_cast<const char *>(&end_time), sizeof(int)); } int off = ofs.tellp(); unsigned labels_offset = 0; unsigned lexicon_offset = 0; unsigned feature_offset = 0; unsigned parameter_offset = 0; write_uint(ofs, 0); // the label offset write_uint(ofs, 0); // the internal lexicon offset write_uint(ofs, 0); // the features offset write_uint(ofs, 0); // the parameter offset labels_offset = ofs.tellp(); labels.dump(ofs); lexicon_offset = ofs.tellp(); internal_lexicon.dump(ofs); feature_offset = ofs.tellp(); space.dump(ofs); parameter_offset = ofs.tellp(); param.dump(ofs, full); ofs.seekp(off); write_uint(ofs, labels_offset); write_uint(ofs, lexicon_offset); write_uint(ofs, feature_offset); write_uint(ofs, parameter_offset); }
static void wbSandbox_report(int nr, siginfo_t *info, void *void_context) { char buf[128]; ucontext_t *ctx = (ucontext_t *)(void_context); unsigned int syscall; if (info->si_code != SYS_SECCOMP) return; if (!ctx) return; syscall = ctx->uc_mcontext.gregs[REG_SYSCALL]; strcpy(buf, msg_needed); if (syscall < sizeof(syscall_names)) { strcat(buf, syscall_names[syscall]); strcat(buf, "("); } write_uint(buf + strlen(buf), syscall); if (syscall < sizeof(syscall_names)) strcat(buf, ")"); strcat(buf, "\n"); size_t w = write(STDOUT_FILENO, buf, strlen(buf)); exit(1); }
void write_maj_arg(t_env *e, va_list ap) { if (e->type == 's' && e->modificator.m != L) write_string(e, ap); else if (e->type == 's' && e->modificator.m == L) write_wstr(e, ap); if (e->type == 'S') write_wstr(e, ap); else if (e->type == 'D') { e->modificator.m = L; write_int(e, ap); } else if (e->type == 'O') write_octal(e, ap); else if (e->type == 'X') write_hexam(e, ap); else if (e->type == 'U') write_uint(e, ap); else if (e->type == 'C') write_wchar(e, ap); }
void write_min_arg(t_env *e, va_list ap) { if (e->type == 'd') write_int(e, ap); else if (e->type == 'p') write_pointor(e, ap); else if (e->type == 'i') write_int(e, ap); else if (e->type == 'o') write_octal(e, ap); else if (e->type == 'u') write_uint(e, ap); else if (e->type == 'x') write_hexa(e, ap); else if (e->type == 'c') { if (e->modificator.m == L) write_wchar(e, ap); else write_char(e, ap); } }
void Model::save(std::ostream & ofs) { // write a signature into the file char chunk[16] = {'o','t','n','e','r', '\0'}; ofs.write(chunk, 16); int off = ofs.tellp(); unsigned labels_offset = 0; unsigned lexicon_offset = 0; unsigned feature_offset = 0; unsigned parameter_offset = 0; write_uint(ofs, 0); // the label offset write_uint(ofs, 0); // the cluster lexicon offset write_uint(ofs, 0); // the features offset write_uint(ofs, 0); // the parameter offset labels_offset = ofs.tellp(); labels.dump(ofs); lexicon_offset = ofs.tellp(); cluster_lexicon.dump(ofs); feature_offset = ofs.tellp(); space.dump(ofs); parameter_offset = ofs.tellp(); param.dump(ofs); ofs.seekp(off); write_uint(ofs, labels_offset); write_uint(ofs, lexicon_offset); write_uint(ofs, feature_offset); write_uint(ofs, parameter_offset); }
void write_uints(int x, int y){ write_uint(x); putchar_unlocked(' '); write_uint(y); putchar_unlocked('\n'); }
void solve(void * args) { unsigned int it, iterations; char checkpoint_file_name[512]; // Structs for the parameters InputParameters * params = (InputParameters *) args; FlowParams flow_params; FsiParams fsi_params; OutputParams output_params; // Parse input parameters input_parse_input_params(params, &flow_params, &fsi_params, &output_params); // Allocate state structs for the flow and particle FlowState * flow_state = flow_alloc_state(flow_params.lx, flow_params.ly); ParticleState * particle_state = fsi_alloc_state(fsi_params.nodes); LbmState * lbm_state = lbm_alloc_state(flow_params.lx, flow_params.ly); // State structs for Lyapunov calculation LyapunovState * lya_state = NULL; FlowState * lya_flow_state = NULL; ParticleState * lya_particle_state = NULL; LbmState * lya_lbm_state = NULL; // Setup output output_init(&output_params); // Try to initialize the solution from a checkpoint file sprintf(checkpoint_file_name, "%s/checkpoint.dat", output_params.output_folder); FILE * cp_handle = fopen(checkpoint_file_name, "r"); if(cp_handle) { // Checkpoint file existed, read the file and initialize the states int lya_exists; read_uint(cp_handle, &it); fsi_read_state_binary(cp_handle, particle_state); flow_read_state_unformatted(cp_handle, flow_state); lbm_read_state_binary(cp_handle, lbm_state); read_uint(cp_handle, &lya_exists); if(lya_exists) { lya_particle_state = fsi_alloc_state(fsi_params.nodes); fsi_read_state_binary(cp_handle, lya_particle_state); lya_flow_state = flow_alloc_state(flow_params.lx, flow_params.ly); flow_read_state_unformatted(cp_handle, lya_flow_state); lya_lbm_state = lbm_alloc_state(flow_params.lx, flow_params.ly); lbm_read_state_binary(cp_handle, lya_lbm_state); lya_state = malloc(sizeof(LyapunovState)); read_double(cp_handle, &lya_state->d0); read_double(cp_handle, &lya_state->cum_sum); read_double(cp_handle, &lya_state->lambda); read_uint(cp_handle, &lya_state->t0); } fclose(cp_handle); } else { // No checkpoint file, initialize normally // Print parameter file output_write_parameters_to_file(&output_params, params); // Initialize from base state it = 0; fsi_init_state(&fsi_params, particle_state); flow_init_state(&flow_params, flow_state); lbm_init_state(flow_state, lbm_state); // Print initial state output_write_state_to_file(0, &output_params, flow_state, particle_state, lya_state); } // Number of iterations iterations = it + output_params.timesteps; // Main loop while(it < iterations) { // Advance the solution it += 1; if( ! lbm_ebf_step(it, &flow_params, flow_state, particle_state, lbm_state)) break; // Check if the Lyapunov exponent should be calculated if(output_params.print_lyapunov) { double d, alpha; // Initialize Lyapunov calculation stuff, if not already done if( ! lya_state) { lya_state = malloc(sizeof(LyapunovState)); lya_state->d0 = 1.0e-4; lya_state->cum_sum = 0; lya_state->t0 = it; lya_state->lambda = 0; // Copy states lya_lbm_state = lbm_clone_state(lbm_state); lya_flow_state = flow_clone_state(flow_state); lya_particle_state = fsi_clone_state(particle_state); // Perturb the particle state lya_particle_state->angle += lya_state->d0; fsi_update_particle_nodes(lya_particle_state); } else { // Advance the perturbed state if( ! lbm_ebf_step(it, &flow_params, lya_flow_state, lya_particle_state, lya_lbm_state)) break; // Calculate the distance between the original and perturbed orbit double ang_vel = particle_state->ang_vel / flow_params.G; double lya_ang_vel = lya_particle_state->ang_vel / flow_params.G; d = pow(lya_particle_state->angle - particle_state->angle, 2) + pow((lya_ang_vel - ang_vel), 2); alpha = sqrt(d / pow(lya_state->d0, 2)); //printf("%.18g %.18g\n", (it - lya_state->t0)*flow_params.f / (2*PI), alpha); if(((it - lya_state->t0) % output_params.lyapunov_calc_step) == 0 && it != lya_state->t0) { // Push the perturbed orbit towards the base orbit lya_particle_state->angle = particle_state->angle + (lya_particle_state->angle - particle_state->angle) / alpha; lya_particle_state->ang_vel = flow_params.G * (ang_vel + (lya_ang_vel - ang_vel) / alpha); // Update particle node positions and reset the flow and lbm state to that of the base state unsigned int i; #pragma omp parallel { fsi_update_particle_nodes(lya_particle_state); #pragma omp for for(i = 0; i < lya_flow_state->lx*lya_flow_state->ly; ++i) { lya_flow_state->u[0][i] = flow_params.u_max * ((flow_state->u[0][i]/flow_params.u_max) + ((lya_flow_state->u[0][i]/flow_params.u_max) - (flow_state->u[0][i]/flow_params.u_max)) / alpha); lya_flow_state->u[1][i] = flow_params.u_max * ((flow_state->u[1][i]/flow_params.u_max) + ((lya_flow_state->u[1][i]/flow_params.u_max) - (flow_state->u[1][i]/flow_params.u_max)) / alpha); lya_flow_state->rho[i] = flow_state->rho[i] + (lya_flow_state->rho[i] - flow_state->rho[i]) / alpha; } lbm_init_state(lya_flow_state, lya_lbm_state); } // Update the lyapunov exponent lya_state->cum_sum += log(alpha); lya_state->lambda = lya_state->cum_sum / (lya_flow_state->G*(it - lya_state->t0)); printf("%d %.12g\n", it-lya_state->t0, lya_state->lambda); } } } // Post process the result if((it % output_params.output_step) == 0) output_write_state_to_file(it, &output_params, flow_state, particle_state, lya_state); } // Write a checkpoint file so the simulation can be resumed at later times cp_handle = fopen(checkpoint_file_name, "w"); write_uint(cp_handle, it); fsi_write_state_binary(cp_handle, particle_state); flow_write_state_unformatted(cp_handle, flow_state); lbm_write_state_binary(cp_handle, lbm_state); if( ! lya_state) { write_uint(cp_handle, 0); } else { write_uint(cp_handle, 1); fsi_write_state_binary(cp_handle, lya_particle_state); flow_write_state_unformatted(cp_handle, lya_flow_state); lbm_write_state_binary(cp_handle, lya_lbm_state); write_double(cp_handle, lya_state->d0); write_double(cp_handle, lya_state->cum_sum); write_double(cp_handle, lya_state->lambda); write_uint(cp_handle, lya_state->t0); } fclose(cp_handle); // Clean up output_destroy(&output_params); fsi_free_state(particle_state); lbm_free_state(lbm_state); flow_free_state(flow_state); if(lya_state) { fsi_free_state(lya_particle_state); lbm_free_state(lya_lbm_state); flow_free_state(lya_flow_state); free(lya_state); } }
int main(int argc, char const *argv[]) { // Usage statements if (argc < 2) { usage(); return -1; } // Option handler int option = atoi(argv[1]); if (option < 1 || option > 7) { usage(); return -1; } int res = 0; float f1 = -187.33667, f2 = 0.0, f3 = 0.0; int i3 = 0; uint u3 = 0; res = read_float(&f2); if (res) return -1; switch (option) { case 1: //fadd f3 = f1 + f2; res = write_float(&f3); break; case 2: //fsub f3 = f1 - f2; res = write_float(&f3); break; case 3: //fmul f3 = f1 * f2; res = write_float(&f3); break; case 4: //fdiv f3 = f1 / f2; res = write_float(&f3); break; case 5: //fcmp f3 = (f1 < f2); res = write_float(&f3); break; case 6: //fptosi i3 = static_cast<int>(f2); res = write_int(&i3); break; case 7: //fptoui u3 = static_cast<uint>(f2); res = write_uint(&u3); break; default: //ERROR should not happen return -1; break; } if (res) return -1; return 0; }
void Model::save(ostream & out) { // write a signature char chunk[16] = {'l','g','d','p', 'j', 0}; out.write(chunk, 16); unsigned int tmp; int off = out.tellp(); unsigned basic_offset = 0; unsigned postag_offset = 0; unsigned deprels_offset = 0; unsigned feature_offset = 0; unsigned parameter_offset = 0; // write pseduo position write_uint(out, 0); // basic offset write_uint(out, 0); // postag offset write_uint(out, 0); // deprels offset write_uint(out, 0); // features offset write_uint(out, 0); // parameters offset // model and feature information // labeled model basic_offset = out.tellp(); tmp = model_opt.labeled; write_uint(out, tmp); // decode order strncpy(chunk, model_opt.decoder_name.c_str(), 16); out.write(chunk, 16); // use dependency tmp = feat_opt.use_dependency; write_uint(out, tmp); // use dependency unigram tmp = feat_opt.use_dependency_unigram; write_uint(out, tmp); // use dependency bigram tmp = feat_opt.use_dependency_bigram; write_uint(out, tmp); // use dependency surrounding tmp = feat_opt.use_dependency_surrounding; write_uint(out, tmp); // use dependency between tmp = feat_opt.use_dependency_between; write_uint(out, tmp); // use sibling tmp = feat_opt.use_sibling; write_uint(out, tmp); // use sibling basic tmp = feat_opt.use_sibling_basic; write_uint(out, tmp); // use sibling linear tmp = feat_opt.use_sibling_linear; write_uint(out, tmp); // use grand tmp = feat_opt.use_grand; write_uint(out, tmp); // use grand basic tmp = feat_opt.use_grand_basic; write_uint(out, tmp); // use grand linear tmp = feat_opt.use_grand_linear; write_uint(out, tmp); // save postag lexicon postag_offset = out.tellp(); postags.dump(out); // save dependency relation lexicon deprels_offset = out.tellp(); deprels.dump(out); feature_offset = out.tellp(); space.save(out); parameter_offset = out.tellp(); param.dump(out); out.seekp(off); write_uint(out, basic_offset); write_uint(out, postag_offset); write_uint(out, deprels_offset); write_uint(out, feature_offset); write_uint(out, parameter_offset); // out.seekp(0, std::ios::end); }