ExtensionFunctions.hpp File Reference

#include "../Shared/funcannotations.h"
#include <cstdint>
#include <cmath>
#include <cstdlib>
#include "heavydbTypes.h"
#include "ExtensionFunctionsArray.hpp"
#include "ExtensionFunctionsGeo.hpp"
#include "ExtensionFunctionsTesting.hpp"
#include "QueryEngine/ExtensionFunctions/h3lib/include/h3Index.h"

Include dependency graph for ExtensionFunctions.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
EXTENSION_NOINLINE double	Acos (const double x)
EXTENSION_NOINLINE double	Asin (const double x)
EXTENSION_NOINLINE double	Atan (const double x)
EXTENSION_NOINLINE double	Atanh (const double x)
EXTENSION_NOINLINE double	Atan2 (const double y, const double x)
EXTENSION_NOINLINE double	Ceil (double x)
EXTENSION_NOINLINE float	Ceil__ (float x)
EXTENSION_NOINLINE int16_t	Ceil__1 (int16_t x)
EXTENSION_NOINLINE int32_t	Ceil__2 (int32_t x)
EXTENSION_NOINLINE int64_t	Ceil__3 (int64_t x)
EXTENSION_NOINLINE double	Cos (const double x)
EXTENSION_NOINLINE double	Cosh (const double x)
EXTENSION_NOINLINE double	Cot (const double x)
EXTENSION_NOINLINE double	degrees (double x)
EXTENSION_NOINLINE double	Exp (double x)
EXTENSION_NOINLINE double	Floor (double x)
EXTENSION_NOINLINE float	Floor__ (float x)
EXTENSION_NOINLINE int16_t	Floor__1 (int16_t x)
EXTENSION_NOINLINE int32_t	Floor__2 (int32_t x)
EXTENSION_NOINLINE int64_t	Floor__3 (int64_t x)
EXTENSION_NOINLINE double	ln (const double x)
EXTENSION_NOINLINE double	ln__ (const float x)
EXTENSION_NOINLINE double	Log (const double x)
EXTENSION_NOINLINE double	Log__ (const float x)
EXTENSION_NOINLINE double	Log10 (const double x)
EXTENSION_NOINLINE double	Log10__ (const float x)
EXTENSION_NOINLINE double	pi ()
EXTENSION_NOINLINE double	power (const double x, const double y)
EXTENSION_NOINLINE double	radians (const double x)
EXTENSION_NOINLINE double	Round (const double x, const int32_t y)
EXTENSION_NOINLINE float	Round__ (const float x, const int32_t y)
EXTENSION_NOINLINE int16_t	Round__1 (const int16_t x, const int32_t y)
EXTENSION_NOINLINE int32_t	Round__2 (const int32_t x, const int32_t y)
EXTENSION_NOINLINE int64_t	Round__3 (const int64_t x, const int32_t y)
EXTENSION_NOINLINE int64_t	Round__4 (const int64_t x, const int32_t y0, const int32_t scale)
EXTENSION_NOINLINE double	Round2_to_digit (const double x, const int32_t y)
EXTENSION_NOINLINE double	round_to_digit (const double x, const int32_t y)
EXTENSION_NOINLINE double	Sin (const double x)
EXTENSION_NOINLINE double	Sinh (const double x)
EXTENSION_NOINLINE double	Sqrt (const double x)
EXTENSION_NOINLINE double	Tan (const double x)
EXTENSION_NOINLINE double	Tanh (const double x)
EXTENSION_NOINLINE double	Tan__ (const float x)
EXTENSION_NOINLINE double	Truncate (const double x, const int32_t y)
EXTENSION_NOINLINE float	Truncate__ (const float x, const int32_t y)
EXTENSION_NOINLINE int16_t	Truncate__1 (const int16_t x, const int32_t y)
EXTENSION_NOINLINE int32_t	Truncate__2 (const int32_t x, const int32_t y)
EXTENSION_NOINLINE int64_t	Truncate__3 (const int64_t x, const int32_t y)
EXTENSION_NOINLINE bool	isNan (const double x)
EXTENSION_NOINLINE bool	isNan__ (const float x)
EXTENSION_NOINLINE double	conv_4326_900913_x (const double x)
EXTENSION_NOINLINE double	conv_4326_900913_y (const double y)
EXTENSION_NOINLINE double	distance_in_meters (const double fromlon, const double fromlat, const double tolon, const double tolat)
	Computes the distance, in meters, between two WGS-84 positions. More...
EXTENSION_NOINLINE double	distance_in_meters__ (const float fromlon, const float fromlat, const float tolon, const float tolat)
EXTENSION_NOINLINE double	approx_distance_in_meters (const float fromlon, const float fromlat, const float tolon, const float tolat)
EXTENSION_NOINLINE float	rect_pixel_bin (const double val, const double min, const double max, const int32_t numbins, const int32_t dimensionsize)
EXTENSION_NOINLINE float	rect_pixel_bin_x (const double valx, const double minx, const double maxx, const double rectwidth, const double offsetx, const int32_t imgwidth)
EXTENSION_NOINLINE float	rect_pixel_bin_y (const double valy, const double miny, const double maxy, const double rectheight, const double offsety, const int32_t imgheight)
EXTENSION_NOINLINE int32_t	rect_pixel_bin_packed (const double valx, const double minx, const double maxx, const double valy, const double miny, const double maxy, const double rectwidth, const double rectheight, const double offsetx, const double offsety, const int32_t imgwidth, const int32_t imgheight)
EXTENSION_NOINLINE float	reg_hex_horiz_pixel_bin_x (const double valx, const double minx, const double maxx, const double valy, const double miny, const double maxy, const double hexwidth, const double hexheight, const double offsetx, const double offsety, const int32_t imgwidth, const int32_t imgheight)
EXTENSION_NOINLINE float	reg_hex_horiz_pixel_bin_y (const double valx, const double minx, const double maxx, const double valy, const double miny, const double maxy, const double hexwidth, const double hexheight, const double offsetx, const double offsety, const int32_t imgwidth, const int32_t imgheight)
EXTENSION_NOINLINE int32_t	reg_hex_horiz_pixel_bin_packed (const double valx, const double minx, const double maxx, const double valy, const double miny, const double maxy, const double hexwidth, const double hexheight, const double offsetx, const double offsety, const int32_t imgwidth, const int32_t imgheight)
EXTENSION_NOINLINE float	reg_hex_vert_pixel_bin_x (const double valx, const double minx, const double maxx, const double valy, const double miny, const double maxy, const double hexwidth, const double hexheight, const double offsetx, const double offsety, const int32_t imgwidth, const int32_t imgheight)
EXTENSION_NOINLINE float	reg_hex_vert_pixel_bin_y (const double valx, const double minx, const double maxx, const double valy, const double miny, const double maxy, const double hexwidth, const double hexheight, const double offsetx, const double offsety, const int32_t imgwidth, const int32_t imgheight)
EXTENSION_NOINLINE int32_t	reg_hex_vert_pixel_bin_packed (const double valx, const double minx, const double maxx, const double valy, const double miny, const double maxy, const double hexwidth, const double hexheight, const double offsetx, const double offsety, const int32_t imgwidth, const int32_t imgheight)
EXTENSION_NOINLINE double	convert_meters_to_merc_pixel_width (const double meters, const double lon, const double lat, const double min_lon, const double max_lon, const int32_t img_width, const double min_width)
EXTENSION_NOINLINE double	convert_meters_to_merc_pixel_height (const double meters, const double lon, const double lat, const double min_lat, const double max_lat, const int32_t img_height, const double min_height)
EXTENSION_INLINE bool	is_point_in_merc_view (const double lon, const double lat, const double min_lon, const double max_lon, const double min_lat, const double max_lat)
EXTENSION_NOINLINE bool	is_point_size_in_merc_view (const double lon, const double lat, const double meters, const double min_lon, const double max_lon, const double min_lat, const double max_lat)

