742 lines
25 KiB
C++
742 lines
25 KiB
C++
|
/*
|
||
|
|
This file is part of SECONDO.
|
||
|
|
|
||
|
|
Copyright (C) 2011, University in Hagen, Department of Computer Science,
|
||
|
|
Database Systems for New Applications.
|
||
|
|
|
||
|
|
SECONDO is free software; you can redistribute it and/or modify
|
||
|
|
it under the terms of the GNU General Public License as published by
|
||
|
|
the Free Software Foundation; either version 2 of the License, or
|
||
|
|
(at your option) any later version.
|
||
|
|
|
||
|
|
SECONDO is distributed in the hope that it will be useful,
|
||
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
GNU General Public License for more details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU General Public License
|
||
|
|
along with SECONDO; if not, write to the Free Software
|
||
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <ListUtils.h>
|
||
|
|
|
||
|
|
#include "map2.h"
|
||
|
|
#include "../sint.h"
|
||
|
|
#include "../sreal.h"
|
||
|
|
#include "../sbool.h"
|
||
|
|
#include "../sstring.h"
|
||
|
|
#include "../msint.h"
|
||
|
|
#include "../msreal.h"
|
||
|
|
#include "../msbool.h"
|
||
|
|
#include "../msstring.h"
|
||
|
|
#include "../util/parse_error.h"
|
||
|
|
#include "../util/types.h"
|
||
|
|
|
||
|
|
namespace raster2
|
||
|
|
{
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
The following declarations are used by the type mapping to check whether the
|
||
|
|
grids of the operator arguments are compatible.
|
||
|
|
|
||
|
|
*/
|
||
|
|
ListExpr map2TypeMap(ListExpr args) {
|
||
|
|
|
||
|
|
if(!nl->HasLength(args,3)){
|
||
|
|
return listutils::typeError("3 arguments expected");
|
||
|
|
}
|
||
|
|
ListExpr arg1 = nl->First(args);
|
||
|
|
ListExpr arg2 = nl->Second(args);
|
||
|
|
ListExpr arg3 = nl->Third(args);
|
||
|
|
|
||
|
|
//cout << "args = " << nl->ToString(args) << endl;
|
||
|
|
//cout << "arg1 = " << nl->ToString(arg1) << endl;
|
||
|
|
//cout << "arg2 = " << nl->ToString(arg2) << endl;
|
||
|
|
//cout << "arg3 = " << nl->ToString(arg3) << endl;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
std::string err = "raster x raster x fun expected" ;
|
||
|
|
|
||
|
|
if(!util::isSType(arg1) && !util::isMSType(arg1)){
|
||
|
|
return listutils::typeError( err
|
||
|
|
+ " (first arg is not a raster type)");
|
||
|
|
}
|
||
|
|
if(!util::isSType(arg2) && !util::isMSType(arg2)){
|
||
|
|
return listutils::typeError( err
|
||
|
|
+ " (second arg is not a raster type)");
|
||
|
|
}
|
||
|
|
if(!listutils::isMap<2>(arg3)){
|
||
|
|
return listutils::typeError( err
|
||
|
|
+ " (third arg is not a function with 2 arguments)");
|
||
|
|
}
|
||
|
|
bool static1 = util::isSType(arg1);
|
||
|
|
bool static2 = util::isSType(arg2);
|
||
|
|
|
||
|
|
// if(static1!=static2){
|
||
|
|
// return listutils::typeError("mix of static and moving "
|
||
|
|
// "rasters not allowed");
|
||
|
|
// }
|
||
|
|
|
||
|
|
std::string bt1 = util::getValueBasicType(nl->ToString(arg1));
|
||
|
|
std::string bt2 = util::getValueBasicType(nl->ToString(arg2));
|
||
|
|
|
||
|
|
ListExpr funarg1 = nl->Second(arg3);
|
||
|
|
ListExpr funarg2 = nl->Third(arg3);
|
||
|
|
ListExpr funres = nl->Fourth(arg3);
|
||
|
|
if(!listutils::isSymbol(funarg1,bt1)){
|
||
|
|
return listutils::typeError("fun argument 1 and raster 1 "
|
||
|
|
"type does not match");
|
||
|
|
}
|
||
|
|
if(!listutils::isSymbol(funarg2,bt2)){
|
||
|
|
return listutils::typeError("fun argument 2 and raster 2 "
|
||
|
|
"type does not match");
|
||
|
|
}
|
||
|
|
std::string restype="";
|
||
|
|
if(static1 && static2){
|
||
|
|
restype=util::getSpatialBasicType(nl->ToString(funres));
|
||
|
|
} else {
|
||
|
|
restype = util::getMovingSpatialBasicType(nl->ToString(funres));
|
||
|
|
}
|
||
|
|
if(restype==""){
|
||
|
|
return listutils::typeError("Functionresult does not corresponds"
|
||
|
|
" to a raster type");
|
||
|
|
}
|
||
|
|
return nl->SymbolAtom(restype);
|
||
|
|
}
|
||
|
|
|
||
|
|
int map2SelectFun(ListExpr args) {
|
||
|
|
int offset = 0;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
NList types(args);
|
||
|
|
std::string first = types.first().str();
|
||
|
|
std::string second = types.second().str();
|
||
|
|
std::string result = types.third().fourth().str();
|
||
|
|
|
||
|
|
std::string idf = first.substr(first.length()-2, 2);
|
||
|
|
std::string ids = second.substr(second.length()-2, 2);
|
||
|
|
std::string idr = result.substr(result.length()-2, 2);
|
||
|
|
|
||
|
|
if (idf == "nt") i = 0;
|
||
|
|
else if (idf == "ol") i = 1;
|
||
|
|
else if (idf == "al") i = 2;
|
||
|
|
else i = 3;
|
||
|
|
offset += util::isSType(first) ? 32 * i : 32 * i + 128;
|
||
|
|
|
||
|
|
if (ids == "nt") i = 0;
|
||
|
|
else if (ids == "ol") i = 1;
|
||
|
|
else if (ids == "al") i = 2;
|
||
|
|
else i = 3;
|
||
|
|
offset += util::isSType(second) ? 4 * i : 4 * i + 16;
|
||
|
|
|
||
|
|
if (idr == "nt") i = 0;
|
||
|
|
else if (idr == "ol") i = 1;
|
||
|
|
else if (idr == "al") i = 2;
|
||
|
|
else i = 3;
|
||
|
|
offset += i;
|
||
|
|
|
||
|
|
return offset;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename S1, typename S2, typename Result>
|
||
|
|
int map2FunSS(Word* args, Word& result, int message, Word& local, Supplier s)
|
||
|
|
{
|
||
|
|
result = qp->ResultStorage(s);
|
||
|
|
|
||
|
|
S1* s1 = static_cast<S1*>(args[0].addr);
|
||
|
|
S2* s2 = static_cast<S2*>(args[1].addr);
|
||
|
|
Address function = args[2].addr;
|
||
|
|
Result* r = static_cast<Result*>(result.addr);
|
||
|
|
|
||
|
|
if(!s1->isDefined() || !s2->isDefined()){
|
||
|
|
r->setDefined(false);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
grid2 g1 = s1->getGrid();
|
||
|
|
grid2 g2 = s2->getGrid();
|
||
|
|
|
||
|
|
if(!g1.matches(g2)){
|
||
|
|
r->setDefined(false);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
r->clear();
|
||
|
|
|
||
|
|
|
||
|
|
double dx = (g1.getOriginX() - g2.getOriginX()) / g1.getLength();
|
||
|
|
double dy = (g1.getOriginY() - g2.getOriginY()) / g1.getLength();
|
||
|
|
int dc = dx + 0.5;
|
||
|
|
int dr = dy + 0.5;
|
||
|
|
assert(g1.getLength() == g2.getLength());
|
||
|
|
assert(AlmostEqual(dx, dc) && AlmostEqual(dy, dr));
|
||
|
|
|
||
|
|
BBox<2> bb1 = s1->bbox();
|
||
|
|
BBox<2> bb2 = s2->bbox();
|
||
|
|
|
||
|
|
BBox<2> bb = bb1.Union(bb2);
|
||
|
|
|
||
|
|
r->setGrid(g1);
|
||
|
|
|
||
|
|
ArgVector& arguments = *qp->Argument(function);
|
||
|
|
Word fresult;
|
||
|
|
|
||
|
|
// Determine the first and last region of concern.
|
||
|
|
const typename S1::index_type& region_size = S1::riter_type::region_size;
|
||
|
|
typename S1::index_type from = g1.getIndex(bb.MinD(0), bb.MinD(1));
|
||
|
|
typename S1::index_type to = g1.getIndex(bb.MaxD(0), bb.MaxD(1));
|
||
|
|
|
||
|
|
// Iterate over regions in the first argument.
|
||
|
|
for (typename S1::riter_type rit = s1->iterate_regions(from, to),
|
||
|
|
re = s1->end_regions();
|
||
|
|
rit != re; ++rit)
|
||
|
|
{
|
||
|
|
typename S1::index_type rfrom = *rit;
|
||
|
|
typename S1::index_type rto = *rit + region_size;
|
||
|
|
|
||
|
|
// Iterate over the cells in the current region.
|
||
|
|
for (typename S1::index_type i1 = rfrom, e = rto;
|
||
|
|
i1 != e; i1.increment(rfrom, rto))
|
||
|
|
{
|
||
|
|
// Calculate the corresponding cell in the second argument
|
||
|
|
typename S2::index_type i2 = (int[]){i1[0] + dc, i1[1] + dr};
|
||
|
|
if (!S1::isUndefined(s1->get(i1)) || !S2::isUndefined(s2->get(i2)))
|
||
|
|
{
|
||
|
|
typename S1::wrapper_type w1 = S1::wrap(s1->get(i1));
|
||
|
|
typename S2::wrapper_type w2 = S2::wrap(s2->get(i2));
|
||
|
|
|
||
|
|
// Apply function
|
||
|
|
arguments[0].setAddr(&w1);
|
||
|
|
arguments[1].setAddr(&w2);
|
||
|
|
qp->Request(function, fresult);
|
||
|
|
|
||
|
|
// Set result
|
||
|
|
typename Result::wrapper_type* mapped =
|
||
|
|
static_cast<typename Result::wrapper_type*>(fresult.addr);
|
||
|
|
r->set(i1, Result::unwrap(*mapped));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename S, typename M, typename Result>
|
||
|
|
int map2FunSM(Word* args, Word& result, int message, Word& local, Supplier s)
|
||
|
|
{
|
||
|
|
result = qp->ResultStorage(s);
|
||
|
|
|
||
|
|
S* sobj = static_cast<S*>(args[0].addr);
|
||
|
|
M* mobj = static_cast<M*>(args[1].addr);
|
||
|
|
Address function = args[2].addr;
|
||
|
|
Result* r = static_cast<Result*>(result.addr);
|
||
|
|
|
||
|
|
grid2 g1 = sobj->getGrid();
|
||
|
|
grid3 g2 = mobj->getGrid();
|
||
|
|
|
||
|
|
if(!g2.matches(g1)){
|
||
|
|
r->setDefined(false);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
r->clear();
|
||
|
|
|
||
|
|
double dx = (g1.getOriginX() - g2.getOriginX()) / g1.getLength();
|
||
|
|
double dy = (g1.getOriginY() - g2.getOriginY()) / g1.getLength();
|
||
|
|
int dc = dx + 0.5;
|
||
|
|
int dr = dy + 0.5;
|
||
|
|
assert(g1.getLength() == g2.getLength());
|
||
|
|
assert(AlmostEqual(dx, dc) && AlmostEqual(dy, dr));
|
||
|
|
|
||
|
|
BBox<2> bbs = sobj->bbox();
|
||
|
|
BBox<3> bbm = mobj->bbox();
|
||
|
|
double minMax[] = {bbm.MinD(0), bbm.MaxD(0), bbm.MinD(1), bbm.MaxD(1)};
|
||
|
|
BBox<2> bbm_proj(true,minMax );
|
||
|
|
BBox<2> bb = bbs.Union(bbm_proj);
|
||
|
|
|
||
|
|
r->setGrid(g2);
|
||
|
|
|
||
|
|
ArgVector& arguments = *qp->Argument(function);
|
||
|
|
Word fresult;
|
||
|
|
|
||
|
|
// Determine the first and last region of concern.
|
||
|
|
const typename M::index_type& region_size = M::riter_type::region_size;
|
||
|
|
typename M::index_type from = g2.getIndex(
|
||
|
|
bb.MinD(0), bb.MinD(1), bb.MinD(2));
|
||
|
|
typename M::index_type to = g2.getIndex(
|
||
|
|
bb.MaxD(0), bb.MaxD(1), bb.MaxD(2));
|
||
|
|
|
||
|
|
// Iterate over regions in the moving spatial argument.
|
||
|
|
for (typename M::riter_type rit = mobj->iterate_regions(from, to),
|
||
|
|
re = mobj->end_regions();
|
||
|
|
rit != re; ++rit)
|
||
|
|
{
|
||
|
|
typename M::index_type rfrom = *rit;
|
||
|
|
typename M::index_type rto = *rit + region_size;
|
||
|
|
|
||
|
|
// Iterate over the cells in the current region.
|
||
|
|
for (typename M::index_type i1 = rfrom, e = rto;
|
||
|
|
i1 != e; i1.increment(rfrom, rto))
|
||
|
|
{
|
||
|
|
// Calculate the corresponding cell in the second argument
|
||
|
|
typename S::index_type i2 = (int[]){i1[0] + dc, i1[1] + dr};
|
||
|
|
if (!M::isUndefined(mobj->get(i1)) || !S::isUndefined(sobj->get(i2)))
|
||
|
|
{
|
||
|
|
typename S::wrapper_type w1 = S::wrap(sobj->get(i2));
|
||
|
|
typename M::wrapper_type w2 = M::wrap(mobj->get(i1));
|
||
|
|
|
||
|
|
// Apply function
|
||
|
|
arguments[0].setAddr(&w1);
|
||
|
|
arguments[1].setAddr(&w2);
|
||
|
|
qp->Request(function, fresult);
|
||
|
|
|
||
|
|
// Set result
|
||
|
|
typename Result::wrapper_type& mapped =
|
||
|
|
*static_cast<typename Result::wrapper_type*>(result.addr);
|
||
|
|
r->set(i1, Result::unwrap(mapped));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename M, typename S, typename Result>
|
||
|
|
int map2FunMS(Word* args, Word& result, int message, Word& local, Supplier s)
|
||
|
|
{
|
||
|
|
result = qp->ResultStorage(s);
|
||
|
|
|
||
|
|
M* mobj = static_cast<M*>(args[0].addr);
|
||
|
|
S* sobj = static_cast<S*>(args[1].addr);
|
||
|
|
Address function = args[2].addr;
|
||
|
|
Result* r = static_cast<Result*>(result.addr);
|
||
|
|
|
||
|
|
grid3 g1 = mobj->getGrid();
|
||
|
|
grid2 g2 = sobj->getGrid();
|
||
|
|
|
||
|
|
if(!g1.matches(g2)){
|
||
|
|
r->setDefined(false);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
r->clear();
|
||
|
|
|
||
|
|
|
||
|
|
double dx = (g1.getOriginX() - g2.getOriginX()) / g1.getLength();
|
||
|
|
double dy = (g1.getOriginY() - g2.getOriginY()) / g1.getLength();
|
||
|
|
int dc = dx + 0.5;
|
||
|
|
int dr = dy + 0.5;
|
||
|
|
assert(g1.getLength() == g2.getLength());
|
||
|
|
assert(AlmostEqual(dx, dc) && AlmostEqual(dy, dr));
|
||
|
|
|
||
|
|
BBox<3> bbm = mobj->bbox();
|
||
|
|
BBox<2> bbs = sobj->bbox();
|
||
|
|
double minMax[] = {bbm.MinD(0), bbm.MaxD(0), bbm.MinD(1), bbm.MaxD(1)};
|
||
|
|
BBox<2> bbm_proj(true,minMax );
|
||
|
|
BBox<2> bb = bbs.Union(bbm_proj);
|
||
|
|
|
||
|
|
r->setGrid(g1);
|
||
|
|
|
||
|
|
ArgVector& arguments = *qp->Argument(function);
|
||
|
|
Word fresult;
|
||
|
|
|
||
|
|
// Determine the first and last region of concern.
|
||
|
|
const typename M::index_type& region_size = M::riter_type::region_size;
|
||
|
|
typename M::index_type from = g1.getIndex(
|
||
|
|
bb.MinD(0), bb.MinD(1), bb.MinD(2));
|
||
|
|
typename M::index_type to = g1.getIndex(
|
||
|
|
bb.MaxD(0), bb.MaxD(1), bb.MaxD(2));
|
||
|
|
|
||
|
|
// Iterate over regions in the moving spatial argument.
|
||
|
|
for (typename M::riter_type rit = mobj->iterate_regions(from, to),
|
||
|
|
re = mobj->end_regions();
|
||
|
|
rit != re; ++rit)
|
||
|
|
{
|
||
|
|
typename M::index_type rfrom = *rit;
|
||
|
|
typename M::index_type rto = *rit + region_size;
|
||
|
|
|
||
|
|
// Iterate over the cells in the current region.
|
||
|
|
for (typename M::index_type i1 = rfrom, e = rto;
|
||
|
|
i1 != e; i1.increment(rfrom, rto))
|
||
|
|
{
|
||
|
|
// Calculate the corresponding cell in the second argument
|
||
|
|
typename S::index_type i2 = (int[]){i1[0] + dc, i1[1] + dr};
|
||
|
|
if (!M::isUndefined(mobj->get(i1)) || !S::isUndefined(sobj->get(i2)))
|
||
|
|
{
|
||
|
|
typename M::wrapper_type w1 = M::wrap(mobj->get(i1));
|
||
|
|
typename S::wrapper_type w2 = S::wrap(sobj->get(i2));
|
||
|
|
|
||
|
|
// Apply function
|
||
|
|
arguments[0].setAddr(&w1);
|
||
|
|
arguments[1].setAddr(&w2);
|
||
|
|
qp->Request(function, fresult);
|
||
|
|
|
||
|
|
// Set result
|
||
|
|
typename Result::wrapper_type& mapped =
|
||
|
|
*static_cast<typename Result::wrapper_type*>(result.addr);
|
||
|
|
r->set(i1, Result::unwrap(mapped));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename M1, typename M2, typename Result>
|
||
|
|
int map2FunMM(Word* args, Word& result, int message, Word& local, Supplier s)
|
||
|
|
{
|
||
|
|
result = qp->ResultStorage(s);
|
||
|
|
|
||
|
|
M1* m1 = static_cast<M1*>(args[0].addr);
|
||
|
|
M2* m2 = static_cast<M2*>(args[1].addr);
|
||
|
|
Address function = args[2].addr;
|
||
|
|
Result* r = static_cast<Result*>(result.addr);
|
||
|
|
|
||
|
|
grid3 g1 = m1->getGrid();
|
||
|
|
grid3 g2 = m2->getGrid();
|
||
|
|
|
||
|
|
if(!g1.matches(g2)){
|
||
|
|
r->setDefined(false);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
r->clear();
|
||
|
|
|
||
|
|
double dx = (g1.getOriginX() - g2.getOriginX()) / g1.getLength();
|
||
|
|
double dy = (g1.getOriginY() - g2.getOriginY()) / g1.getLength();
|
||
|
|
int dc = dx + 0.5;
|
||
|
|
int dr = dy + 0.5;
|
||
|
|
assert(g1.getLength() == g2.getLength());
|
||
|
|
assert(AlmostEqual(dx, dc) && AlmostEqual(dy, dr));
|
||
|
|
|
||
|
|
// If one value is undefined, the mapped value is undefined. This means we
|
||
|
|
// only need to consider the intersection of the two bounding boxes.
|
||
|
|
BBox<3> bb1 = m1->bbox();
|
||
|
|
BBox<3> bb2 = m2->bbox();
|
||
|
|
|
||
|
|
BBox<3> bb = bb1.Union(bb2);
|
||
|
|
|
||
|
|
// If the intersection of the bboxes is empty, we are done.
|
||
|
|
if (bb.IsDefined()) {
|
||
|
|
r->setGrid(g1);
|
||
|
|
|
||
|
|
ArgVector& arguments = *qp->Argument(function);
|
||
|
|
Word result;
|
||
|
|
|
||
|
|
// Determine the first and last region of concern.
|
||
|
|
const typename M1::index_type& region_size
|
||
|
|
= M1::riter_type::region_size;
|
||
|
|
typename M1::index_type from
|
||
|
|
= g1.getIndex(bb.MinD(0), bb.MinD(1), bb.MinD(2));
|
||
|
|
typename M1::index_type to
|
||
|
|
= g1.getIndex(bb.MaxD(0), bb.MaxD(1), bb.MaxD(2));
|
||
|
|
|
||
|
|
// Iterate over regions in the first argument.
|
||
|
|
for (typename M1::riter_type rit = m1->iterate_regions(from, to),
|
||
|
|
re = m1->end_regions();
|
||
|
|
rit != re; ++rit)
|
||
|
|
{
|
||
|
|
typename M1::index_type rfrom = *rit;
|
||
|
|
typename M1::index_type rto = *rit + region_size;
|
||
|
|
|
||
|
|
// Iterate over the cells in the current region.
|
||
|
|
for (typename M1::index_type i1 = rfrom, e = rto;
|
||
|
|
i1 != e; i1.increment(rfrom, rto))
|
||
|
|
{
|
||
|
|
// Calculate the corresponding cell in the second argument and check
|
||
|
|
// whether both have defined values
|
||
|
|
typename M2::index_type i2 = (int[]){i1[0] + dc, i1[1] + dr, i1[2]};
|
||
|
|
if (!M1::isUndefined(m1->get(i1)) || !M2::isUndefined(m2->get(i2)))
|
||
|
|
{
|
||
|
|
typename M1::wrapper_type w1 = M1::wrap(m1->get(i1));
|
||
|
|
typename M2::wrapper_type w2 = M2::wrap(m2->get(i2));
|
||
|
|
|
||
|
|
arguments[0].setAddr(&w1);
|
||
|
|
arguments[1].setAddr(&w2);
|
||
|
|
qp->Request(function, result);
|
||
|
|
|
||
|
|
typename Result::wrapper_type& mapped =
|
||
|
|
*static_cast<typename Result::wrapper_type*>(result.addr);
|
||
|
|
r->set(i1, Result::unwrap(mapped));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
ValueMapping map2Funs[] = {
|
||
|
|
map2FunSS<sint, sint, sint>,
|
||
|
|
map2FunSS<sint, sint, sbool>,
|
||
|
|
map2FunSS<sint, sint, sreal>,
|
||
|
|
map2FunSS<sint, sint, sstring>,
|
||
|
|
map2FunSS<sint, sbool, sint>,
|
||
|
|
map2FunSS<sint, sbool, sbool>,
|
||
|
|
map2FunSS<sint, sbool, sreal>,
|
||
|
|
map2FunSS<sint, sbool, sstring>,
|
||
|
|
map2FunSS<sint, sreal, sint>,
|
||
|
|
map2FunSS<sint, sreal, sbool>,
|
||
|
|
map2FunSS<sint, sreal, sreal>,
|
||
|
|
map2FunSS<sint, sreal, sstring>,
|
||
|
|
map2FunSS<sint, sstring, sint>,
|
||
|
|
map2FunSS<sint, sstring, sbool>,
|
||
|
|
map2FunSS<sint, sstring, sreal>,
|
||
|
|
map2FunSS<sint, sstring, sstring>,
|
||
|
|
map2FunSM<sint, msint, msint>,
|
||
|
|
map2FunSM<sint, msint, msbool>,
|
||
|
|
map2FunSM<sint, msint, msreal>,
|
||
|
|
map2FunSM<sint, msint, msstring>,
|
||
|
|
map2FunSM<sint, msbool, msint>,
|
||
|
|
map2FunSM<sint, msbool, msbool>,
|
||
|
|
map2FunSM<sint, msbool, msreal>,
|
||
|
|
map2FunSM<sint, msbool, msstring>,
|
||
|
|
map2FunSM<sint, msreal, msint>,
|
||
|
|
map2FunSM<sint, msreal, msbool>,
|
||
|
|
map2FunSM<sint, msreal, msreal>,
|
||
|
|
map2FunSM<sint, msreal, msstring>,
|
||
|
|
map2FunSM<sint, msstring, msint>,
|
||
|
|
map2FunSM<sint, msstring, msbool>,
|
||
|
|
map2FunSM<sint, msstring, msreal>,
|
||
|
|
map2FunSM<sint, msstring, msstring>,
|
||
|
|
|
||
|
|
map2FunSS<sbool, sint, sint>,
|
||
|
|
map2FunSS<sbool, sint, sbool>,
|
||
|
|
map2FunSS<sbool, sint, sreal>,
|
||
|
|
map2FunSS<sbool, sint, sstring>,
|
||
|
|
map2FunSS<sbool, sbool, sint>,
|
||
|
|
map2FunSS<sbool, sbool, sbool>,
|
||
|
|
map2FunSS<sbool, sbool, sreal>,
|
||
|
|
map2FunSS<sbool, sbool, sstring>,
|
||
|
|
map2FunSS<sbool, sreal, sint>,
|
||
|
|
map2FunSS<sbool, sreal, sbool>,
|
||
|
|
map2FunSS<sbool, sreal, sreal>,
|
||
|
|
map2FunSS<sbool, sreal, sstring>,
|
||
|
|
map2FunSS<sbool, sstring, sint>,
|
||
|
|
map2FunSS<sbool, sstring, sbool>,
|
||
|
|
map2FunSS<sbool, sstring, sreal>,
|
||
|
|
map2FunSS<sbool, sstring, sstring>,
|
||
|
|
map2FunSM<sbool, msint, msint>,
|
||
|
|
map2FunSM<sbool, msint, msbool>,
|
||
|
|
map2FunSM<sbool, msint, msreal>,
|
||
|
|
map2FunSM<sbool, msint, msstring>,
|
||
|
|
map2FunSM<sbool, msbool, msint>,
|
||
|
|
map2FunSM<sbool, msbool, msbool>,
|
||
|
|
map2FunSM<sbool, msbool, msreal>,
|
||
|
|
map2FunSM<sbool, msbool, msstring>,
|
||
|
|
map2FunSM<sbool, msreal, msint>,
|
||
|
|
map2FunSM<sbool, msreal, msbool>,
|
||
|
|
map2FunSM<sbool, msreal, msreal>,
|
||
|
|
map2FunSM<sbool, msreal, msstring>,
|
||
|
|
map2FunSM<sbool, msstring, msint>,
|
||
|
|
map2FunSM<sbool, msstring, msbool>,
|
||
|
|
map2FunSM<sbool, msstring, msreal>,
|
||
|
|
map2FunSM<sbool, msstring, msstring>,
|
||
|
|
|
||
|
|
map2FunSS<sreal, sint, sint>,
|
||
|
|
map2FunSS<sreal, sint, sbool>,
|
||
|
|
map2FunSS<sreal, sint, sreal>,
|
||
|
|
map2FunSS<sreal, sint, sstring>,
|
||
|
|
map2FunSS<sreal, sbool, sint>,
|
||
|
|
map2FunSS<sreal, sbool, sbool>,
|
||
|
|
map2FunSS<sreal, sbool, sreal>,
|
||
|
|
map2FunSS<sreal, sbool, sstring>,
|
||
|
|
map2FunSS<sreal, sreal, sint>,
|
||
|
|
map2FunSS<sreal, sreal, sbool>,
|
||
|
|
map2FunSS<sreal, sreal, sreal>,
|
||
|
|
map2FunSS<sreal, sreal, sstring>,
|
||
|
|
map2FunSS<sreal, sstring, sint>,
|
||
|
|
map2FunSS<sreal, sstring, sbool>,
|
||
|
|
map2FunSS<sreal, sstring, sreal>,
|
||
|
|
map2FunSS<sreal, sstring, sstring>,
|
||
|
|
map2FunSM<sreal, msint, msint>,
|
||
|
|
map2FunSM<sreal, msint, msbool>,
|
||
|
|
map2FunSM<sreal, msint, msreal>,
|
||
|
|
map2FunSM<sreal, msint, msstring>,
|
||
|
|
map2FunSM<sreal, msbool, msint>,
|
||
|
|
map2FunSM<sreal, msbool, msbool>,
|
||
|
|
map2FunSM<sreal, msbool, msreal>,
|
||
|
|
map2FunSM<sreal, msbool, msstring>,
|
||
|
|
map2FunSM<sreal, msreal, msint>,
|
||
|
|
map2FunSM<sreal, msreal, msbool>,
|
||
|
|
map2FunSM<sreal, msreal, msreal>,
|
||
|
|
map2FunSM<sreal, msreal, msstring>,
|
||
|
|
map2FunSM<sreal, msstring, msint>,
|
||
|
|
map2FunSM<sreal, msstring, msbool>,
|
||
|
|
map2FunSM<sreal, msstring, msreal>,
|
||
|
|
map2FunSM<sreal, msstring, msstring>,
|
||
|
|
|
||
|
|
map2FunSS<sstring, sint, sint>,
|
||
|
|
map2FunSS<sstring, sint, sbool>,
|
||
|
|
map2FunSS<sstring, sint, sreal>,
|
||
|
|
map2FunSS<sstring, sint, sstring>,
|
||
|
|
map2FunSS<sstring, sbool, sint>,
|
||
|
|
map2FunSS<sstring, sbool, sbool>,
|
||
|
|
map2FunSS<sstring, sbool, sreal>,
|
||
|
|
map2FunSS<sstring, sbool, sstring>,
|
||
|
|
map2FunSS<sstring, sreal, sint>,
|
||
|
|
map2FunSS<sstring, sreal, sbool>,
|
||
|
|
map2FunSS<sstring, sreal, sreal>,
|
||
|
|
map2FunSS<sstring, sreal, sstring>,
|
||
|
|
map2FunSS<sstring, sstring, sint>,
|
||
|
|
map2FunSS<sstring, sstring, sbool>,
|
||
|
|
map2FunSS<sstring, sstring, sreal>,
|
||
|
|
map2FunSS<sstring, sstring, sstring>,
|
||
|
|
map2FunSM<sstring, msint, msint>,
|
||
|
|
map2FunSM<sstring, msint, msbool>,
|
||
|
|
map2FunSM<sstring, msint, msreal>,
|
||
|
|
map2FunSM<sstring, msint, msstring>,
|
||
|
|
map2FunSM<sstring, msbool, msint>,
|
||
|
|
map2FunSM<sstring, msbool, msbool>,
|
||
|
|
map2FunSM<sstring, msbool, msreal>,
|
||
|
|
map2FunSM<sstring, msbool, msstring>,
|
||
|
|
map2FunSM<sstring, msreal, msint>,
|
||
|
|
map2FunSM<sstring, msreal, msbool>,
|
||
|
|
map2FunSM<sstring, msreal, msreal>,
|
||
|
|
map2FunSM<sstring, msreal, msstring>,
|
||
|
|
map2FunSM<sstring, msstring, msint>,
|
||
|
|
map2FunSM<sstring, msstring, msbool>,
|
||
|
|
map2FunSM<sstring, msstring, msreal>,
|
||
|
|
map2FunSM<sstring, msstring, msstring>,
|
||
|
|
|
||
|
|
map2FunMS<msint, sint, msint>,
|
||
|
|
map2FunMS<msint, sint, msbool>,
|
||
|
|
map2FunMS<msint, sint, msreal>,
|
||
|
|
map2FunMS<msint, sint, msstring>,
|
||
|
|
map2FunMS<msint, sbool, msint>,
|
||
|
|
map2FunMS<msint, sbool, msbool>,
|
||
|
|
map2FunMS<msint, sbool, msreal>,
|
||
|
|
map2FunMS<msint, sbool, msstring>,
|
||
|
|
map2FunMS<msint, sreal, msint>,
|
||
|
|
map2FunMS<msint, sreal, msbool>,
|
||
|
|
map2FunMS<msint, sreal, msreal>,
|
||
|
|
map2FunMS<msint, sreal, msstring>,
|
||
|
|
map2FunMS<msint, sstring, msint>,
|
||
|
|
map2FunMS<msint, sstring, msbool>,
|
||
|
|
map2FunMS<msint, sstring, msreal>,
|
||
|
|
map2FunMS<msint, sstring, msstring>,
|
||
|
|
map2FunMM<msint, msint, msint>,
|
||
|
|
map2FunMM<msint, msint, msbool>,
|
||
|
|
map2FunMM<msint, msint, msreal>,
|
||
|
|
map2FunMM<msint, msint, msstring>,
|
||
|
|
map2FunMM<msint, msbool, msint>,
|
||
|
|
map2FunMM<msint, msbool, msbool>,
|
||
|
|
map2FunMM<msint, msbool, msreal>,
|
||
|
|
map2FunMM<msint, msbool, msstring>,
|
||
|
|
map2FunMM<msint, msreal, msint>,
|
||
|
|
map2FunMM<msint, msreal, msbool>,
|
||
|
|
map2FunMM<msint, msreal, msreal>,
|
||
|
|
map2FunMM<msint, msreal, msstring>,
|
||
|
|
map2FunMM<msint, msstring, msint>,
|
||
|
|
map2FunMM<msint, msstring, msbool>,
|
||
|
|
map2FunMM<msint, msstring, msreal>,
|
||
|
|
map2FunMM<msint, msstring, msstring>,
|
||
|
|
|
||
|
|
map2FunMS<msbool, sint, msint>,
|
||
|
|
map2FunMS<msbool, sint, msbool>,
|
||
|
|
map2FunMS<msbool, sint, msreal>,
|
||
|
|
map2FunMS<msbool, sint, msstring>,
|
||
|
|
map2FunMS<msbool, sbool, msint>,
|
||
|
|
map2FunMS<msbool, sbool, msbool>,
|
||
|
|
map2FunMS<msbool, sbool, msreal>,
|
||
|
|
map2FunMS<msbool, sbool, msstring>,
|
||
|
|
map2FunMS<msbool, sreal, msint>,
|
||
|
|
map2FunMS<msbool, sreal, msbool>,
|
||
|
|
map2FunMS<msbool, sreal, msreal>,
|
||
|
|
map2FunMS<msbool, sreal, msstring>,
|
||
|
|
map2FunMS<msbool, sstring, msint>,
|
||
|
|
map2FunMS<msbool, sstring, msbool>,
|
||
|
|
map2FunMS<msbool, sstring, msreal>,
|
||
|
|
map2FunMS<msbool, sstring, msstring>,
|
||
|
|
map2FunMM<msbool, msint, msint>,
|
||
|
|
map2FunMM<msbool, msint, msbool>,
|
||
|
|
map2FunMM<msbool, msint, msreal>,
|
||
|
|
map2FunMM<msbool, msint, msstring>,
|
||
|
|
map2FunMM<msbool, msbool, msint>,
|
||
|
|
map2FunMM<msbool, msbool, msbool>,
|
||
|
|
map2FunMM<msbool, msbool, msreal>,
|
||
|
|
map2FunMM<msbool, msbool, msstring>,
|
||
|
|
map2FunMM<msbool, msreal, msint>,
|
||
|
|
map2FunMM<msbool, msreal, msbool>,
|
||
|
|
map2FunMM<msbool, msreal, msreal>,
|
||
|
|
map2FunMM<msbool, msreal, msstring>,
|
||
|
|
map2FunMM<msbool, msstring, msint>,
|
||
|
|
map2FunMM<msbool, msstring, msbool>,
|
||
|
|
map2FunMM<msbool, msstring, msreal>,
|
||
|
|
map2FunMM<msbool, msstring, msstring>,
|
||
|
|
|
||
|
|
map2FunMS<msreal, sint, msint>,
|
||
|
|
map2FunMS<msreal, sint, msbool>,
|
||
|
|
map2FunMS<msreal, sint, msreal>,
|
||
|
|
map2FunMS<msreal, sint, msstring>,
|
||
|
|
map2FunMS<msreal, sbool, msint>,
|
||
|
|
map2FunMS<msreal, sbool, msbool>,
|
||
|
|
map2FunMS<msreal, sbool, msreal>,
|
||
|
|
map2FunMS<msreal, sbool, msstring>,
|
||
|
|
map2FunMS<msreal, sreal, msint>,
|
||
|
|
map2FunMS<msreal, sreal, msbool>,
|
||
|
|
map2FunMS<msreal, sreal, msreal>,
|
||
|
|
map2FunMS<msreal, sreal, msstring>,
|
||
|
|
map2FunMS<msreal, sstring, msint>,
|
||
|
|
map2FunMS<msreal, sstring, msbool>,
|
||
|
|
map2FunMS<msreal, sstring, msreal>,
|
||
|
|
map2FunMS<msreal, sstring, msstring>,
|
||
|
|
map2FunMM<msreal, msint, msint>,
|
||
|
|
map2FunMM<msreal, msint, msbool>,
|
||
|
|
map2FunMM<msreal, msint, msreal>,
|
||
|
|
map2FunMM<msreal, msint, msstring>,
|
||
|
|
map2FunMM<msreal, msbool, msint>,
|
||
|
|
map2FunMM<msreal, msbool, msbool>,
|
||
|
|
map2FunMM<msreal, msbool, msreal>,
|
||
|
|
map2FunMM<msreal, msbool, msstring>,
|
||
|
|
map2FunMM<msreal, msreal, msint>,
|
||
|
|
map2FunMM<msreal, msreal, msbool>,
|
||
|
|
map2FunMM<msreal, msreal, msreal>,
|
||
|
|
map2FunMM<msreal, msreal, msstring>,
|
||
|
|
map2FunMM<msreal, msstring, msint>,
|
||
|
|
map2FunMM<msreal, msstring, msbool>,
|
||
|
|
map2FunMM<msreal, msstring, msreal>,
|
||
|
|
map2FunMM<msreal, msstring, msstring>,
|
||
|
|
|
||
|
|
map2FunMS<msstring, sint, msint>,
|
||
|
|
map2FunMS<msstring, sint, msbool>,
|
||
|
|
map2FunMS<msstring, sint, msreal>,
|
||
|
|
map2FunMS<msstring, sint, msstring>,
|
||
|
|
map2FunMS<msstring, sbool, msint>,
|
||
|
|
map2FunMS<msstring, sbool, msbool>,
|
||
|
|
map2FunMS<msstring, sbool, msreal>,
|
||
|
|
map2FunMS<msstring, sbool, msstring>,
|
||
|
|
map2FunMS<msstring, sreal, msint>,
|
||
|
|
map2FunMS<msstring, sreal, msbool>,
|
||
|
|
map2FunMS<msstring, sreal, msreal>,
|
||
|
|
map2FunMS<msstring, sreal, msstring>,
|
||
|
|
map2FunMS<msstring, sstring, msint>,
|
||
|
|
map2FunMS<msstring, sstring, msbool>,
|
||
|
|
map2FunMS<msstring, sstring, msreal>,
|
||
|
|
map2FunMS<msstring, sstring, msstring>,
|
||
|
|
map2FunMM<msstring, msint, msint>,
|
||
|
|
map2FunMM<msstring, msint, msbool>,
|
||
|
|
map2FunMM<msstring, msint, msreal>,
|
||
|
|
map2FunMM<msstring, msint, msstring>,
|
||
|
|
map2FunMM<msstring, msbool, msint>,
|
||
|
|
map2FunMM<msstring, msbool, msbool>,
|
||
|
|
map2FunMM<msstring, msbool, msreal>,
|
||
|
|
map2FunMM<msstring, msbool, msstring>,
|
||
|
|
map2FunMM<msstring, msreal, msint>,
|
||
|
|
map2FunMM<msstring, msreal, msbool>,
|
||
|
|
map2FunMM<msstring, msreal, msreal>,
|
||
|
|
map2FunMM<msstring, msreal, msstring>,
|
||
|
|
map2FunMM<msstring, msstring, msint>,
|
||
|
|
map2FunMM<msstring, msstring, msbool>,
|
||
|
|
map2FunMM<msstring, msstring, msreal>,
|
||
|
|
map2FunMM<msstring, msstring, msstring>,
|
||
|
|
0
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
}
|