/* Index Offsets {{{ */ size_t CYGetIndex(const CYUTF8String &value) { if (value.data[0] != '0') { size_t index(0); for (size_t i(0); i != value.size; ++i) { if (!DigitRange_[value.data[i]]) return _not(size_t); index *= 10; index += value.data[i] - '0'; } return index; } else if (value.size == 1) return 0; else return _not(size_t); }
static Value * eval(const Ast *expr) { switch(expr->class) { case N_CALL: return call(expr); case N_ASSIGNMENT: return assignment(expr); case N_IDENTIFIER: return identifier(expr); case N_NEG: return _neg(expr); case N_NOT: return _not(expr); case N_EQ: return _eq(expr); case N_NEQ: return _neq(expr); case N_AND: return _and(expr); case N_IOR: return _ior(expr); case N_XOR: return _neq(expr); // alias case N_LT: return _lt(expr); case N_LE: return _le(expr); case N_GE: return _ge(expr); case N_GT: return _gt(expr); case N_ADD: return _add(expr); case N_SUB: return _sub(expr); case N_MUL: return _mul(expr); case N_DIV: return _div(expr); case N_POW: return _pow(expr); case N_MOD: return _mod(expr); case N_BOOLEAN: return _bool(expr); case N_INTEGER: return _int(expr); case N_FLOAT: return _float(expr); case N_STRING: return _string(expr); case N_SET: return _set(expr); case N_R: return _relation(expr); } printf("EVALFAIL %d ", expr->class); pn(expr); assert(false && "should not be reached"); }
char _floatnum2logic( t_longint* longint, cfloatnum x) { floatstruct tmp; int digits; digits = float_getexponent(x)+1; if (float_iszero(x) || digits <= 0) { longint->length = 1; longint->value[0] = 0; } else { if (digits > MATHPRECISION) return 0; float_create(&tmp); /* floatnum2longint rounds, we have to truncate first */ float_copy(&tmp, x, digits); if (float_getsign(x) < 0) float_add(&tmp, &tmp, &c1, EXACT); _floatnum2longint(longint, &tmp); float_free(&tmp); if (_bitlength(longint) > LOGICRANGE) return 0; } _zeroextend(longint); if (float_getsign(x) < 0) _not(longint); return 1; }
static void *Symbol(const mach_header_xx *mach, const char *name) { const struct symtab_command *stp(NULL); forlc (command, mach, LC_SYMTAB, struct symtab_command) stp = command; if (stp == NULL) return NULL; size_t slide(_not(size_t)); const nlist_xx *symbols(NULL); const char *strings(NULL); forlc (segment, mach, LC_SEGMENT_XX, segment_command_xx) { if (segment->fileoff == 0) slide = reinterpret_cast<size_t>(mach) - segment->vmaddr; if (stp->symoff >= segment->fileoff && stp->symoff < segment->fileoff + segment->filesize) symbols = reinterpret_cast<const nlist_xx *>(stp->symoff - segment->fileoff + segment->vmaddr + slide); if (stp->stroff >= segment->fileoff && stp->stroff < segment->fileoff + segment->filesize) strings = reinterpret_cast<const char *>(stp->stroff - segment->fileoff + segment->vmaddr + slide); } if (slide == _not(size_t) || symbols == NULL || strings == NULL) return NULL; for (size_t i(0); i != stp->nsyms; ++i) { const nlist_xx *symbol(&symbols[i]); if (symbol->n_un.n_strx == 0 || (symbol->n_type & N_STAB) != 0) continue; const char *nambuf(strings + symbol->n_un.n_strx); if ($strcmp(name, nambuf) != 0) continue; uintptr_t value(symbol->n_value); if (value == 0) continue; value += slide; return reinterpret_cast<void *>(value); } return NULL; }
char float_not( floatnum x) { t_longint lx; if(!_cvtlogic(&lx, x)) return _setnan(x); _not(&lx); _logic2floatnum(x, &lx); return 1; }
void Parse_(apr_pool_t *pool, struct Signature *signature, const char **name, char eos, Callback callback) { _assert(*name != NULL); // XXX: this is just a stupid check :( bool named(**name == '"'); signature->elements = NULL; signature->count = 0; for (;;) { if (**name == eos) { ++*name; return; } signature->elements = (struct Element *) prealloc_(pool, signature->elements, signature->count * sizeof(struct Element), (signature->count + 1) * sizeof(struct Element)); _assert(signature->elements != NULL); struct Element *element = &signature->elements[signature->count++]; if (**name != '"') element->name = NULL; else { const char *quote = strchr(++*name, '"'); element->name = apr_pstrmemdup(pool, *name, quote - *name); *name = quote + 1; } element->type = Parse_(pool, name, eos, named, callback); if (**name < '0' || **name > '9') element->offset = _not(size_t); else { element->offset = 0; do element->offset = element->offset * 10 + (*(*name)++ - '0'); while (**name >= '0' && **name <= '9'); } } }
bool CYIsKey(CYUTF8String value) { const char *data(value.data); size_t size(value.size); if (size == 0) return false; if (DigitRange_[data[0]]) { size_t index(CYGetIndex(value)); if (index == _not(size_t)) return false; } else { if (!WordStartRange_[data[0]]) return false; for (size_t i(1); i != size; ++i) if (!WordEndRange_[data[i]]) return false; } return true; }
static CYUTF8String Run(CYPool &pool, int client, CYUTF8String code) { const char *json; uint32_t size; if (client == -1) { mode_ = Running; #ifdef CY_EXECUTE json = CYExecute(pool, code); #else json = NULL; #endif mode_ = Working; if (json == NULL) size = 0; else size = strlen(json); } else { mode_ = Sending; size = code.size; CYSendAll(client, &size, sizeof(size)); CYSendAll(client, code.data, code.size); mode_ = Waiting; CYRecvAll(client, &size, sizeof(size)); if (size == _not(uint32_t)) json = NULL; else { char *temp(new(pool) char[size + 1]); CYRecvAll(client, temp, size); temp[size] = '\0'; json = temp; } mode_ = Working; } return CYUTF8String(json, size); }
Array(Type &type, size_t size = _not(size_t)) : type(type), size(size) { }
void VMDriver::execute(){ if( this->m_state == STATE_IDLE ){ printf( "Error: state is idle. \n"); return; } assert( this->currentAssembly() ); while( this->isActive() ){ if( this->isBreak() ){ break; } unsigned char content = this->getByte( m_funcAddr , m_pc ); m_pc++; switch( content ){ case EMnemonic::MovPtr : _mov_ptr(); break; case EMnemonic::Mov : _mov(); break; case EMnemonic::Add : _add(); break; case EMnemonic::Sub : _sub(); break; case EMnemonic::Mul : _mul(); break; case EMnemonic::Div : _div(); break; case EMnemonic::Rem : _rem(); break; case EMnemonic::Inc : _inc(); break; case EMnemonic::Dec : _dec(); break; case EMnemonic::Push : _push(); break; case EMnemonic::PushPtr : _push_ptr(); break; case EMnemonic::Pop : _pop(); break; case EMnemonic::Call : _call(); break; case EMnemonic::ST : _st(); break; case EMnemonic::LD : _ld(); break; case EMnemonic::EndFunc : _endFunc(); break; case EMnemonic::CmpGeq : case EMnemonic::CmpG : case EMnemonic::CmpLeq : case EMnemonic::CmpL : case EMnemonic::CmpEq : case EMnemonic::CmpNEq : _cmp( content ); break; case EMnemonic::Not : _not(); break; case EMnemonic::Minus : _minus(); break; case EMnemonic::LogOr : case EMnemonic::LogAnd : _log( content ); break; case EMnemonic::Jmp : _jmp(); break; case EMnemonic::JumpZero : _jumpzero(); break; case EMnemonic::JumpNotZero : _jumpnotzero(); break; case EMnemonic::RET : _ret(); break; } } }
int Main(int argc, char const * const argv[], char const * const envp[]) { _aprcall(apr_initialize()); apr_pool_t *pool; apr_pool_create(&pool, NULL); bool tty(isatty(STDIN_FILENO)); bool compile(false); CYOptions options; append_history$ = (int (*)(int, const char *)) (dlsym(RTLD_DEFAULT, "append_history")); #ifdef CY_ATTACH pid_t pid(_not(pid_t)); #endif const char *host(NULL); const char *port(NULL); apr_getopt_t *state; _aprcall(apr_getopt_init(&state, pool, argc, argv)); for (;;) { char opt; const char *arg; apr_status_t status(apr_getopt(state, "cg:n:" #ifdef CY_ATTACH "p:" #endif "r:" "s" , &opt, &arg)); switch (status) { case APR_EOF: goto getopt; case APR_BADCH: case APR_BADARG: fprintf(stderr, "usage: cycript [-c]" #ifdef CY_ATTACH " [-p <pid|name>]" #endif " [-r <host:port>]" " [<script> [<arg>...]]\n" ); return 1; default: _aprcall(status); } switch (opt) { case 'c': compile = true; break; case 'g': if (false); else if (strcmp(arg, "rename") == 0) options.verbose_ = true; #if YYDEBUG else if (strcmp(arg, "bison") == 0) bison_ = true; #endif else { fprintf(stderr, "invalid name for -g\n"); return 1; } break; case 'n': if (false); else if (strcmp(arg, "minify") == 0) pretty_ = true; else { fprintf(stderr, "invalid name for -n\n"); return 1; } break; #ifdef CY_ATTACH case 'p': { size_t size(strlen(arg)); char *end; pid = strtoul(arg, &end, 0); if (arg + size != end) { // XXX: arg needs to be escaped in some horrendous way of doom const char *command(apr_pstrcat(pool, "ps axc|sed -e '/^ *[0-9]/{s/^ *\\([0-9]*\\)\\( *[^ ]*\\)\\{3\\} *-*\\([^ ]*\\)/\\3 \\1/;/^", arg, " /{s/^[^ ]* //;q;};};d'", NULL)); if (FILE *pids = popen(command, "r")) { char value[32]; size = 0; for (;;) { size_t read(fread(value + size, 1, sizeof(value) - size, pids)); if (read == 0) break; else { size += read; if (size == sizeof(value)) { pid = _not(pid_t); goto fail; } } } size: if (size == 0) goto fail; if (value[size - 1] == '\n') { --size; goto size; } value[size] = '\0'; size = strlen(value); pid = strtoul(value, &end, 0); if (value + size != end) fail: pid = _not(pid_t); _syscall(pclose(pids)); } if (pid == _not(pid_t)) { fprintf(stderr, "invalid pid for -p\n"); return 1; } } } break; #endif case 'r': { //size_t size(strlen(arg)); char *colon(strrchr(arg, ':')); if (colon == NULL) { fprintf(stderr, "missing colon in hostspec\n"); return 1; } /*char *end; port = strtoul(colon + 1, &end, 10); if (end != arg + size) { fprintf(stderr, "invalid port in hostspec\n"); return 1; }*/ host = arg; *colon = '\0'; port = colon + 1; } break; case 's': strict_ = true; break; } } getopt:; const char *script; int ind(state->ind); #ifdef CY_ATTACH if (pid != _not(pid_t) && ind < argc - 1) { fprintf(stderr, "-p cannot set argv\n"); return 1; } if (pid != _not(pid_t) && compile) { fprintf(stderr, "-p conflicts with -c\n"); return 1; } #endif if (ind == argc) script = NULL; else { #ifdef CY_EXECUTE // XXX: const_cast?! wtf gcc :( CYSetArgs(argc - ind - 1, const_cast<const char **>(argv + ind + 1)); #endif script = argv[ind]; if (strcmp(script, "-") == 0) script = NULL; } #ifdef CY_ATTACH if (pid != _not(pid_t) && script == NULL && !tty) { fprintf(stderr, "non-terminal attaching to remote console\n"); return 1; } #endif #ifdef CY_ATTACH if (pid == _not(pid_t)) client_ = -1; else { int server(_syscall(socket(PF_UNIX, SOCK_STREAM, 0))); try { struct sockaddr_un address; memset(&address, 0, sizeof(address)); address.sun_family = AF_UNIX; sprintf(address.sun_path, "/tmp/.s.cy.%u", getpid()); _syscall(bind(server, reinterpret_cast<sockaddr *>(&address), SUN_LEN(&address))); _syscall(chmod(address.sun_path, 0777)); try { _syscall(listen(server, 1)); InjectLibrary(pid); client_ = _syscall(accept(server, NULL, NULL)); } catch (...) { // XXX: exception? unlink(address.sun_path); throw; } } catch (...) { _syscall(close(server)); throw; } } #else client_ = -1; #endif if (client_ == -1 && host != NULL && port != NULL) { struct addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = 0; hints.ai_flags = 0; struct addrinfo *infos; _syscall(getaddrinfo(host, port, &hints, &infos)); _assert(infos != NULL); try { for (struct addrinfo *info(infos); info != NULL; info = info->ai_next) { int client(_syscall(socket(info->ai_family, info->ai_socktype, info->ai_protocol))); try { _syscall(connect(client, info->ai_addr, info->ai_addrlen)); client_ = client; break; } catch (...) { _syscall(close(client)); throw; } } } catch (...) { freeaddrinfo(infos); throw; } } if (script == NULL && tty) Console(options); else { CYLocalPool pool; char *start, *end; std::istream *indirect; if (script == NULL) { start = NULL; end = NULL; indirect = &std::cin; } else { size_t size; start = reinterpret_cast<char *>(Map(script, &size)); end = start + size; if (size >= 2 && start[0] == '#' && start[1] == '!') { start += 2; if (void *line = memchr(start, '\n', end - start)) start = reinterpret_cast<char *>(line); else start = end; } indirect = NULL; } CYStream direct(start, end); std::istream &stream(indirect == NULL ? direct : *indirect); CYDriver driver(stream, script ?: "<stdin>"); cy::parser parser(driver); Setup(driver, parser); if (parser.parse() != 0 || !driver.errors_.empty()) { for (CYDriver::Errors::const_iterator i(driver.errors_.begin()); i != driver.errors_.end(); ++i) std::cerr << i->location_.begin << ": " << i->message_ << std::endl; } else if (driver.program_ != NULL) if (client_ != -1) { // XXX: this code means that you can't pipe to another process std::string code(start, end-start); Run(client_, false, code, &std::cout); } else { std::ostringstream str; CYOutput out(str, options); Setup(out, driver, options); out << *driver.program_; std::string code(str.str()); if (compile) std::cout << code; else Run(client_, false, code, &std::cout); } } apr_pool_destroy(pool); return 0; }
Matrix& LASSO::train(Matrix& X, Matrix& Y, Options& options) { int p = size(X, 2); int ny = size(Y, 2); double epsilon = options.epsilon; int maxIter = options.maxIter; double lambda = options.lambda; bool calc_OV = options.calc_OV; bool verbose = options.verbose; /*XNX = [X, -X]; H_G = XNX' * XNX; D = repmat(diag(H_G), [1, n_y]); XNXTY = XNX' * Y; A = (X' * X + lambda * eye(p)) \ (X' * Y);*/ Matrix& XNX = horzcat(2, &X, &uminus(X)); Matrix& H_G = XNX.transpose().mtimes(XNX); double* Q = new double[size(H_G, 1)]; for (int i = 0; i < size(H_G, 1); i++) { Q[i] = H_G.getEntry(i, i); } Matrix& XNXTY = XNX.transpose().mtimes(Y); Matrix& A = mldivide( plus(X.transpose().mtimes(X), times(lambda, eye(p))), X.transpose().mtimes(Y) ); /*AA = [subplus(A); subplus(-A)]; C = -XNXTY + lambda; Grad = C + H_G * AA; tol = epsilon * norm(Grad); PGrad = zeros(size(Grad));*/ Matrix& AA = vertcat(2, &subplus(A), &subplus(uminus(A))); Matrix& C = plus(uminus(XNXTY), lambda); Matrix& Grad = plus(C, mtimes(H_G, AA)); double tol = epsilon * norm(Grad); Matrix& PGrad = zeros(size(Grad)); std::list<double> J; double fval = 0; // J(1) = sum(sum((Y - X * A).^2)) / 2 + lambda * sum(sum(abs(A))); if (calc_OV) { fval = sum(sum(pow(minus(Y, mtimes(X, A)), 2))) / 2 + lambda * sum(sum(abs(A))); J.push_back(fval); } Matrix& I_k = Grad.copy(); double d = 0; int k = 0; DenseVector& SFPlusCi = *new DenseVector(AA.getColumnDimension()); Matrix& S = H_G; Vector** SRows = null; if (typeid(H_G) == typeid(DenseMatrix)) SRows = denseMatrix2DenseRowVectors(S); else SRows = sparseMatrix2SparseRowVectors(S); Vector** CRows = null; if (typeid(C) == typeid(DenseMatrix)) CRows = denseMatrix2DenseRowVectors(C); else CRows = sparseMatrix2SparseRowVectors(C); double** FData = ((DenseMatrix&) AA).getData(); double* FRow = null; double* pr = null; int K = 2 * p; while (true) { /*I_k = Grad < 0 | AA > 0; I_k_com = not(I_k); PGrad(I_k) = Grad(I_k); PGrad(I_k_com) = 0;*/ _or(I_k, lt(Grad, 0), gt(AA, 0)); Matrix& I_k_com = _not(I_k); assign(PGrad, Grad); logicalIndexingAssignment(PGrad, I_k_com, 0); d = norm(PGrad, inf); if (d < tol) { if (verbose) println("Converge successfully!"); break; } /*for i = 1:2*p AA(i, :) = max(AA(i, :) - (C(i, :) + H_G(i, :) * AA) ./ (D(i, :)), 0); end A = AA(1:p,:) - AA(p+1:end,:);*/ for (int i = 0; i < K; i++) { // SFPlusCi = SRows[i].operate(AA); operate(SFPlusCi, *SRows[i], AA); plusAssign(SFPlusCi, *CRows[i]); timesAssign(SFPlusCi, 1 / Q[i]); pr = SFPlusCi.getPr(); // F(i, :) = max(F(i, :) - (S(i, :) * F + C(i, :)) / D[i]), 0); // F(i, :) = max(F(i, :) - SFPlusCi, 0) FRow = FData[i]; for (int j = 0; j < AA.getColumnDimension(); j++) { FRow[j] = max(FRow[j] - pr[j], 0); } } // Grad = plus(C, mtimes(H_G, AA)); plus(Grad, C, mtimes(H_G, AA)); k = k + 1; if (k > maxIter) { if (verbose) println("Maximal iterations"); break; } if (calc_OV) { fval = sum(sum(pow(minus(Y, mtimes(XNX, AA)), 2))) / 2 + lambda * sum(sum(abs(AA))); J.push_back(fval); } if (k % 10 == 0 && verbose) { if (calc_OV) fprintf("Iter %d - ||PGrad||: %f, ofv: %f\n", k, d, J.back()); else fprintf("Iter %d - ||PGrad||: %f\n", k, d); } } Matrix& res = minus( AA.getSubMatrix(0, p - 1, 0, ny - 1), AA.getSubMatrix(p, 2 * p - 1, 0, ny - 1) ); return res; }