static void tensorLogspace(rpc::RPCMessage& raw_message) {
thpp::Tensor *r = unpackRetrieveTensor(raw_message);
long n = unpackInteger(raw_message);
if (thpp::isInteger(r->type())) {
long long a = unpackInteger(raw_message);
long long b = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(r)->logspace(a, b, n);
} else if (thpp::isFloat(r->type())) {
double a = unpackFloat(raw_message);
double b = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(r)->logspace(a, b, n);
} else {
throw std::invalid_argument("expected scalar type");
}
}
static void tensorBhistc(rpc::RPCMessage& raw_message) {
thpp::Tensor *hist = unpackRetrieveTensor(raw_message);
thpp::Tensor *tensor = unpackRetrieveTensor(raw_message);
long nbins = unpackInteger(raw_message);
if (thpp::isInteger(hist->type())) {
long long minvalue = unpackInteger(raw_message);
long long maxvalue = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(hist)->bhistc(*tensor, nbins, minvalue, maxvalue);
} else if (thpp::isFloat(hist->type())) {
double minvalue = unpackFloat(raw_message);
double maxvalue = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(hist)->bhistc(*tensor, nbins, minvalue, maxvalue);
} else {
throw std::invalid_argument("expected scalar type");
}
}
static void tensorRange(rpc::RPCMessage& raw_message) {
thpp::Tensor *r = unpackRetrieveTensor(raw_message);
thpp::Type type = peekType(raw_message);
if (thpp::isInteger(type)) {
long long xmin = unpackInteger(raw_message);
long long xmax = unpackInteger(raw_message);
long long step = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(r)->range(xmin, xmax, step);
} else if (thpp::isFloat(type)) {
double xmin = unpackFloat(raw_message);
double xmax = unpackFloat(raw_message);
double step = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(r)->range(xmin, xmax, step);
} else {
throw std::runtime_error("expected a scalar type");
}
}
static void tensorRenorm(rpc::RPCMessage& raw_message) {
thpp::Tensor *res = unpackRetrieveTensor(raw_message);
thpp::Tensor *src = unpackRetrieveTensor(raw_message);
int dimension = unpackInteger(raw_message);
if (thpp::isInteger(res->type())) {
long long value = unpackInteger(raw_message);
long long maxnorm = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(res)->renorm(*src, value, dimension, maxnorm);
} else if (thpp::isFloat(res->type())) {
double value = unpackFloat(raw_message);
double maxnorm = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(res)->renorm(*src, value, dimension, maxnorm);
} else {
throw std::invalid_argument("expected scalar type");
}
}
static void tensorTpow(rpc::RPCMessage& raw_message) {
thpp::Tensor *r = unpackRetrieveTensor(raw_message);
thpp::Tensor *t = unpackRetrieveTensor(raw_message);
if (thpp::isInteger(r->type())) {
long long value = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(r)->tpow(value, *t);
} else if (thpp::isFloat(t->type())) {
double value = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(r)->tpow(value, *t);
} else {
throw std::runtime_error("expected a scalar type");
}
}
static void tensorFill(rpc::RPCMessage& raw_message) {
thpp::Tensor *t = unpackRetrieveTensor(raw_message);
thpp::Type type = peekType(raw_message);
if (thpp::isInteger(type)) {
auto value = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(t)->fill(value);
} else if (thpp::isFloat(type)) {
auto value = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(t)->fill(value);
} else {
throw std::runtime_error("expected a scalar type");
}
}
static void tensorIndexFill(rpc::RPCMessage& raw_message) {
thpp::Tensor *tensor = unpackRetrieveTensor(raw_message);
int dim = unpackInteger(raw_message);
thpp::Tensor *index = unpackRetrieveTensor(raw_message);
thpp::Type type = peekType(raw_message);
if (thpp::isInteger(type)) {
auto val = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(tensor)->indexFill(dim, *index, val);
} else if (thpp::isFloat(type)) {
auto val = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(tensor)->indexFill(dim, *index, val);
} else {
throw std::runtime_error("expected a scalar type");
}
}
static void tensorNorm(rpc::RPCMessage& raw_message) {
thpp::Tensor *r = unpackRetrieveTensor(raw_message);
thpp::Tensor *t = unpackRetrieveTensor(raw_message);
int dimension = unpackInteger(raw_message);
int keepdim = unpackInteger(raw_message);
if (thpp::isInteger(r->type())) {
long long value = unpackInteger(raw_message);
finalize(raw_message);
dynamic_cast<thpp::IntTensor*>(r)->norm(*t, value, dimension, keepdim);
} else if (thpp::isFloat(r->type())) {
double value = unpackFloat(raw_message);
finalize(raw_message);
dynamic_cast<thpp::FloatTensor*>(r)->norm(*t, value, dimension, keepdim);
} else {
throw std::runtime_error("expected scalar type");
}
}
static void tensorNormall(rpc::RPCMessage& raw_message) {
thpp::Tensor *r = unpackRetrieveTensor(raw_message);
if (thpp::isInteger(r->type())) {
long long value = unpackInteger(raw_message);
finalize(raw_message);
long long response = dynamic_cast<thpp::IntTensor*>(r)->normall(value);
sendValueToMaster(response);
} else if (thpp::isFloat(r->type())) {
double value = unpackFloat(raw_message);
finalize(raw_message);
double response = dynamic_cast<thpp::FloatTensor*>(r)->normall(value);
sendValueToMaster(response);
} else {
throw std::invalid_argument("expected scalar type");
}
}
MyFloat::MyFloat(float f){
unpackFloat(f);
}
