/usr/include/opengm/datastructures/sparsemarray/sparsemarray.hxx is in libopengm-dev 2.3.6-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | #pragma once
#ifndef OPENGM_SPARSEMARRAY
#define OPENGM_SPARSEMARRAY
#include <algorithm>
#include <iostream>
#include <map>
#include "opengm/functions/function_properties_base.hxx"
namespace opengm {
template<class T,class I,class L,class CONTAINER=std::map<I,T> >
class SparseFunction : public FunctionBase<SparseFunction<T, I, L,CONTAINER>, T, I, L> {
public:
typedef CONTAINER ContainerType;
typedef typename ContainerType::key_type KeyType;
typedef typename ContainerType::mapped_type MappedType;
typedef std::pair<KeyType,MappedType> KeyValPairType;
typedef T ValueType;
typedef I IndexType;
typedef L LabelType;
typedef typename ContainerType::const_iterator ConstContainerIteratorType;
typedef typename ContainerType::iterator ContainerIteratorType;
SparseFunction():
dimension_(0),
defaultValue_(0),
container_(),
shape_(),
strides_(){
}
//constructors
template<class SHAPE_ITERATOR>
SparseFunction(SHAPE_ITERATOR shapeBegin,SHAPE_ITERATOR shapeEnd ,const ValueType defaultValue):
dimension_(std::distance(shapeBegin,shapeEnd)),
defaultValue_(defaultValue),
container_(){
shape_.resize(dimension_);
strides_.resize(dimension_);
// compute strides
LabelType strideVal=1;
for(unsigned short dim=0;dim<dimension_;++dim){
shape_[dim]=*shapeBegin;
strides_[dim]=strideVal;
strideVal*=shape_[dim];
++shapeBegin;
}
}
size_t size()const{
size_t size =1;
for(unsigned short dim=0;dim<dimension_;++dim){
size*=static_cast<size_t>(shape_[dim]);
}
return size;
}
const ContainerType & container()const{
return container_;
}
ContainerType & container(){
return container_;
}
const size_t dimension()const{
return dimension_;
}
const LabelType shape(const IndexType i)const{
return shape_[i];
}
template<class COORDINATE_ITERATOR>
void keyToCoordinate(const KeyType key, COORDINATE_ITERATOR coordinate )const{
typedef typename std::iterator_traits<COORDINATE_ITERATOR>::value_type CoordType;
KeyType keyRest=key;
if(dimension_!=1){
for(unsigned short d=0;d<dimension_;++d){
const unsigned short dim=(dimension_-1)-d;
const KeyType c=keyRest/static_cast<KeyType>( strides_[dim] );
keyRest=keyRest-c*static_cast<KeyType>( strides_[dim] );
coordinate[dim]=static_cast<CoordType>(c);
}
}
else{
*coordinate=static_cast<CoordType>(key);
}
}
template<class COORDINATE_ITERATOR>
KeyType coordinateToKey(COORDINATE_ITERATOR coordinate)const{
KeyType key=static_cast<KeyType>(0);
for(unsigned short dim=0;dim<dimension_;++dim){
key+=strides_[dim]*static_cast<KeyType>(*coordinate);
++coordinate;
}
return key;
}
template<class COORDINATE_ITERATOR,size_t DIM>
KeyType coordinateToKeyWithDim(COORDINATE_ITERATOR coordinate )const{
KeyType key=static_cast<KeyType>(0);
for(unsigned short dim=0;dim<DIM;++dim){
key+=strides_[dim]*static_cast<KeyType>(coordinate[dim]);
}
return key;
}
template<class COORDINATE_ITERATOR>
ValueType operator()(COORDINATE_ITERATOR coordinate)const{
typedef COORDINATE_ITERATOR CoordType;
KeyType key;//=coordinateToKey(coordinate);
switch (dimension_)
{
case 1:
return valueFromKey(coordinateToKeyWithDim<CoordType,1>(coordinate));
case 2:
return valueFromKey(coordinateToKeyWithDim<CoordType,2>(coordinate));
case 3:
return valueFromKey(coordinateToKeyWithDim<CoordType,3>(coordinate));
case 4:
return valueFromKey(coordinateToKeyWithDim<CoordType,4>(coordinate));
case 5:
return valueFromKey(coordinateToKeyWithDim<CoordType,5>(coordinate));
case 6:
return valueFromKey(coordinateToKeyWithDim<CoordType,6>(coordinate));
case 7:
return valueFromKey(coordinateToKeyWithDim<CoordType,7>(coordinate));
case 8:
return valueFromKey(coordinateToKeyWithDim<CoordType,8>(coordinate));
case 9:
return valueFromKey(coordinateToKeyWithDim<CoordType,9>(coordinate));
case 10:
return valueFromKey(coordinateToKeyWithDim<CoordType,10>(coordinate));
case 11:
return valueFromKey(coordinateToKeyWithDim<CoordType,11>(coordinate));
case 12:
return valueFromKey(coordinateToKeyWithDim<CoordType,12>(coordinate));
case 13:
return valueFromKey(coordinateToKeyWithDim<CoordType,13>(coordinate));
case 14:
return valueFromKey(coordinateToKeyWithDim<CoordType,14>(coordinate));
case 15:
return valueFromKey(coordinateToKeyWithDim<CoordType,15>(coordinate));
case 16:
return valueFromKey(coordinateToKeyWithDim<CoordType,16>(coordinate));
default:
return valueFromKey(coordinateToKey(coordinate));
}
}
ValueType defaultValue()const{
return defaultValue_;
}
ValueType valueFromKey(const KeyType key)const{
ConstContainerIteratorType iter=container_.find(key);
if(iter!=container_.end()){
return iter->second;
}
else{
return defaultValue_;
}
}
template<class COORDINATE_ITERATOR>
void insert(COORDINATE_ITERATOR coordinate,const ValueType value){
container_.insert(KeyValPairType(coordinateToKey(coordinate),value));
}
private:
unsigned short dimension_;
ValueType defaultValue_;
ContainerType container_;
std::vector<LabelType> shape_;
std::vector<size_t> strides_;
};
}
#endif
|