void OpenSMOKE_SensitivityAnalysis::GiveMe_SensitivityCoefficients(const double deltat) { // Implicit Method if (iImplicit == true) { JAlfa *= deltat; Sum(JAlfa, Sold, &Sold); Jacobian *= -deltat; Sum(I,Jacobian, &Jacobian); BzzFactorizedGauss AFactorized(Jacobian); Solve(&AFactorized, Sold, &S); } /* else // Explicit Method { Product(JacobianOld, Sold, &S); Sum(JacobianOld, JalfaOld, &JacobianOld); JacobianOld *= deltat; Sum(Sold, JacobianOld, &S); }*/ // Update old value Sold = S; }
int main() { int N = 50; int PenDrive = 4000; int *Arquivos = (int*)malloc(sizeof(int) * N); GenerateFiles(Arquivos, N, 300); int *Arq = Sort(Arquivos,N); printf("Total espeaço: %i\n", PenDrive); printa(Arq, N); int soma = 0, i=0; soma = Sum(Arq,N); printf("Total Arquivos (MB): %i \n",soma); for(i=0;i<N ;i++) if(PenDrive >= Arq[i]){ printf("+ %i MB\n", Arq[i]); PenDrive -= Arq[i]; Arq[i] = 0; } printf("Sobrou (MB): %i \n",PenDrive); soma= Sum(Arq,N); printf("Sobrou %i MB nos Arquivos!\n",soma); return 0; }
vector<vector<int> > FourSum::fourSum(vector<int> &num, int target) { vector<Sum> doubleSum; vector<vector<int> > result; for (int i = 0; i < num.size(); i++) { for (int j = i + 1; j < num.size(); j++) { Sum sum = Sum(num[i]+num[j], i, j); doubleSum.push_back(sum); } } sort(doubleSum.begin(), doubleSum.end()); for (vector<Sum>::iterator i = doubleSum.begin(); i != doubleSum.end(); i++) { vector<Sum>::iterator start = lower_bound(doubleSum.begin(), doubleSum.end(), Sum(target-(i->value))); if (start != doubleSum.end() && (start->value) + (i->value) == target) { vector<Sum>::iterator iter = start; while (iter != doubleSum.end() && (iter->value) == (start->value)) { if ((iter->x != i->x) && (iter->x != i->y) && (iter->y != i->x) && (iter->y != i->y)) { vector<int> elem; elem.push_back(num[iter->x]); elem.push_back(num[iter->y]); elem.push_back(num[i->x]); elem.push_back(num[i->y]); sort(elem.begin(), elem.end()); if (find(result.begin(), result.end(), elem) == result.end()) result.push_back(elem); } iter++; } } } return result; }
void OpenSMOKE_KPP_SingleReactor::SolveCSTR_Corrector_Linearized(const double deltat, BzzMatrix &tmpMatrix) { // Reactions kinetics->UpdateProperties(omega_, temperature_, pressure_, R_); Product(volume_, R_, &RV_); GetJacobian(omega_, tmpMatrix); // A = d(RV)/domega * Volume/mtot; // The formulation is the same, both for deferred=on and deferred=off // The difference is the Jacobian calculation (see GetJacobian function) if (data_->PredictorCorrector_DeferredConvection() == false || data_->PredictorCorrector_DeferredConvection() == true) { // Rigth hand side Product(-M_, omega_, &rhs_); // outflow Sum(&rhs_, RV_); // reaction Sum(&rhs_, mInTot_); // inflow rhs_ *= deltat/mass_; // Matrix tmpMatrix *= -deltat; for(int i=1;i<=numberOfSpecies;i++) tmpMatrix[i][i] += 1.; // Linear System solution BzzFactorizedGauss AGauss(tmpMatrix); Solve(AGauss, &rhs_); // Updating omega_ += rhs_; } }
void OpenSMOKE_KPP_SingleReactor::ODESystemContinousReactor(BzzVector &omega, double t, BzzVector &domega) { if (data_->PredictorCorrector_DeferredConvection() == true || data_->networkStatus() == KPP_NETWORK_STATUS_SEQUENTIAL_CSTR ) { // Formation rates kinetics->UpdateProperties(omega, temperature_, pressure_, R_); Product(volume_, R_, &RV_); // mass*domegaj = -mOut*omegaj + mjIn + Rj*V Product(-M_, omega, &domega); Sum(&domega, RV_); Sum(&domega, mInTot_); domega /= mass_; } else { // Formation rates kinetics->UpdateProperties(omega, temperature_, pressure_, R_); Product(volume_, R_, &RV_); // mass*domegaj = -mOut*omegaj(n) + mjIn + Rj*V domega = RV_; Sum(&domega, mInTot_); Difference(&domega, mOut_x_omega_old_); domega /= mass_; } }
int main() { freopen("t.in", "r", stdin); scanf("%d\n", &n); for(int i = 1, a, b; i < n; i ++) { scanf("%d %d\n", &a, &b); Add_Edge(a, b); Add_Edge(b, a); } dfs(1); for(int i = 1; i <= n; i ++) Update(start[i], exist[start[i]] ^= 1); scanf("%d\n", &m); while(m --) { char ctrl; int x; scanf("%c %d\n", &ctrl, &x); if(ctrl == 'C') { int v; exist[start[x]] ^= 1; if(exist[start[x]]) v = 1; else v = -1; Update(start[x], v); } else printf("%d\n", Sum(over[x]) - Sum(start[x] - 1)); } }
static void CompressBlock(JPEGCompressor *self,int comp, const JPEGBlock *current,const JPEGBlock *north,const JPEGBlock *west, const JPEGQuantizationTable *quantization) { // Calculate EOB context. int average; if(!north&&!west) average=0; else if(!north) average=Sum(0,west); else if(!west) average=Sum(0,north); else average=(Sum(0,north)+Sum(0,west)+1)/2; int eobcontext=Min(Category(average),12); // Write EOB bits using binary tree. WriteBitString(&self->encoder,current->eob,6, self->eobbins[comp][eobcontext], self->eobshift); // Compress AC components in decreasing order, if any. for(unsigned int k=current->eob;k>=1;k--) { CompressACComponent(self,comp,k,k!=current->eob,current,north,west,quantization); } // Compress DC component. CompressDCComponent(self,comp,current,north,west,quantization); }
int main() { int n; while (scanf("%d", &n) && n < 3) { if (n == 0) { scanf("%d", &size); memset(C, 0, sizeof(C)); } else if (n == 1) { int x, y, a; scanf("%d %d %d", &x, &y, &a); x += 1; y += 1; A[x][y] += a; Add(x, y, a); } else if (n == 2) { int l, b, r, t; scanf("%d %d %d %d", &l, &b, &r, &t); l += 1; b += 1; r += 1; t += 1; // printf("%d\n", Sum(max(l, r), max(b, t)) - Sum(min(l, r), max(b, t))); printf("%d\n", Sum(r, t) + Sum(l - 1, b - 1) - Sum(r, b - 1) - Sum(l - 1, t)); } for (int i = 0; i <= 10; i++) { for (int j = 0; j <= 10; ++j) { printf("%d ", C[i][j]); } printf("\n"); } printf("\n"); } }
//s is the previous sum from the ancestors int Sum(TreeNode* root, int s) { if(!root) return 0; //reaches the leaf, calculate this path sum if((!root->left)&&(!root->right)) return s*10+root->val; //recurse into the left and right subtree return Sum(root->left,s*10+root->val)+Sum(root->right,s*10+root->val); }
TEST(Util, SumTest) { VVReal tmp; Init(2, 2, 1.0, &tmp); EXPECT_DOUBLE_EQ(4, Sum(tmp)); VVVReal tmp2; Init(2, 2, 2, 2.0, &tmp2); EXPECT_DOUBLE_EQ(16, Sum(tmp2)); }
func Flacker() { if(Not(Random(15))) And(CastObjects(SU3V,Sum(1,Random(1)),Sum(5,Random(15)),Sum(-14,Random(28)),Sum(1,Random(2))),Sound("Spark*")); if(Not(Random(2))) return(0); if(Random(6)) return(ObjectSetAction(Local(0),"Neon")&&SetAction("FlackerAn")); if(Random(6)) return(ObjectSetAction(Local(0),"Aus")&&SetAction("FlackerAus")); return(1); }
void LayerConv::CalcWeights(Layer *prev_layer, int passnum) { StartTimer(); if (passnum < 2) return; Mat weights_der; if (passnum == 2) { weights_der.attach(weights_.der()); } else if (passnum == 3) { weights_der.attach(weights_.der2()); } #if COMP_REGIME != 2 std::vector< std::vector<Mat> > prev_activ, filters_der, deriv; InitMaps(prev_layer->activ_mat_, prev_layer->mapsize_, prev_activ); InitMaps(weights_der, filtersize_, filters_der); InitMaps(deriv_mat_, mapsize_, deriv); size_t i,j; int k; //#pragma omp parallel{ //for num_threads(12) private(fil_der) for (i = 0; i < outputmaps_; ++i) { for (j = 0; j < prev_layer->outputmaps_; ++j) { Mat fil_der(filtersize_); fil_der.assign(0); #if COMP_REGIME == 1 #endif for (k = 0; k < batchsize_; ++k) { Mat ker_mat(filtersize_); Filter(prev_activ[k][j], deriv[k][i], padding_, false, ker_mat); #if COMP_REGIME == 1 //#pragma omp critical #endif fil_der += ker_mat; } filters_der[i][j] = fil_der; } } #else // GPU WeightActs(prev_layer->activ_mat_, deriv_mat_, weights_der, prev_layer->mapsize_, filtersize_[0], padding_[0], sum_width_, !unshared_); #endif weights_der /= (ftype) batchsize_; weights_der.Validate(); if (passnum == 2) { mexAssert(deriv_mat_.order() == false, "deriv_mat_.order() should be false"); if (!unshared_) { deriv_mat_.reshape(batchsize_ * deriv_mat_.size2() / outputmaps_, outputmaps_); Sum(deriv_mat_, biases_.der(), 1); deriv_mat_.reshape(batchsize_, deriv_mat_.size1() * outputmaps_ / batchsize_); } else { Sum(deriv_mat_, biases_.der(), 1); } (biases_.der() /= (ftype) batchsize_) *= bias_coef_; biases_.der().Validate(); } MeasureTime("CalcWeights Conv Layer",2); }
wxInt32 FindTotal(wxInt32 player) { wxInt32 total = 0; total += Sum(shPlayableTradeCards, player); total += Sum(shPlayableScienceCards, player); total += Sum(shPlayablePoliticsCards, player); return total; }
inline void Tupdate(int x) { Size(x)=Size(Lch(x))+1+Size(Rch(x)); Sum(x)=Sum(Lch(x))+Val(x)+Sum(Rch(x)); Lms(x)=max(Lms(Lch(x)),Sum(Lch(x))+Val(x)+Lms(Rch(x))); Rms(x)=max(Rms(Rch(x)),Rms(Lch(x))+Val(x)+Sum(Rch(x))); Ms(x)=Rms(Lch(x))+Val(x)+Lms(Rch(x)); if (Lch(x)) Ms(x)=max(Ms(x),Ms(Lch(x))); if (Rch(x)) Ms(x)=max(Ms(x),Ms(Rch(x))); }
void Code4() { int i_array[] = {1, 2, 3}; std::cout << Sum(i_array, 0) << "\n"; std::vector<int> i_vec = {4, 5, 6}; std::cout << Sum(i_vec, 0) << "\n"; std::vector<std::string> str_vec = { "ふるいけや", "かわずとびこむ", "みずのおと" }; std::cout << Sum(str_vec, std::string("")) << "\n"; }
void pull( Treap * a ){ a->sum = Sum( a->l ) + Sum( a->r ) + a->val; a->lsum = Sum( a->l ) + a->val + max( 0 , lSum( a->r ) ); if( a->l ) a->lsum = max( lSum( a->l ) , a->lsum ); a->rsum = Sum( a->r ) + a->val + max( 0 , rSum( a->l ) ); if( a->r ) a->rsum = max( rSum( a->r ) , a->rsum ); a->maxsum = max( 0 , rSum( a->l ) ) + a->val + max( 0 , lSum( a->r ) ); a->maxsum = max( a->maxsum , max( maxSum( a->l ) , maxSum( a->r ) ) ); a->sz = Size( a->l ) + Size( a->r ) + 1; }
//--------------------------------------------------------------------------- wxSize wxMultiCellSizer::CalcMin() { if (m_children.GetCount() == 0) return wxSize(10,10); GetMinimums(); int m_minWidth = Sum(m_maxWidth, m_cell_count.GetWidth()); int m_minHeight = Sum(m_maxHeight, m_cell_count.GetHeight()); return wxSize( m_minWidth, m_minHeight ); }
Value Sum(int ql, int qr, int v, int l, int r) { assert(0 <= l && l <= ql && ql <= qr && qr <= r && r < size_); if (ql == l && qr == r) { return tree_[v]; } int mid = (l + r) / 2; if (qr <= mid) return Sum(ql, qr, 2 * v + 1, l, mid); if (ql >= mid + 1) return Sum(ql, qr, 2 * v + 2, mid + 1, r); return join(Sum(ql, mid, 2 * v + 1, l, mid), Sum(mid + 1, qr, 2 * v + 2, mid + 1, r)); }
int Sum(struct node *root, int sum) { if(root==NULL) return 0; sum = sum *10 + root->data; if(root->left == NULL && root->right==NULL) return sum; else return Sum(root->left, sum) + Sum(root->right, sum); }
Mistral2_Expression* Mistral2_Sum::add(Mistral2Solver *solver, bool top_level){ if(!has_been_added()) { #ifdef _DEBUGWRAP std::cout << "add sum constraint" << std::endl; #endif _solver = solver; // _v * _w + o = _x // _v * _w - _x = -o int i, n=_vars.size(); Mistral::VarArray scope(n); Mistral::Vector<int> w; bool weighted = false; bool boolean = true; w.initialise(n, n); for(i=0; i<n; ++i) { _vars.get_item(i)->add(_solver,false); if(_weights.size() > i) w[i] = _weights.get_item(i); else w[i] = 1; scope[i] = _vars.get_item(i)->_self; if(w[i] != 1) weighted = true; if(!scope[i].is_boolean()) boolean = false; } //w[n] = _weights.get_item(n); if(boolean) { if(weighted) _self = BoolSum(scope, w); else _self = BoolSum(scope, w); } else { if(weighted) _self = Sum(scope, w, -Mistral::INFTY, Mistral::INFTY, _offset); else _self = Sum(scope, w, -Mistral::INFTY, Mistral::INFTY, _offset); } if( top_level ) { _solver->solver->add( _self ); } } return this; }
CryptoPP::ECP::Point Mul (const CryptoPP::ECP::Point& p, const CryptoPP::Integer& e) const { CryptoPP::ECP::Point res {0, 1}; if (!e.IsZero ()) { auto bitCount = e.BitCount (); for (int i = bitCount - 1; i >= 0; i--) { res = Sum (res, res); if (e.GetBit (i)) res = Sum (res, p); } } return res; }
double OpenSMOKE_KPP_SingleReactor::Residuals(BzzVector& omega, BzzVector& residuals) { kinetics->UpdateProperties(omega, temperature_, pressure_, R_); Product(volume_, R_, &RV_); Product(-M_, omega, &residuals); Sum(&residuals, RV_); Sum(&residuals, mInTot_); Product(-1, &residuals); double F = residuals.GetSumAbsElements() / double(numberOfSpecies); return F; }
namespace DefaultArguments { const int z = int(); constexpr int Sum(int a = 0, const int &b = 0, const int *c = &z, char d = 0) { return a + b + *c + d; } const int four = 4; constexpr int eight = 8; constexpr const int twentyseven = 27; static_assert(Sum() == 0, ""); static_assert(Sum(1) == 1, ""); static_assert(Sum(1, four) == 5, ""); static_assert(Sum(1, eight, &twentyseven) == 36, ""); static_assert(Sum(1, 2, &four, eight) == 15, ""); }
int main() { int abundant[28000]; int i,j,s=0,c=0; for(i=1;i<=28200;i++) { if(Sum(i)>i) { //printf("%d ",i); abundant[c]=i;c++; } } //C will come out to be the size of array.C-1 wil be last abundant no. int HASH[28200]; //HASH=(int *)malloc(c*sizeof(int)); for(i=0;i<28200;i++) HASH[i]=0; for(i=0;i<c;i++) { for(j=0;j<c;j++) { s=abundant[i]+abundant[j]; if(s<=28200) HASH[s]=1; } } long long sum=0; //print the no. wich cannot be break into 2 abundant no. for(i=0;i<28200;i++) { if(HASH[i]==0) sum=sum+i;//printf("%d ",i); } printf("%lld",sum); }
int main() { scanf("%d",&N); for (int i=1;i<=N;++i) { scanf("%d",&Val(i)); Sum(i)=Ms(i)=Lms(i)=Rms(i)=Val(i); Par(i)=i-1,Rch(i-1)=i,Size(i)=N-i+1; splay(root,i); } splay(root,1),Par(N+1)=1,Lch(1)=N+1,Size(N+1)=1,splay(root,N+1); splay(root,N),Par(N+2)=N,Rch(N)=N+2,Size(N+2)=1,splay(root,N+2); tot=N+2; for (scanf("%d",&Que);Que--;) { scanf("%s%d",cmd,&x); if (cmd[0]=='D') D(Findkth(root,x+1)); else { scanf("%d",&y); if (cmd[0]=='Q') Q(Findkth(root,x),Findkth(root,y+2)); else if (cmd[0]=='I') I(Findkth(root,x+1),y); else R(Findkth(root,x+1),y); } } print_r(root); printf("\n"); print_l(root); printf("\n"); return 0; }
int Sha::_Sum(lua_State* L){ // check arg if((lua_gettop(L)<2) || (lua_isnumber(L, 1)==0) || (lua_isstring(L, 2)==0)){ lua_pushnil(L); lua_pushstring(L, "invalid arg"); return 2; } const int64_t type =static_cast<int64_t>(lua_tonumber(L, 1)); if(!(type>=TYPE_MIN && type<=TYPE_MAX)){ lua_pushnil(L); lua_pushstring(L, "invalid arg, type is out of range"); return 2; } size_t s; const char* data =lua_tolstring(L, 2, &s); ASSERT(data); // sum char result[SHA512_BUFFER_LENGTH + 1] ={0}; if(Sum(type, data, s, result)){ lua_pushstring(L, result); return 1; } else{ lua_pushnil(L); lua_pushstring(L, "Sha::Sum error"); return 2; } }
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; }
double Average(const vector<double>& v) { double av = Sum(v); if (!v.empty()) av /= (double)v.size(); return av; }
void * reduce_phase2(const void * _exp) { if(isA(_exp, Integer())) return domainCast(_exp, Real()); else if(isA(_exp, Real()) || isA(_exp, Var())) return copy(_exp); else if(isA(_exp, Sum()) || isA(_exp, Product())) { void * s = copy(_exp); size_t i; for(i = 0; i < size(s); ++i) { delete(argv(s, i)); setArgv(s, i, reduce_phase2(argv(_exp, i))); } return s; } else if(isA(_exp, Pow())) { void * p = copy(_exp); delete(base(p)); delete(power(p)); setBase(p, reduce_phase2(base(_exp))); setPower(p, reduce_phase2(power(_exp))); return p; } else if(isOf(_exp, Apply_1())) { void * f = copy(_exp); delete(arg(f)); setArg(f, reduce_phase2(arg(_exp))); return f; } assert(0); }
/* ---------------------------------------------------------------------------- ** procedure for making the Abel integration for deconvolution of the image ** y <-> array with values for deconvolution and results ** N <- width of the array ** adl <- array with pre-calculated weighting factors */ static void abel ( float *y, int N, double *adl) { register int n; double *rho, *rhop; /* results and new index */ float *yp; /* new indizes for the y-array */ MALLOCARRAY(rho, N); if( !rho ) pm_error( "out of memory" ); rhop = rho; yp = y; for (n=0 ; n<N ; n++) { *(rhop++) = ((*yp++) - Sum(n,rho,N,adl))/(adl[n*N+n]); /* *(rhop++) = ((*yp++) - Sum(n,rho,N))/(dr(n,n+0.5,N)); old version */ if ( *rhop < 0.0 ) *rhop = 0.0; /* error correction ! */ /* if (n > 2) rhop[n-1] = (rho[n-2]+rho[n-1]+rho[n])/3.0; stabilization*/ } for (n=0 ; n<N ; n++) { if (( n>=1 )&&( n<N-1 )) (*y++) = ((rho[n-1]*0.5+rho[n]+rho[n+1]*0.5)/2.0);/*1D median filter*/ else (*y++) = rho[n]; } free(rho); }