Maps

## Detailed Description

This group contains map adaptors that are used to create "implicit" maps from other maps.

Most of them are read-only maps. They can make arithmetic and logical operations between one or two maps (negation, shifting, addition, multiplication, logical 'and', 'or', 'not' etc.) or e.g. convert a map to another one of different Value type.

The typical usage of this classes is passing implicit maps to algorithms. If a function type algorithm is called then the function type map adaptors can be used comfortable. For example let's see the usage of map adaptors with the `graphToEps()` function.

```  Color nodeColor(int deg) {
if (deg >= 2) {
return Color(0.5, 0.0, 0.5);
} else if (deg == 1) {
return Color(1.0, 0.5, 1.0);
} else {
return Color(0.0, 0.0, 0.0);
}
}

Digraph::NodeMap<int> degree_map(graph);

graphToEps(graph, "graph.eps")
.coords(coords).scaleToA4().undirected()
.nodeColors(composeMap(functorToMap(nodeColor), degree_map))
.run();
```

The `functorToMap()` function makes an `int` to `Color` map from the `nodeColor()` function. The `composeMap()` compose the `degree_map` and the previously created map. The composed map is a proper function to get the color of each node.

The usage with class type algorithms is little bit harder. In this case the function type map adaptors can not be used, because the function map adaptors give back temporary objects.

```  Digraph graph;

typedef Digraph::ArcMap<double> DoubleArcMap;
DoubleArcMap length(graph);
DoubleArcMap speed(graph);

typedef DivMap<DoubleArcMap, DoubleArcMap> TimeMap;
TimeMap time(length, speed);

Dijkstra<Digraph, TimeMap> dijkstra(graph, time);
dijkstra.run(source, target);
```

We have a length map and a maximum speed map on the arcs of a digraph. The minimum time to pass the arc can be calculated as the division of the two maps which can be done implicitly with the `DivMap` template class. We use the implicit minimum time map as the length map of the `Dijkstra` algorithm.

## Classes

class  ComposeMap< M1, M2 >
Composition of two maps. More...
class  CombineMap< M1, M2, F, V >
Combination of two maps using an STL (binary) functor. More...
class  FunctorToMap< F, K, V >
Converts an STL style (unary) functor to a map. More...
class  MapToFunctor< M >
Converts a map to an STL style (unary) functor. More...
class  ConvertMap< M, V >
Map adaptor to convert the `Value` type of a map to another type using the default conversion. More...
class  ForkMap< M1, M2 >
Applies all map setting operations to two maps. More...
Sum of two maps. More...
class  SubMap< M1, M2 >
Difference of two maps. More...
class  MulMap< M1, M2 >
Product of two maps. More...
class  DivMap< M1, M2 >
Quotient of two maps. More...
class  ShiftMap< M, C >
Shifts a map with a constant. More...
class  ShiftWriteMap< M, C >
Shifts a map with a constant (read-write version). More...
class  ScaleMap< M, C >
Scales a map with a constant. More...
class  ScaleWriteMap< M, C >
Scales a map with a constant (read-write version). More...
class  NegMap< M >
Negative of a map. More...
class  NegWriteMap< M >
Negative of a map (read-write version) More...
class  AbsMap< M >
Absolute value of a map. More...
class  AndMap< M1, M2 >
Logical 'and' of two maps. More...
class  OrMap< M1, M2 >
Logical 'or' of two maps. More...
class  NotMap< M >
Logical 'not' of a map. More...
class  NotWriteMap< M >
Logical 'not' of a map (read-write version) More...
class  EqualMap< M1, M2 >
Combination of two maps using the `==` operator. More...
class  LessMap< M1, M2 >
Combination of two maps using the `<` operator. More...

## Functions