Function Documentation

EXTENSION_NOINLINE double Acos

(

const double

x

)

Definition at line 42 of file ExtensionFunctions.hpp.

                            {
  return acos(x);
}

EXTENSION_NOINLINE double approx_distance_in_meters	(	const float	fromlon,
		const float	fromlat,
		const float	tolon,
		const float	tolat
	)

Definition at line 455 of file ExtensionFunctions.hpp.

References distance_in_meters__().

                                                    {
#ifdef __CUDACC__
  float latitudeArc = (fromlat - tolat) * 0.017453292519943295769236907684886;
  float longitudeArc = (fromlon - tolon) * 0.017453292519943295769236907684886;
  float latitudeH = __sinf(latitudeArc * 0.5);
  latitudeH *= latitudeH;
  float lontitudeH = __sinf(longitudeArc * 0.5);
  lontitudeH *= lontitudeH;
  float tmp = __cosf(fromlat * 0.017453292519943295769236907684886) *
              __cosf(tolat * 0.017453292519943295769236907684886);
  return 6372797.560856 * (2.0 * asinf(__fsqrt_rd(latitudeH + tmp * lontitudeH)));
#else
  return distance_in_meters__(fromlon, fromlat, tolon, tolat);
#endif
}

Here is the call graph for this function:

EXTENSION_NOINLINE double Asin

(

const double

x

)

Definition at line 47 of file ExtensionFunctions.hpp.

                            {
  return asin(x);
}

EXTENSION_NOINLINE double Atan

(

const double

x

)

Definition at line 52 of file ExtensionFunctions.hpp.

                            {
  return atan(x);
}

EXTENSION_NOINLINE double Atan2	(	const double	y,
		const double	x
	)

Definition at line 62 of file ExtensionFunctions.hpp.

                                             {
  return atan2(y, x);
}

EXTENSION_NOINLINE double Atanh

(

const double

x

)

Definition at line 57 of file ExtensionFunctions.hpp.

                             {
  return atanh(x);
}

EXTENSION_NOINLINE double Ceil

(

double

x

)

Definition at line 67 of file ExtensionFunctions.hpp.

                      {
  return ceil(x);
}

EXTENSION_NOINLINE float Ceil__

(

float

x

)

Definition at line 72 of file ExtensionFunctions.hpp.

                      {
  return ceil(x);
}

EXTENSION_NOINLINE int16_t Ceil__1

(

int16_t

x

)

Definition at line 77 of file ExtensionFunctions.hpp.

                           {
  return x;
}

EXTENSION_NOINLINE int32_t Ceil__2

(

int32_t

x

)

Definition at line 82 of file ExtensionFunctions.hpp.

                           {
  return x;
}

EXTENSION_NOINLINE int64_t Ceil__3

(

int64_t

x

)

Definition at line 87 of file ExtensionFunctions.hpp.

                           {
  return x;
}

EXTENSION_NOINLINE double conv_4326_900913_x

(

const double

x

)

Definition at line 392 of file ExtensionFunctions.hpp.

Referenced by conv_4326_900913(), convert_meters_to_merc_pixel_width(), and import_export::RasterImporter::getProjectedPixelCoords().

                                          {
  return x * 111319.490778;
}

Here is the caller graph for this function:

EXTENSION_NOINLINE double conv_4326_900913_y

(

const double

y

)

Definition at line 397 of file ExtensionFunctions.hpp.

Referenced by conv_4326_900913(), convert_meters_to_merc_pixel_height(), and import_export::RasterImporter::getProjectedPixelCoords().

                                          {
  return 6378136.99911 * log(tan(.00872664626 * y + .785398163397));
}

Here is the caller graph for this function:

EXTENSION_NOINLINE double convert_meters_to_merc_pixel_height	(	const double	meters,
		const double	lon,
		const double	lat,
		const double	min_lat,
		const double	max_lat,
		const int32_t	img_height,
		const double	min_height
	)

Definition at line 1076 of file ExtensionFunctions.hpp.

References conv_4326_900913_y().

                                                                    {
  const double const1 = 0.017453292519943295769236907684886;
  const double const2 = 6372797.560856;
  const double latdiff = meters / (const1 * const2);
  const double newlat =
      (lat < 0) ? lat + latdiff : lat - latdiff;  // assumes a lat range of [-90, 90]
  double t1 = conv_4326_900913_y(lat);
  double t2 = conv_4326_900913_y(newlat);
  const double min_merc_y = conv_4326_900913_y(min_lat);
  const double max_merc_y = conv_4326_900913_y(max_lat);
  const double merc_diff = max_merc_y - min_merc_y;
  t1 = ((t1 - min_merc_y) / merc_diff) * static_cast<double>(img_height);
  t2 = ((t2 - min_merc_y) / merc_diff) * static_cast<double>(img_height);

  // TODO(croot): need to account for edge cases, such as getting close to the poles.
  const double sz = fabs(t1 - t2);
  return (sz < min_height ? min_height : sz);
}

