int main(void)
{
int i = 0,r = 0,tmp = 0,x,y,z,w,res;
double tstart,tend;
struct NUMBER a,b,c,d;
struct timeval tv;
gettimeofday(&tv,NULL);
tstart= (double)tv.tv_sec + (double)tv.tv_usec * 1.e-6;
setInt(&a,5);
arctan(&a,&b);
setInt(&a,16);
multiple(&a,&b,&c);
setInt(&a,239);
arctan(&a,&b);
setInt(&a,4);
multiple(&a,&b,&d);
sub(&c,&d,&a);
printf("a= ");
dispNumber(&a);
putchar('\n');
gettimeofday(&tv,NULL);
tend = (double)tv.tv_sec + (double)tv.tv_usec * 1.e-6;
printf("所要時間 = %f秒\n",tend - tstart);
return(0);
}
void StopRule::cmpVecA (int k, DoubleVector &aVec) {
DoubleVector eVec_ (k, k);
int count_;
for (count_ = 0; count_ < k; count_ ++)
eVec_[count_] = 1.0;
DoubleMatrix lamdaMat_;
cmpLamdaMat (k, lamdaMat_);
// OutStream::write (lamdaMat_, std::cout);
DoubleMatrix invLamdaMat_;
cmpInvMat (lamdaMat_, invLamdaMat_, k);
// OutStream::write (invLamdaMat_, std::cout);
DoubleMatrix proMat_;
multiple (lamdaMat_, invLamdaMat_, proMat_);
//OutStream::write (proMat_, std::cout);
DoubleVector tmp1Vec_;
multiple (eVec_, invLamdaMat_, tmp1Vec_);
//OutStream::write (tmp1Vec_, std::cout);
double tmp2_ = multiple (tmp1Vec_, eVec_);
double invTmp2_ = 1.0 / tmp2_;
for (int row_ = 0; row_ < k; row_ ++)
for (int col_ = 0; col_ < k; col_ ++)
invLamdaMat_[row_][col_] *= invTmp2_;
DoubleVector tmp3Vec_;
multiple (invLamdaMat_, eVec_, aVec);
}
int qr_decom(Matrix *src_matr, Matrix *q_matr, Matrix *r_matr) {
size_t row_len = src_matr->row_len;
size_t col_len = src_matr->col_len;
Matrix ortho_matr, coef_matr, d_matr, d_inv_matr;
ortho_decom(src_matr, &ortho_matr, &coef_matr);
init_matrix(&d_matr, col_len, col_len);
size_t j;
float *ortho_arr = ortho_matr.arr;
float *d_arr = d_matr.arr;
for (j = 0; j < col_len; j++) {
float sum_multi = col_vec_multi(ortho_arr, ortho_arr, j, j, col_len, row_len);
*(d_arr + j * col_len + j) = sum_multi;
}
inverse(&d_matr, &d_inv_matr);
init_matrix(q_matr, row_len, col_len);
init_matrix(r_matr, col_len, col_len);
multiple(&ortho_matr, &d_inv_matr, q_matr);
multiple(&d_matr, &coef_matr, r_matr);
//clear
release_matrix(&ortho_matr);
release_matrix(&coef_matr);
release_matrix(&d_matr);
release_matrix(&d_inv_matr);
return 0;
}
int multiple(struct NUMBER *a,struct NUMBER *b,struct NUMBER *c)
{
int i,j,h=0,tempb,tempa,e;
struct NUMBER d,mai1,mai2,temp;
clearByZero(&d);
clearByZero(c);
if(getSign(a)==1)
{
if(getSign(b)==1)
{
for(i=0;i<KETA-1;i++)
{
h=0;
clearByZero(&d);
tempb=b->n[i];
for(j=0;j<KETA;j++)
{
tempa=a->n[j];
e=tempa*tempb + h;
if(j+i<KETA)
d.n[j+i]=e%10;
h=e/10;
}
copyNumber(c,&temp);
add(&temp,&d,c);
}
}
else if(getSign(b)==-1)
{
getAbs(b,&mai1);
multiple(a,&mai1,c);
setSign(c,-1);
}
}
else if(getSign(a)==-1)
{
if(getSign(b)==1)
{
getAbs(a,&mai1);
multiple(b,&mai1,c);
setSign(c,-1);
}
else if(getSign(b)==-1)
{
getAbs(a,&mai1);
getAbs(b,&mai2);
multiple(&mai1,&mai2,c);
}
}
}
int fastpower(struct NUMBER *a,struct NUMBER *b,struct NUMBER *c)
{
int res = 0,i = 0,mulKeta = KETA * 3.3 + 1;
struct NUMBER tmp_b,tmp_c,one,two,tmp,surplus;
struct NUMBER mul;
setInt(&two,2);//twoは2という定数とする
setInt(&one,1);//oneは1という定数とする
copyNumber(b,&tmp_b);//tmp_bにbを代入
setInt(c,1);//cを1に
if(isZero(b) == 0)//bが最初から0ならば
return(0);//n^0は(0を除いて)必ず1になるためこれでOK
if(getSign(b) == -1)//bが負なら
return(-1);
i = 0;
while(1)
{
copyNumber(&tmp_b,&tmp);//tmpにtmp_bを代入
divide(&tmp,&two,&tmp_b,&surplus);//tmp_b /= 2,surplus = tmp_b % 2をおこなう
if(i == 0)
copyNumber(a,&mul);
else
{
copyNumber(&mul,&tmp);
res = multiple(&tmp,&tmp,&mul);//mul ^ i = mul ^ i/2^2
}
if(res == -1)
return(-1);//multipleで何か起きた場合、異常終了
if(numComp(&surplus,&one) == 0)//余り = 1だったら
{
copyNumber(c,&tmp_c);
res = multiple(&tmp_c,&mul,c);//c *= mul[i]
}
if(res == -1)
return(-1);
i++;
if(isZero(&tmp_b) == 0)
break;//tmp_bが0になったらbreak
}
return(0);//ここまで正常にできれば成功
}
void main()
{
int m,n;
printf("Please enter m,n :");
scanf("%d,%d",&m,&n);
printf("%d和%d的最大公约数为%d，最小公倍数为%d\n",m,n,divisor(m,n),multiple(m,n));
}
int power(struct NUMBER *a,struct NUMBER *b,struct NUMBER *c)
{
int res = 0;
struct NUMBER tmp_b,tmp_c,tmp;
if(isZero(b) == 0)//bが最初から0ならば
{
setInt(c,1);//cを1に
return(0);//n^0は(0を除いて)必ず1になるため
}
if(getSign(b) == -1)//bが負なら
return(-1);
copyNumber(b,&tmp_b);//bが破壊されないようにtmp_bに
copyNumber(a,c);//aをcにコピー、cの初期値をaとする
copyNumber(&tmp_b,&tmp);//tmp_bにtmpを代入、グダグダなのはわかってる。
decrement(&tmp,&tmp_b);//もうすでにcにはa^1があるので、1をまず引く
while(1)
{
if(isZero(&tmp_b) == 0)
break;//bが0になったら終了
copyNumber(c,&tmp_c);//tmp_cに現在のcの値を代入する
res = multiple(a,&tmp_c,c);
if(res == -1)
break;
copyNumber(&tmp_b,&tmp);//tmp_bにtmpを代入、グダグダなのはわかってる。
decrement(&tmp,&tmp_b);//tmp_b--;を実行してます
}
return(res);
}
Maemo5Popup* QtMaemoWebPopup::createPopup()
{
Maemo5Popup* result = multiple() ? createMultipleSelectionPopup() : createSingleSelectionPopup();
connect(result, SIGNAL(finished(int)), this, SLOT(popupClosed()));
connect(result, SIGNAL(itemClicked(int)), this, SLOT(itemClicked(int)));
return result;
}
int main()
{
std::cout << "-> wynik mnożenia: " << multiple(2,2) << "\n-> wynik dodawania: " << add(2,3) << std::endl;
std::cin.get();
return 0;
}
int main(void) {
int i;
Number num, num2, num_result;
int loop_count = 1000;
int actual, expected;
srandom(time(NULL));
for (i = 0; i < loop_count; i++) {
int a = random() % 1000;
int b = random() % 1000;
a *= (random() % 2 == 0) ? 1: -1;
b *= (random() % 2 == 0) ? 1: -1;
set_int(&num, a);
set_int(&num2, b);
expected = a * b;
multiple(&num, &num2, &num_result);
get_int(&num_result, &actual);
if (actual != expected) {
puts("NG!!");
return -1;
}
}
puts("OK.");
return 0;
}
int main(int argc, char** argv)
{
int result;
result = multiple(6,7);
printf("Hello from %s %d\n",argv[0],result);
return (EXIT_SUCCESS);
}
int main(){
int y;
printf("Enter an integer between 1 and 32000:");
scanf("%d",&y );
if(multiple(y)){
printf("%d is a multiple of X\n",y);
}else {
printf("%d is not a multiple of X\n",y);
}
return 0;
}
int main(int argc, char *argv[])
{
Q a = read();
Q b = read();
printf("a: "); write(a); printf("\n");
printf("b: "); write(b); printf("\n");
printf("a / b: "); write(divide(a, b)); printf("\n");
printf("a * b: "); write(multiple(a, b)); printf("\n");
printf("a + b: "); write(plus(a, b)); printf("\n");
printf("a - b: "); write(minus(a, b)); printf("\n");
system("PAUSE");
return 0;
}
int arctan(struct NUMBER *a,struct NUMBER *b)
{
struct NUMBER i,tmp1,tmp2;
struct NUMBER apow,tenpow,mone,n;//計算に使う変数
int j,res;
clearByZero(b);
clearByZero(&i);
clearByZero(&tmp1);
clearByZero(&tmp2);
clearByZero(&apow);
clearByZero(&tenpow);
setInt(&n,1);
tenpow.n[KETA-1] = 1;//tenpowは10^(KETA-1)
j = 0;
while(1)
{
res = fastpower(a,&n,&apow);//apow = a^n
if(res != 0)
break;
res = multiple(&n,&apow,&tmp1);//tmp1 = n * apow
if(res != 0)
break;
res = divide(&tenpow,&tmp1,&tmp2,&apow);//tmp2 = tenpow/tmp1,apowは使わないからこれ以降使わないから
if(res != 0)
break;
if(i.n[0]%2)//iが奇数なら,手っ取り早く偶奇を見たいからこう
setSign(&tmp2,-1);
else //iが偶数なら
setSign(&tmp2,1);
copyNumber(b,&tmp1);
add(&tmp1,&tmp2,b);//b += (1/n * 1/(a^n)) * 10^(KETA-1),オーバーフローなどはないので戻り値は保存しない
if(firstNotZero(&tmp2) <= KETA/10)//(1/i * 1/(a^i)) * 10^(KETA-1)がKETAの1/10程度になったら
break;
/*2i +1の操作*/
copyNumber(&i,&tmp1);//i → tmp
increment(&tmp1,&i);//i++
copyNumber(&i,&tmp1);//i → tmp1
add(&tmp1,&i,&n);//n = 2i(n= i + i)
copyNumber(&n,&tmp1);//i → tmp
increment(&tmp1,&n);//i++
}
return(res);
}
void prepare()
{
long i,j,k,tmp;
memset(out,0,sizeof(out));
memset(online,0,sizeof(online));
for (i=1;i<=n;i++)
for (j=1;j<=n;j++)
if (i!=j)
for (k=1;k<=m;k++)
{
tmp=multiple(insd[k],vertex[j],vertex[i]);
if (tmp>=0) out[i][j]++;
if (tmp==0) online[i][j]=1;
}
}
int
main(void)
{
struct stack *stack;
stack = newStack();
if (stack == NULL)
exit(EXIT_FAILURE);
simple(stack);
multiple(stack);
freeStack(stack);
exit(EXIT_SUCCESS);
}
int main()
{
int num1, num2;
while(1) {
printf("Give me two numbers (^C to end): ");
scanf("%d%d", &num1, &num2);
if(multiple(num1, num2))
printf("%d is multiple of %d\n", num1, num2);
else
printf("%d is NOT multiple of %d\n", num1, num2);
} /* end while(1) */
return 0;
} /* E0F main */
void computeNumCTAs(KernelPointer kernel, int smemDynamicBytes, bool bManualCoalesce)
{
cudaDeviceProp devprop;
int deviceID = -1;
cudaError_t err = cudaGetDevice(&deviceID);
assert(err == cudaSuccess);
cudaGetDeviceProperties(&devprop, deviceID);
// Determine the maximum number of CTAs that can be run simultaneously for each kernel
// This is equivalent to the calculation done in the CUDA Occupancy Calculator spreadsheet
const unsigned int regAllocationUnit = (devprop.major < 2 && devprop.minor < 2) ? 256 : 512; // in registers
const unsigned int warpAllocationMultiple = 2;
const unsigned int smemAllocationUnit = 512; // in bytes
const unsigned int maxThreadsPerSM = bManualCoalesce ? 768 : 1024; // sm_12 GPUs increase threads/SM to 1024
const unsigned int maxBlocksPerSM = 8;
cudaFuncAttributes attr;
err = cudaFuncGetAttributes(&attr, (const char*)kernel);
assert(err == cudaSuccess);
// Number of warps (round up to nearest whole multiple of warp size)
size_t numWarps = multiple(RadixSort::CTA_SIZE, devprop.warpSize);
// Round up to warp allocation multiple
numWarps = ceiling(numWarps, warpAllocationMultiple);
// Number of regs is regs per thread times number of warps times warp size
size_t regsPerCTA = attr.numRegs * devprop.warpSize * numWarps;
// Round up to multiple of register allocation unit size
regsPerCTA = ceiling(regsPerCTA, regAllocationUnit);
size_t smemBytes = attr.sharedSizeBytes + smemDynamicBytes;
size_t smemPerCTA = ceiling(smemBytes, smemAllocationUnit);
size_t ctaLimitRegs = regsPerCTA > 0 ? devprop.regsPerBlock / regsPerCTA : maxBlocksPerSM;
size_t ctaLimitSMem = smemPerCTA > 0 ? devprop.sharedMemPerBlock / smemPerCTA : maxBlocksPerSM;
size_t ctaLimitThreads = maxThreadsPerSM / RadixSort::CTA_SIZE;
unsigned int numSMs = devprop.multiProcessorCount;
int maxCTAs = numSMs * std::min<size_t>(ctaLimitRegs, std::min<size_t>(ctaLimitSMem, std::min<size_t>(ctaLimitThreads, maxBlocksPerSM)));
setNumCTAs(kernel, maxCTAs);
}
int main()
{
int i, j, n = sizeof(x)/4; // n is number of points available
float reqd_x = 2.5; // value of x for wihich we need f(x) value
float px = fx[0];
for( i = 1; i < n; i++ )
{
px += (newdiv(i,0) * multiple(i,reqd_x));
}
printf("\nValue of f(%.2f) at p%d(%.2f) = %f\n",reqd_x, n-1, reqd_x, px);
getch();
return 0;
} //end main
int main(){
int a=20,b=20; //局部变量
printf("in main:a=%d,b=%d\n",a,b);
func1();
func2();
func3(50,50);
{
int a=40,b=40; //复合结构中的局部变量
printf("in compound:a=%d,b=%d\n",a,b);
}
multiple(2,3);
system("pause");
}
/* ARGSUSED */
main( int argc, char *argv[])
{
regexp *r;
int i;
set_regerror_func( try_regerror);
#ifdef ERRAVAIL
progname = mkprogname(argv[0]);
#endif
if (argc == 1) {
multiple();
exit(status);
}
r = regcomp(argv[1]);
if (r == NULL)
error("regcomp failure", "");
#ifdef DEBUG
regdump(r);
if (argc > 4)
regnarrate++;
#endif
if (argc > 2) {
i = regexec(r, argv[2]);
printf("%d", i);
for (i = 1; i < NSUBEXP; i++)
if (r->startp[i] != NULL && r->endp[i] != NULL)
printf(" \\%d", i);
printf("\n");
}
if (argc > 3) {
regsub(r, argv[3], buf);
printf("%s\n", buf);
}
exit(status);
}
int main(void)
{
srandom(time(NULL));
struct NUMBER a,b,c,d,e;
int r;
int x=0,y=0,z=0;
int i,flag;
//setint のテスト
setInt(&a,-12344);
printf("a = ");
dispNumber(&a);
printf("\n");
//setSignのテスト
copyNumber(&a,&b);
setSign(&b,1);
printf("b = ");
dispNumber(&b);
printf("\n");
//getSignのテスト
r=getSign(&b);
printf("getSign() = %d\n",r);
//numCompのテスト
r=numComp(&a,&b);
printf("numComp() = %d\n",r);
setInt(&b,-9996702);
printf("b = ");
dispNumber(&b);
printf("\n");
//addのテストプログラム
add(&b,&a,&c);
printf("add = ");
dispNumber(&c);
printf("\n");
//subのテストプログラム
sub(&c,&a,&d);
printf("sub = ");
dispNumber(&d);
printf("\n");
setInt(&a,12345);
setInt(&b,67894);
//multipleのテスト
multiple(&b,&a,&d);
printf("mul = ");
dispNumber(&d);
printf("\n");
setInt(&a,INT_MIN);
printf("a = ");
dispNumber(&a);
printf("\n");
putchar('\n');
return 0;
}
void ScalarOperatorNode::run(ExecutionNode* previous)
{
m_previousNode= previous;
if(nullptr != m_internalNode)
{
m_internalNode->run(this);
}
if(nullptr != previous)
{
auto previousResult= previous->getResult();
if(nullptr != previousResult)
{
ExecutionNode* internal= m_internalNode;
if(nullptr != internal)
{
while(nullptr != internal->getNextNode())
{
internal= internal->getNextNode();
}
Result* internalResult= internal->getResult();
m_result->setPrevious(internalResult);
if(nullptr != m_internalNode->getResult())
{
m_internalNode->getResult()->setPrevious(previousResult);
}
switch(m_arithmeticOperator)
{
case Die::PLUS:
m_scalarResult->setValue(add(previousResult->getResult(Result::SCALAR).toReal(),
internalResult->getResult(Result::SCALAR).toReal()));
break;
case Die::MINUS:
m_scalarResult->setValue(substract(previousResult->getResult(Result::SCALAR).toReal(),
internalResult->getResult(Result::SCALAR).toReal()));
break;
case Die::MULTIPLICATION:
m_scalarResult->setValue(multiple(previousResult->getResult(Result::SCALAR).toReal(),
internalResult->getResult(Result::SCALAR).toReal()));
break;
case Die::DIVIDE:
m_scalarResult->setValue(divide(previousResult->getResult(Result::SCALAR).toReal(),
internalResult->getResult(Result::SCALAR).toReal()));
break;
case Die::INTEGER_DIVIDE:
m_scalarResult->setValue(static_cast<int>(divide(previousResult->getResult(Result::SCALAR).toReal(),
internalResult->getResult(Result::SCALAR).toReal())));
break;
case Die::POW:
m_scalarResult->setValue(pow(previousResult->getResult(Result::SCALAR).toReal(),
internalResult->getResult(Result::SCALAR).toReal()));
break;
}
}
if(nullptr != m_nextNode)
{
m_nextNode->run(this);
}
}
}
}
NumericVector PBC::algo() {
unsigned int nFunc = binMat_[0].size(); // Number of function
unsigned int nVar = binMat_.size(); // Number of variable (nFunc = nVar + 1)
unsigned int nPara = theta_.size(); // Total number of parameters
vector<int> nbNeighbor(nVar); // Number neighbor of variable
unsigned nbTheta = (int)(nPara/nFunc); // Number of parameters for each function
vector< vector <double> > a(nFunc); // Vector of parameters
for (int unsigned i = 0; i < nFunc; i++) {
vector<double> tmp(nbTheta);
for (int unsigned j = 0; j < nbTheta; j++)
tmp[j] = theta_[nbTheta * i + j];
a[i] = tmp;
vector<double>().swap(tmp);
}
vector <bool> isLeaf_v(nVar);
// Find the number neighbor of variable and leaf variables
for (unsigned i = 0; i < nVar; i++) {
int tmp = 0;
for (unsigned j = 0; j < nFunc; j++)
tmp += binMat_[i][j];
nbNeighbor[i] = tmp;
if (tmp > 1)
isLeaf_v[i] = false;
else
isLeaf_v[i] = true;
}
algoInit(isLeaf_v); // Initialisation of algorithm
NumericVector ret(nPara+1); // Results (P and gradient of P)
bool isStop = false; // For stopping algorithm
while (!isStop){
// Messages from functions to variables
for (int unsigned i = 0; i < nFunc; i++) {
vector <int> neiVar; // Neighbor variables of function
for (int unsigned j = 0; j < nVar; j++)
if (binMat_[j][i] == 1)
neiVar.push_back(j);
// Update mu and lamda functions from function to variable
fv_mu_[neiVar[1]][i] = dxPhi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], dxf_, g_, dxg_, type_) * vf_mu_[neiVar[0]][i]
+ Phi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], f_, g_, dxg_, type_) * vf_la_[neiVar[0]][i];
fv_mu_[neiVar[0]][i] = dxPhi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], dxf_, g_, dxg_, type_) * vf_mu_[neiVar[1]][i]
+ Phi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], f_, g_, dxg_, type_) * vf_la_[neiVar[1]][i];
fv_la_[neiVar[1]][i] = dxdyPhi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], dxdyf_, g_, dxg_, type_) * vf_mu_[neiVar[0]][i]
+ dxPhi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], dxf_, g_, dxg_, type_) * vf_la_[neiVar[0]][i];
fv_la_[neiVar[0]][i] = dxdyPhi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], dxdyf_, g_, dxg_, type_) * vf_mu_[neiVar[1]][i]
+ dxPhi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], dxf_, g_, dxg_, type_) * vf_la_[neiVar[1]][i];
if (out_ > 0){
vector <double> grPhi(nPara), grDxPhi1(nPara), grDxPhi2(nPara), grDxDyPhi(nPara);
for (unsigned int ii = 0; ii < nbTheta; ii++){
grPhi = addNumberVector(graPhi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], graf_, g_, dxg_, type_)[ii], i * nbTheta + ii, grPhi);
grDxPhi1 = addNumberVector(graDxPhi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], gradxf_, g_, dxg_, type_)[ii], i * nbTheta + ii, grDxPhi1);
grDxPhi2 = addNumberVector(graDxPhi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], gradxf_, g_, dxg_, type_)[ii], i * nbTheta + ii, grDxPhi2);
grDxDyPhi = addNumberVector(graDxDyPhi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], gradxdyf_, g_, dxg_, type_)[ii], i * nbTheta + ii, grDxDyPhi);
}
// Update gradient
gra_fv_mu_[neiVar[1]][i] = add(add(add((multiple(grDxPhi1,vf_mu_[neiVar[0]][i])),
(multiple(gra_vf_mu_[neiVar[0]][i],dxPhi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], dxf_, g_, dxg_, type_)))),
(multiple(grPhi,vf_la_[neiVar[0]][i]))),
(multiple(gra_vf_la_[neiVar[0]][i],Phi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], f_, g_, dxg_, type_))));
gra_fv_mu_[neiVar[0]][i] = add(add(add((multiple(grDxPhi2,vf_mu_[neiVar[1]][i])),
(multiple(gra_vf_mu_[neiVar[1]][i],dxPhi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], dxf_, g_, dxg_, type_)))),
(multiple(grPhi,vf_la_[neiVar[1]][i]))),
(multiple(gra_vf_la_[neiVar[1]][i],Phi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], f_, g_, dxg_, type_))));
gra_fv_la_[neiVar[1]][i] = add(add(add((multiple(grDxDyPhi,vf_mu_[neiVar[0]][i])),
(multiple(gra_vf_mu_[neiVar[0]][i],dxdyPhi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], dxdyf_, g_, dxg_, type_)))),
(multiple(grDxPhi2,vf_la_[neiVar[0]][i]))),
(multiple(gra_vf_la_[neiVar[0]][i],dxPhi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], dxf_, g_, dxg_, type_))));
gra_fv_la_[neiVar[0]][i] = add(add(add((multiple(grDxDyPhi,vf_mu_[neiVar[1]][i])),
(multiple(gra_vf_mu_[neiVar[1]][i],dxdyPhi(vect_[neiVar[1]], nbNeighbor[neiVar[1]], vect_[neiVar[0]], nbNeighbor[neiVar[0]], a[i], dxdyf_, g_, dxg_, type_)))),
(multiple(grDxPhi1,vf_la_[neiVar[1]][i]))),
(multiple(gra_vf_la_[neiVar[1]][i],dxPhi(vect_[neiVar[0]], nbNeighbor[neiVar[0]], vect_[neiVar[1]], nbNeighbor[neiVar[1]], a[i], dxf_, g_, dxg_, type_))));
vector<double>().swap(grPhi); // Free memory
vector<double>().swap(grDxPhi1); // Free memory
vector<double>().swap(grDxPhi2); // Free memory
vector<double>().swap(grDxDyPhi); // Free memory
}
vector<int>().swap(neiVar); // Free memory
}
// Messages from variables to functions
for (int unsigned i = 0; i < nVar; i++)
if (!isLeaf_v[i]) {
vector <int> neiFunc; // Neighbor functions of variable
for (int unsigned j = 0; j < nFunc; j++)
if (binMat_[i][j] == 1)
neiFunc.push_back(j);
for (unsigned j = 0; j < neiFunc.size(); j++) {
double prod = 1;
double sum = 0;
vector <double> gra_sum(nPara), gra_sum2(nPara);
for (unsigned k = 0; k < neiFunc.size(); k++)
if ((k != j)&&(fv_mu_[i][neiFunc[k]]!=0)) {
prod *= fv_mu_[i][neiFunc[k]];
sum += fv_la_[i][neiFunc[k]] / fv_mu_[i][neiFunc[k]];
if (out_ > 0){
gra_sum = add(multiple(gra_fv_mu_[i][neiFunc[k]], 1/fv_mu_[i][neiFunc[k]]), gra_sum);
gra_sum2 = add(multiple(add(multiple(gra_fv_la_[i][neiFunc[k]], fv_mu_[i][neiFunc[k]]),
multiple(gra_fv_mu_[i][neiFunc[k]],- fv_la_[i][neiFunc[k]])), pow(fv_mu_[i][neiFunc[k]], -2)), gra_sum2);
}
}
// Update lamda and mu functions from variable to function
vf_mu_[i][neiFunc[j]] = prod;
vf_la_[i][neiFunc[j]] = prod * sum;
if (out_ > 0){
gra_vf_mu_[i][neiFunc[j]] = multiple(gra_sum, prod);
gra_vf_la_[i][neiFunc[j]] = add(multiple(gra_vf_mu_[i][neiFunc[j]], sum),multiple(gra_sum2, prod));
vector<double>().swap(gra_sum); // Free memory
vector<double>().swap(gra_sum2); // free memory
}
}
vector<int>().swap(neiFunc); // Free memory
}
nIteration_ --;
if (nIteration_ < 1)
isStop = true;
}
vector<double>().swap(theta_); // Free memory
vector<double>().swap(vect_); // Free memory
vector<int>().swap(nbNeighbor); // Free memory
vector< vector<double> >().swap(a); // Free memory
vector <int> neiRoot; // Neighbor functions of root
for (unsigned i = 0; i < binMat_[root_].size(); i++)
if (binMat_[root_][i] == 1)
neiRoot.push_back(i);
vector< vector<int> >().swap(binMat_); // Free memory
// Initialisation values for results
double u = 1;
double z = 0;
vector <double> gra_u(nPara), gra_z(nPara), gra_p(nPara);
// Calculate P and gradient of P
for (unsigned i = 0; i < neiRoot.size(); i++) {
if (fv_mu_[root_][neiRoot[i]]!=0){
u *= fv_mu_[root_][neiRoot[i]];
z += fv_la_[root_][neiRoot[i]] / fv_mu_[root_][neiRoot[i]];
if (out_ > 0){
gra_u = add(multiple(gra_fv_mu_[root_][neiRoot[i]], 1/fv_mu_[root_][neiRoot[i]]), gra_u);
gra_z = add(multiple(add(multiple(gra_fv_la_[root_][neiRoot[i]], fv_mu_[root_][neiRoot[i]]),
multiple(gra_fv_mu_[root_][neiRoot[i]], -fv_la_[root_][neiRoot[i]])), pow(fv_mu_[root_][neiRoot[i]] , -2)), gra_z);
}
}
}
vector< vector< vector<double> > >().swap(gra_fv_mu_); // Free memory
vector< vector< vector<double> > >().swap(gra_fv_la_); // Free memory
vector< vector< vector<double> > >().swap(gra_vf_mu_); // Free memory
vector< vector< vector<double> > >().swap(gra_vf_la_); // free memory
vector< vector<double> >().swap(fv_mu_); // Free memory
vector< vector<double> >().swap(fv_la_); // Free memory
vector< vector<double> >().swap(vf_mu_); // Free memory
vector< vector<double> >().swap(vf_la_); // Free memory
vector<int>().swap(neiRoot); // Free memory
double p = u * z; // Compute density
ret[0] = p;
if (out_ > 0) {
gra_u = multiple(gra_u, u);
gra_p = add(multiple(gra_z, u),multiple(gra_u, z)); // Compute gradient
for (int i = 1; i < ret.size(); i++)
ret[i] = gra_p[i-1];
vector<double>().swap(gra_u); // Free memory
vector<double>().swap(gra_z); // Free memory
vector<double>().swap(gra_p); // Free memory
vector<bool>().swap(isLeaf_v); // Free memory
}
return ret;
}
PyObject* wrap_mul(PyObject* self,PyObject* args) {
int a,b;
if (!PyArg_ParseTuple(args,"i|i",&a,&b))
return NULL;
return Py_BuildValue("s",multiple(a,b).c_str());
}
// MS Excel-style CEIL() function
// Rounds x up to nearest multiple of f
inline size_t ceiling(size_t x, size_t f)
{
return multiple(x, f) * f;
}
void main(){
sum(1,2);
multiple(5,10);
printf("git hub changing")
}
int bdd_do_insert ( char *safe_trame )
{
// Déclaration variable
Ref modele ; // Modèle propre à la trame qui sera appliqué en requête sur la BDD
char* morceau = NULL ; // Variable contenant chaque morceau de la trame (strtok_r)
char* safe_morceau = NULL ; // Variable contenant chaque morceau de la trame (strtok_r)
char* groupes = NULL ;
char* groupes_test = NULL ;
int groupes_free = FALSE ;
char* valeur = NULL ;
char* user = NULL ;
char* politiques = NULL ;
char* politiques_test = NULL ;
int politiques_free = FALSE ;
int cpt = 0 ; // Compteur
// On découpe les 7 éléments restant de notre trame
for ( cpt = 0; cpt < 7; cpt++ )
{
// On découpe la trame en morceaux repérés via un "*"
if ( ( morceau = strtok_r ( NULL, "*", &safe_trame ) ) == NULL )
{
perror ( "Erreur_bdd_do_insert : information manquante " ) ;
if ( politiques_free == TRUE )
free ( politiques ) ;
if ( groupes_free == TRUE )
free ( groupes ) ;
bdd_send_msg ( INSERT, "ERROR" ) ;
return ERRNO ;
}
// On vérifie que l'information est présente
if ( strcmp ( morceau, "EOF") == 0 )
{
perror ( "Erreur_bdd_do_insert : information manquante II " ) ;
if ( politiques_free == TRUE )
free ( politiques ) ;
if ( groupes_free == TRUE )
free ( groupes ) ;
bdd_send_msg ( INSERT, "ERROR" ) ;
return ERRNO ;
}
else
{
// On affecte l'information
switch ( cpt )
{
case ZERO :
modele.statut = multiple ( calculate_SHA256 ( morceau ) ) ;
break ;
case UN :
modele.affectation = multiple ( calculate_SHA256 ( morceau ) ) ;
break ;
case DEUX :
groupes_test = morceau ;
groupes = (char*) malloc ( ( strlen ( groupes_test ) + 1 ) * sizeof ( char ) ) ;
memset ( groupes, '\0', strlen ( groupes_test ) + 1 ) ;
sprintf ( groupes, "%s", groupes_test ) ;
groupes_free = TRUE ;
break ;
case TROIS :
modele.type = multiple ( calculate_SHA256 ( morceau ) ) ;
break ;
case QUATRE :
valeur = morceau ;
break ;
case CINQ :
user = morceau ;
break ;
case SIX :
politiques_test = morceau ;
politiques = (char*) malloc ( ( strlen ( politiques_test ) + 1 ) * sizeof ( char ) ) ;
memset ( politiques, '\0', strlen ( politiques_test ) + 1 ) ;
sprintf ( politiques, "%s", politiques_test ) ;
politiques_free = TRUE ;
break ;
default :
perror ( "Erreur_do_insert : overflow compteur cpt " ) ;
if ( politiques_free == TRUE )
free ( politiques ) ;
if ( groupes_free == TRUE )
free ( groupes ) ;
bdd_send_msg ( INSERT, "ERROR" ) ;
return ERRNO ;
break ;
}
}
}
// On vérifie le format des politiques
morceau = NULL ;
cpt = 0 ;
do
{
// On découpe
if ( cpt == 0 )
morceau = strtok_r ( politiques_test, "$", &safe_morceau ) ;
else
morceau = strtok_r ( NULL, "$", &safe_morceau ) ;
// On inc cpt
cpt++ ;
} while ( morceau != NULL ) ;
if ( cpt != 4 )
{
perror ( "Erreur_bdd_do_insert : politiques() " ) ;
free ( politiques ) ;
free ( groupes ) ;
bdd_send_msg ( INSERT, "ERROR" ) ;
return ERRNO ;
}
// On compte le nombre de groupes
morceau = NULL ;
safe_morceau = NULL ;
int nbr_grp = 0 ;
do
{
// On découpe
if ( nbr_grp == 0 )
morceau = strtok_r ( groupes_test, ";", &safe_morceau ) ;
else
morceau = strtok_r ( NULL, ";", &safe_morceau ) ;
// On inc cpt
nbr_grp++ ;
} while ( morceau != NULL ) ;
// PHASE 2
// Déclaration variables
char* reference_str = NULL ;
char* valeur_finale = NULL ;
char* reponse = NULL ;
char* temporaire = NULL ;
int first = TRUE ;
unsigned long taille = 0 ;
// Ini
reference_str = (char*) malloc ( TAILLE_MAX_REF * sizeof ( char ) ) ;
memset ( reference_str, '\0', TAILLE_MAX_REF ) ;
taille = strlen ( valeur ) + strlen ( user ) + strlen ( politiques ) + 3 ;
valeur_finale = (char*) malloc ( taille * sizeof ( char ) ) ;
memset ( valeur_finale, '\0', taille ) ;
temporaire = (char*) malloc ( TAILLE_MAX_REF * nbr_grp * sizeof ( char ) ) ;
memset ( temporaire, '\0', TAILLE_MAX_REF * nbr_grp ) ;
// On créé autant de référence qu'il y a de groupes
morceau = NULL ;
safe_morceau = NULL ;
cpt = 0 ;
do
{
// On découpe
if ( cpt == 0 )
morceau = strtok_r ( groupes, ";", &safe_morceau ) ;
else
morceau = strtok_r ( NULL, ";", &safe_morceau ) ;
// On vérifie
if ( morceau != NULL )
{
// On prépare la référénce qui va être inséreée en BDD
modele.groupe = multiple ( calculate_SHA256 ( morceau ) ) ;
memset ( reference_str, '\0', TAILLE_MAX_REF ) ;
if ( ref_concatenation ( &modele, reference_str ) == ERRNO )
{
perror ( "Erreur_bdd_do_insert : ref_concatenation() " ) ;
free ( politiques ) ;
free ( reference_str ) ;
free ( valeur_finale ) ;
free ( groupes ) ;
free ( temporaire ) ;
bdd_send_msg ( INSERT, "ERROR" ) ;
return ERRNO ;
}
// On prépare la valeur_final qui va être insrérée en BDD
memset ( valeur_finale, '\0', taille ) ;
sprintf ( valeur_finale, "%s*%s*%s", user, valeur, politiques ) ;
// On réalise l'insertion
if ( bdd_do_request ( mysql_bdd, INSERT, reference_str, valeur_finale, NULL ) == ERRNO )
{
perror ( "Erreur_bdd_do_insert : bdd_do_request() " ) ;
free ( politiques ) ;
free ( reference_str ) ;
free ( valeur_finale ) ;
free ( groupes ) ;
free ( temporaire ) ;
bdd_send_msg ( INSERT, "ERROR" ) ;
return ERRNO ;
}
else
nbr_tuples++ ;
// On ajoute la référence à la réponse
if ( first == TRUE )
{
sprintf ( temporaire, "%s", reference_str ) ;
first = FALSE ;
}
else if ( first == FALSE )
sprintf ( temporaire + strlen ( temporaire ), ";%s", reference_str ) ;
// On inc cpt
cpt++ ;
}
} while ( morceau != NULL ) ;
// On envoie la réponse
taille = strlen ( temporaire ) + 10 ;
reponse = (char*) malloc ( taille * sizeof ( char ) ) ;
memset ( reponse, '\0', taille ) ;
sprintf ( reponse, "%d*%s*EOF", INSERT, temporaire ) ;
res_send ( reponse ) ;
// Free
free ( politiques ) ;
free ( reference_str ) ;
free ( valeur_finale ) ;
free ( groupes ) ;
free ( temporaire ) ;
free ( reponse ) ;
// On indique que tout s'est bien déroulé
return TRUE ;
}
void computeNumCTAs(KernelPointer kernel, int smemDynamicBytes, bool bManualCoalesce)
{
cudaDeviceProp devprop;
int deviceID = -1;
cudaError_t err = cudaGetDevice(&deviceID);
assert(err == cudaSuccess);
cudaGetDeviceProperties(&devprop, deviceID);
int smVersion = devprop.major * 10 + devprop.minor;
// Determine the maximum number of CTAs that can be run simultaneously for each kernel
// This is equivalent to the calculation done in the CUDA Occupancy Calculator spreadsheet
const unsigned int warpAllocationMultiple = 2;
const unsigned int maxBlocksPerSM = 8;
unsigned int maxThreadsPerSM = 768;
unsigned int regAllocationUnit = 256; // in registers
unsigned int smemAllocationUnit = 512; // in bytes
bool blockRegisterAllocation = true; // otherwise warp granularity (sm_20)
if (smVersion >= 20)
{
maxThreadsPerSM = 1536;
regAllocationUnit = 64;
blockRegisterAllocation = false;
smemAllocationUnit = 128;
}
else if (smVersion >= 12)
{
maxThreadsPerSM = 1024;
regAllocationUnit = 512;
}
cudaFuncAttributes attr;
err = cudaFuncGetAttributes(&attr, (const char*)kernel);
assert(err == cudaSuccess);
// Number of warps (round up to nearest whole multiple of warp size)
size_t numWarps = multiple(RadixSort::CTA_SIZE, devprop.warpSize);
// Round up to warp allocation multiple
numWarps = ceiling(numWarps, warpAllocationMultiple);
size_t regsPerCTA = 0;
if (blockRegisterAllocation)
{
// Number of regs is regs per thread times number of warps times warp size
// rounded up to multiple of register allocation unit size
regsPerCTA = ceiling(attr.numRegs * devprop.warpSize * numWarps, regAllocationUnit);
}
else
{
// warp register allocation
// Number of regs is regs per thread times warp size, rounded up to multiple of
// register allocation unit size, times number of warps.
regsPerCTA = ceiling(attr.numRegs * devprop.warpSize, regAllocationUnit) * numWarps;
}
size_t smemBytes = attr.sharedSizeBytes + smemDynamicBytes;
size_t smemPerCTA = ceiling(smemBytes, smemAllocationUnit);
size_t ctaLimitRegs = regsPerCTA > 0 ? devprop.regsPerBlock / regsPerCTA : maxBlocksPerSM;
size_t ctaLimitSMem = smemPerCTA > 0 ? devprop.sharedMemPerBlock / smemPerCTA : maxBlocksPerSM;
size_t ctaLimitThreads = maxThreadsPerSM / RadixSort::CTA_SIZE;
unsigned int numSMs = devprop.multiProcessorCount;
int maxCTAs = numSMs * std::min<size_t>(ctaLimitRegs, std::min<size_t>(ctaLimitSMem, std::min<size_t>(ctaLimitThreads, maxBlocksPerSM)));
setNumCTAs(kernel, maxCTAs);
}
void print(std::ostream& out) const {
out << '[' << type() << " spans=" << spans() << " multiple=" << multiple() << ']';
}
