/* * deep_inventory() * * This function returns the recursive inventory of an object. The returned * array of objects is flat, ie there is no structure reflecting the * internal containment relations. * */ struct vector * deep_inventory(struct object *ob, int take_top) { struct vector *dinv, *ainv, *sinv, *tinv; int il; ainv = all_inventory(ob); if (take_top) { sinv = allocate_array(1); sinv->item[0].type = T_OBJECT; add_ref(ob,"deep_inventory"); sinv->item[0].u.ob = ob; dinv = add_array(sinv, ainv); free_vector(sinv); free_vector(ainv); ainv = dinv; } sinv = ainv; for (il = take_top ? 1 : 0 ; il < ainv->size ; il++) { if (ainv->item[il].u.ob->contains) { dinv = deep_inventory(ainv->item[il].u.ob,0); tinv = add_array(sinv, dinv); if (sinv != ainv) free_vector(sinv); sinv = tinv; free_vector(dinv); } } if (ainv != sinv) free_vector(ainv); return sinv; }
main() { int len,*arr1,*arr2,*add_arr,i; printf("enter the size of the 2 arrays"); scanf("%d",&len); arr1=(int *)malloc(len*sizeof(int)); arr2=(int *)malloc(len*sizeof(int)); printf("enter 1st array elements"); for(i=0;i<len;i++) { scanf("%d",arr1+i); } printf("enter 2nd array elements"); for(i=0;i<len;i++) { scanf("%d",arr2+i); } add_arr=add_array(len,arr1,arr2); printf("the resultant array is "); for(i=0;i<len;i++) { printf("%3d",*(add_arr+i)); } getch(); }
static void task_sum_work( void * arg , TPI_ThreadPool pool ) { int p_size , p_rank ; if ( ! TPI_Rank( pool , & p_rank , & p_size ) ) { struct TaskX * const t = (struct TaskX *) arg ; const unsigned p_next = p_rank + 1 ; const unsigned n = t->number ; const double * const xb = t->x_beg + ( n * p_rank ) / p_size ; const double * const xe = t->x_beg + ( n * p_next ) / p_size ; double * const v = t->x_sum ; double partial[4] = { 0 , 0 , 0 , 0 }; add_array( partial , xb , xe ); TPI_Lock( pool , 0 ); xdsum_add_dsum( v , partial ); TPI_Unlock( pool , 0 ); } }
static double multigrid_recurse(struct element **sel, double ****f, double ****x, int var, int level, double eps, void (*opeval) ()) { if (level == (*sel)->precon->nlevels - 1) return conjugate_gradient(sel, f, x, var, opeval, jacobi_preconditioner, eps, 500); const int m = 15; const int n1 = (*sel)->basis->n; const int n2 = (*sel)->precon->nmg[level + 1]; double ****r = new_4d_array(n1, n1, n1, (*sel)->nel); double ****fn = new_4d_array(n2, n2, n2, (*sel)->nel); double ****e = new_4d_array(n2, n2, n2, (*sel)->nel); if (level == 0) compute_residual(sel, x, f, r, var, opeval); else copy_array(***f, ***r, n1 * n1 * n1 * (*sel)->nel); switch_multigrid_level(sel, level + 1); multigrid_restriction(sel, r, fn, level + 1); multigrid_recurse(sel, fn, e, var, level + 1, eps, opeval); switch_multigrid_level(sel, level); multigrid_prolongation(sel, e, r, level); add_array(***r, ***x, n1 * n1 * n1 * (*sel)->nel, 1.0); double err = conjugate_gradient(sel, f, x, var, opeval, jacobi_preconditioner, eps, m); free_4d_array(r); free_4d_array(fn); free_4d_array(e); return err; }
static void compute_residual(struct element **sel, double ****x, double ****f, double ****r, int var, void (*opeval) ()) { const int n = (*sel)->basis->ntot; global_opeval(sel, x, r, var, opeval); scale_array(***r, n * (*sel)->nel, -1.0); add_array(***f, ***r, n * (*sel)->nel, 1.0); }
int main (){ int sum; verify_array(48); sum = add_array(48); verify_array(48); Exit(sum); }
void testAdd() { printf("=== Test add ===\n"); uint32_t a[] = { 0x01234567, 0x89abcdef }; uint32_t b[] = { 0x12000002, 0x77000001 }; uint32_t c[2]; add_array(2, a, b, c); uint32_t expected[] = { 0x1323456a, 0x00abcdf0 }; assertArrayEquals(2, expected, c); }
int main(int argc, char **argv) { int *a, *b; int n = 3; a = malloc(sizeof(int) * 3); b = malloc(sizeof(int) * 3); int i, sum; for (i = 0; i < n; i++) { a[i] = i; b[i] = i; } sum = add_array(a, b, 3); printf("The addition is %d\n", sum); return 0; }
static void read_snmp_conf(const char *address) /* I - Single address to probe */ { cups_file_t *fp; /* File pointer */ char filename[1024], /* Filename */ line[1024], /* Line from file */ *value; /* Value on line */ int linenum; /* Line number */ const char *cups_serverroot; /* CUPS_SERVERROOT env var */ const char *debug; /* CUPS_DEBUG_LEVEL env var */ const char *runtime; /* CUPS_MAX_RUN_TIME env var */ /* * Initialize the global address and community lists... */ Addresses = cupsArrayNew(NULL, NULL); Communities = cupsArrayNew(NULL, NULL); if (address) add_array(Addresses, address); if ((debug = getenv("CUPS_DEBUG_LEVEL")) != NULL) DebugLevel = atoi(debug); if ((runtime = getenv("CUPS_MAX_RUN_TIME")) != NULL) MaxRunTime = atoi(runtime); /* * Find the snmp.conf file... */ if ((cups_serverroot = getenv("CUPS_SERVERROOT")) == NULL) cups_serverroot = CUPS_SERVERROOT; snprintf(filename, sizeof(filename), "%s/snmp.conf", cups_serverroot); if ((fp = cupsFileOpen(filename, "r")) != NULL) { /* * Read the snmp.conf file... */ linenum = 0; while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum)) { if (!value) fprintf(stderr, "ERROR: Missing value on line %d of %s!\n", linenum, filename); else if (!_cups_strcasecmp(line, "Address")) { if (!address) add_array(Addresses, value); } else if (!_cups_strcasecmp(line, "Community")) add_array(Communities, value); else if (!_cups_strcasecmp(line, "DebugLevel")) DebugLevel = atoi(value); else if (!_cups_strcasecmp(line, "DeviceURI")) { if (*value != '\"') fprintf(stderr, "ERROR: Missing double quote for regular expression on " "line %d of %s!\n", linenum, filename); else add_device_uri(value); } else if (!_cups_strcasecmp(line, "HostNameLookups")) HostNameLookups = !_cups_strcasecmp(value, "on") || !_cups_strcasecmp(value, "yes") || !_cups_strcasecmp(value, "true") || !_cups_strcasecmp(value, "double"); else if (!_cups_strcasecmp(line, "MaxRunTime")) MaxRunTime = atoi(value); else fprintf(stderr, "ERROR: Unknown directive %s on line %d of %s!\n", line, linenum, filename); } cupsFileClose(fp); } /* * Use defaults if parameters are undefined... */ if (cupsArrayCount(Addresses) == 0) { /* * If we have no addresses, exit immediately... */ fprintf(stderr, "DEBUG: No address specified and no Address line in %s...\n", filename); exit(0); } if (cupsArrayCount(Communities) == 0) { fputs("INFO: Using default SNMP Community public\n", stderr); add_array(Communities, "public"); } }
void c_add_eq(int is_void) { DEBUG_CHECK(sp->type != T_LVALUE, "non-lvalue argument to +=\n"); lval = sp->u.lvalue; sp--; /* points to the RHS */ switch (lval->type) { case T_STRING: if (sp->type == T_STRING) { SVALUE_STRING_JOIN(lval, sp, "f_add_eq: 1"); } else if (sp->type == T_NUMBER) { char buff[20]; sprintf(buff, "%d", sp->u.number); EXTEND_SVALUE_STRING(lval, buff, "f_add_eq: 2"); } else if (sp->type == T_REAL) { char buff[40]; sprintf(buff, "%f", sp->u.real); EXTEND_SVALUE_STRING(lval, buff, "f_add_eq: 2"); } else { bad_argument(sp, T_STRING | T_NUMBER | T_REAL, 2, (is_void ? F_VOID_ADD_EQ : F_ADD_EQ)); } break; case T_NUMBER: if (sp->type == T_NUMBER) { lval->u.number += sp->u.number; /* both sides are numbers, no freeing required */ } else if (sp->type == T_REAL) { lval->u.number += sp->u.real; /* both sides are numbers, no freeing required */ } else { error("Left hand side of += is a number (or zero); right side is not a number.\n"); } break; case T_REAL: if (sp->type == T_NUMBER) { lval->u.real += sp->u.number; /* both sides are numerics, no freeing required */ } if (sp->type == T_REAL) { lval->u.real += sp->u.real; /* both sides are numerics, no freeing required */ } else { error("Left hand side of += is a number (or zero); right side is not a number.\n"); } break; #ifndef NO_BUFFER_TYPE case T_BUFFER: if (sp->type != T_BUFFER) { bad_argument(sp, T_BUFFER, 2, (is_void ? F_VOID_ADD_EQ : F_ADD_EQ)); } else { buffer_t *b; b = allocate_buffer(lval->u.buf->size + sp->u.buf->size); memcpy(b->item, lval->u.buf->item, lval->u.buf->size); memcpy(b->item + lval->u.buf->size, sp->u.buf->item, sp->u.buf->size); free_buffer(sp->u.buf); free_buffer(lval->u.buf); lval->u.buf = b; } break; #endif case T_ARRAY: if (sp->type != T_ARRAY) bad_argument(sp, T_ARRAY, 2, (is_void ? F_VOID_ADD_EQ : F_ADD_EQ)); else { /* add_array now frees the arrays */ lval->u.arr = add_array(lval->u.arr, sp->u.arr); } break; case T_MAPPING: if (sp->type != T_MAPPING) bad_argument(sp, T_MAPPING, 2, (is_void ? F_VOID_ADD_EQ : F_ADD_EQ)); else { absorb_mapping(lval->u.map, sp->u.map); free_mapping(sp->u.map); /* free RHS */ /* LHS not freed because its being reused */ } break; case T_LVALUE_BYTE: if (sp->type != T_NUMBER) error("Bad right type to += of char lvalue.\n"); else *global_lvalue_byte.u.lvalue_byte += sp->u.number; break; default: bad_arg(1, (is_void ? F_VOID_ADD_EQ : F_ADD_EQ)); } if (!is_void) { /* not void add_eq */ assign_svalue_no_free(sp, lval); } else { /* * but if (void)add_eq then no need to produce an * rvalue */ sp--; } }
void c_add() { switch (sp->type) { #ifndef NO_BUFFER_TYPE case T_BUFFER: { if (!((sp-1)->type == T_BUFFER)) { error("Bad type argument to +. Had %s and %s.\n", type_name((sp - 1)->type), type_name(sp->type)); } else { buffer_t *b; b = allocate_buffer(sp->u.buf->size + (sp - 1)->u.buf->size); memcpy(b->item, (sp - 1)->u.buf->item, (sp - 1)->u.buf->size); memcpy(b->item + (sp - 1)->u.buf->size, sp->u.buf->item, sp->u.buf->size); free_buffer((sp--)->u.buf); free_buffer(sp->u.buf); sp->u.buf = b; } break; } /* end of x + T_BUFFER */ #endif case T_NUMBER: { switch ((--sp)->type) { case T_NUMBER: sp->u.number += (sp+1)->u.number; break; case T_REAL: sp->u.real += (sp+1)->u.number; break; case T_STRING: { char buff[20]; sprintf(buff, "%d", (sp+1)->u.number); EXTEND_SVALUE_STRING(sp, buff, "f_add: 2"); break; } default: error("Bad type argument to +. Had %s and %s.\n", type_name(sp->type), type_name((sp+1)->type)); } break; } /* end of x + NUMBER */ case T_REAL: { switch ((--sp)->type) { case T_NUMBER: sp->type = T_REAL; sp->u.real = sp->u.number + (sp+1)->u.real; break; case T_REAL: sp->u.real += (sp+1)->u.real; break; case T_STRING: { char buff[40]; sprintf(buff, "%f", (sp+1)->u.real); EXTEND_SVALUE_STRING(sp, buff, "f_add: 2"); break; } default: error("Bad type argument to +. Had %s and %s\n", type_name(sp->type), type_name((sp+1)->type)); } break; } /* end of x + T_REAL */ case T_ARRAY: { if (!((sp-1)->type == T_ARRAY)) { error("Bad type argument to +. Had %s and %s\n", type_name((sp - 1)->type), type_name(sp->type)); } else { /* add_array now free's the arrays */ (sp-1)->u.arr = add_array((sp - 1)->u.arr, sp->u.arr); sp--; break; } } /* end of x + T_ARRAY */ case T_MAPPING: { if ((sp-1)->type == T_MAPPING) { mapping_t *map; map = add_mapping((sp - 1)->u.map, sp->u.map); free_mapping((sp--)->u.map); free_mapping(sp->u.map); sp->u.map = map; break; } else error("Bad type argument to +. Had %s and %s\n", type_name((sp - 1)->type), type_name(sp->type)); } /* end of x + T_MAPPING */ case T_STRING: { switch ((sp-1)->type) { case T_NUMBER: { char buff[20]; sprintf(buff, "%d", (sp-1)->u.number); SVALUE_STRING_ADD_LEFT(buff, "f_add: 3"); break; } /* end of T_NUMBER + T_STRING */ case T_REAL: { char buff[40]; sprintf(buff, "%f", (sp - 1)->u.real); SVALUE_STRING_ADD_LEFT(buff, "f_add: 3"); break; } /* end of T_REAL + T_STRING */ case T_STRING: { SVALUE_STRING_JOIN(sp-1, sp, "f_add: 1"); sp--; break; } /* end of T_STRING + T_STRING */ default: error("Bad type argument to +. Had %s and %s\n", type_name((sp - 1)->type), type_name(sp->type)); } break; } /* end of x + T_STRING */ default: error("Bad type argument to +. Had %s and %s.\n", type_name((sp-1)->type), type_name(sp->type)); } }
/** * ファイルを読み込んでドキュメントと転置索引を作る関数 * @param char *file_name 開くファイル名 */ void read_file(char *file_name) { FILE *fp; int c; int pre_word_id = -1, cur_word_id; // 単語のID char *word; // 現在の単語 char *line; // 現在の行 int word_len = 0; // 単語の現在の文字数 int line_len = 0; // 行の現在の文字数 int word_len_max = WORD_LENGTH_UNIT; // 単語の文字数の初期単位 int line_len_max = LINE_LENGTH_UNIT; // 行の文字数の初期単位 STATE state = S_SPACE; // 状態 if ((fp = fopen(file_name, "r")) == NULL) { fprintf(stderr, "File Open Error: %s\n", file_name); exit(1); } // ある程度の大きさで確保 word = (char *)malloc(sizeof(char) * word_len_max); line = (char *)malloc(sizeof(char) * line_len_max); if (word == NULL || line == NULL) { printf("Memory Allocation Error\n"); exit(1); } // 終わりまで1文字ずつ取得 while (1) { c = getc(fp); // 文字の取得 // 空白文字か判別 if (isspace(c) || c == EOF) { if (state == S_WORD) // 文字が入力されていたなら { // 単語にNULL文字を追加 set_character(&word, '\0', &word_len, &word_len_max); cur_word_id = add_array(word, n_docs); // 配列に追加 if (pre_word_id != -1) // 前回の単語がある場合 associate_words(pre_word_id, cur_word_id, n_docs); // 関連付け word_len = 0; // 単語の文字数の初期化 pre_word_id = cur_word_id; // 前回の単語のIDを保存 } if (c == '\n' || c == '\r' || c == EOF) // 改行かファイルの終わりなら { // 行にNULL文字を追加 set_character(&line, '\0', &line_len, &line_len_max); // 行をドキュメントとして保存 if (strlen(line) > 0) insert_document(line); // 配列に追加 line_len = 0; // 行の文字数の初期化 pre_word_id = -1; // 前回の単語はない } else { // 行の場合は空白も入れる set_character(&line, c, &line_len, &line_len_max); } if (c == EOF) // 繰り返しを抜ける break; state = S_SPACE; // 状態の変更 } // 空白文字でない場合(単語の場合) else { // 文字の保存 set_character(&word, tolower(c), &word_len, &word_len_max); // 小文字で保存 set_character(&line, c, &line_len, &line_len_max); state = S_WORD; // 状態の変更 } } // 解放 fclose(fp); free(word); free(line); }
void xdsum_add_array( double * s , unsigned n , const double * x ) { add_array( s , x , x + n ); }
int main() { print_array(array, LENGTH); add_array(array, LENGTH, 5); print_array(array, LENGTH); return 0; }
/* * user can modify his list for grouply mail sending */ static int set_group() { char strName[STRLEN]; int num_send = 0; clear(); prints(_msg_max_group, MAX_MAILGROUPS); for (;;) { /* show the list for grouply mail sending */ show_array(mgatop); getdata(1, 0, _msg_ask_group_add, genbuf, 2, ECHONOSP | LOWCASE, NULL); switch (genbuf[0]) { case 'a': if (num_send >= MAX_MAILGROUPS) { prints(_msg_mail_group_max_prompt, MAX_MAILGROUPS); getkey(); } else { if (getdata(2, 0, _msg_receiver, strName, sizeof(strName), ECHONOSP, NULL)) { #if EMAIL_LIMIT if (curuser.ident != 7 && strchr(strName, '@')) { prints("\n%s", _msg_sorry_email); clrtoeol(); getkey(); } else #endif if (strchr(strName, '@') || get_passwd(NULL, strName) > 0) { if (!cmp_array(mgatop, strName, strcmp)) { add_array(mgatop, strName, malloc_str); num_send++; } } } } break; case 'f': { int i; load_friend(&friend_cache, curuser.userid); for (i = 0; i < friend_cache->number; i++) { if (!friend_cache->datap[i]) continue; if (num_send >= MAX_MAILGROUPS) { prints(_msg_mail_group_max_prompt, MAX_MAILGROUPS); getkey(); break; } if (!cmp_array(mgatop, friend_cache->datap[i], strcmp)) { add_array(mgatop, friend_cache->datap[i], malloc_str); num_send++; } } } break; case 'd': if (getdata(2, 0, _msg_delete, genbuf, IDLEN, ECHONOSP, NULL)) { mgatop = cmpd_array(mgatop, genbuf, strcmp); num_send--; } break; case 'q': return -1; case 'e': default: if (num_send == 0) return -1; clrtobot(); return 0; } } }
AST_Decl *UTL_Scope::call_add() { AST_Decl *result = NULL; AST_Decl *decl; UTL_ScopeActiveIterator *i; UTL_Scope *scope; i = new UTL_ScopeActiveIterator(this, UTL_Scope::IK_decls); while (!(i->is_done())) { decl = i->item(); scope = 0; switch (decl->node_type()) { case AST_Decl::NT_argument: result = add_argument(AST_Argument::narrow_from_decl(decl)); break; case AST_Decl::NT_array: result = add_array(AST_Array::narrow_from_decl(decl)); break; case AST_Decl::NT_attr: result = add_attribute(AST_Attribute::narrow_from_decl(decl)); break; case AST_Decl::NT_const: result = add_constant(AST_Constant::narrow_from_decl(decl)); break; case AST_Decl::NT_enum: scope = AST_Enum::narrow_from_decl(decl); result = add_enum(AST_Enum::narrow_from_decl(decl)); break; case AST_Decl::NT_enum_val: result = add_enum_val(AST_EnumVal::narrow_from_decl(decl)); break; case AST_Decl::NT_except: scope = AST_Exception::narrow_from_decl(decl); result = add_exception(AST_Exception::narrow_from_decl(decl)); break; case AST_Decl::NT_field: result = add_field(AST_Field::narrow_from_decl(decl)); break; case AST_Decl::NT_interface: scope = AST_Interface::narrow_from_decl(decl); result = add_interface(AST_Interface::narrow_from_decl(decl)); break; case AST_Decl::NT_interface_fwd: result = add_interface_fwd(AST_InterfaceFwd::narrow_from_decl(decl)); break; case AST_Decl::NT_module: scope = AST_Module::narrow_from_decl(decl); result = add_module(AST_Module::narrow_from_decl(decl)); break; case AST_Decl::NT_op: result = add_operation(AST_Operation::narrow_from_decl(decl)); scope = AST_Operation::narrow_from_decl(decl); break; case AST_Decl::NT_pre_defined: result = add_predefined_type(AST_PredefinedType::narrow_from_decl(decl)); break; case AST_Decl::NT_sequence: result = add_sequence(AST_Sequence::narrow_from_decl(decl)); break; case AST_Decl::NT_string: result = add_string(AST_String::narrow_from_decl(decl)); break; case AST_Decl::NT_struct: result = add_structure(AST_Structure::narrow_from_decl(decl)); scope = AST_Structure::narrow_from_decl(decl); break; case AST_Decl::NT_typedef: result = add_typedef(AST_Typedef::narrow_from_decl(decl)); break; case AST_Decl::NT_union: result = add_union(AST_Union::narrow_from_decl(decl)); scope = AST_Union::narrow_from_decl(decl); break; case AST_Decl::NT_union_branch: result = add_union_branch(AST_UnionBranch::narrow_from_decl(decl)); break; // case AST_Decl::NT_opaque: // result = add_opaque(AST_Opaque::narrow_from_decl(decl)); // break; case AST_Decl::NT_value: result = add_valuetype (AST_Value::narrow_from_decl (decl)); scope = AST_Value::narrow_from_decl (decl); break; case AST_Decl::NT_value_fwd: result = add_valuetype_fwd(AST_ValueFwd::narrow_from_decl(decl)); break; case AST_Decl::NT_state_member: result = add_state_member(AST_StateMember::narrow_from_decl(decl)); break; default: return NULL; } if (scope) scope->call_add(); i->next(); } delete i; return result; }