Here is the call graph for this function:

EXTENSION_NOINLINE double convert_meters_to_merc_pixel_width	(	const double	meters,
		const double	lon,
		const double	lat,
		const double	min_lon,
		const double	max_lon,
		const int32_t	img_width,
		const double	min_width
	)

Definition at line 1050 of file ExtensionFunctions.hpp.

References conv_4326_900913_x().

                                                                  {
  const double const1 = 0.017453292519943295769236907684886;
  const double const2 = 6372797.560856;
  double t1 = sinf(meters / (2.0 * const2));
  double t2 = cosf(const1 * lat);
  const double newlon = lon - (2.0 * asinf(t1 / t2)) / const1;
  t1 = conv_4326_900913_x(lon);
  t2 = conv_4326_900913_x(newlon);
  const double min_merc_x = conv_4326_900913_x(min_lon);
  const double max_merc_x = conv_4326_900913_x(max_lon);
  const double merc_diff = max_merc_x - min_merc_x;
  t1 = ((t1 - min_merc_x) / merc_diff) * static_cast<double>(img_width);
  t2 = ((t2 - min_merc_x) / merc_diff) * static_cast<double>(img_width);

  // TODO(croot): need to account for edge cases, such as getting close to the poles.
  const double sz = fabs(t1 - t2);
  return (sz < min_width ? min_width : sz);
}

Here is the call graph for this function:

EXTENSION_NOINLINE double Cos

(

const double

x

)

Definition at line 92 of file ExtensionFunctions.hpp.

                           {
  return cos(x);
}

EXTENSION_NOINLINE double Cosh

(

const double

x

)

Definition at line 97 of file ExtensionFunctions.hpp.

                            {
  return cosh(x);
}

EXTENSION_NOINLINE double Cot

(

const double

x

)

Definition at line 102 of file ExtensionFunctions.hpp.

                           {
  return 1 / tan(x);
}

EXTENSION_NOINLINE double degrees

(

double

x

)

Definition at line 107 of file ExtensionFunctions.hpp.

References M_PI.

Referenced by degsToRads().

                         {
  return x * (180.0 / M_PI);
}

Here is the caller graph for this function:

EXTENSION_NOINLINE double distance_in_meters	(	const double	fromlon,
		const double	fromlat,
		const double	tolon,
		const double	tolat
	)

Computes the distance, in meters, between two WGS-84 positions.

The result is equal to EARTH_RADIUS_IN_METERS*ArcInRadians(from,to)

ArcInRadians is equal to Distance(from,to)/EARTH_RADIUS_IN_METERS = 2*asin(sqrt(h(d/EARTH_RADIUS_IN_METERS )))

where:

• d is the distance in meters between 'from' and 'to' positions.
• h is the haversine function: h(x)=sin²(x/2)

code attribution: http://blog.julien.cayzac.name/2008/10/arc-and-distance-between-two-points-on.html

The haversine formula gives: h(d/R) = h(from.lat-to.lat)+h(from.lon-to.lon)+cos(from.lat)*cos(to.lat)

See Also

http://en.wikipedia.org/wiki/Law_of_haversines

Definition at line 423 of file ExtensionFunctions.hpp.

Referenced by GeoRaster< T, Z >::calculate_bins_and_scales(), length_linestring(), ST_Distance_Point_LineString_Geodesic(), and ST_Distance_Point_Point_Geodesic().

                                              {
  double latitudeArc = (fromlat - tolat) * 0.017453292519943295769236907684886;
  double longitudeArc = (fromlon - tolon) * 0.017453292519943295769236907684886;
  double latitudeH = sin(latitudeArc * 0.5);
  latitudeH *= latitudeH;
  double lontitudeH = sin(longitudeArc * 0.5);
  lontitudeH *= lontitudeH;
  double tmp = cos(fromlat * 0.017453292519943295769236907684886) *
               cos(tolat * 0.017453292519943295769236907684886);
  return 6372797.560856 * (2.0 * asin(sqrt(latitudeH + tmp * lontitudeH)));
}

Here is the caller graph for this function:

EXTENSION_NOINLINE double distance_in_meters__	(	const float	fromlon,
		const float	fromlat,
		const float	tolon,
		const float	tolat
	)

Definition at line 439 of file ExtensionFunctions.hpp.

Referenced by approx_distance_in_meters().

                                               {
  float latitudeArc = (fromlat - tolat) * 0.017453292519943295769236907684886;
  float longitudeArc = (fromlon - tolon) * 0.017453292519943295769236907684886;
  float latitudeH = sinf(latitudeArc * 0.5);
  latitudeH *= latitudeH;
  float lontitudeH = sinf(longitudeArc * 0.5);
  lontitudeH *= lontitudeH;
  float tmp = cosf(fromlat * 0.017453292519943295769236907684886) *
              cosf(tolat * 0.017453292519943295769236907684886);
  return 6372797.560856 * (2.0 * asinf(sqrtf(latitudeH + tmp * lontitudeH)));
}

Here is the caller graph for this function:

EXTENSION_NOINLINE double Exp

(

double

x

)

Definition at line 112 of file ExtensionFunctions.hpp.

                     {
  return exp(x);
}

EXTENSION_NOINLINE double Floor

(

double

x

)

Definition at line 117 of file ExtensionFunctions.hpp.

                       {
  return floor(x);
}

EXTENSION_NOINLINE float Floor__

(

float

x

)

Definition at line 122 of file ExtensionFunctions.hpp.

                       {
  return floor(x);
}

EXTENSION_NOINLINE int16_t Floor__1

(

int16_t

x

)

Definition at line 127 of file ExtensionFunctions.hpp.

                            {
  return x;
}

EXTENSION_NOINLINE int32_t Floor__2

(

int32_t

x

)

Definition at line 132 of file ExtensionFunctions.hpp.

                            {
  return x;
}

EXTENSION_NOINLINE int64_t Floor__3

(

int64_t

x

)

Definition at line 137 of file ExtensionFunctions.hpp.

                            {
  return x;
}

EXTENSION_INLINE bool is_point_in_merc_view	(	const double	lon,
		const double	lat,
		const double	min_lon,
		const double	max_lon,
		const double	min_lat,
		const double	max_lat
	)

