/* 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;
}