template<typename M1 , typename M2 >
ComposeMap< M1, M2 > composeMap (const M1 &m1, const M2 &m2)
Returns a `ComposeMap` class.
template<typename M1 , typename M2 , typename F , typename V >
CombineMap< M1, M2, F, V > combineMap (const M1 &m1, const M2 &m2, const F &f)
Returns a `CombineMap` class.
template<typename K , typename V , typename F >
FunctorToMap< F, K, V > functorToMap (const F &f)
Returns a `FunctorToMap` class.
template<typename M >
MapToFunctor< M > mapToFunctor (const M &m)
Returns a `MapToFunctor` class.
template<typename V , typename M >
ConvertMap< M, V > convertMap (const M &map)
Returns a `ConvertMap` class.
template<typename M1 , typename M2 >
ForkMap< M1, M2 > forkMap (M1 &m1, M2 &m2)
Returns a `ForkMap` class.
template<typename M1 , typename M2 >
Returns an `AddMap` class.
template<typename M1 , typename M2 >
SubMap< M1, M2 > subMap (const M1 &m1, const M2 &m2)
Returns a `SubMap` class.
template<typename M1 , typename M2 >
MulMap< M1, M2 > mulMap (const M1 &m1, const M2 &m2)
Returns a `MulMap` class.
template<typename M1 , typename M2 >
DivMap< M1, M2 > divMap (const M1 &m1, const M2 &m2)
Returns a `DivMap` class.
template<typename M , typename C >
ShiftMap< M, C > shiftMap (const M &m, const C &v)
Returns a `ShiftMap` class.
template<typename M , typename C >
ShiftWriteMap< M, C > shiftWriteMap (M &m, const C &v)
Returns a `ShiftWriteMap` class.
template<typename M , typename C >
ScaleMap< M, C > scaleMap (const M &m, const C &v)
Returns a `ScaleMap` class.
template<typename M , typename C >
ScaleWriteMap< M, C > scaleWriteMap (M &m, const C &v)
Returns a `ScaleWriteMap` class.
template<typename M >
NegMap< M > negMap (const M &m)
Returns a `NegMap` class.
template<typename M >
NegWriteMap< M > negWriteMap (M &m)
Returns a `NegWriteMap` class.
template<typename M >
AbsMap< M > absMap (const M &m)
Returns an `AbsMap` class.
template<typename M1 , typename M2 >
AndMap< M1, M2 > andMap (const M1 &m1, const M2 &m2)
Returns an `AndMap` class.
template<typename M1 , typename M2 >
OrMap< M1, M2 > orMap (const M1 &m1, const M2 &m2)
Returns an `OrMap` class.
template<typename M >
NotMap< M > notMap (const M &m)
Returns a `NotMap` class.
template<typename M >
NotWriteMap< M > notWriteMap (M &m)
Returns a `NotWriteMap` class.
template<typename M1 , typename M2 >
EqualMap< M1, M2 > equalMap (const M1 &m1, const M2 &m2)
Returns an `EqualMap` class.
template<typename M1 , typename M2 >
LessMap< M1, M2 > lessMap (const M1 &m1, const M2 &m2)
Returns an `LessMap` class.

## Function Documentation

 ComposeMap< M1, M2 > composeMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns a `ComposeMap` class.

If `m1` and `m2` are maps and the `Value` type of `m2` is convertible to the `Key` of `m1`, then `composeMap(m1,m2)[x]` will be equal to `m1[m2[x]]`.

 CombineMap< M1, M2, F, V > combineMap ( const M1 & m1, const M2 & m2, const F & f ) ` [related, inherited]`

This function just returns a `CombineMap` class.

For example, if `m1` and `m2` are both maps with `double` values, then

```   combineMap(m1,m2,std::plus<double>())
```

is equivalent to

```   addMap(m1,m2)
```

This function is specialized for adaptable binary function classes and C++ functions.

 FunctorToMap< F, K, V > functorToMap ( const F & f ) ` [related, inherited]`

This function just returns a `FunctorToMap` class.

This function is specialized for adaptable binary function classes and C++ functions.

 MapToFunctor< M > mapToFunctor ( const M & m ) ` [related, inherited]`

This function just returns a `MapToFunctor` class.

 ConvertMap< M, V > convertMap ( const M & map ) ` [related, inherited]`

This function just returns a `ConvertMap` class.

 ForkMap< M1, M2 > forkMap ( M1 & m1, M2 & m2 ) ` [related, inherited]`

This function just returns a `ForkMap` class.

 AddMap< M1, M2 > addMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns an `AddMap` class.

For example, if `m1` and `m2` are both maps with `double` values, then `addMap(m1,m2)[x]` will be equal to `m1[x]+m2[x]`.

 SubMap< M1, M2 > subMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns a `SubMap` class.