Definition at line 1101 of file ExtensionFunctions.hpp.

                                                                  {
  return !(lon < min_lon || lon > max_lon || lat < min_lat || lat > max_lat);
}

EXTENSION_NOINLINE bool is_point_size_in_merc_view	(	const double	lon,
		const double	lat,
		const double	meters,
		const double	min_lon,
		const double	max_lon,
		const double	min_lat,
		const double	max_lat
	)

Definition at line 1110 of file ExtensionFunctions.hpp.

                                                                         {
  const double const1 = 0.017453292519943295769236907684886;
  const double const2 = 6372797.560856;
  const double latdiff = meters / (const1 * const2);
  const double t1 = sinf(meters / (2.0 * const2));
  const double t2 = cosf(const1 * lat);
  const double londiff = (2.0 * asinf(t1 / t2)) / const1;
  return !(lon + londiff < min_lon || lon - londiff > max_lon ||
           lat + latdiff < min_lat || lat - latdiff > max_lat);
}

EXTENSION_NOINLINE bool isNan

(

const double

x

)

Definition at line 382 of file ExtensionFunctions.hpp.

                           {
  return std::isnan(x);
}

EXTENSION_NOINLINE bool isNan__

(

const float

x

)

Definition at line 387 of file ExtensionFunctions.hpp.

                            {
  return std::isnan(x);
}

EXTENSION_NOINLINE double ln

(

const double

x

)

Definition at line 142 of file ExtensionFunctions.hpp.

                          {
  return log(x);
}

EXTENSION_NOINLINE double ln__

(

const float

x

)

Definition at line 147 of file ExtensionFunctions.hpp.

                           {
  return logf(x);
}

EXTENSION_NOINLINE double Log

(

const double

x

)

Definition at line 152 of file ExtensionFunctions.hpp.

                           {
  return log(x);
}

EXTENSION_NOINLINE double Log10

(

const double

x

)

Definition at line 162 of file ExtensionFunctions.hpp.

                             {
  return log10(x);
}

EXTENSION_NOINLINE double Log10__

(

const float

x

)

Definition at line 167 of file ExtensionFunctions.hpp.

                              {
  return log10f(x);
}

EXTENSION_NOINLINE double Log__

(

const float

x

)

Definition at line 157 of file ExtensionFunctions.hpp.

                            {
  return logf(x);
}

EXTENSION_NOINLINE double pi

(

)

Definition at line 172 of file ExtensionFunctions.hpp.

References M_PI.

Referenced by geotransform_4326_to_900913().

            {
  return M_PI;
}

Here is the caller graph for this function:

EXTENSION_NOINLINE double power	(	const double	x,
		const double	y
	)

Definition at line 177 of file ExtensionFunctions.hpp.

Referenced by anonymous_namespace{misc.h}::inversePowersOfImpl(), anonymous_namespace{misc.h}::power(), and anonymous_namespace{misc.h}::powersOfImpl().

                                             {
  return pow(x, y);
}

Here is the caller graph for this function:

EXTENSION_NOINLINE double radians

(

const double

x

)

Definition at line 182 of file ExtensionFunctions.hpp.

References M_PI.

Referenced by radsToDegs().

                               {
  return x * (M_PI / 180.0);
}

Here is the caller graph for this function:

EXTENSION_NOINLINE float rect_pixel_bin	(	const double	val,
		const double	min,
		const double	max,
		const int32_t	numbins,
		const int32_t	dimensionsize
	)

deprecated

Definition at line 475 of file ExtensionFunctions.hpp.

                                                  {
  float numbinsf = float(numbins);
  return float(int32_t(float((val - min) / (max - min)) * numbinsf)) *
         float(dimensionsize) / numbinsf;
}

EXTENSION_NOINLINE int32_t rect_pixel_bin_packed	(	const double	valx,
		const double	minx,
		const double	maxx,
		const double	valy,
		const double	miny,
		const double	maxy,
		const double	rectwidth,
		const double	rectheight,
		const double	offsetx,
		const double	offsety,
		const int32_t	imgwidth,
		const int32_t	imgheight
	)

Definition at line 535 of file ExtensionFunctions.hpp.

                                                       {
  const float imgwidthf = float(imgwidth);
  const float rectwidthf = float(rectwidth);
  double min = minx;
  float offset = offsetx;
  if (offset != 0) {
    offset = fmodf(offset, rectwidthf);
    if (offset > 0) {
      offset -= rectwidthf;
    }
    min += offset * (maxx - minx) / imgwidthf;
  }
  float rx = float(int32_t(float((valx - min) / (maxx - min)) * (imgwidthf - offset) /
                           rectwidthf)) *
                 rectwidthf +
             offset + rectwidthf / 2.0f;

  const float imgheightf = float(imgheight);
  const float rectheightf = rectheight;
  min = miny;
  offset = offsety;
  if (offset != 0) {
    offset = fmodf(offset, rectheightf);
    if (offset > 0) {
      offset -= rectheightf;
    }
    min += offset * (maxy - miny) / imgheightf;
  }
  float ry = float(int32_t(float((valy - min) / (maxy - min)) * (imgheightf - offset) /
                           rectheightf)) *
                 rectheightf +
             offset + rectheightf / 2.0f;

  // and pack as two 14.2 fixed-point values into 32bits
  int32_t ux = static_cast<int32_t>(rx * 4.0f);
  int32_t uy = static_cast<int32_t>(ry * 4.0f);
  return (ux & 0x7FFF) | ((uy & 0x7FFF) << 16);
}

EXTENSION_NOINLINE float rect_pixel_bin_x	(	const double	valx,
		const double	minx,
		const double	maxx,
		const double	rectwidth,
		const double	offsetx,
		const int32_t	imgwidth
	)

Definition at line 487 of file ExtensionFunctions.hpp.

                                               {
  const float imgwidthf = float(imgwidth);
  const float rectwidthf = float(rectwidth);
  double min = minx;
  float offset = offsetx;
  if (offset != 0) {
    offset = fmodf(offset, rectwidthf);
    if (offset > 0) {
      offset -= rectwidthf;
    }
    min += offset * (maxx - minx) / imgwidthf;
  }
  return float(int32_t(float((valx - min) / (maxx - min)) * (imgwidthf - offset) /
                       rectwidthf)) *
             rectwidthf +
         offset + rectwidthf / 2.0f;
}

