Example #1
0
void XEM::ProbaComputation(){
  m_probacompo=ones<mat>(p_results->p_data->m_n, p_results->p_model->m_g);
  for (int k=0; k<p_results->p_model->m_g; k++){
    tmpval = ones<vec>(p_results->p_data->m_n) * paramCurrent_p->m_pi(k);
    for (int b=0; b<=max(p_results->p_model->m_omega);b++){
      if (p_results->p_model->m_sizeblock(b) == 1){
        for (int h=0; h<p_results->p_data->m_modalities; h++){
          tmpval(p_results->p_data->m_whotake[idxvbles[b](0)][h]) = tmpval(p_results->p_data->m_whotake[idxvbles[b](0)][h])  * paramCurrent_p->m_alpha[b][0](k, h);
        }          
      }else if (p_results->p_model->m_sizeblock(b) > 1){
        tmpindep = (1-paramCurrent_p->m_epsilon(k,b)) * ones<vec>(p_results->p_data->m_n);
        for (int j=0; j<p_results->p_model->m_sizeblock(b);j++){
          for (int h=0; h<p_results->p_data->m_modalities; h++){
            tmpindep(p_results->p_data->m_whotake[idxvbles[b](j)][h]) = tmpindep(p_results->p_data->m_whotake[idxvbles[b](j)][h])  * paramCurrent_p->m_alpha[b][j](k, h);
          }   
        }
        m_probablock[k][b].col(0) = tmpindep;
        tmpdep = (paramCurrent_p->m_epsilon(k,b)) * onDiag.col(b);
        for (int h=0; h<p_results->p_data->m_modalities; h++){
          tmpdep(p_results->p_data->m_whotake[idxvbles[b](0)][h]) = tmpdep(p_results->p_data->m_whotake[idxvbles[b](0)][h]) * paramCurrent_p->m_beta[b](k,h);
        }
        m_probablock[k][b].col(1) = tmpdep;
        tmpval = tmpval % (tmpdep + tmpindep);
      }   
    }
    m_probacompo.col(k)=tmpval;
  }
  m_probacompo = log(m_probacompo);
}
Example #2
0
    BOOST_FOREACH(const size_t& ID, range1)
    {
        ParticleEventData tmpval(Sim->particles[ID],
                                 *Sim->species[Sim->particles[ID]],
                                 eType);

        Sim->particles[ID].getVelocity() -= dP / structmass1;

        tmpval.setDeltaKE(0.5 * Sim->species[tmpval.getSpeciesID()]->getMass(ID)
                          * (Sim->particles[ID].getVelocity().nrm2()
                             - tmpval.getOldVel().nrm2()));

        retVal.L1partChanges.push_back(tmpval);
    }
  virtual void gradient(Vector<Real> &g,
                        const Vector<Real> &x,
                        Real &tol) {
    g.zero();
    // split x
    const Vector_SimOpt<Real> &xuz = Teuchos::dyn_cast<const Vector_SimOpt<Real> >(x);
    Teuchos::RCP<const Vector<Real> > xuptr = xuz.get_1();
    Teuchos::RCP<const Vector<Real> > xzptr = xuz.get_2();
    const SimulatedVector<Real> &pxu = Teuchos::dyn_cast<const SimulatedVector<Real> >(*xuptr);
    const RiskVector<Real> &rxz = Teuchos::dyn_cast<const RiskVector<Real> >(*xzptr);
    Real xt = rxz.getStatistic(0);
    Teuchos::RCP<const Vector<Real> > xz = rxz.getVector();
    // split g
    Vector_SimOpt<Real> &guz = Teuchos::dyn_cast<Vector_SimOpt<Real> >(g);
    Teuchos::RCP<Vector<Real> > guptr = guz.get_1();
    Teuchos::RCP<Vector<Real> > gzptr = guz.get_2();
    SimulatedVector<Real> &pgu = Teuchos::dyn_cast<SimulatedVector<Real> >(*guptr);
    RiskVector<Real> &rgz = Teuchos::dyn_cast<RiskVector<Real> >(*gzptr);
    Teuchos::RCP<Vector<Real> > gz = rgz.getVector();

    std::vector<Real> param;
    Real weight(0), one(1), sum(0), tmpsum(0), tmpval(0), tmpplus(0);
    //Teuchos::RCP<Vector<Real> > tmp1 = gzptr->clone();
    //Teuchos::RCP<Vector<Real> > tmp2 = gzptr->clone();
    Teuchos::RCP<Vector<Real> > tmp1 = gz->clone();
    Teuchos::RCP<Vector<Real> > tmp2 = gz->clone();
    for (typename std::vector<SimulatedVector<Real> >::size_type i=0; i<pgu.numVectors(); ++i) {
      param = sampler_->getMyPoint(static_cast<int>(i));
      weight = sampler_->getMyWeight(static_cast<int>(i));
      pobj_->setParameter(param);
      //tmpval = pobj_->value(*(pxu.get(i)), *xzptr, tol);
      tmpval = pobj_->value(*(pxu.get(i)), *xz, tol);
      tmpplus = pfunc_->evaluate(tmpval-xt, 1);
      tmpsum += weight*tmpplus;
      //Vector_SimOpt<Real> xi(Teuchos::rcp_const_cast<Vector<Real> >(pxu.get(i)), Teuchos::rcp_const_cast<Vector<Real> >(xzptr));
      Vector_SimOpt<Real> xi(Teuchos::rcp_const_cast<Vector<Real> >(pxu.get(i)), Teuchos::rcp_const_cast<Vector<Real> >(xz));
      Vector_SimOpt<Real> gi(pgu.get(i), tmp1);
      pobj_->gradient(gi, xi, tol);
      gi.scale(weight*tmpplus);
      tmp2->plus(*tmp1);
      pgu.get(i)->scale(one/(one-alpha_));
    }
    //sampler_->sumAll(*tmp2, *gzptr);
    //gzptr->scale(one/(one-alpha_));
    sampler_->sumAll(*tmp2, *gz);
    gz->scale(one/(one-alpha_));
    sampler_->sumAll(&tmpsum, &sum, 1);
    rgz.setStatistic(one - (one/(one-alpha_))*sum);
  }
void register_LoadUrlImage_js(JSContext* cx, JSObject* global)
{
    JS::RootedValue nsval(cx);
    JS::RootedValue tmpval(cx);
    JS::RootedObject pJsbObject(cx);

    JS_GetProperty(cx, global, "LoadUrlImage", &nsval);
    if (nsval == JSVAL_VOID) {
        pJsbObject = JS_NewObject(cx, NULL, NULL, NULL);
        nsval = OBJECT_TO_JSVAL(global);
        JS_SetProperty(cx, global, "LoadUrlImage", nsval);
    }
    else
    {
        JS_ValueToObject(cx, nsval, &pJsbObject);
    }

    JS_DefineFunction(cx, global, "loadUrlImage", JSB_LoadUrlImage_loadUrlImage, 2, JSPROP_READONLY | JSPROP_PERMANENT);
}