C RUBY-ON-RAILS MYSQL ASP.NET DEVELOPMENT RUBY .NET LINUX SQL-SERVER REGEX WINDOWS ALGORITHM ECLIPSE VISUAL-STUDIO STRING SVN PERFORMANCE APACHE-FLEX UNIT-TESTING SECURITY LINQ UNIX MATH EMAIL OOP LANGUAGE-AGNOSTIC VB6 MSBUILD

# Avoid Overflow when Calculating π by Evaluating a Series Using 16-bit Arithmetic?

By : Mathias
Date : October 25 2020, 07:10 PM
Baking-Pi Challenge - Understanding & Improving
code :
``````//---------------------------------------------------------------------------
AnsiString str_hex2dec(const AnsiString &hex)
{
char c;
AnsiString dec="",s;
int i,j,l,ll,cy,val;
int  i0,i1,i2,i3,sig;
sig=+1; l=hex.Length();
if (l) { c=hex[l]; if (c=='h') l--; if (c=='H') l--; }
i0=0; i1=l; i2=0; i3=l;
for (i=1;i<=l;i++)      // scan for parts of number
{
char c=hex[i];
if (c=='-') sig=-sig;
if ((c=='.')||(c==',')) i1=i-1;
if ((c>='0')&&(c<='9')) { if (!i0) i0=i; if ((!i2)&&(i>i1)) i2=i; }
if ((c>='A')&&(c<='F')) { if (!i0) i0=i; if ((!i2)&&(i>i1)) i2=i; }
if ((c>='a')&&(c<='f')) { if (!i0) i0=i; if ((!i2)&&(i>i1)) i2=i; }
}

l=0; s=""; if (i0) for (i=i0;i<=i1;i++)
{
c=hex[i];
if ((c>='0')&&(c<='9')) c-='0';
else if ((c>='A')&&(c<='F')) c-='A'-10;
else if ((c>='a')&&(c<='f')) c-='A'-10;
for (cy=c,j=1;j<=l;j++)
{
val=(s[j]<<4)+cy;
s[j]=val%10;
cy  =val/10;
}
while (cy>0)
{
l++;
s+=char(cy%10);
cy/=10;
}
}
if (s!="")
{
for (j=1;j<=l;j++) { c=s[j]; if (c<10) c+='0'; else c+='A'-10; s[j]=c; }
for (i=l,j=1;j<i;j++,i--) { c=s[i]; s[i]=s[j]; s[j]=c; }
dec+=s;
}
if (dec=="") dec="0";
if (sig<0) dec="-"+dec;

if (i2)
{
dec+='.';
s=hex.SubString(i2,i3-i2+1);
l=s.Length();
for (i=1;i<=l;i++)
{
c=s[i];
if ((c>='0')&&(c<='9')) c-='0';
else if ((c>='A')&&(c<='F')) c-='A'-10;
else if ((c>='a')&&(c<='f')) c-='A'-10;
s[i]=c;
}
ll=((l*1234)>>10);  // num of decimals to compute
for (cy=0,i=1;i<=ll;i++)
{
for (cy=0,j=l;j>=1;j--)
{
val=s[j];
val*=10;
val+=cy;
s[j]=val&15;
cy=val>>4;
}
dec+=char(cy+'0');
for (;;)
{
if (!l) break;;
if (s[l]) break;
l--;
}
if (!l) break;;
}
}

return dec;
}
//---------------------------------------------------------------------------
AnsiString pi_BBP() // https://en.wikipedia.org/wiki/Bailey–Borwein–Plouffe_formula
{
const int N=100;        // 32*N bit uint arithmetics
int sh;
AnsiString s;
uint<N> pi,a,b,k,k2,k3,k4;

for (pi=0,sh=(N<<5)-8,k=0;sh>=0;k++,sh-=4)
{
k2=k*k;
k3=k2*k;
k4=k3*k;
a =k2* 120;
a+=k * 151;
a+=     47;
b =k4* 512;
b+=k3*1024;
b+=k2* 712;
b+=k * 194;
b+=     15;
a<<=sh;
pi+=a/b;
}
pi<<=4;
s=pi.strhex();
s=s.Insert(".",2);
return str_hex2dec(s);
}
//---------------------------------------------------------------------------
``````
``````ref: 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989
BPP: 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912983367336244065664308602139494639522473719070217986094370277053921717629317675238467481846766940513200056812714526356082778577134275778960917363717872146844090122495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859502445945534690830264252230825334468503526193118817101000313783875288658753320838142061717766914730359825349042875546873115956286388235378759375195778185778048187
``````