EXTENSION_NOINLINE float rect_pixel_bin_y	(	const double	valy,
		const double	miny,
		const double	maxy,
		const double	rectheight,
		const double	offsety,
		const int32_t	imgheight
	)

Definition at line 511 of file ExtensionFunctions.hpp.

                                                {
  const float imgheightf = float(imgheight);
  const float rectheightf = rectheight;
  double min = miny;
  float offset = offsety;
  if (offset != 0) {
    offset = fmodf(offset, rectheightf);
    if (offset > 0) {
      offset -= rectheightf;
    }
    min += offset * (maxy - miny) / imgheightf;
  }
  return float(int32_t(float((valy - min) / (maxy - min)) * (imgheightf - offset) /
                       rectheightf)) *
             rectheightf +
         offset + rectheightf / 2.0f;
}

EXTENSION_NOINLINE int32_t reg_hex_horiz_pixel_bin_packed	(	const double	valx,
		const double	minx,
		const double	maxx,
		const double	valy,
		const double	miny,
		const double	maxy,
		const double	hexwidth,
		const double	hexheight,
		const double	offsetx,
		const double	offsety,
		const int32_t	imgwidth,
		const int32_t	imgheight
	)

Definition at line 738 of file ExtensionFunctions.hpp.

References anonymous_namespace{Utm.h}::f.

                                                                {
  const float sqrt3 = 1.7320508075688772;
  const float imgwidthf = float(imgwidth);
  const float imgheightf = float(imgheight);
  const float hexwidthf = float(hexwidth);
  const float hexheightf = float(hexheight);

  // expand the bounds of the data according
  // to the input offsets. This is done because
  // we also expand the image size according to the
  // offsets because this algorithm layers the hexagon
  // bins starting at the bottom left corner
  double xmin = minx;
  float xoffset = offsetx;
  if (xoffset != 0) {
    xoffset = fmodf(xoffset, hexwidthf);
    if (xoffset > 0) {
      xoffset -= hexwidthf;
    }
    xmin += xoffset * (maxx - xmin) / imgwidthf;
  }

  double ymin = miny;
  float yoffset = offsety;
  if (yoffset != 0) {
    yoffset = fmodf(yoffset, 1.5f * hexheightf);
    if (yoffset > 0) {
      yoffset -= 1.5f * hexheightf;
    }
    ymin += yoffset * (maxy - ymin) / imgheightf;
  }

  // get the pixel position of the point
  // assumes a linear scale here
  // Rounds to the nearest pixel.
  const float pix_x =
      roundf((imgwidthf - xoffset) * float((valx - xmin) / (maxx - xmin)));
  const float pix_y =
      roundf((imgheightf - yoffset) * float((valy - ymin) / (maxy - ymin)));

  // Now convert the pixel position into a
  // cube-coordinate system representation
  const float hexsize = hexheightf / 2.0f;
  const float cube_x = ((pix_x / sqrt3) - (pix_y / 3.0f)) / hexsize;
  const float cube_z = (pix_y * 2.0f / 3.0f) / hexsize;
  const float cube_y = -cube_x - cube_z;

  // need to round the cube coordinates above
  float rx = round(cube_x);
  float ry = round(cube_y);
  float rz = round(cube_z);
  const float x_diff = fabs(rx - cube_x);
  const float y_diff = fabs(ry - cube_y);
  const float z_diff = fabs(rz - cube_z);
  if (x_diff > y_diff && x_diff > z_diff) {
    rx = -ry - rz;
  } else if (y_diff <= z_diff) {
    rz = -rx - ry;
  }

  // now convert the cube/hex coord to pixel locations
  float hx = hexsize * sqrt3 * (rx + rz / 2.0f) + xoffset;
  float hy = hexsize * 3.0f / 2.0f * rz + yoffset;

  // and pack as two 14.2 fixed-point values into 32bits
  int32_t ux = static_cast<int32_t>(hx * 4.0f);
  int32_t uy = static_cast<int32_t>(hy * 4.0f);
  return (ux & 0x7FFF) | ((uy & 0x7FFF) << 16);
}

EXTENSION_NOINLINE float reg_hex_horiz_pixel_bin_x	(	const double	valx,
		const double	minx,
		const double	maxx,
		const double	valy,
		const double	miny,
		const double	maxy,
		const double	hexwidth,
		const double	hexheight,
		const double	offsetx,
		const double	offsety,
		const int32_t	imgwidth,
		const int32_t	imgheight
	)

Definition at line 586 of file ExtensionFunctions.hpp.

References anonymous_namespace{Utm.h}::f.

                                                         {
  const float sqrt3 = 1.7320508075688772;
  const float imgwidthf = float(imgwidth);
  const float imgheightf = float(imgheight);
  const float hexwidthf = float(hexwidth);
  const float hexheightf = float(hexheight);

  // expand the bounds of the data according
  // to the input offsets. This is done because
  // we also expand the image size according to the
  // offsets because this algorithm layers the hexagon
  // bins starting at the bottom left corner
  double xmin = minx;
  float xoffset = offsetx;
  if (xoffset != 0) {
    xoffset = fmodf(xoffset, hexwidthf);
    if (xoffset > 0) {
      xoffset -= hexwidthf;
    }
    xmin += xoffset * (maxx - xmin) / imgwidthf;
  }

  double ymin = miny;
  float yoffset = offsety;
  if (yoffset != 0) {
    yoffset = fmodf(yoffset, 1.5f * hexheightf);
    if (yoffset > 0) {
      yoffset -= 1.5f * hexheightf;
    }
    ymin += yoffset * (maxy - ymin) / imgheightf;
  }

  // get the pixel position of the point
  // assumes a linear scale here
  // Rounds to the nearest pixel.
  const float pix_x =
      roundf((imgwidthf - xoffset) * float((valx - xmin) / (maxx - xmin)));
  const float pix_y =
      roundf((imgheightf - yoffset) * float((valy - ymin) / (maxy - ymin)));

  // Now convert the pixel position into a
  // cube-coordinate system representation
  const float hexsize = hexheightf / 2.0f;
  const float cube_x = ((pix_x / sqrt3) - (pix_y / 3.0f)) / hexsize;
  const float cube_z = (pix_y * 2.0f / 3.0f) / hexsize;
  const float cube_y = -cube_x - cube_z;

  // need to round the cube coordinates above
  float rx = round(cube_x);
  float ry = round(cube_y);
  float rz = round(cube_z);
  const float x_diff = fabs(rx - cube_x);
  const float y_diff = fabs(ry - cube_y);
  const float z_diff = fabs(rz - cube_z);
  if (x_diff > y_diff && x_diff > z_diff) {
    rx = -ry - rz;
  } else if (y_diff > z_diff) {
    ry = -rx - rz;
  } else {
    rz = -rx - ry;
  }

  // now convert the cube/hex coord to a pixel location
  return hexsize * sqrt3 * (rx + rz / 2.0f) + xoffset;
}

