Permalink
Browse files

add forgotten .cpp files

  • Loading branch information...
Soeren Sonnenburg
Soeren Sonnenburg committed Sep 21, 2011
1 parent b3eccaf commit 00f777798e47982a81931c084d4cef323e11d98c
@@ -0,0 +1,115 @@
#include <shogun/preprocessor/DecompressString.h>
namespace shogun
{
/** default constructor */
template <class ST>
CDecompressString<ST>::CDecompressString() : CStringPreprocessor<ST>()
{
compressor=NULL;
}
template <class ST>
CDecompressString<ST>::CDecompressString(E_COMPRESSION_TYPE ct) : CStringPreprocessor<ST>()
{
compressor=new CCompressor(ct);
}
template <class ST>
CDecompressString<ST>::~CDecompressString()
{
delete compressor;
}
template <class ST>
bool CDecompressString<ST>::init(CFeatures* f)
{
ASSERT(f->get_feature_class()==C_STRING);
return true;
}
template <class ST>
void CDecompressString<ST>::cleanup()
{
}
template <class ST>
bool CDecompressString<ST>::load(FILE* f)
{
SG_SET_LOCALE_C;
SG_RESET_LOCALE;
return false;
}
template <class ST>
bool CDecompressString<ST>::save(FILE* f)
{
SG_SET_LOCALE_C;
SG_RESET_LOCALE;
return false;
}
template <class ST>
bool CDecompressString<ST>::apply_to_string_features(CFeatures* f)
{
int32_t i;
int32_t num_vec=((CStringFeatures<ST>*)f)->get_num_vectors();
for (i=0; i<num_vec; i++)
{
int32_t len=0;
bool free_vec;
ST* vec=((CStringFeatures<ST>*)f)->
get_feature_vector(i, len, free_vec);
ST* decompressed=apply_to_string(vec, len);
((CStringFeatures<ST>*)f)->
free_feature_vector(vec, i, free_vec);
((CStringFeatures<ST>*)f)->
cleanup_feature_vector(i);
((CStringFeatures<ST>*)f)->
set_feature_vector(i, decompressed, len);
}
return true;
}
template <class ST>
ST* CDecompressString<ST>::apply_to_string(ST* f, int32_t &len)
{
uint64_t compressed_size=((int32_t*) f)[0];
uint64_t uncompressed_size=((int32_t*) f)[1];
int32_t offs=CMath::ceil(2.0*sizeof(int32_t)/sizeof(ST));
ASSERT(uint64_t(len)==uint64_t(offs)+compressed_size);
len=uncompressed_size;
uncompressed_size*=sizeof(ST);
ST* vec=SG_MALLOC(ST, len);
compressor->decompress((uint8_t*) (&f[offs]), compressed_size,
(uint8_t*) vec, uncompressed_size);
ASSERT(uncompressed_size==((uint64_t) len)*sizeof(ST));
return vec;
}
template <class ST>
EPreprocessorType CDecompressString<ST>::get_type() const
{
return P_DECOMPRESSSTRING;
}
template class CDecompressString<bool>;
template class CDecompressString<char>;
template class CDecompressString<int8_t>;
template class CDecompressString<uint8_t>;
template class CDecompressString<int16_t>;
template class CDecompressString<uint16_t>;
template class CDecompressString<int32_t>;
template class CDecompressString<uint32_t>;
template class CDecompressString<int64_t>;
template class CDecompressString<uint64_t>;
template class CDecompressString<float32_t>;
template class CDecompressString<float64_t>;
template class CDecompressString<floatmax_t>;
}
@@ -0,0 +1,96 @@
#include <shogun/preprocessor/DimensionReductionPreprocessor.h>
#include <shogun/kernel/GaussianKernel.h>
#include <shogun/distance/EuclidianDistance.h>
using namespace shogun;
CDimensionReductionPreprocessor::CDimensionReductionPreprocessor()
: CSimplePreprocessor<float64_t>()
{
m_target_dim = 1;
m_distance = new CEuclidianDistance();
m_distance->parallel = this->parallel;
SG_REF(this->parallel);
m_kernel = new CGaussianKernel();
m_kernel->parallel = this->parallel;
SG_REF(this->parallel);
init();
}
CDimensionReductionPreprocessor::~CDimensionReductionPreprocessor()
{
delete m_distance;
SG_UNREF(this->parallel);
delete m_kernel;
SG_UNREF(this->parallel);
}
bool CDimensionReductionPreprocessor::init(CFeatures* data)
{
return true;
}
void CDimensionReductionPreprocessor::cleanup()
{
}
SGMatrix<float64_t> CDimensionReductionPreprocessor::apply_to_feature_matrix(CFeatures* features)
{
return ((CSimpleFeatures<float64_t>*)features)->get_feature_matrix();
};
SGVector<float64_t> CDimensionReductionPreprocessor::apply_to_feature_vector(SGVector<float64_t> vector)
{
return vector;
};
EPreprocessorType CDimensionReductionPreprocessor::get_type() const { return P_DIMENSIONREDUCTIONPREPROCESSOR; };
void CDimensionReductionPreprocessor::set_target_dim(int32_t dim)
{
ASSERT(dim>0 || dim==AUTO_TARGET_DIM);
m_target_dim = dim;
}
int32_t CDimensionReductionPreprocessor::get_target_dim() const
{
return m_target_dim;
}
void CDimensionReductionPreprocessor::set_distance(CDistance* distance)
{
SG_UNREF(m_distance->parallel);
SG_UNREF(m_distance);
SG_REF(distance);
m_distance = distance;
m_distance->parallel = this->parallel;
SG_REF(this->parallel);
}
void CDimensionReductionPreprocessor::set_kernel(CKernel* kernel)
{
SG_UNREF(m_kernel->parallel);
SG_UNREF(m_kernel);
SG_REF(kernel);
m_kernel = kernel;
m_kernel->parallel = this->parallel;
SG_REF(this->parallel);
}
int32_t CDimensionReductionPreprocessor::detect_dim(SGMatrix<float64_t> distance_matrix)
{
SG_NOTIMPLEMENTED;
return 0;
}
void CDimensionReductionPreprocessor::init()
{
m_parameters->add(&m_target_dim, "target_dim",
"target dimensionality of preprocessor");
m_parameters->add((CSGObject**)&m_distance, "distance",
"distance to be used for embedding");
m_parameters->add((CSGObject**)&m_kernel, "kernel",
"kernel to be used for embedding");
}
@@ -0,0 +1,101 @@
#include <shogun/preprocessor/SimplePreprocessor.h>
namespace shogun
{
template <class ST>
CSimplePreprocessor<ST>::CSimplePreprocessor() : CPreprocessor()
{
}
template<> EFeatureType CSimplePreprocessor<floatmax_t>::get_feature_type()
{
return F_LONGREAL;
}
template<> EFeatureType CSimplePreprocessor<float64_t>::get_feature_type()
{
return F_DREAL;
}
template<> EFeatureType CSimplePreprocessor<float32_t>::get_feature_type()
{
return F_SHORTREAL;
}
template<> EFeatureType CSimplePreprocessor<int16_t>::get_feature_type()
{
return F_SHORT;
}
template<> EFeatureType CSimplePreprocessor<uint16_t>::get_feature_type()
{
return F_WORD;
}
template<> EFeatureType CSimplePreprocessor<char>::get_feature_type()
{
return F_CHAR;
}
template<> EFeatureType CSimplePreprocessor<int8_t>::get_feature_type()
{
return F_CHAR;
}
template<> EFeatureType CSimplePreprocessor<uint8_t>::get_feature_type()
{
return F_BYTE;
}
template<> EFeatureType CSimplePreprocessor<int32_t>::get_feature_type()
{
return F_INT;
}
template<> EFeatureType CSimplePreprocessor<uint32_t>::get_feature_type()
{
return F_UINT;
}
template<> EFeatureType CSimplePreprocessor<int64_t>::get_feature_type()
{
return F_LONG;
}
template<> EFeatureType CSimplePreprocessor<uint64_t>::get_feature_type()
{
return F_ULONG;
}
template<> EFeatureType CSimplePreprocessor<bool>::get_feature_type()
{
return F_BOOL;
}
template <class ST>
EFeatureClass CSimplePreprocessor<ST>::get_feature_class()
{
return C_SIMPLE;
}
template <class ST>
EPreprocessorType CSimplePreprocessor<ST>::get_type() const
{
return P_UNKNOWN;
}
template class CSimplePreprocessor<bool>;
template class CSimplePreprocessor<char>;
template class CSimplePreprocessor<int8_t>;
template class CSimplePreprocessor<uint8_t>;
template class CSimplePreprocessor<int16_t>;
template class CSimplePreprocessor<uint16_t>;
template class CSimplePreprocessor<int32_t>;
template class CSimplePreprocessor<uint32_t>;
template class CSimplePreprocessor<int64_t>;
template class CSimplePreprocessor<uint64_t>;
template class CSimplePreprocessor<float32_t>;
template class CSimplePreprocessor<float64_t>;
template class CSimplePreprocessor<floatmax_t>;
}

0 comments on commit 00f7777

Please sign in to comment.