int main()
{
// printf("hello, world");
char result[BUFFER_SIZE];
char remainder[BUFFER_SIZE];
// please make sure the bit length is enough before calculate
// especially when you do a large power operation
// you can change it by define: BIG_INT_BIT_LEN
// the default bit length for BigInt is 1024
// routine test
puts(Add("2010", "4", result));
puts(Sub("0", "2014", result));
puts(Mul("2", "43", result));
puts(Div("86", "10", result, remainder));
puts(remainder);
puts(Mod("-86", "10", result));
puts(PowMod("7", "80", "86", result));
// BigInt test
puts(Sub("233333333333333333333333333333333333333333333333", "33", result));
puts(Mul("2333333333333333333333333333333", "2333333333333333333", result));
puts(Div("2333333333333333333333333333333", "2333333333333333332", result, remainder));
puts(remainder);
puts(Pow("8", "86", result));
return 0;
}
bool RopeJoint::SolvePositionConstraints(const SolverData& data)
{
Vec2 cA = data.positions[m_indexA].c;
float32 aA = data.positions[m_indexA].a;
Vec2 cB = data.positions[m_indexB].c;
float32 aB = data.positions[m_indexB].a;
Rot qA(aA), qB(aB);
Vec2 rA = Mul(qA, m_localAnchorA - m_localCenterA);
Vec2 rB = Mul(qB, m_localAnchorB - m_localCenterB);
Vec2 u = cB + rB - cA - rA;
float32 length = u.Normalize();
float32 C = length - m_maxLength;
C = Clamp(C, 0.0f, maxLinearCorrection);
float32 impulse = -m_mass * C;
Vec2 P = impulse * u;
cA -= m_invMassA * P;
aA -= m_invIA * Cross(rA, P);
cB += m_invMassB * P;
aB += m_invIB * Cross(rB, P);
data.positions[m_indexA].c = cA;
data.positions[m_indexA].a = aA;
data.positions[m_indexB].c = cB;
data.positions[m_indexB].a = aB;
return length - m_maxLength < linearSlop;
}
int ConjGradientMod(float3N &X, float3Nx3N &A, float3N &B,int3 hack)
{
// obsolete!!!
// Solves for unknown X in equation AX=B
conjgrad_loopcount=0;
int n=B.count;
float3N q(n),d(n),tmp(n),r(n);
r = B - Mul(tmp,A,X); // just use B if X known to be zero
r[hack[0]] = r[hack[1]] = r[hack[2]] = float3(0,0,0);
d = r;
float s = dot(r,r);
float starget = s * squared(conjgrad_epsilon);
while( s>starget && conjgrad_loopcount++ < conjgrad_looplimit)
{
Mul(q,A,d); // q = A*d;
q[hack[0]] = q[hack[1]] = q[hack[2]] = float3(0,0,0);
float a = s/dot(d,q);
X = X + d*a;
if(conjgrad_loopcount%50==0)
{
r = B - Mul(tmp,A,X);
r[hack[0]] = r[hack[1]] = r[hack[2]] = float3(0,0,0);
}
else
{
r = r - q*a;
}
float s_prev = s;
s = dot(r,r);
d = r+d*(s/s_prev);
d[hack[0]] = d[hack[1]] = d[hack[2]] = float3(0,0,0);
}
conjgrad_lasterror = s;
return conjgrad_loopcount<conjgrad_looplimit; // true means we reached desired accuracy in given time - ie stable
}
int ConjGradientFiltered(float3N &X, const float3Nx3N &A, const float3N &B,const float3Nx3N &S)
{
// Solves for unknown X in equation AX=B
conjgrad_loopcount=0;
int n=B.count;
float3N q(n),d(n),tmp(n),r(n);
r = B - Mul(tmp,A,X); // just use B if X known to be zero
filter(r,S);
d = r;
float s = dot(r,r);
float starget = s * squared(conjgrad_epsilon);
while( s>starget && conjgrad_loopcount++ < conjgrad_looplimit)
{
Mul(q,A,d); // q = A*d;
filter(q,S);
float a = s/dot(d,q);
X = X + d*a;
if(conjgrad_loopcount%50==0)
{
r = B - Mul(tmp,A,X);
filter(r,S);
}
else
{
r = r - q*a;
}
float s_prev = s;
s = dot(r,r);
d = r+d*(s/s_prev);
filter(d,S);
}
conjgrad_lasterror = s;
return conjgrad_loopcount<conjgrad_looplimit; // true means we reached desired accuracy in given time - ie stable
}
void Intermediate ( Quaternion* q0, Quaternion* q1, Quaternion* q2,
Quaternion* a, Quaternion* b)
{
/* assert: q0, q1, q2 are unit quaternions */
/*Quaternion q0inv = q0.UnitInverse();
Quaternion q1inv = q1.UnitInverse();
Quaternion p0 = q0inv*q1;
Quaternion p1 = q1inv*q2;
Quaternion arg = 0.25*(p0.Log()-p1.Log());
Quaternion marg = -arg;
a = q1*arg.Exp();
b = q1*marg.Exp();
*/
Quaternion p0, p1;
UnitInverse(&p0, q0);
UnitInverse(&p1, q1);
MulSelf(&p0, q1);
MulSelf(&p1, q2);
LogSelf(&p0);
LogSelf(&p1);
Sub(a,&p0, &p1);
MulScalSelf(a, 0.25);
Neg(b, a);
ExpSelf(a);
ExpSelf(b);
Mul(a, q1, a);
Mul(b, q1, b);
}
u64 SumOfDivisorsOfBinomialCoefficient(u64 n, u64 k) {
if (n == 2) {
return k == 1 ? 3 : 1;
} else if (n < 2) {
return 1;
}
Vector primes = GetPrimes(n);
Vector powers;
for (auto x: primes) {
powers.push_back(
PowerOfDivisor(x, n) -
PowerOfDivisor(x, k) -
PowerOfDivisor(x, n - k)
);
}
u64 result = 1;
for (u64 i = 0; i < primes.size(); ++i) {
u64 sum_of_powers = 0;
u64 x = 1;
for (u64 p = 0; p <= powers[i]; ++p) {
sum_of_powers = Sum(sum_of_powers, x);
x = Mul(x, primes[i]);
}
result = Mul(result, sum_of_powers);
}
return result;
}
void mul(Ring_Element& ans,const Ring_Element& a,const Ring_Element& b)
{
if (a.rep!=b.rep) { throw rep_mismatch(); }
if (a.FFTD!=b.FFTD) { throw pr_mismatch(); }
ans.partial_assign(a);
if (ans.rep==evaluation)
{ // In evaluation representation, so we can just multiply componentwise
for (int i=0; i<(*ans.FFTD).phi_m(); i++)
{ Mul(ans.element[i],a.element[i],b.element[i],(*a.FFTD).get_prD()); }
}
else if ((*ans.FFTD).get_twop()!=0)
{ // This is the case where m is not a power of two
// Here we have to do a poly mult followed by a reduction
// We could be clever (e.g. use Karatsuba etc), but instead
// we do the school book method followed by term re-writing
// School book mult
vector<modp> aa(2*(*a.FFTD).phi_m());
for (int i=0; i<2*(*a.FFTD).phi_m(); i++)
{ assignZero(aa[i],(*a.FFTD).get_prD()); }
modp temp;
for (int i=0; i<(*a.FFTD).phi_m(); i++)
{ for (int j=0; j<(*a.FFTD).phi_m(); j++)
{ Mul(temp,a.element[i],b.element[j],(*a.FFTD).get_prD());
int k=i+j;
Add(aa[k],aa[k],temp,(*a.FFTD).get_prD());
}
}
// Now apply reduction, assumes Ring.poly is monic
for (int i=2*(*a.FFTD).phi_m()-1; i>=(*a.FFTD).phi_m(); i--)
{ reduce_step(aa,i,*a.FFTD);
assignZero(aa[i],(*a.FFTD).get_prD());
}
// Now stick into answer
for (int i=0; i<(*ans.FFTD).phi_m(); i++)
{ ans.element[i]=aa[i]; }
}
else if ((*ans.FFTD).get_twop()==0)
{ // m a power of two case
Ring_Element aa(*ans.FFTD,ans.rep);
modp temp;
for (int i=0; i<(*ans.FFTD).phi_m(); i++)
{ for (int j=0; j<(*ans.FFTD).phi_m(); j++)
{ Mul(temp,a.element[i],b.element[j],(*a.FFTD).get_prD());
int k=i+j;
if (k>=(*ans.FFTD).phi_m())
{ k-=(*ans.FFTD).phi_m();
Negate(temp,temp,(*a.FFTD).get_prD());
}
Add(aa.element[k],aa.element[k],temp,(*a.FFTD).get_prD());
}
}
ans=aa;
}
else
{ throw not_implemented(); }
}
/*----------------------------------------------------------------------------------------------
Core routine to map between local and Utc. This assumes that DST doesn't kick in
near a year boundary so that when the switch happens, the DST and STD times are in the
same year.
----------------------------------------------------------------------------------------------*/
int64 TimeMapper::MapMsec(int64 msecSrc, bool fToUtc)
{
int64 msecT;
int msecDay;
int day;
int dayMin;
int dyear;
int yday;
int yt;
int ymin;
// First determines the year type and minute within the year.
// Mod to 400 year period.
msecT = ModPos(msecSrc, kmsecPerPeriod);
// Find the day within the 400 year period.
day = (int)(msecT / kmsecPerDay);
Assert(0 <= day && day < kdayPerPeriod);
// Get the time within the day.
msecDay = (int)(msecT - day * (int64)kmsecPerDay);
Assert(0 <= msecDay && msecDay < kmsecPerDay);
// Find the year within the 400 year period (dyear) and the day within that year (yday).
Assert(0 <= day && day < 146097);
dyear = YearFromDayInPeriod(day, &yday);
Assert(0 <= dyear && dyear < 400);
Assert(0 <= yday && (yday < 365 || yday == 365 && SilTime::IsLeapYear(dyear + kyearBase)));
// Calculate the day number (within the 400 year period) of the first day of
// the year (dayMin).
dayMin = day - yday;
Assert(dayMin == DayFromYearInPeriod(dyear));
// Get the year type. kdayMonday is used because T0 is a Monday.
yt = ModPos(dayMin + kwdayMonday, kdayPerWeek);
if (SilTime::IsLeapYear(dyear + kyearBase))
yt += kdayPerWeek;
// Calculate the minute within the year.
ymin = yday * kminPerDay + msecDay / kmsecPerMin;
if (!fToUtc)
{
// Mapping from utc to local.
if (m_rgyminMin[yt] <= ymin && ymin < m_rgyminLim[yt])
return msecSrc + Mul(m_dminTz2, kmsecPerMin);
return msecSrc + Mul(m_dminTz1, kmsecPerMin);
}
// The overlap is always ambiguous and there's nothing we can do about it.
ymin -= m_dminTz2;
if (m_rgyminMin[yt] <= ymin && ymin < m_rgyminLim[yt])
return msecSrc - Mul(m_dminTz2, kmsecPerMin);
return msecSrc - Mul(m_dminTz1, kmsecPerMin);
}
//If you ever call something with 1 octave, call this instead
void plainSIMD3d(SIMD* out, Settings* S,ISIMDNoise3d noise )
{
SIMD vfx = Mul(S->x.m, S->frequency);
SIMD vfy = Mul(S->y.m, S->frequency);
SIMD vfz = Mul(S->z.m, S->frequency);
*out = noise(&vfx, &vfy, &vfz);
}
Rect Rect::operator*(mat4 matrix) const
{
matrix = Transpose(matrix);
vec4 returnVec1 = Mul(vec4(m_LeftBottom.x, m_LeftBottom.y, 0, 1), matrix);
vec4 returnVec2 = Mul(vec4(m_RightBottom.x, m_RightBottom.y, 0, 1), matrix);
vec4 returnVec3 = Mul(vec4(m_LeftTop.x, m_LeftTop.y, 0, 1), matrix);
vec4 returnVec4 = Mul(vec4(m_RightTop.x, m_RightTop.y, 0, 1), matrix);
return Rect(vec2(returnVec1.x , returnVec1.y),
vec2(returnVec2.x , returnVec2.y),
vec2(returnVec3.x , returnVec3.y),
vec2(returnVec4.x , returnVec4.y));
}
void Power( Matrix A, int P )
{
Matrix R;
memset(R, 0, sizeof(R));
for (int i = 0; i < N; i++)
R[i][i] = 1;
for (; P; P >>= 1)
{
if (P & 1)
Mul(R, A);
Mul(A, A);
}
A = R;
}
void f ()
{
Matrix<2, 3> q;
Matrix<2, 4> a;
Matrix<4, 3> b;
q = Mul (q, a, b);
}
/****************************************************
FFT()
参数：
TD为时域值
FD为频域值
power为2的幂数
返回值：
无
说明：
本函数实现快速傅立叶变换
****************************************************/
void FFT(COMPLEX * TD, COMPLEX * FD, int power)
{
int count;
int i,j,k,bfsize,p;
double angle;
COMPLEX *W,*X1,*X2,*X;
/*计算傅立叶变换点数*/
count=1<<power;
/*分配运算所需存储器*/
W=(COMPLEX *)malloc(sizeof(COMPLEX)*count/2);
X1=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
X2=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
/*计算加权系数*/
for(i=0;i<count/2;i++)
{
angle=-i*PI*2/count;
W[i].re=cos(angle);
W[i].im=sin(angle);
}
/*将时域点写入存储器*/
memcpy(X1,TD,sizeof(COMPLEX)*count);
/*蝶形运算*/
for(k=0;k<power;k++)
{
for(j=0;j<1<<k;j++)
{
bfsize=1<<(power-k);
for(i=0;i<bfsize/2;i++)
{
p=j*bfsize;
X2[i+p]=Add(X1[i+p],X1[i+p+bfsize/2]);
X2[i+p+bfsize/2]=Mul(Sub(X1[i+p],X1[i+p+bfsize/2]),W[i*(1<<k)]);
}
}
X=X1;
X1=X2;
X2=X;
}
/*重新排序*/
for(j=0;j<count;j++)
{
p=0;
for(i=0;i<power;i++)
{
if (j&(1<<i)) p+=1<<(power-i-1);
}
FD[j]=X1[p];
}
/*释放存储器*/
free(W);
free(X1);
free(X2);
}
void FastMul(const BigInt &A,const BigInt &B, BigInt &C) {
ulong Len = 2;
while ( Len < A.Size + B.Size ) Len *=2;
if ( Len < 40 ) {
BigInt Atmp(A), Btmp(B);
Mul(Atmp,Btmp,C);
return;
}
ulong x;
const ushort *a=A.Coef, *b=B.Coef;
for (x = 0; x < A.Size; x++) LongNum1[x] = a[x];
for (; x < Len; x++) LongNum1[x] = 0.0;
FHT_F(LongNum1,Len);
if (a == b) {
FHTConvolution(LongNum1,LongNum1,Len);
} else {
for (x = 0; x < B.Size; x++) LongNum2[x] = b[x];
for (; x < Len; x++) LongNum2[x] = 0.0;
FHT_F(LongNum2,Len);
FHTConvolution(LongNum1,LongNum2,Len);
}
FHT_T(LongNum1,Len);
CarryNormalize(LongNum1, Len, C);
}
char *Ricerca_e_deriva(char *funzione_1, char *funzione_2, char *operatore, char *output)
{
output = (char *)malloc(sizeof(char)*10000);
if ( strcmp(operatore,"x") == 0 || ( strcmp(operatore,"plus") != 0 && strcmp(operatore,"mul") != 0 && strcmp(operatore,"sot") != 0 && strcmp(operatore,"pow") != 0 ))
output = D_Fondamentali(operatore); // Se il primo operando è una x oppure non è nessuna delle funzioni previste allora chiama D_Fondamentali
if(strcmp(operatore,"pow") == 0) // Potenza
output = Pow(funzione_1,funzione_2, output);
if(strcmp(operatore,"mul") == 0) // Prodotto
output = Mul(funzione_1 ,funzione_2, output);
if(strcmp(operatore,"div") == 0) // Rapporto
output = Div(funzione_1 ,funzione_2, output);
if(strcmp(operatore,"plus") == 0) // Somma
output = Sum(funzione_1,funzione_2, output);
if(strcmp(operatore,"sot") == 0) // Differenza
output = Sot(funzione_1,funzione_2, output);
if(strcmp(operatore,"sin") == 0) // Seno
output = Sin(funzione_1, "", output);
if(strcmp(operatore,"cos") == 0) // Coseno
output = Cos(funzione_1, "", output);
return output; // Ritorno la funzione già derivata
}
BigData BigData::operator*(const BigData& bigData)
{
if (0 == m_llValue || 0 == bigData.m_llValue)
{
return BigData(INT64(0));
}
if (!IsINT64Owerflow() && !bigData.IsINT64Owerflow())
{
if (m_strData[0] == bigData.m_strData[0])//同号
{
// 10 /2 = 5 >= 1 2 3 4 5
// 10 /-2 = -5 <= -5 -4 -3 -2 -1
if (('+' == m_strData[0] && MAX_INT64 / m_llValue >= bigData.m_llValue) ||
('-' == m_strData[0] && MAX_INT64 / m_llValue <= bigData.m_llValue))
{
return BigData(m_llValue*bigData.m_llValue);
}
}
else//不同号
{
// -10 /2 = -5 <=
// -10/-2 = 5 >
if (('+' == m_strData[0] && MIN_INT64 / m_llValue <= bigData.m_llValue) ||
('-' == m_strData[0] && MIN_INT64 / m_llValue >= bigData.m_llValue))
{
return BigData(m_llValue*bigData.m_llValue);
}
}
}
return BigData(Mul(m_strData, bigData.m_strData).c_str());
}
BigData BigData::operator*(const BigData& bigData)
{
if (m_llValue == 0 || bigData.m_llValue == 0)
{
return BigData(INT64(0));
}
if (!IsINT64Overflow() && !bigData.IsINT64Overflow())
{
if (m_strData[0] == bigData.m_strData[0])
{
if ((m_strData[0] == '+' && MAX_INT64 / m_llValue >= bigData.m_llValue)
|| (m_strData[0] == '-' && MAX_INT64 / m_llValue <= bigData.m_llValue))
{
return BigData(m_llValue * bigData.m_llValue);
}
}
else
{
if ((m_strData[0] == '+' && MIN_INT64 / m_llValue <= bigData.m_llValue)
|| (m_strData[0] == '-' && MIN_INT64 / m_llValue >= bigData.m_llValue))
{
return BigData(m_llValue * bigData.m_llValue);
}
}
}
return BigData(Mul(m_strData, bigData.m_strData).c_str());
}
BigData BigData::operator* (const BigData& bigdata)
{
if (!IsOverFlowINT64() && !bigdata.IsOverFlowINT64())
{
if (_value == 0 || bigdata._value == 0)
{
return BigData((INT64) 0);
}
//10 /2 = 5 >= 3 10 / -2 = -5 <= -4
if (_pData[0] == bigdata._pData[0])
{
if ((_pData[0] == '+' && LLONG_MAX / _value >= bigdata._value) ||
(_pData[0] == '-' && LLONG_MAX / _value <= bigdata._value))
{
return BigData(_value * bigdata._value);
}
}
else
{
// -10 / 2 = -5 <= -4 -10 / -2 = 5 >= 4
if ((_pData[0] == '+' && (LLONG_MIN /_value <= bigdata._value)) ||
(_pData[0] == '-' && (LLONG_MIN / _value >= bigdata._value)))
{
return BigData(_value * bigdata._value);
}
}
}
return BigData((char *)Mul(_pData, bigdata._pData).c_str());
}
BigData BigData::operator*(const BigData& bigdata)
{
if ((0 == _value) || (0 == bigdata._value))
{
return BigData(INT64(0));
}
if (IsINT64OverFlow() && bigdata.IsINT64OverFlow())
{
if (_strData[0] == bigdata._strData[0])
{
if (((_value > 0) && ((long long)MAX_INT64 / _value >= bigdata._value)) ||
((_value < 0) && ((long long)MAX_INT64 / _value <= bigdata._value))) //同号相乘 结果为正
{
return BigData(_value*bigdata._value);
}
}
else
{
if (((_value > 0) && ((long long)MIN_INT64 / _value <= bigdata._value)) ||
((_value < 0) && ((long long)MIN_INT64 / _value >= bigdata._value))) //异号相乘 结果为负
{
return BigData(_value*bigdata._value);
}
}
}
return BigData(Mul(_strData, bigdata._strData).c_str());
}
int IntersectRayAABB(Point p, Point d, AABB a, float *tmin, Point *q)
{
(*tmin) = 0.0f;
float tmax = FLT_MAX;
//for all three slabs
int i;
for (i = 0; i < 3; ++i)
{
if (Abs(d[i]) < EPSILON)
if (p[i] < a.min[i] || p[i] > a.max[i]) return 0;
else
{
float ood = 1.0f / d[i];
float t1 = (a.min[i] - p[i]) * ood;
float t2 = (a.max[i] - p[i]) * ood;
if(t1 > t2) Swap(t1,t2);
(*tmin) = Max(tmin, t1);
tmax = Max(tmax, t2);
if((*tmin) > tmax) return 0;
}
}
(*q) = p + Mul(d,(*tmin));
return 1;
}
float* ofxObject::updateMatrix(float *iParentMatrix)
{
// if the object has multiple parents, the hierarchy tree matrix needs to be set to dirty, using mMatrixDirty.
if (parents.size() > 1) matrixDirty = true;
if (matrixDirty || localMatrixDirty || alwaysMatrixDirty) {
if (localMatrixDirty) {
updateLocalMatrix();
}
//matrix multiplication
Mul(localMatrix, iParentMatrix, matrix);
/*
if(id==1)
printf("matrix:\n%f\t%f\t%f\t%f\n%f\t%f\t%f\t%f\n%f\t%f\t%f\t%f\n%f\t%f\t%f\t%f\n",
matrix[0], matrix[1], matrix[2], matrix[3],
matrix[4], matrix[5], matrix[6], matrix[7],
matrix[8], matrix[9], matrix[10], matrix[11],
matrix[12], matrix[13], matrix[14], matrix[15]);
*/
// set matrix dirty flags of all children
for (unsigned int i = 0; i < children.size(); i++)
children[i]->matrixDirty = true;
//if(id == 1) printf("updateMatrix() %f\n", ofGetElapsedTimef());
//reset matrix dirty flag
matrixDirty = false;
}
return matrix;
}
void RenderFrame(Application &app, LockBufferInfo &frame_info)
{
app.render_scene_time = GetTime(app.api);
// Calculate view_projection matrix.
float4 camera_transform[4], camera_projection[4], view_projection[4];
CreateCameraTransform(camera_transform, app.camera.pos, app.camera.axis);
CreatePerspectiveProjection(camera_projection, app.camera.fov, float(app.framebuffer.width) / float(app.framebuffer.height), 0.5f, 100.0f);
Mul(view_projection, camera_transform, camera_projection);
// Build rasterizer input commands.
Build(app.rasterizer_input, app.scene, view_projection);
app.frame_info = &frame_info;
// Start the rasterizer threads
U32 event_id = app.rasterizer_event_id;
SetEvent(app.start_rasterization_event[event_id]);
// Wait for the threads to finish.
WaitForMultipleObjects(DefaultThreadAmount, app.rasterization_finished_event, TRUE, INFINITE);
ResetEvent(app.start_rasterization_event[event_id]);
app.rasterizer_event_id = (event_id + 1) % 2;
app.frame_info = NULL;
app.render_scene_time = GetTime(app.api) - app.render_scene_time;
}
BigData BigData::operator*(const BigData& bigData)
{
if (0 == m_llValue || 0 == bigData.m_llValue)
{
return BigData(INT64(0));
}
if (!IsINT64Owerflow() && !bigData.IsINT64Owerflow())
{
if (m_strData[0] == bigData.m_strData[0])
{
if (('+' == m_strData[0] && MAX_INT64 / m_llValue >= bigData.m_llValue) || ('-' == m_strData[0] && MAX_INT64 / m_llValue <= bigData.m_llValue))
{
return BigData(m_llValue*bigData.m_llValue);
}
}
else
{
//-10/2
//-10/-2
if (('+' == m_strData[0] && MIN_INT64 / m_llValue <= bigData.m_llValue) || ('-' == m_strData[0] && MIN_INT64 / m_llValue >= bigData.m_llValue))
{
return BigData(m_llValue*bigData.m_llValue);
}
}
}
return BigData(Mul(m_strData, bigData.m_strData).c_str());
}
void Quaternion::Set(const D3DXVECTOR3& vector, float angle){
x = vector.x;
y = vector.y;
z = vector.z;
Mul(sin(angle / 2));
w = cos(angle / 2);
}
int main()
{
int num = 101;
Mul mul(11);
std::cout << run(num, mul) << std::endl;
std::cout << run(num,Mul(101)) << std::endl;
return 0;
}
static word_t
multiply_with_overflow (long x, long y)
{
word_t ans = (Mul ((LONG_TO_FIXNUM (x)), (LONG_TO_FIXNUM (y))));
return (ans == SHARP_F
? SHARP_T /* This need only be !NFIX for overflow-test. */
: FIXNUM_TO_LONG (ans));
}
void MtlBlinnSW3D::Transmit(ShadeContext3D &sc)
{
BlinnBlock &block = (BlinnBlock &) sc.GetMaterialBlock(this);
const Vector4f &vertexColor = IsSet(block.VertexColor) ? *block.VertexColor : WHITE4F;
Color4f diffuseMtl;
if (DiffuseMtl)
{
DiffuseMtl->Shade(sc);
diffuseMtl = *block.Color;
}
else
diffuseMtl = WHITE4F;
Color4f Kd = Mul(PreDiffuse, Mul(diffuseMtl, vertexColor));
if (fabs(Kd.A) < 0.0001f)
Kd = Color4f(1.0f, 1.0f, 1.0f, 0.0f);
else
{
Kd.R /= Kd.A;
Kd.G /= Kd.A;
Kd.B /= Kd.A;
}
float32 y = Kd.Luminance();
Color4f satColor = Lerp(Color4f(y, y, y, 1.0f), Kd, Saturation);
satColor.A = 1.0f;
Color4f textureDetail = Lerp(Color4f(0.0f, 0.0f, 0.0f, 1.0f), satColor, ColorDetail);
textureDetail.A = 1.0f;
float32 alphaDetail = Lerp(0.0f, 1.0f - Kd.A, AlphaDetail);
Color4f outTrans = (1.0f - alphaDetail) * textureDetail + Color4f(alphaDetail); // compute 1 - (1 - ad) * (1 - td)
outTrans = Color4f(1.0f) - Mul(Color4f(1.0f) - outTrans, Color4f(1.0f) - Transmittance);
sc.Transmittance.R = max(min(outTrans.R, 1.0f), 0.0f);
sc.Transmittance.G = max(min(outTrans.G, 1.0f), 0.0f);
sc.Transmittance.B = max(min(outTrans.B, 1.0f), 0.0f);
sc.Transmittance.A = outTrans.A;
FuASSERT(sc.Transmittance.A >= 0.0f && sc.Transmittance.A <= 1.002f, (""));
}
void main(void) {
int a = 1, b = 2, c = 3, d = 4;
int result1, result2;
result1 = Sum(a * b, c * d);
result2 = Mul(a + b, c + d);
printf("result1=%d\n", result1);
printf("result2=%d\n", result2);
/* system("pause"); */
}
Quaternion::Quaternion(const D3DXVECTOR3& vector, float angle):
x(vector.x),
y(vector.y),
z(vector.z),
w(0)
{
Mul(sin(angle / 2));
w = cos(angle / 2);
}
inline void Body::Advance(float32 alpha)
{
// Advance to the new safe time. This doesn't sync the broad-phase.
m_sweep.Advance(alpha);
m_sweep.c = m_sweep.c0;
m_sweep.a = m_sweep.a0;
m_xf.q.Set(m_sweep.a);
m_xf.p = m_sweep.c - Mul(m_xf.q, m_sweep.localCenter);
}