Share :

## SQL Server giving arithmetic overflow when calculating avg

By : Aljerdani
Date : March 29 2020, 07:55 AM
wish help you to fix your issue Internally SQL Server is summing the values (to divide by the count later) and storing them in the columns data type - in this case an int - which isn't large enough to hold the sum - if you cast the value as a bigint first it will sum the values also storing those values in a bigint - which is probably large enough, then the average calculation can proceed.
code :
``````select avg(cast(number as bigint)) from LargeNumbers
``````

## Overflow Error evaluating arithmetic expression with integers in VBA

By : user3237752
Date : March 29 2020, 07:55 AM
hop of those help? If my logic is correct, Dim or 'Dimension' is a way of telling the application that you expect use a variable of a certain type, and that type pertains to a certain amount of 'bits' (of memory).
This reserves a section of the system's memory, which has been allocated a certain amount of bits dependant on the variable type that you have instructed in your code. These bits then define how many (If you're familiar with C++ or similar then you will probably already know all this...)
code :
``````unsigned 16 bits =         0 - 65,536    (2^16)
signed 16 bits   =   -32,768 - 32,767
32,767           =    111111111111111    (Binary)
32,768           =    1000000000000000 <--- note the extra bit
``````
``````Dim t as Integer
t = 1639
Debug.Print (20 * t - 1)
``````
``````20 * t = 20 * 1639 = 32,780
32,780 = 1000000000001100 (Binary)
``````
``````Sub SO()

Dim t As Integer, c As Long

t = 1639
c = 20

Debug.Print (20 * (t - 1))  '// No Error
Debug.Print (c * (t - 1))   '// No Error
Debug.Print ((c * t) - 1)   '// No Error

c = (20 * t - 1)            '// Error
Debug.Print (20 * t - 1)    '// Error

End Sub
``````

## Avoid arithmetic overflow on aggregate function

By : jikang sun
Date : March 29 2020, 07:55 AM
I hope this helps you . Casting to bigint before the aggregate then try_casting the result back to int would be preferable to me
But a way without that is
code :
``````SET ARITHABORT OFF
SET ANSI_WARNINGS OFF

DECLARE @tbl TABLE ( [i] INT );

INSERT  INTO @tbl
( [i] )
VALUES  ( POWER(2, 30) ),
( POWER(2, 30) );

SELECT  SUM([t].[i])
FROM    @tbl AS [t];
``````

## c++ overflow while calculating an arithmetic expression

By : Majiet ze Liar
Date : March 29 2020, 07:55 AM
will be helpful for those in need When you compile your example code, the compiler usually throws a warning identifying exactly the part of your expression that overflows
code :
``````main.cpp:4:24: warning: integer overflow in expression [-Woverflow]
std::cout << 30000 * (5 * 30000 - 22207) / 2 + 50488389 << std::endl;
~~~~~~^~~~~~~~~~~~~~~~~~~~~
``````
``````#include <iostream>
#include <cmath>

int main(int argc, char* argv[]) {
std::cout << std::trunc(30000.0 * (5.0 * 30000.0 - 22207.0) / 2.0 + 50488389.0) << std::endl;
// ^^     ^^        ^^        ^^     ^^           ^^

return 0;
}
``````
``````std::cout  << std::fixed << std::setprecision(0)
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
<< std::trunc(30000.0 * (5.0 * 30000.0 - 22207.0) / 2.0 + 50488389.0) << std::endl;
``````

## Avoid Instant.toEpochMilli() Arithmetic Overflow

By : Jeremy Fr
Date : March 29 2020, 07:55 AM
``````private Instant capped(Instant instant) {
``````millis = capped(deadline).toEpochMilli();