frozenleaves/pytorch
1
0
Fork 0
mirror of https://github.com/pytorch/pytorch.git synced 2025-10-20 21:14:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Rebase fixes

Browse Source
This commit is contained in:
Adam Paszke
2017-04-28 14:48:15 -07:00
parent 14e1bfddbc
commit ac3ba9a2ad
13 changed files with 511 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -5,6 +5,7 @@ torch.egg-info/
torch/version.py
torch/csrc/generic/TensorMethods.cpp
torch/lib/*.so*
torch/lib/*.a*
torch/lib/*.dylib*
torch/lib/*.h
torch/lib/build

1
torch/lib/THD/base/data_channels/DataChannelMPI.cpp
View File

@ -8,6 +8,7 @@
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <iostream>
namespace thd {

2
torch/lib/THD/master_worker/worker/dispatch/Tensor.cpp
View File

@ -296,7 +296,7 @@ static void tensorSqueeze1d(rpc::RPCMessage& raw_message) {
thpp::Tensor *src = unpackRetrieveTensor(raw_message);
int dimension = unpackInteger(raw_message);
finalize(raw_message);
tensor->squeeze1d(*src, dimension);
tensor->squeeze(*src, dimension);
}
static void tensorFree(rpc::RPCMessage& raw_message) {

2
torch/lib/THPP/Tensor.hpp
View File

@ -69,7 +69,7 @@ struct Tensor {
virtual Tensor& transpose(const Tensor& src, int dimension1, int dimension2) = 0;
virtual Tensor& unfold(const Tensor& src, int dimension, long size, long step) = 0;
virtual Tensor& squeeze(const Tensor& src) = 0;
virtual Tensor& squeeze1d(const Tensor& src, int dimension) = 0;
virtual Tensor& squeeze(const Tensor& src, int dimension) = 0;
virtual Tensor& unsqueeze(const Tensor& src, int dimension) = 0;
virtual Tensor& copy(const Tensor& src) = 0;

92
torch/lib/THPP/tensors/THCSTensor.hpp
View File

@ -40,6 +40,10 @@ public:
virtual THCSTensor* clone() const override;
virtual THCSTensor* clone_shallow() override;
virtual std::unique_ptr<Tensor> contiguous() const override;
virtual THCSTensor* newSelect(int dimension, long sliceIndex) const override;
virtual THCSTensor* newNarrow(int dimension, long firstIndex, long size) const override;
virtual THCSTensor* newTranspose(int dimension1, int dimension2) const override;
virtual THCSTensor* newUnfold(int dimension, long size, long step) const override;
virtual int nDim() const override;
virtual long_range sizes() const override;
@ -80,13 +84,38 @@ public:
int dimension2) override;
virtual THCSTensor& unfold(const Tensor& src, int dimension,
long size, long step) override;
virtual THCSTensor& squeeze(const Tensor& src) override;
virtual THCSTensor& squeeze(const Tensor& src, int dimension) override;
virtual THCSTensor& unsqueeze(const Tensor& src, int dimension) override;
virtual THCSTensor& gesv(const Tensor& ra, const Tensor& b, const Tensor& a) override;
virtual THCSTensor& trtrs(const Tensor& ra, const Tensor& b, const Tensor& a,
const char *uplo, const char *trans, const char *diag) override;
virtual THCSTensor& gels(const Tensor& ra, const Tensor& b, const Tensor& a) override;
virtual THCSTensor& syev(const Tensor& rv, const Tensor& a,
const char *jobz, const char *uplo) override;
virtual THCSTensor& geev(const Tensor& rv, const Tensor& a, const char *jobvr) override;
virtual THCSTensor& gesvd(const Tensor& rs, const Tensor& rv,
const Tensor& a, const char *jobu) override;
virtual THCSTensor& gesvd2(const Tensor& rs, const Tensor& rv, const Tensor& ra,
const Tensor& a, const char *jobu) override;
virtual THCSTensor& getri(const Tensor& a) override;
virtual THCSTensor& potrf(const Tensor& a, const char *uplo) override;
virtual THCSTensor& potrs(const Tensor& b, const Tensor& a, const char *uplo) override;
virtual THCSTensor& potri(const Tensor& a, const char *uplo) override;
virtual THCSTensor& qr(const Tensor& rr, const Tensor& a) override;
virtual THCSTensor& geqrf(const Tensor& rtau, const Tensor& a) override;
virtual THCSTensor& orgqr(const Tensor& a, const Tensor& tau) override;
virtual THCSTensor& ormqr(const Tensor& a, const Tensor& tau, const Tensor& c,
const char *side, const char *trans) override;
virtual THCSTensor& pstrf(const Tensor& rpiv, const Tensor& a,
const char *uplo, scalar_type tol) override;
virtual THCSTensor& diag(const Tensor& src, int k) override;
virtual THCSTensor& eye(long n, long m) override;
virtual THCSTensor& range(scalar_type xmin, scalar_type xmax,
scalar_type step) override;
virtual THCSTensor& randperm(const Generator& _generator, long n) override;
virtual THCSTensor& sort(const Tensor& ri, const Tensor& src,
int dimension, int desc) override;
virtual THCSTensor& topk(const Tensor& ri, const Tensor& src,
@ -128,6 +157,58 @@ public:
virtual THCSTensor& asin(const Tensor& src) override;
virtual THCSTensor& sinh(const Tensor& src) override;
virtual THCSTensor& tan(const Tensor& src) override;
virtual THCSTensor& atan(const Tensor& src) override;
virtual THCSTensor& atan2(const Tensor& src1, const Tensor& src2) override;
virtual THCSTensor& tanh(const Tensor& src) override;
virtual THCSTensor& pow(const Tensor& src, scalar_type value) override;
virtual THCSTensor& tpow(scalar_type value, const Tensor& src) override;
virtual THCSTensor& sqrt(const Tensor& src) override;
virtual THCSTensor& rsqrt(const Tensor& src) override;
virtual THCSTensor& ceil(const Tensor& src) override;
virtual THCSTensor& floor(const Tensor& src) override;
virtual THCSTensor& round(const Tensor& src) override;
virtual THCSTensor& trunc(const Tensor& src) override;
virtual THCSTensor& frac(const Tensor& src) override;
virtual THCSTensor& lerp(const Tensor& a, const Tensor& b, scalar_type weight) override;
virtual THCSTensor& mean(const Tensor& src, int dimension) override;
virtual THCSTensor& std(const Tensor& src, int dimension, int flag) override;
virtual THCSTensor& var(const Tensor& src, int dimension, int flag) override;
virtual THCSTensor& norm(const Tensor& src, scalar_type value, int dimension) override;
virtual THCSTensor& renorm(const Tensor& src, scalar_type value, int dimension, scalar_type maxnorm) override;
virtual THCSTensor& histc(const Tensor& src, long nbins, scalar_type minvalue, scalar_type maxvalue) override;
virtual THCSTensor& bhistc(const Tensor& src, long nbins, scalar_type minvalue, scalar_type maxvalue) override;
virtual scalar_type dist(const Tensor& src, scalar_type value) override;
virtual scalar_type meanall() override;
virtual scalar_type varall() override;
virtual scalar_type stdall() override;
virtual scalar_type normall(scalar_type value) override;
virtual THCSTensor& linspace(scalar_type a, scalar_type b, long n) override;
virtual THCSTensor& logspace(scalar_type a, scalar_type b, long n) override;
virtual THCSTensor& rand(const Generator& _generator, THLongStorage *size) override;
virtual THCSTensor& randn(const Generator& _generator, THLongStorage *size) override;
virtual int logicalall() override;
virtual int logicalany() override;
virtual THCSTensor& random(const Generator& _generator) override;
virtual THCSTensor& geometric(const Generator& _generator, double p) override;
virtual THCSTensor& bernoulli(const Generator& _generator, double p) override;
virtual THCSTensor& bernoulli_FloatTensor(const Generator& _generator, const Tensor& p) override;
virtual THCSTensor& bernoulli_DoubleTensor(const Generator& _generator, const Tensor& p) override;
virtual THCSTensor& uniform(const Generator& _generator, double a, double b) override;
virtual THCSTensor& normal(const Generator& _generator, double mean, double stdv) override;
virtual THCSTensor& exponential(const Generator& _generator, double lambda) override;
virtual THCSTensor& cauchy(const Generator& _generator, double median, double sigma) override;
virtual THCSTensor& logNormal(const Generator& _generator, double mean, double stdv) override;
// Note: the order of *Tensor and *Prob_dist is reversed compared to
// the declarations in TH/generic/THTensorMath.h, so for instance
// the call:
// THRealTensor_multinomial(r, _generator, prob_dist, n_sample, with_replacement)
// is equivalent to `prob_dist->multinomial(r, _generator, n_sample, with_replacement)`.
// It is done this way so that the first argument can be casted onto a float tensor type.
virtual THCSTensor& multinomial(const Tensor& r, const Generator& _generator,
int n_sample, int with_replacement) override;
virtual THCSTensor& ltValue(const Tensor& t, scalar_type value) override;
virtual THCSTensor& leValue(const Tensor& t, scalar_type value) override;
virtual THCSTensor& gtValue(const Tensor& t, scalar_type value) override;
@ -142,6 +223,17 @@ public:
virtual THCSTensor& eqValueT(const Tensor& t, scalar_type value) override;
virtual THCSTensor& fill(scalar_type value) override;
virtual THCSTensor& maskedFill(const Tensor& mask, scalar_type value) override;
virtual THCSTensor& maskedCopy(const Tensor& mask, const Tensor& src) override;
virtual THCSTensor& maskedSelect(const Tensor& mask, const Tensor& src) override;
// NOTE like in byte comparison operations, the order in nonzero
// is reversed compared to THS, i.e. tensor->nonzero(subscript) is equivalent
// to THCSTensor_(nonzero)(subscript, tensor)
virtual THCSTensor& nonzero(const Tensor& subscript) override;
virtual THCSTensor& indexSelect(const Tensor& src, int dim, const Tensor& index) override;
virtual THCSTensor& indexCopy(int dim, const Tensor& index, const Tensor& src) override;
virtual THCSTensor& indexAdd(int dim, const Tensor& index, const Tensor& src) override;
virtual THCSTensor& indexFill(int dim, const Tensor& index, scalar_type value) override;
virtual THCSTensor& copy(const Tensor& src) override;
virtual THCSTensor& cat(const std::vector<Tensor*>& src, int dimension) override;

10
torch/lib/THPP/tensors/THCTensor.hpp
View File

@ -42,10 +42,10 @@ public:
virtual THCTensor* clone() const override;
virtual THCTensor* clone_shallow() override;
virtual std::unique_ptr<Tensor> contiguous() const override;
virtual THCTensor* newSelect(int dimension, long sliceIndex) const override;
virtual THCTensor* newNarrow(int dimension, long firstIndex, long size) const override;
virtual THCTensor* newTranspose(int dimension1, int dimension2) const override;
virtual THCTensor* newUnfold(int dimension, long size, long step) const override;
virtual THCTensor* newSelect(int dimension, long sliceIndex) const override;
virtual THCTensor* newNarrow(int dimension, long firstIndex, long size) const override;
virtual THCTensor* newTranspose(int dimension1, int dimension2) const override;
virtual THCTensor* newUnfold(int dimension, long size, long step) const override;
virtual int nDim() const override;
virtual long_range sizes() const override;
@ -87,7 +87,7 @@ public:
virtual THCTensor& unfold(const Tensor& src, int dimension,
long size, long step) override;
virtual THCTensor& squeeze(const Tensor& src) override;
virtual THCTensor& squeeze1d(const Tensor& src, int dimension) override;
virtual THCTensor& squeeze(const Tensor& src, int dimension) override;
virtual THCTensor& unsqueeze(const Tensor& src, int dimension) override;
virtual THCTensor& gesv(const Tensor& ra, const Tensor& b, const Tensor& a) override;

10
torch/lib/THPP/tensors/THSTensor.hpp
View File

@ -43,10 +43,10 @@ public:
virtual THSTensor* clone() const override;
virtual THSTensor* clone_shallow() override;
virtual std::unique_ptr<Tensor> contiguous() const override;
virtual THSTensor* newSelect(int dimension, long sliceIndex) const override;
virtual THSTensor* newNarrow(int dimension, long firstIndex, long size) const override;
virtual THSTensor* newTranspose(int dimension1, int dimension2) const override;
virtual THSTensor* newUnfold(int dimension, long size, long step) const override;
virtual THSTensor* newSelect(int dimension, long sliceIndex) const override;
virtual THSTensor* newNarrow(int dimension, long firstIndex, long size) const override;
virtual THSTensor* newTranspose(int dimension1, int dimension2) const override;
virtual THSTensor* newUnfold(int dimension, long size, long step) const override;
virtual int nDim() const override;
virtual long_range sizes() const override;
@ -88,7 +88,7 @@ public:
virtual THSTensor& unfold(const Tensor& src, int dimension,
long size, long step) override;
virtual THSTensor& squeeze(const Tensor& src) override;
virtual THSTensor& squeeze1d(const Tensor& src, int dimension) override;
virtual THSTensor& squeeze(const Tensor& src, int dimension) override;
virtual THSTensor& unsqueeze(const Tensor& src, int dimension) override;
virtual THSTensor& gesv(const Tensor& ra, const Tensor& b, const Tensor& a) override;

10
torch/lib/THPP/tensors/THTensor.hpp
View File

@ -50,10 +50,10 @@ public:
virtual THTensor* clone() const override;
virtual THTensor* clone_shallow() override;
virtual std::unique_ptr<Tensor> contiguous() const override;
virtual THTensor* newSelect(int dimension, long sliceIndex) const override;
virtual THTensor* newNarrow(int dimension, long firstIndex, long size) const override;
virtual THTensor* newTranspose(int dimension1, int dimension2) const override;
virtual THTensor* newUnfold(int dimension, long size, long step) const override;
virtual THTensor* newSelect(int dimension, long sliceIndex) const override;
virtual THTensor* newNarrow(int dimension, long firstIndex, long size) const override;
virtual THTensor* newTranspose(int dimension1, int dimension2) const override;
virtual THTensor* newUnfold(int dimension, long size, long step) const override;
virtual int nDim() const override;
virtual long_range sizes() const override;
@ -95,7 +95,7 @@ public:
virtual THTensor& unfold(const Tensor& src, int dimension,
long size, long step) override;
virtual THTensor& squeeze(const Tensor& src) override;
virtual THTensor& squeeze1d(const Tensor& src, int dimension) override;
virtual THTensor& squeeze(const Tensor& src, int dimension) override;
virtual THTensor& unsqueeze(const Tensor& src, int dimension) override;
virtual THTensor& gesv(const Tensor& ra, const Tensor& b, const Tensor& a) override;

384
torch/lib/THPP/tensors/generic/THCSTensor.cpp
View File

@ -44,6 +44,26 @@ auto THCSTensor<real>::contiguous() const -> std::unique_ptr<Tensor> {
throw std::runtime_error("THCSTensor::contiguous() not supported");
}
template<>
auto THCSTensor<real>::newSelect(int dimension, long sliceIndex) const -> THCSTensor* {
throw std::runtime_error("newSelect is not yet available for sparse tensors");
}
template<>
auto THCSTensor<real>::newNarrow(int dimension, long firstIndex, long size) const -> THCSTensor* {
throw std::runtime_error("newNarrow is not yet available for sparse tensors");
}
template<>
auto THCSTensor<real>::newTranspose(int dimension1, int dimension2) const -> THCSTensor* {
throw std::runtime_error("newTranspose is not yet available for sparse tensors");
}
template<>
auto THCSTensor<real>::newUnfold(int dimension, long size, long step) const -> THCSTensor* {
throw std::runtime_error("newUnfold is not yet available for sparse tensors");
}
template<>
int THCSTensor<real>::nDim() const {
return tensor->nDimensionI;
@ -183,6 +203,11 @@ auto THCSTensor<real>::unfold(const Tensor& src, int dimension,
throw std::runtime_error("THCSTensor::unfold not supported");
}
template<>
auto THCSTensor<real>::squeeze(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::squeeze not supported");
}
template<>
auto THCSTensor<real>::squeeze(const Tensor& src, int dimension) -> THCSTensor& {
throw std::runtime_error("THCSTensor::squeeze not supported");
@ -193,6 +218,96 @@ auto THCSTensor<real>::unsqueeze(const Tensor& src, int dimension) -> THCSTensor
throw std::runtime_error("THCSTensor::unsqueeze not supported");
}
#define LAPACK_ERROR "Lapack operations are not available for sparse tensors"
template<>
auto THCSTensor<real>::gesv(const Tensor& ra, const Tensor& b, const Tensor& a) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
return *this;
}
template<>
auto THCSTensor<real>::trtrs(const Tensor& ra, const Tensor& b, const Tensor& a,
const char *uplo, const char *trans, const char *diag) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::gels(const Tensor& ra, const Tensor& b, const Tensor& a) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::syev(const Tensor& rv, const Tensor& a,
const char *jobz, const char *uplo) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::geev(const Tensor& rv, const Tensor& a, const char *jobvr) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::gesvd(const Tensor& rs, const Tensor& rv,
const Tensor& a, const char *jobu) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::gesvd2(const Tensor& rs, const Tensor& rv, const Tensor& ra,
const Tensor& a, const char *jobu) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::getri(const Tensor& a) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::potrf(const Tensor& a, const char *uplo) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::potrs(const Tensor& b, const Tensor& a, const char *uplo) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::potri(const Tensor& a, const char *uplo) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::qr(const Tensor& rr, const Tensor& a) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::geqrf(const Tensor& rtau, const Tensor& a) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::orgqr(const Tensor& a, const Tensor& tau) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::ormqr(const Tensor& a, const Tensor& tau, const Tensor& c,
const char *side, const char *trans) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
template<>
auto THCSTensor<real>::pstrf(const Tensor& rpiv, const Tensor& a,
const char *uplo, scalar_type tol) -> THCSTensor& {
throw std::runtime_error(LAPACK_ERROR);
}
#ifdef THCS_REAL_IS_HALF
#define cast_scalar(v) THC_float2half(v)
#define uncast_scalar(v) THC_half2float(v)
@ -206,6 +321,48 @@ auto THCSTensor<real>::fill(scalar_type value) -> THCSTensor& {
throw std::runtime_error("THCSTensor::fill() not supported");
}
template<>
auto THCSTensor<real>::maskedFill(const Tensor& mask, scalar_type value) -> THCSTensor& {
throw std::runtime_error("THSTensor::maskedFill() not supported");
}
template<>
auto THCSTensor<real>::maskedCopy(const Tensor& mask, const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::maskedCopy() not supported");
}
template<>
auto THCSTensor<real>::maskedSelect(const Tensor& src, const Tensor& mask) -> THCSTensor& {
throw std::runtime_error("THCSTensor::maskedSelect() not supported");
}
template<>
auto THCSTensor<real>::nonzero(const Tensor& subscript) -> THCSTensor& {
throw std::runtime_error("THCSTensor::nonzero() not supported");
}
template<>
auto THCSTensor<real>::indexSelect(const Tensor& src, int dim, const Tensor& index) -> THCSTensor& {
throw std::runtime_error("THCSTensor::indexSelect() not supported");
}
template<>
auto THCSTensor<real>::indexCopy(int dim, const Tensor& index, const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::indexCopy() not supported");
}
template<>
auto THCSTensor<real>::indexAdd(int dim, const Tensor& index, const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::indexAdd() not supported");
}
template<>
auto THCSTensor<real>::indexFill(int dim, const Tensor& index, scalar_type value) -> THCSTensor& {
throw std::runtime_error("THCSTensor::indexFill() not supported");
}
template<>
auto THCSTensor<real>::retain() -> THCSTensor& {
THCSTensor_(retain)(state, tensor);
@ -234,6 +391,11 @@ auto THCSTensor<real>::range(scalar_type xmin, scalar_type xmax,
throw std::runtime_error("THCSTensor::range() not supported");
}
template<>
auto THCSTensor<real>::randperm(const Generator& _generator, long n) -> THCSTensor& {
throw std::runtime_error("THCSTensor::randperm() not supported");
}
template<>
auto THCSTensor<real>::sort(const Tensor& ri, const Tensor& src,
int dimension, int desc) -> THCSTensor& {
@ -368,6 +530,228 @@ auto THCSTensor<real>::copy(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::copy() not supported");
}
template<>
auto THCSTensor<real>::tan(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::tan() not supported");
}
template<>
auto THCSTensor<real>::atan(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::atan() not supported");
}
template<>
auto THCSTensor<real>::atan2(const Tensor& src1, const Tensor& src2) -> THCSTensor& {
throw std::runtime_error("THCSTensor::atan2() not supported");
}
template<>
auto THCSTensor<real>::tanh(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::tanh() not supported");
}
template<>
auto THCSTensor<real>::pow(const Tensor& src, scalar_type value) -> THCSTensor& {
throw std::runtime_error("THCSTensor::pow() not supported");
}
template<>
auto THCSTensor<real>::tpow(scalar_type value, const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::tpow() not supported");
}
template<>
auto THCSTensor<real>::sqrt(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::sqrt() not supported");
}
template<>
auto THCSTensor<real>::rsqrt(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::rsqrt() not supported");
}
template<>
auto THCSTensor<real>::ceil(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::ceil() not supported");
}
template<>
auto THCSTensor<real>::floor(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::floor() not supported");
}
template<>
auto THCSTensor<real>::round(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::round() not supported");
}
template<>
auto THCSTensor<real>::trunc(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::trunc() not supported");
}
template<>
auto THCSTensor<real>::frac(const Tensor& src) -> THCSTensor& {
throw std::runtime_error("THCSTensor::frac() not supported");
}
template<>
auto THCSTensor<real>::lerp(const Tensor& a, const Tensor& b, scalar_type weight) -> THCSTensor& {
throw std::runtime_error("THCSTensor::lerp() not supported");
}
template<>
auto THCSTensor<real>::mean(const Tensor& src, int dimension) -> THCSTensor& {
throw std::runtime_error("THCSTensor::mean() not supported");
}
template<>
auto THCSTensor<real>::std(const Tensor& src, int dimension, int flag) -> THCSTensor& {
throw std::runtime_error("THCSTensor::std() not supported");
}
template<>
auto THCSTensor<real>::var(const Tensor& src, int dimension, int flag) -> THCSTensor& {
throw std::runtime_error("THCSTensor::var() not supported");
}
template<>
auto THCSTensor<real>::norm(const Tensor& src, scalar_type value, int dimension) -> THCSTensor& {
throw std::runtime_error("THCSTensor::norm() not supported");
}
template<>
auto THCSTensor<real>::renorm(const Tensor& src, scalar_type value, int dimension, scalar_type maxnorm) -> THCSTensor& {
throw std::runtime_error("THCSTensor::renorm() not supported");
}
template<>
auto THCSTensor<real>::histc(const Tensor& src, long nbins, scalar_type minvalue, scalar_type maxvalue) -> THCSTensor& {
throw std::runtime_error("THCSTensor::histc() not supported");
}
template<>
auto THCSTensor<real>::bhistc(const Tensor& src, long nbins, scalar_type minvalue, scalar_type maxvalue) -> THCSTensor& {
throw std::runtime_error("THCSTensor::bhistc() not supported");
}
template<>
auto THCSTensor<real>::dist(const Tensor& src, scalar_type value) -> scalar_type {
throw std::runtime_error("THCSTensor::dist() not supported");
}
template<>
auto THCSTensor<real>::meanall() -> scalar_type {
throw std::runtime_error("THCSTensor::meanall() not supported");
}
template<>
auto THCSTensor<real>::varall() -> scalar_type {
throw std::runtime_error("THCSTensor::varall() not supported");
}
template<>
auto THCSTensor<real>::stdall() -> scalar_type {
throw std::runtime_error("THCSTensor::stdall() not supported");
}
template<>
auto THCSTensor<real>::normall(scalar_type value) -> scalar_type {
throw std::runtime_error("THCSTensor::normall() not supported");
}
template<>
auto THCSTensor<real>::linspace(scalar_type a, scalar_type b, long n) -> THCSTensor& {
throw std::runtime_error("THCSTensor::linspace() not supported");
}
template<>
auto THCSTensor<real>::logspace(scalar_type a, scalar_type b, long n) -> THCSTensor& {
throw std::runtime_error("THCSTensor::logspace() not supported");
}
template<>
auto THCSTensor<real>::rand(const Generator& _generator, THLongStorage *size) -> THCSTensor& {
throw std::runtime_error("THCSTensor::rand() not supported");
}
template<>
auto THCSTensor<real>::randn(const Generator& _generator, THLongStorage *size) -> THCSTensor& {
throw std::runtime_error("THCSTensor::randn() not supported");
}
template<>
int THCSTensor<real>::logicalall() {
throw std::runtime_error("THCSTensor::logicalall() not supported");
}
template<>
int THCSTensor<real>::logicalany() {
throw std::runtime_error("THCSTensor::logicalany() not supported");
}
template<>
auto THCSTensor<real>::random(const Generator& _generator) -> THCSTensor& {
throw std::runtime_error("THCSTensor::random() not supported");
}
template<>
auto THCSTensor<real>::geometric(const Generator& _generator, double p) -> THCSTensor& {
throw std::runtime_error("THCSTensor::geometric() not supported");
}
template<>
auto THCSTensor<real>::bernoulli(const Generator& _generator, double p) -> THCSTensor& {
throw std::runtime_error("THCSTensor::bernoulli() not supported");
}
template<>
auto THCSTensor<real>::bernoulli_FloatTensor(const Generator& _generator, const Tensor& p) -> THCSTensor& {
throw std::runtime_error("THCSTensor::bernoulli_FloatTensor() not supported");
}
template<>
auto THCSTensor<real>::bernoulli_DoubleTensor(const Generator& _generator, const Tensor& p) -> THCSTensor& {
throw std::runtime_error("THCSTensor::bernoulli_DoubleTensor() not supported");
}
template<>
auto THCSTensor<real>::uniform(const Generator& _generator, double a, double b) -> THCSTensor& {
throw std::runtime_error("THCSTensor::uniform() not supported");
}
template<>
auto THCSTensor<real>::normal(const Generator& _generator, double mean, double stdv) -> THCSTensor& {
throw std::runtime_error("THCSTensor::normal() not supported");
}
template<>
auto THCSTensor<real>::exponential(const Generator& _generator, double lambda) -> THCSTensor& {
throw std::runtime_error("THCSTensor::exponential() not supported");
}
template<>
auto THCSTensor<real>::cauchy(const Generator& _generator, double median, double sigma) -> THCSTensor& {
throw std::runtime_error("THCSTensor::cauchy() not supported");
}
template<>
auto THCSTensor<real>::logNormal(const Generator& _generator, double mean, double stdv) -> THCSTensor& {
throw std::runtime_error("THCSTensor::logNormal() not supported");
}
// Note: the order of *Tensor and *Prob_dist is reversed compared to
// the declarations in TH/generic/THTensorMath.h, so for instance
// the call:
// THRealTensor_multinomial(r, _generator, prob_dist, n_sample, with_replacement)
// is equivalent to `prob_dist->multinomial(r, _generator, n_sample, with_replacement)`.
// It is done this way so that the first argument can be casted onto a float tensor type.
template<>
auto THCSTensor<real>::multinomial(const Tensor& r, const Generator& _generator,
int n_sample, int with_replacement) -> THCSTensor& {
throw std::runtime_error("THCSTensor::multinomial() not supported");
}
template<>
auto THCSTensor<real>::cat(const std::vector<Tensor*>& src, int dimension) -> THCSTensor& {
throw std::runtime_error("THCSTensor::cat() not supported");

10
torch/lib/THPP/tensors/generic/THCTensor.cpp
View File

@ -59,22 +59,22 @@ auto THCTensor<real>::contiguous() const -> std::unique_ptr<Tensor> {
template<>
auto THCTensor<real>::newSelect(int dimension, long sliceIndex) const -> THCTensor* {
throw std::runtime_error("newSelect is not yet available for CUDA tensors");
}
}
template<>
auto THCTensor<real>::newNarrow(int dimension, long firstIndex, long size) const -> THCTensor* {
throw std::runtime_error("newNarrow is not yet available for CUDA tensors");
}
}
template<>
auto THCTensor<real>::newTranspose(int dimension1, int dimension2) const -> THCTensor* {
throw std::runtime_error("newTranspose is not yet available for CUDA tensors");
}
}
template<>
auto THCTensor<real>::newUnfold(int dimension, long size, long step) const -> THCTensor* {
throw std::runtime_error("newUnfold is not yet available for CUDA tensors");
}
}
template<>
int THCTensor<real>::nDim() const {
@ -272,7 +272,7 @@ auto THCTensor<real>::squeeze(const Tensor& src) -> THCTensor& {
}
template<>
auto THCTensor<real>::squeeze1d(const Tensor& src, int dimension) -> THCTensor& {
auto THCTensor<real>::squeeze(const Tensor& src, int dimension) -> THCTensor& {
auto src_raw = (dynamic_cast<const THCTensor<real>&>(src)).tensor;
THCTensor_(squeeze1d)(state, tensor, src_raw, dimension);
return *this;

10
torch/lib/THPP/tensors/generic/THSTensor.cpp
View File

@ -46,22 +46,22 @@ auto THSTensor<real>::contiguous() const -> std::unique_ptr<Tensor> {
template<>
auto THSTensor<real>::newSelect(int dimension, long sliceIndex) const -> THSTensor* {
throw std::runtime_error("newSelect is not yet available for sparse tensors");
}
}
template<>
auto THSTensor<real>::newNarrow(int dimension, long firstIndex, long size) const -> THSTensor* {
throw std::runtime_error("newNarrow is not yet available for sparse tensors");
}
}
template<>
auto THSTensor<real>::newTranspose(int dimension1, int dimension2) const -> THSTensor* {
throw std::runtime_error("newTranspose is not yet available for sparse tensors");
}
}
template<>
auto THSTensor<real>::newUnfold(int dimension, long size, long step) const -> THSTensor* {
throw std::runtime_error("newUnfold is not yet available for sparse tensors");
}
}
template<>
int THSTensor<real>::nDim() const {
@ -208,7 +208,7 @@ auto THSTensor<real>::squeeze(const Tensor& src) -> THSTensor& {
}
template<>
auto THSTensor<real>::squeeze1d(const Tensor& src, int dimension) -> THSTensor& {
auto THSTensor<real>::squeeze(const Tensor& src, int dimension) -> THSTensor& {
throw std::runtime_error("THSTensor::squeeze1d not supported");
}

10
torch/lib/THPP/tensors/generic/THTensor.cpp
View File

@ -71,22 +71,22 @@ auto THTensor<real>::contiguous() const -> std::unique_ptr<Tensor> {
template<>
auto THTensor<real>::newSelect(int dimension, long sliceIndex) const -> THTensor* {
return new THTensor(THTensor_(newSelect)(tensor, dimension, sliceIndex));
}
}
template<>
auto THTensor<real>::newNarrow(int dimension, long firstIndex, long size) const -> THTensor* {
return new THTensor(THTensor_(newNarrow)(tensor, dimension, firstIndex, size));
}
}
template<>
auto THTensor<real>::newTranspose(int dimension1, int dimension2) const -> THTensor* {
return new THTensor(THTensor_(newTranspose)(tensor, dimension1, dimension2));
}
}
template<>
auto THTensor<real>::newUnfold(int dimension, long size, long step) const -> THTensor* {
return new THTensor(THTensor_(newUnfold)(tensor, dimension, size, step));
}
}
template<>
int THTensor<real>::nDim() const {
@ -281,7 +281,7 @@ auto THTensor<real>::squeeze(const Tensor& src) -> THTensor& {
}
template<>
auto THTensor<real>::squeeze1d(const Tensor& src, int dimension) -> THTensor& {
auto THTensor<real>::squeeze(const Tensor& src, int dimension) -> THTensor& {
auto src_raw = (dynamic_cast<const THTensor<real>&>(src)).tensor;
THTensor_(squeeze1d)(tensor, src_raw, dimension);
return *this;

2
torch/lib/build_all.sh
View File

@ -114,7 +114,7 @@ CPP_FLAGS=" -std=c++11 "
build libshm
if [[ $WITH_DISTRIBUTED -eq 1 ]]; then
build gloo "-DBUILD_SHARED=1"
build gloo
build THD
fi