Exemple #1
0
void Heap<T, Compare>::FilterDown (int i)
{
	int currentpos, childpos;
	T target;
	currentpos=i;
	childpos=2*i+1;
	target=m_pdata[i];
	while (childpos<curr_size)
	{
		if ( (childpos+1<curr_size) && m_f(m_pdata[childpos+1],m_pdata[childpos]))
			{
			++childpos;
			}
		if (m_f(target,m_pdata[childpos]))
			{
			break;
			}
		else
		{
			std::swap(m_pdata[currentpos], m_pdata[childpos]);
			currentpos=childpos;
			childpos=2*currentpos+1;
		}
	}
	m_pdata[currentpos]=target;
}
Exemple #2
0
void GridMeterScalarFunc::measure(data_sp data)
{
  Phase *phase = ((Simulation*) M_GRID_AVERAGER->parent())->phase();
  vector<double> *moments = data->vectorDoubleByOffset(m_moment_o).value();
  int n_cells = M_GRID_AVERAGER->nCells();

  moments->resize(n_cells);

  FOR_EACH_FREE_PARTICLE_C
    (phase, m_colour,
     int index = M_GRID_AVERAGER->location(c, __iSLFE->mySlot);
     int n = M_GRID_AVERAGER->nParticles(c, index);
         
     if (n) {
       // the argument of the sin is a scalar product
       double e; 
       m_f(&e, __iSLFE);
       e*= __iSLFE->tag.doubleByOffset(m_scalar_o);

       if(m_moment != 1) {
	 double temp = e;
	 for(size_t pow = 2; pow <= m_moment; ++pow)
	   e*=temp;
       }

       /* fixme!!! Slow! Better divide only once per cell. */
       (*moments)[index] += e/n;
     }
    );
Exemple #3
0
void CBC::operator()(NTupleRW<symbol>& Vec, int mode /*=Encrypt*/)
{
	int len=m_f.GetSize();

	if (mode==Encrypt) {
		//Vec=Vec^m_lastblock;
		for (int j=0;j<len;j++) Vec[j]=Vec[j]^m_lastblock[j];

		m_f(Vec,Cipher::Encrypt);
		Copy(m_lastblock,Vec,len);
	} else { // Decrypt
		static Array<symbol,symbol> tmp(len);
		Copy(tmp,Vec,len);
		m_f(Vec,Cipher::Decrypt);
		//Vec=Vec^m_lastblock;
		for (int j=0;j<len;j++) Vec[j]=Vec[j]^m_lastblock[j];
		Copy(m_lastblock,tmp,len);
	}
}
Exemple #4
0
void for_each_level_fn::apply(level const & l) {
    if (!m_f(l))
        return;
    switch (l.kind()) {
    case level_kind::Succ:                          apply(succ_of(l)); break;
    case level_kind::Max: case level_kind::IMax:    apply(to_max_core(l).m_lhs); apply(to_max_core(l).m_rhs); break;
    case level_kind::Zero: case level_kind::Param:
    case level_kind::Meta: case level_kind::Global: break;
    }
}
Exemple #5
0
		void draw_lines() const{
			T dist = (m_r2 - m_r1) / m_count;
			T r = m_r1;
			Open_polyline op;
			for(int i = 0; i < m_count; ++i) {
				op.add(Point(m_orig.x + int(r * m_xscale), m_orig.y - int(m_f(r) * m_yscale)));
				r += dist;
			}
			op.draw_lines();
		}
Exemple #6
0
  Seq<Shrinkables<T>>
  shrinkElements(const Shrinkables<T> &shrinkables) const {
    using Key = Decay<typename std::result_of<F(T)>::type>;
    const auto keys = std::make_shared<std::set<Key>>();
    for (const auto &shrinkable : shrinkables) {
      keys->insert(m_f(shrinkable.value()));
    }

    return shrink::eachElement(shrinkables,
                               [=](const Shrinkable<T> &s) {
                                 const auto valueKey = m_f(s.value());
                                 return seq::filter(
                                     s.shrinks(),
                                     [=](const Shrinkable<T> &shrink) {
                                       const auto shrinkKey = m_f(shrink.value());
                                       return (!(valueKey < shrinkKey) &&
                                               !(shrinkKey < valueKey)) ||
                                           keys->count(shrinkKey) == 0;
                                     });
                               });
  }
Exemple #7
0
    void operator()( Wt::WContainerWidget* pcw ) {
      std::cout << "callback ";
      auto pMemberTop( new Wt::WText( "member top" ) );
      pMemberTop->setStyleClass( "MemmberTop" );
      pcw->addWidget( pMemberTop );
      
      m_f( pcw );

      auto pMemberBottom( new Wt::WText( "member bottom" ) );
      pMemberBottom->setStyleClass( "MemberBottom" );
      pcw->addWidget( pMemberBottom );
    }
 double operator()(const double x, const double y) const noexcept
 {
   const auto co_double = m_f(x,y);
   const Plane::Coordinat3D co_apfloat(
     apfloat(boost::geometry::get<0>(co_double)),
     apfloat(boost::geometry::get<1>(co_double)),
     apfloat(boost::geometry::get<2>(co_double))
   );
   const auto error_apfloat = m_plane.CalcError(co_apfloat);
   return Geometry().ToDoubleSafe(error_apfloat);
   //return m_plane.CalcError(m_f(x,y));
 }
Exemple #9
0
void FeistelCipher::operator()(NTupleRW<symbol>& Vec, int mode /*=Encrypt*/) const
{
	m_Init(Vec);
	if (m_f.GetSize()==1) {
		//SubArray<symbol> R(Vec,1,1);
		for (int i=0;i<m_Rounds;i++) {
			symbol t=Vec[1];
			//m_f(R,mode==Decrypt?m_Rounds-1-i:i);
			Vec[1]=m_f(Vec[1],mode==Decrypt?m_Rounds-1-i:i);
			Vec[1]=Vec[1]^Vec[0];
			Vec[0]=t;
		}
#if !defined(_MSC_VER) || _MSC_VER <= 1200
		swap(Vec[0],Vec[1]);
#else
		std::swap(Vec[0],Vec[1]);
#endif
	} else {
		int len=m_f.GetSize();
		//SubArray L(Vec,0,len); // benutze Vec stattdessen, ist schneller
		NTupleRW<symbol>& L=Vec;
		SubArray<symbol> R(Vec,len,len);
		static Array<symbol,symbol> t(len);
		for (int i=0;i<m_Rounds;i++) {
			//symbol t=Vec[1];
			Copy(t,R,len); //for (int j=0;j<len;j++) t[j]=R[j];
			m_f(R,mode==Decrypt?m_Rounds-1-i:i);
			//Vec[1]=Vec[1]^Vec[0];
			for (int j=0;j<len;j++) R[j]=R[j]^L[j];
			//Vec[0]=t;
			Copy(L,t,len); //for (int j=0;j<len;j++) L[j]=t[j];
		}
#if !defined(_MSC_VER) || _MSC_VER <= 1200
		for (int j=0;j<len;j++) swap(Vec[j],Vec[j+len]);
#else
		for (int j=0;j<len;j++) std::swap(Vec[j],Vec[j+len]);
#endif
	}
	m_End(Vec);
}
Exemple #10
0
        void compute_value() {
            if ( m_first == m_last) {
                m_processed_last = true;
                return;
            }

            if ( m_f( m_val, *m_first, m_idx)) {
                ++m_idx;
                return;
            }
            else
                ++m_first;
        }
Exemple #11
0
level replace_level_fn::apply(level const & l) {
    optional<level> r = m_f(l);
    if (r)
        return *r;
    switch (l.kind()) {
    case level_kind::Succ:
        return update_succ(l, apply(succ_of(l)));
    case level_kind::Max: case level_kind::IMax:
        return update_max(l, apply(to_max_core(l).m_lhs), apply(to_max_core(l).m_rhs));
    case level_kind::Zero: case level_kind::Param: case level_kind::Meta: case level_kind::Global:
        return l;
    }
    lean_unreachable(); // LCOV_EXCL_LINE
}
Exemple #12
0
 Shrinkables<T> generateElements(const Random &random,
                                 int size,
                                 std::size_t count,
                                 const Gen<T> &gen) const {
   using Key = Decay<typename std::result_of<F(T)>::type>;
   std::set<Key> values;
   return detail::generateShrinkables(random,
                                      size,
                                      count,
                                      gen,
                                      [&](const Shrinkable<T> &s) {
                                        return values.insert(m_f(s.value()))
                                            .second;
                                      });
 }
        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
        {
          if (m_arity < 0 || params.size() == size_t(m_arity))
          {

            if (test_guard(params, t_conversions))
            {
              return m_f(params);
            } else {
              throw exception::guard_error();
            }

          } else {
            throw exception::arity_error(static_cast<int>(params.size()), m_arity);
          } 
        }
        void compute_value() {
            if ( m_first == m_last) {
                m_processed_last = true;
                return;
            }

            iterator_type begin = m_first;
            while ( m_first != m_last) {
                iterator_type prev = m_first;
                ++m_first;
				if ( m_first == m_last)
					break;
                if ( !m_slicer( *prev, *m_first))
                    break;
            }
            m_f( m_val, begin, m_first);
        }
Exemple #15
0
void EvolutionScreen::Finalize()
{
	Textbox* main_frame = this->main_frame;
	Textbox* evolved = new Textbox();

	bool learned_move = false;
	std::function<void(TextItem* s)> m_f = nullptr;
	for (int i = 0; i < 16; i++)
	{
		if (pokemon_to->learnset[i].level == 0)
			break;
		if (pokemon_to->learnset[i].level == pokemon->level)
		{
			m_f = PokemonUtils::LearnMove(evolved, pokemon, pokemon_to->learnset[i].move);
			learned_move = true;
		}
	}

	std::function<void(TextItem* s)> a = [m_f, evolved](TextItem* src) {
		evolved->CancelClose(); 
		m_f(src); 
	};
	evolved->SetText(new TextItem(evolved, (!m_f ? [main_frame, evolved](TextItem* src) {evolved->Close(); main_frame->Close(); } : a), string(pokemon->nickname).append(pokestring(" evolved\ninto ")).append(pokemon_to->original_name).append(pokestring("!\t\t\t\t\t\t\a"))));
	main_frame->ShowTextbox(evolved, false);
	if (learned_move)
	{
		auto b = [evolved, main_frame, this](TextItem* s)
		{
			evolved->Close(true);
			main_frame->Close();
			this->parent->Close();
		};
		evolved->SetCloseCallback(b);
	}

	pokemon->id = pokemon_to->id;
	pokemon->pokedex_index = pokemon_to->pokedex_index;
	pokemon->LoadStats();
	unsigned int hp = pokemon->max_hp;
	pokemon->RecalculateStats();
	pokemon->hp += pokemon->max_hp - hp;
}
Exemple #16
0
void Heap<T, Compare>::FilterUp (int i)  
{ 
	int currentpos, parentpos;
	T target;
	currentpos=i;
	parentpos=(i-1)/2;
	target=m_pdata[i];
	while (currentpos)
	{
		if (!(m_f(m_pdata[currentpos],m_pdata[parentpos])))
			{
			break;
			}
		else
		{
			std::swap(m_pdata[parentpos], m_pdata[currentpos]);
			currentpos=parentpos;
			parentpos=(currentpos-1)/2;
		}
	}
	m_pdata[currentpos]=target;
}
Exemple #17
0
        void compute_value() {
            if ( m_first == m_last) {
                m_processed_last = true;
                return;
            }

            // FIXME for iterator categories > input_iterator
            // don't use any temporary
            m_val = m_init;
            while ( true) {
                src_value_type tmp = *m_first;
                m_f( m_val, tmp);
                ++m_first;
                if ( m_first != m_last) {
                    if ( !m_slicer( tmp, *m_first))
                        // got to a new slice
                        break;
                }
                else
                    // got to the end
                    break;
            }
        }
Exemple #18
0
 TaggedConstant
 operator()(const Tuple& k)
 {
   return m_f(k);
 }
Exemple #19
0
				std::shared_ptr<torrent_plugin> new_torrent(torrent_handle const& t, void* user) override
				{ return m_f(t, user); }
 typename super_t::reference dereference() const
 { return m_f(*this->base()); }
Exemple #21
0
 Real operator()(const S& row)
 {
    return -Real(m_f(row));
 }
Exemple #22
0
void cv::GCPUKernel::apply(GCPUContext &ctx)
{
    GAPI_Assert(m_f);
    m_f(ctx);
}
 template <class T> output_proxy& operator=(const T& value) {
   m_f(value); 
   return *this; 
 }
 virtual void exec()
 {
     m_f();
 }
 output_proxy& operator=(const T& value) {
   m_f(value);
   return *this; 
 }
Exemple #26
0
 bool operator()(const wxChar* s1, const wxChar* s2)
     { return m_f(s1, s2) < 0; }
 typename IteratorAdaptorT::reference
 dereference(const IteratorAdaptorT &iter) const
 { return m_f(*iter.base()); }
Exemple #28
0
	~ScopeExit() { m_f(); }
Exemple #29
0
 bool operator()(const wxString& s1, const wxString& s2)
     { return m_f(s1, s2) < 0; }
Exemple #30
0
void Task::operator()()
{
	m_f();
}