int main(int argc, char *argv[]) {
struct timeval start, stop;
string file = argv[1];
float *l_quantity = new float[Q6_LINEITEM];
float *l_extendedprice = new float[Q6_LINEITEM];
float *l_discount = new float[Q6_LINEITEM];
long *l_shipdate = new long[Q6_LINEITEM];
float revenue = 0.0f;
test(revenue);
init(file, l_quantity, l_extendedprice, l_discount, l_shipdate);
gettimeofday(&start, NULL);
for (int i = 0; i < Q6_LINEITEM; i++)
if (pred1(l_shipdate[i])
&& pred2(l_shipdate[i])
&& pred3(l_discount[i])
&& pred4(l_discount[i])
&& pred5(l_quantity[i]))
revenue += getRevenue(l_extendedprice[i], l_discount[i]);
gettimeofday(&stop, NULL);
test(revenue);
printTime("tpch_q6", start, stop);
delete[] l_quantity;
delete[] l_extendedprice;
delete[] l_discount;
delete[] l_shipdate;
return 0;
}
bool operator== (const rset<Type1, Type2, Type1Equality, Type2Equality>& x,
const rset<Type1, Type2, Type1Equality, Type2Equality>& y)
{
typedef rset<Type1, Type2, Type1Equality, Type2Equality> set_type;
typedef typename set_type::const_iterator iterator;
typedef typename set_type::first_compare_type first_compare_type;
typedef typename set_type::second_compare_type second_compare_type;
if (x.size() != y.size())
return false;
iterator x_iter(x.begin());
iterator x_last(x.end());
iterator y_iter(y.begin());
first_compare_type pred1(x.first_compare());
second_compare_type pred2(x.second_compare());
for (; x_iter != x_last; ++x_iter, ++y_iter)
if (!pred1(x_iter->first, y_iter->first) ||
!pred2(x_iter->second, y_iter->second))
return false;
return true;
}
int main(int argc, char *argv[]) {
struct timeval start, stop;
string file = argv[1];
char *l_returnflag = new char[Q1_LINEITEM];
char *l_linestatus = new char[Q1_LINEITEM];
float *l_quantity = new float[Q1_LINEITEM];
float *l_extendedprice = new float[Q1_LINEITEM];
float *l_discount = new float[Q1_LINEITEM];
float *l_tax = new float[Q1_LINEITEM];
long *l_shipdate = new long[Q1_LINEITEM];
init(file, l_returnflag, l_linestatus, l_quantity, l_extendedprice,
l_discount, l_tax, l_shipdate);
unordered_map<short,char *> *vals = new unordered_map<short,char *>();
test(vals);
gettimeofday(&start, NULL);
for (int i = 0; i < Q1_LINEITEM; i++)
if (pred1(l_shipdate[i])) {
short key = getKey(l_returnflag[i], l_linestatus[i]);
char *val = getVal(vals, key, l_returnflag[i], l_linestatus[i]);
*((int *) (val + 2)) += 1;
*((float *) (val + 6)) += l_quantity[i];
*((float *) (val + 10)) += l_extendedprice[i];
*((float *) (val + 14)) += getPrice(l_extendedprice[i], l_discount[i]);
*((float *) (val + 18)) += getTax(l_extendedprice[i], l_discount[i], l_tax[i]);
*((float *) (val + 22)) += l_discount[i];
}
gettimeofday(&stop, NULL);
test(vals);
printTime("tpch_q1", start, stop);
delete[] l_returnflag;
delete[] l_linestatus;
delete[] l_quantity;
delete[] l_extendedprice;
delete[] l_discount;
delete[] l_tax;
delete[] l_shipdate;
delete vals;
return 0;
}
void Delaunay::Triangulate(const VertexSet& vertices, TriangleSet& output)
{
if (vertices.size() < 3)
{
return;
}
cVertexIterator iterVertex = vertices.begin();
double xMin = iterVertex->GetX();
double yMin = iterVertex->GetY();
double xMax = xMin;
double yMax = yMin;
++iterVertex;
for (; iterVertex != vertices.end(); ++iterVertex)
{
xMax = iterVertex->GetX();
double y = iterVertex->GetY();
if (y < yMin)
{
yMin = y;
}
if (y > yMax)
{
yMax = y;
}
}
double dx = xMax - xMin;
double dy = yMax - yMin;
double ddx = dx * 0.01;
double ddy = dy * 0.01;
xMin -= ddx;
xMax += ddx;
dx += 2 * ddx;
yMin -= ddy;
yMax += ddy;
dy += 2 * ddy;
Vertex vSuper[3];
vSuper[0] = Vertex(xMin - dy * sqrt3 / 3.0, yMin);
vSuper[1] = Vertex(xMax + dy * sqrt3 / 3.0, yMin);
vSuper[2] = Vertex((xMin + xMax) * 0.5, yMax + dx * sqrt3 * 0.5);
TriangleSet workset;
workset.insert(Triangle(vSuper));
for (iterVertex = vertices.begin(); iterVertex != vertices.end(); ++iterVertex)
{
TriangleIsCompleted pred1(iterVertex, output, vSuper);
TriangleSet::iterator iter = workset.begin();
while (iter != workset.end())
{
if (pred1(*iter))
{
iter = workset.erase(iter);
}
else
{
++iter;
}
}
EdgeSet edges;
VertexIsInCircumstanceCircle pred2(iterVertex, edges);
iter = workset.begin();
while (iter != workset.end())
{
if (pred2(*iter))
{
iter = workset.erase(iter);
}
else
{
++iter;
}
}
for (EdgeIterator edgeIter = edges.begin(); edgeIter != edges.end(); ++edgeIter)
{
workset.insert(Triangle(edgeIter->m_pv0, edgeIter->m_pv1, &(*iterVertex)));
}
}
TriangleIterator where = output.begin();
TriangleHasVertex pred(vSuper);
for (auto t : workset)
{
if (!pred(t))
{
output.insert(output.begin(), t);
}
}
}
static inline void apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Result & result)
{
// TODO: If Areal geometry may have infinite size, change the following line:
// The result should be FFFFFFFFF
relate::set<exterior, exterior, result_dimension<Geometry2>::value>(result);// FFFFFFFFd, d in [1,9] or T
if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
return;
// get and analyse turns
typedef typename turns::get_turns<Geometry1, Geometry2>::turn_info turn_type;
std::vector<turn_type> turns;
interrupt_policy_areal_areal<Result> interrupt_policy(geometry1, geometry2, result);
turns::get_turns<Geometry1, Geometry2>::apply(turns, geometry1, geometry2, interrupt_policy);
if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
return;
no_turns_aa_pred<Geometry2, Result, false> pred1(geometry2, result);
for_each_disjoint_geometry_if<0, Geometry1>::apply(turns.begin(), turns.end(), geometry1, pred1);
if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
return;
no_turns_aa_pred<Geometry1, Result, true> pred2(geometry1, result);
for_each_disjoint_geometry_if<1, Geometry2>::apply(turns.begin(), turns.end(), geometry2, pred2);
if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
return;
if ( turns.empty() )
return;
if ( may_update<interior, interior, '2'>(result)
|| may_update<interior, exterior, '2'>(result)
|| may_update<boundary, interior, '1'>(result)
|| may_update<boundary, exterior, '1'>(result)
|| may_update<exterior, interior, '2'>(result) )
{
// sort turns
typedef turns::less<0, turns::less_op_areal_areal<0> > less;
std::sort(turns.begin(), turns.end(), less());
/*if ( may_update<interior, exterior, '2'>(result)
|| may_update<boundary, exterior, '1'>(result)
|| may_update<boundary, interior, '1'>(result)
|| may_update<exterior, interior, '2'>(result) )*/
{
// analyse sorted turns
turns_analyser<turn_type, 0> analyser;
analyse_each_turn(result, analyser, turns.begin(), turns.end());
if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
return;
}
if ( may_update<interior, interior, '2'>(result)
|| may_update<interior, exterior, '2'>(result)
|| may_update<boundary, interior, '1'>(result)
|| may_update<boundary, exterior, '1'>(result)
|| may_update<exterior, interior, '2'>(result) )
{
// analyse rings for which turns were not generated
// or only i/i or u/u was generated
uncertain_rings_analyser<0, Result, Geometry1, Geometry2> rings_analyser(result, geometry1, geometry2);
analyse_uncertain_rings<0>::apply(rings_analyser, turns.begin(), turns.end());
if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
return;
}
}
if ( may_update<interior, interior, '2', true>(result)
|| may_update<interior, exterior, '2', true>(result)
|| may_update<boundary, interior, '1', true>(result)
|| may_update<boundary, exterior, '1', true>(result)
|| may_update<exterior, interior, '2', true>(result) )
{
// sort turns
typedef turns::less<1, turns::less_op_areal_areal<1> > less;
std::sort(turns.begin(), turns.end(), less());
/*if ( may_update<interior, exterior, '2', true>(result)
|| may_update<boundary, exterior, '1', true>(result)
|| may_update<boundary, interior, '1', true>(result)
|| may_update<exterior, interior, '2', true>(result) )*/
{
// analyse sorted turns
turns_analyser<turn_type, 1> analyser;
analyse_each_turn(result, analyser, turns.begin(), turns.end());
if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
return;
}
if ( may_update<interior, interior, '2', true>(result)
|| may_update<interior, exterior, '2', true>(result)
|| may_update<boundary, interior, '1', true>(result)
|| may_update<boundary, exterior, '1', true>(result)
|| may_update<exterior, interior, '2', true>(result) )
{
// analyse rings for which turns were not generated
// or only i/i or u/u was generated
uncertain_rings_analyser<1, Result, Geometry2, Geometry1> rings_analyser(result, geometry2, geometry1);
analyse_uncertain_rings<1>::apply(rings_analyser, turns.begin(), turns.end());
//if ( result.interrupt )
// return;
}
}
}
