SQLite

      p2 = len-p1;
      if( p2<0 ) p2 = 0;
    }
    sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT);
  }
}

/*
** The library round() function is only available if
** SQLITE_ENABLE_MATH_FUNCTIONS is defined.  Without that macro, we
** have to grow our own.
**
** The sqlite3Round(x) routine only needs to deal with non-negative
** numbers.
*/
#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
# define sqlite3Round(X) round(X)
#else
static double sqlite3Round(double x){
  assert( x>=0.0 );
  if( x>+4503599627370496.0 ){
    return x;
  }else{
    sqlite3_int64 ii = (sqlite3_int64)(x+0.5);
    return (double)ii;
  }
}
#endif

/*
** This is the value of the least significant bit of the significand
** relative to the total magnitude of the number for an IEEE754 binary64.
** Since the significant is 53 bits, this is pow(2,-52).
*/
#define SQLITE_DOUBLE_EPSILON 2.220446049250313080847263336181640625e-16

/*
** Implementation of the round() function
*/
#ifndef SQLITE_OMIT_FLOATING_POINT
static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  int n = 0;
  double r;
  char *zBuf;
  int n = 0;        /* Second argument. Digits to the right of decimal point */
  double r;         /* First argument.  Value to be rounded */
  double rX = 1.0;  /* Scaling factor.  pow(10,n) */
  double rSgn;      /* Sign of the first argument */
  assert( argc==1 || argc==2 );
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  r = sqlite3_value_double(argv[0]);
  if( r<0 ){
    rSgn = -1.0;
    r = -r;
  }else{
    rSgn = 1.0;
  }
  if( argc==2 ){
    double rY = 10.0;   /* Use to compute rX */
    int i;              /* Loop counter for computing rX */
    if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
    n = sqlite3_value_int(argv[1]);
    if( n>30 ) n = 30;
    if( n<0 ) n = 0;
  }
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  r = sqlite3_value_double(argv[0]);
  /* If Y==0 and X will fit in a 64-bit int,
  ** handle the rounding directly,
  ** otherwise use printf.
  */
  if( r<-4503599627370496.0 || r>+4503599627370496.0 ){
    /* The value has no fractional part so there is nothing to round */
  }else if( n==0 ){ 
    r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5)));
  }else{
    zBuf = sqlite3_mprintf("%!.*f",n,r);
    if( zBuf==0 ){
    for(i=n, rY=10; i>0; i>>=1, rY=rY*rY){
      if( i&1 ) rX *= rY;
      sqlite3_result_error_nomem(context);
      return;
    }
    sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
    sqlite3_free(zBuf);
  }
  r = rSgn*sqlite3Round(r*rX + rX*r*SQLITE_DOUBLE_EPSILON)/rX;
  sqlite3_result_double(context, r);
}
#endif

/*
** Allocate nByte bytes of space using sqlite3Malloc(). If the
** allocation fails, call sqlite3_result_error_nomem() to notify

  int argc,
  sqlite3_value **argv
){
  assert( argc==0 );
  (void)argv;
  sqlite3_result_double(context, M_PI);
}

#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */

/*
** Implementation of sign(X) function.
*/
static void signFunc(
  sqlite3_context *context,

# 2024-06-10
#
# The author disclaims copyright to this source code.  In place of
# a legal notice, here is a blessing:
#
#    May you do good and not evil.
#    May you find forgiveness for yourself and forgive others.
#    May you share freely, never taking more than you give.
#
#***********************************************************************
# 
#  https://sqlite.org/forum/forumpost/c0753dfb2d5d7f75
#

set testdir [file dirname $argv0]
source $testdir/tester.tcl
set testprefix round2

load_static_extension db stmtrand ieee754
do_execsql_test 1.1 {
  WITH RECURSIVE
    c(n) AS (VALUES(0) UNION ALL SELECT n+1 FROM c WHERE n<100000),
    r(a,b) AS MATERIALIZED (SELECT stmtrand()%100000, stmtrand()%100000 FROM c),
    f(x,y,n) AS (
       SELECT CAST(format('%d.%d5',a,b) AS real),
              CAST(format('%d.%d6',a,b) AS real),
               length(format('%d',b)) FROM r)
    SELECT x, n, round(x,n), round(y,n) FROM f
     WHERE round(x,n)<>round(y,n);

} {}
do_execsql_test 1.2 {
  SELECT round(0.15,1);
} 0.2
do_execsql_test 1.3 {
  SELECT round(0.14999999999999999,1);
} 0.2
do_execsql_test 1.4 {
  SELECT round(0.1499999999999999944488848768742172978818416595458984375,1);
} 0.2
do_execsql_test 1.5 {
  SELECT round(ieee754_from_blob(x'3fc3333333333333'),1);
} 0.2
do_execsql_test 1.6 {
  SELECT round(ieee754_from_blob(x'3fc3333333333332'),1);
} 0.1



finish_test