static void tensorEye(rpc::RPCMessage& raw_message) { thpp::Tensor *tensor = unpackRetrieveTensor(raw_message); long n = unpackInteger(raw_message); long m = unpackInteger(raw_message); finalize(raw_message); tensor->eye(n, m); }
static void tensorMean(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); finalize(raw_message); r->mean(*t, dimension, keepdim); }
static void tensorSort(rpc::RPCMessage& raw_message) { thpp::Tensor *rt = unpackRetrieveTensor(raw_message); thpp::Tensor *ri = unpackRetrieveTensor(raw_message); thpp::Tensor *tensor = unpackRetrieveTensor(raw_message); int dimension = unpackInteger(raw_message); int desc = unpackInteger(raw_message); finalize(raw_message); rt->sort(*ri, *tensor, dimension, desc); }
static void tensorStd(rpc::RPCMessage& raw_message) { thpp::Tensor *r = unpackRetrieveTensor(raw_message); thpp::Tensor *t = unpackRetrieveTensor(raw_message); int dimension = unpackInteger(raw_message); int biased = unpackInteger(raw_message); int keepdim = unpackInteger(raw_message); finalize(raw_message); r->std(*t, dimension, biased, keepdim); }
static void tensorCatArray(rpc::RPCMessage& raw_message) { thpp::Tensor *result = unpackRetrieveTensor(raw_message); int numInputs = unpackInteger(raw_message); std::vector<thpp::Tensor*> inputs(numInputs); for (std::size_t i = 0; i < numInputs; i++) inputs[i] = unpackRetrieveTensor(raw_message); int dimension = unpackInteger(raw_message); finalize(raw_message); result->catArray(inputs, dimension); }
static void tensorTopk(rpc::RPCMessage& raw_message) { thpp::Tensor *rt = unpackRetrieveTensor(raw_message); thpp::Tensor *ri = unpackRetrieveTensor(raw_message); thpp::Tensor *tensor = unpackRetrieveTensor(raw_message); long k = unpackInteger(raw_message); int dimension = unpackInteger(raw_message); int dir = unpackInteger(raw_message); int sorted = unpackInteger(raw_message); finalize(raw_message); rt->topk(*ri, *tensor, k, dimension, dir, sorted); }
static void tensorTriu(rpc::RPCMessage& raw_message) { thpp::Tensor *r = unpackRetrieveTensor(raw_message); thpp::Tensor *t = unpackRetrieveTensor(raw_message); long k = unpackInteger(raw_message); finalize(raw_message); r->triu(*t, k); }
static void tensorRandperm(rpc::RPCMessage& raw_message) { thpp::Tensor *r = unpackRetrieveTensor(raw_message); thpp::Generator *_generator = unpackRetrieveGenerator(raw_message); long n = unpackInteger(raw_message); finalize(raw_message); r->randperm(*_generator, n); }
/** Unpack an entire setting description from the buffer * * @param pBuffer the buffer to unpack from * @param index the index in the buffer to start at * @param size the size of the buffer in bytes * @param setting the structure to hold the setting value * * @return the new index for the next piece of data or 0 if an error occurs. */ static int unpackSetting(unsigned char *pBuffer, int index, int size, SettingDescription &setting) { if ((index + 1)>=size) // Make sure we have the type modifier at least return 0; // 1 byte for type setting.typeAndModifier = pBuffer[index++]; // The name if ((index=unpackString(pBuffer, index, size, &setting.name))<=0) return index; // And the value itself switch(setting.typeAndModifier & SETTING_TYPE_MASK) { case StringSetting: index = unpackString(pBuffer, index, size, &setting.value.string); break; case IntegerSetting: index = unpackInteger(pBuffer, index, size, setting.value.integer); break; case BooleanSetting: index = unpackBoolean(pBuffer, index, size, setting.value.boolean); break; case NumberSetting: index = unpackDouble(pBuffer, index, size, setting.value.number); break; default: index = 0; } return index; }
static void tensorDiag(rpc::RPCMessage& raw_message) { thpp::Tensor *r = unpackRetrieveTensor(raw_message); thpp::Tensor *t = unpackRetrieveTensor(raw_message); int k = unpackInteger(raw_message); finalize(raw_message); r->diag(*t, k); }
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 tensorIndexAdd(rpc::RPCMessage& raw_message) { thpp::Tensor *tensor = unpackRetrieveTensor(raw_message); int dim = unpackInteger(raw_message); thpp::Tensor *index = unpackRetrieveTensor(raw_message); thpp::Tensor *src = unpackRetrieveTensor(raw_message); finalize(raw_message); tensor->indexAdd(dim, *index, *src); }
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 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 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 tensorStdall(rpc::RPCMessage& raw_message) { thpp::Tensor *tensor = unpackRetrieveTensor(raw_message); int biased = unpackInteger(raw_message); finalize(raw_message); if (thpp::isInteger(tensor->type())) { long long response = dynamic_cast<thpp::IntTensor*>(tensor)->stdall(biased); sendValueToMaster(response); } else if (thpp::isFloat(tensor->type())) { double response = dynamic_cast<thpp::FloatTensor*>(tensor)->stdall(biased); sendValueToMaster(response); } 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 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"); } }