EXTENSION_NOINLINE float reg_hex_horiz_pixel_bin_y	(	const double	valx,
		const double	minx,
		const double	maxx,
		const double	valy,
		const double	miny,
		const double	maxy,
		const double	hexwidth,
		const double	hexheight,
		const double	offsetx,
		const double	offsety,
		const int32_t	imgwidth,
		const int32_t	imgheight
	)

Definition at line 664 of file ExtensionFunctions.hpp.

References anonymous_namespace{Utm.h}::f.

                                                         {
  const float sqrt3 = 1.7320508075688772;
  const float imgwidthf = float(imgwidth);
  const float imgheightf = float(imgheight);
  const float hexwidthf = float(hexwidth);
  const float hexheightf = float(hexheight);

  // expand the bounds of the data according
  // to the input offsets. This is done because
  // we also expand the image size according to the
  // offsets because this algorithm layers the hexagon
  // bins starting at the bottom left corner
  double xmin = minx;
  float xoffset = offsetx;
  if (xoffset != 0) {
    xoffset = fmodf(xoffset, hexwidthf);
    if (xoffset > 0) {
      xoffset -= hexwidthf;
    }
    xmin += xoffset * (maxx - xmin) / imgwidthf;
  }

  double ymin = miny;
  float yoffset = offsety;
  if (yoffset != 0) {
    yoffset = fmodf(yoffset, 1.5f * hexheightf);
    if (yoffset > 0) {
      yoffset -= 1.5f * hexheightf;
    }
    ymin += yoffset * (maxy - ymin) / imgheightf;
  }

  // get the pixel position of the point
  // assumes a linear scale here
  // Rounds to the nearest pixel.
  const float pix_x =
      roundf((imgwidthf - xoffset) * float((valx - xmin) / (maxx - xmin)));
  const float pix_y =
      roundf((imgheightf - yoffset) * float((valy - ymin) / (maxy - ymin)));

  // Now convert the pixel position into a
  // cube-coordinate system representation
  const float hexsize = hexheightf / 2.0f;
  const float cube_x = ((pix_x / sqrt3) - (pix_y / 3.0f)) / hexsize;
  const float cube_z = (pix_y * 2.0f / 3.0f) / hexsize;
  const float cube_y = -cube_x - cube_z;

  // need to round the cube coordinates above
  float rx = round(cube_x);
  float ry = round(cube_y);
  float rz = round(cube_z);
  const float x_diff = fabs(rx - cube_x);
  const float y_diff = fabs(ry - cube_y);
  const float z_diff = fabs(rz - cube_z);
  if ((x_diff <= y_diff || x_diff <= z_diff) && y_diff <= z_diff) {
    rz = -rx - ry;
  }

  // now convert the cube/hex coord to a pixel location
  return hexsize * 3.0f / 2.0f * rz + yoffset;
}

EXTENSION_NOINLINE int32_t reg_hex_vert_pixel_bin_packed	(	const double	valx,
		const double	minx,
		const double	maxx,
		const double	valy,
		const double	miny,
		const double	maxy,
		const double	hexwidth,
		const double	hexheight,
		const double	offsetx,
		const double	offsety,
		const int32_t	imgwidth,
		const int32_t	imgheight
	)

Definition at line 970 of file ExtensionFunctions.hpp.

References anonymous_namespace{Utm.h}::f.

                                                               {
  const float sqrt3 = 1.7320508075688772;
  const float imgwidthf = float(imgwidth);
  const float imgheightf = float(imgheight);
  const float hexwidthf = float(hexwidth);
  const float hexheightf = float(hexheight);

  // expand the bounds of the data according
  // to the input offsets. This is done because
  // we also expand the image size according to the
  // offsets because this algorithm layers the hexagon
  // bins starting at the bottom left corner
  double xmin = minx;
  float xoffset = offsetx;
  if (xoffset != 0) {
    xoffset = fmodf(xoffset, 1.5f * hexwidthf);
    if (xoffset > 0) {
      xoffset -= 1.5f * hexwidthf;
    }
    xmin += xoffset * (maxx - xmin) / imgwidthf;
  }

  double ymin = miny;
  float yoffset = offsety;
  if (yoffset != 0) {
    yoffset = fmodf(yoffset, hexheightf);
    if (yoffset > 0) {
      yoffset -= hexheightf;
    }
    ymin += yoffset * (maxy - ymin) / imgheightf;
  }

  // get the pixel position of the point
  // assumes a linear scale here
  // Rounds to the nearest pixel.
  const float pix_x = roundf((imgwidthf - xoffset) * float(valx - xmin) / (maxx - xmin));
  const float pix_y = roundf((imgheightf - yoffset) * float(valy - ymin) / (maxy - ymin));

  // Now convert the pixel position into a
  // cube-coordinate system representation
  const float hexsize = hexwidthf / 2.0f;
  const float cube_x = (pix_x * 2.0f / 3.0f) / hexsize;
  const float cube_z = ((pix_y / sqrt3) - (pix_x / 3.0f)) / hexsize;
  const float cube_y = -cube_x - cube_z;

  // need to round the cube coordinates above
  float rx = round(cube_x);
  float ry = round(cube_y);
  float rz = round(cube_z);
  const float x_diff = fabs(rx - cube_x);
  const float y_diff = fabs(ry - cube_y);
  const float z_diff = fabs(rz - cube_z);
  if (x_diff > y_diff && x_diff > z_diff) {
    rx = -ry - rz;
  } else if (y_diff <= z_diff) {
    rz = -rx - ry;
  }

  // now convert the cube/hex coord to a pixel location
  float hx = hexsize * 3.0f / 2.0f * rx + xoffset;
  float hy = hexsize * sqrt3 * (rz + rx / 2.0f) + yoffset;

  // and pack as two 14.2 fixed-point values into 32bits
  int32_t ux = static_cast<int32_t>(hx * 4.0f);
  int32_t uy = static_cast<int32_t>(hy * 4.0f);
  return (ux & 0x7FFF) | ((uy & 0x7FFF) << 16);
}