For example, if `m1` and `m2` are both maps with `double` values, then `subMap(m1,m2)[x]` will be equal to `m1[x]-m2[x]`.

 MulMap< M1, M2 > mulMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns a `MulMap` class.

For example, if `m1` and `m2` are both maps with `double` values, then `mulMap(m1,m2)[x]` will be equal to `m1[x]*m2[x]`.

 DivMap< M1, M2 > divMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns a `DivMap` class.

For example, if `m1` and `m2` are both maps with `double` values, then `divMap(m1,m2)[x]` will be equal to `m1[x]/m2[x]`.

 ShiftMap< M, C > shiftMap ( const M & m, const C & v ) ` [related, inherited]`

This function just returns a `ShiftMap` class.

For example, if `m` is a map with `double` values and `v` is `double`, then `shiftMap(m,v)[x]` will be equal to `m[x]+v`.

 ShiftWriteMap< M, C > shiftWriteMap ( M & m, const C & v ) ` [related, inherited]`

This function just returns a `ShiftWriteMap` class.

For example, if `m` is a map with `double` values and `v` is `double`, then `shiftWriteMap(m,v)[x]` will be equal to `m[x]+v`. Moreover it makes also possible to write the map.

 ScaleMap< M, C > scaleMap ( const M & m, const C & v ) ` [related, inherited]`

This function just returns a `ScaleMap` class.

For example, if `m` is a map with `double` values and `v` is `double`, then `scaleMap(m,v)[x]` will be equal to `v*m[x]`.

 ScaleWriteMap< M, C > scaleWriteMap ( M & m, const C & v ) ` [related, inherited]`

This function just returns a `ScaleWriteMap` class.

For example, if `m` is a map with `double` values and `v` is `double`, then `scaleWriteMap(m,v)[x]` will be equal to `v*m[x]`. Moreover it makes also possible to write the map.

 NegMap< M > negMap ( const M & m ) ` [related, inherited]`

This function just returns a `NegMap` class.

For example, if `m` is a map with `double` values, then `negMap(m)[x]` will be equal to `-m[x]`.

 NegWriteMap< M > negWriteMap ( M & m ) ` [related, inherited]`

This function just returns a `NegWriteMap` class.

For example, if `m` is a map with `double` values, then `negWriteMap(m)[x]` will be equal to `-m[x]`. Moreover it makes also possible to write the map.

 AbsMap< M > absMap ( const M & m ) ` [related, inherited]`

This function just returns an `AbsMap` class.

For example, if `m` is a map with `double` values, then `absMap(m)[x]` will be equal to `m[x]` if it is positive or zero and `-m[x]` if `m[x]` is negative.

 AndMap< M1, M2 > andMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns an `AndMap` class.

For example, if `m1` and `m2` are both maps with `bool` values, then `andMap(m1,m2)[x]` will be equal to `m1[x]&&m2[x]`.

 OrMap< M1, M2 > orMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns an `OrMap` class.

For example, if `m1` and `m2` are both maps with `bool` values, then `orMap(m1,m2)[x]` will be equal to `m1[x]||m2[x]`.

 NotMap< M > notMap ( const M & m ) ` [related, inherited]`

This function just returns a `NotMap` class.

For example, if `m` is a map with `bool` values, then `notMap(m)[x]` will be equal to `!m[x]`.

 NotWriteMap< M > notWriteMap ( M & m ) ` [related, inherited]`

This function just returns a `NotWriteMap` class.

For example, if `m` is a map with `bool` values, then `notWriteMap(m)[x]` will be equal to `!m[x]`. Moreover it makes also possible to write the map.

 EqualMap< M1, M2 > equalMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns an `EqualMap` class.

For example, if `m1` and `m2` are maps with keys and values of the same type, then `equalMap(m1,m2)[x]` will be equal to `m1[x]==m2[x]`.

 LessMap< M1, M2 > lessMap ( const M1 & m1, const M2 & m2 ) ` [related, inherited]`

This function just returns an `LessMap` class.

For example, if `m1` and `m2` are maps with keys and values of the same type, then `lessMap(m1,m2)[x]` will be equal to `m1[x]<m2[x]`.