EXTENSION_NOINLINE float reg_hex_vert_pixel_bin_x	(	const double	valx,
		const double	minx,
		const double	maxx,
		const double	valy,
		const double	miny,
		const double	maxy,
		const double	hexwidth,
		const double	hexheight,
		const double	offsetx,
		const double	offsety,
		const int32_t	imgwidth,
		const int32_t	imgheight
	)

Definition at line 820 of file ExtensionFunctions.hpp.

References anonymous_namespace{Utm.h}::f.

                                                        {
  const float sqrt3 = 1.7320508075688772;
  const float imgwidthf = float(imgwidth);
  const float imgheightf = float(imgheight);
  const float hexwidthf = float(hexwidth);
  const float hexheightf = float(hexheight);

  // expand the bounds of the data according
  // to the input offsets. This is done because
  // we also expand the image size according to the
  // offsets because this algorithm layers the hexagon
  // bins starting at the bottom left corner
  double xmin = minx;
  float xoffset = offsetx;
  if (xoffset != 0) {
    xoffset = fmodf(xoffset, 1.5f * hexwidthf);
    if (xoffset > 0) {
      xoffset -= 1.5f * hexwidthf;
    }
    xmin += xoffset * (maxx - xmin) / imgwidthf;
  }

  double ymin = miny;
  float yoffset = offsety;
  if (yoffset != 0) {
    yoffset = fmodf(yoffset, hexheightf);
    if (yoffset > 0) {
      yoffset -= hexheightf;
    }
    ymin += yoffset * (maxy - ymin) / imgheightf;
  }

  // get the pixel position of the point
  // assumes a linear scale here
  // Rounds to the nearest pixel.
  const float pix_x =
      roundf((imgwidthf - xoffset) * float((valx - xmin) / (maxx - xmin)));
  const float pix_y =
      roundf((imgheightf - yoffset) * float((valy - ymin) / (maxy - ymin)));

  // Now convert the pixel position into a
  // cube-coordinate system representation
  const float hexsize = hexwidthf / 2.0f;
  const float cube_x = (pix_x * 2.0f / 3.0f) / hexsize;
  const float cube_z = ((pix_y / sqrt3) - (pix_x / 3.0f)) / hexsize;
  const float cube_y = -cube_x - cube_z;

  // need to round the cube coordinates above
  float rx = round(cube_x);
  float ry = round(cube_y);
  float rz = round(cube_z);
  const float x_diff = fabs(rx - cube_x);
  const float y_diff = fabs(ry - cube_y);
  const float z_diff = fabs(rz - cube_z);
  if (x_diff > y_diff && x_diff > z_diff) {
    rx = -ry - rz;
  }

  // now convert the cube/hex coord to a pixel location
  return hexsize * 3.0f / 2.0f * rx + xoffset;
}

EXTENSION_NOINLINE float reg_hex_vert_pixel_bin_y	(	const double	valx,
		const double	minx,
		const double	maxx,
		const double	valy,
		const double	miny,
		const double	maxy,
		const double	hexwidth,
		const double	hexheight,
		const double	offsetx,
		const double	offsety,
		const int32_t	imgwidth,
		const int32_t	imgheight
	)

Definition at line 894 of file ExtensionFunctions.hpp.

References anonymous_namespace{Utm.h}::f.

                                                        {
  const float sqrt3 = 1.7320508075688772;
  const float imgwidthf = float(imgwidth);
  const float imgheightf = float(imgheight);
  const float hexwidthf = float(hexwidth);
  const float hexheightf = float(hexheight);

  // expand the bounds of the data according
  // to the input offsets. This is done because
  // we also expand the image size according to the
  // offsets because this algorithm layers the hexagon
  // bins starting at the bottom left corner
  float xmin = minx;
  float xoffset = offsetx;
  if (xoffset != 0) {
    xoffset = fmodf(xoffset, 1.5f * hexwidthf);
    if (xoffset > 0) {
      xoffset -= 1.5f * hexwidthf;
    }
    xmin += xoffset * (maxx - xmin) / imgwidthf;
  }

  float ymin = miny;
  float yoffset = offsety;
  if (yoffset != 0) {
    yoffset = fmodf(yoffset, hexheightf);
    if (yoffset > 0) {
      yoffset -= hexheightf;
    }
    ymin += yoffset * (maxy - ymin) / imgheightf;
  }

  // get the pixel position of the point
  // assumes a linear scale here
  // Rounds to the nearest pixel.
  const float pix_x = roundf((imgwidthf - xoffset) * (valx - xmin) / (maxx - xmin));
  const float pix_y = roundf((imgheightf - yoffset) * (valy - ymin) / (maxy - ymin));

  // Now convert the pixel position into a
  // cube-coordinate system representation
  const float hexsize = hexwidthf / 2.0f;
  const float cube_x = (pix_x * 2.0f / 3.0f) / hexsize;
  const float cube_z = ((pix_y / sqrt3) - (pix_x / 3.0f)) / hexsize;
  const float cube_y = -cube_x - cube_z;

  // need to round the cube coordinates above
  float rx = round(cube_x);
  float ry = round(cube_y);
  float rz = round(cube_z);
  const float x_diff = fabs(rx - cube_x);
  const float y_diff = fabs(ry - cube_y);
  const float z_diff = fabs(rz - cube_z);
  if (x_diff > y_diff && x_diff > z_diff) {
    rx = -ry - rz;
  } else if (y_diff > z_diff) {
    ry = -rx - rz;
  } else {
    rz = -rx - ry;
  }

  // now convert the cube/hex coord to a pixel location
  return hexsize * sqrt3 * (rz + rx / 2.0f) + yoffset;
}

EXTENSION_NOINLINE double Round	(	const double	x,
		const int32_t	y
	)

Definition at line 187 of file ExtensionFunctions.hpp.

                                              {
  if (y == 0) {
    return round(x) + 0.0;
  }

  double exp = pow(10, y);
#if defined(__powerpc__) && !defined(__CUDACC__)
  int32_t yy = y - 1;
  exp = 10 * powf((float)10L, yy);
#endif
  return (round(x * exp) / exp) + 0.0;
}

EXTENSION_NOINLINE double Round2_to_digit	(	const double	x,
		const int32_t	y
	)

Definition at line 289 of file ExtensionFunctions.hpp.

                                                        {
  double exp = pow(10, y);
  return round(x * exp) / exp;
}

EXTENSION_NOINLINE float Round__	(	const float	x,
		const int32_t	y
	)

Definition at line 201 of file ExtensionFunctions.hpp.

                                              {
  if (y == 0) {
    return roundf(x) + 0.0f;
  }

  float exp = powf((float)10L, y);
#if defined(__powerpc__) && !defined(__CUDACC__)
  int32_t yy = y - 1;
  exp = 10 * powf((float)10L, yy);
#endif
  return roundf(x * exp) / exp + 0.0f;
}

EXTENSION_NOINLINE int16_t Round__1	(	const int16_t	x,
		const int32_t	y
	)

Definition at line 215 of file ExtensionFunctions.hpp.

                                                   {
  if (y >= 0) {
    return x;
  }

  int32_t p = pow((float)10L, std::abs(y));
  int32_t p_half = p >> 1;

  int64_t temp = x;
#if defined(__powerpc__) && !defined(__CUDACC__)
  int16_t xx = x;
  xx += 1;
  temp = xx;
  temp -= 1;
#endif
  temp = temp >= 0 ? temp + p_half : temp - p_half;
  temp = temp / p;
  return temp * p;
}

EXTENSION_NOINLINE int32_t Round__2	(	const int32_t	x,
		const int32_t	y
	)

Definition at line 236 of file ExtensionFunctions.hpp.

                                                   {
  if (y >= 0) {
    return x;
  }

  int32_t p = pow((float)10L, std::abs(y));
  int32_t p_half = p >> 1;

  int64_t temp = x;
#if defined(__powerpc__) && !defined(__CUDACC__)
  int32_t xx = x;
  xx += 1;
  temp = xx;
  temp -= 1;
#endif
  temp = temp >= 0 ? temp + p_half : temp - p_half;
  temp = temp / p;
  return temp * p;
}

EXTENSION_NOINLINE int64_t Round__3	(	const int64_t	x,
		const int32_t	y
	)

Definition at line 257 of file ExtensionFunctions.hpp.

                                                   {
  if (y >= 0) {
    return x;
  }

  int64_t p = pow((double)10L, std::abs(y));
  int64_t p_half = p >> 1;

  int64_t temp = x;
  temp = temp >= 0 ? temp + p_half : temp - p_half;
  temp = temp / p;
  return temp * p;
}

EXTENSION_NOINLINE int64_t Round__4	(	const int64_t	x,
		const int32_t	y0,
		const int32_t	scale
	)

Definition at line 272 of file ExtensionFunctions.hpp.

                                                                         {
  int32_t y = y0 - scale;

  if (y >= 0) {
    return x;
  }

  int64_t p = pow((double)10L, std::abs(y));
  int64_t p_half = p >> 1;

  int64_t temp = x;
  temp = temp >= 0 ? temp + p_half : temp - p_half;
  temp = temp / p;
  return temp * p;
}

EXTENSION_NOINLINE double round_to_digit	(	const double	x,
		const int32_t	y
	)

Definition at line 295 of file ExtensionFunctions.hpp.

                                                       {
  double exp = pow(10, y);
  return round(x * exp) / exp;
}

EXTENSION_NOINLINE double Sin

(

const double

x

)

Definition at line 301 of file ExtensionFunctions.hpp.

                           {
  return sin(x);
}

EXTENSION_NOINLINE double Sinh

(

const double

x

)

Definition at line 306 of file ExtensionFunctions.hpp.

                            {
  return sinh(x);
}

EXTENSION_NOINLINE double Sqrt

(

const double

x

)

Definition at line 311 of file ExtensionFunctions.hpp.

                            {
  return sqrt(x);
}

EXTENSION_NOINLINE double Tan

(

const double

x

)

Definition at line 316 of file ExtensionFunctions.hpp.

                           {
  return tan(x);
}

EXTENSION_NOINLINE double Tan__

(

const float

x

)

Definition at line 326 of file ExtensionFunctions.hpp.

                            {
  return tanf(x);
}

EXTENSION_NOINLINE double Tanh

(

const double

x

)

Definition at line 321 of file ExtensionFunctions.hpp.

                            {
  return tanh(x);
}

EXTENSION_NOINLINE double Truncate	(	const double	x,
		const int32_t	y
	)

Definition at line 331 of file ExtensionFunctions.hpp.

Referenced by com.mapd.calcite.parser.HeavyDBSqlOperatorTable::addUDF().

                                                 {
  double p = pow((double)10L, y);
  int64_t temp = x * p;
  return temp / p;
}

Here is the caller graph for this function:

EXTENSION_NOINLINE float Truncate__	(	const float	x,
		const int32_t	y
	)

Definition at line 338 of file ExtensionFunctions.hpp.

                                                 {
  float p = powf((float)10L, y);
  int64_t temp = x * p;
  return temp / p;
}

EXTENSION_NOINLINE int16_t Truncate__1	(	const int16_t	x,
		const int32_t	y
	)

Definition at line 345 of file ExtensionFunctions.hpp.

                                                      {
  if (y >= 0) {
    return x;
  }
  int32_t p = pow((float)10L, std::abs(y));
  int64_t temp = x / p;
#if defined(__powerpc__) && !defined(__CUDACC__)
  int16_t xx = x;
  xx += 1;
  temp = xx;
  temp -= 1;
  temp /= p;
#endif
  return temp * p;
}

EXTENSION_NOINLINE int32_t Truncate__2	(	const int32_t	x,
		const int32_t	y
	)

Definition at line 362 of file ExtensionFunctions.hpp.

                                                      {
  if (y >= 0) {
    return x;
  }
  int32_t p = pow((float)10L, std::abs(y));
  int64_t temp = x / p;
  return temp * p;
}

EXTENSION_NOINLINE int64_t Truncate__3	(	const int64_t	x,
		const int32_t	y
	)

Definition at line 372 of file ExtensionFunctions.hpp.

                                                      {
  if (y >= 0) {
    return x;
  }
  int64_t p = pow((double)10L, std::abs(y));
  int64_t temp = x / p;
  return temp * p;
}