Esempio n. 1
0
eOSState cMenuBouquetsList::DeleteBouquet()
{
    if (Interface->Confirm(tr("Delete Bouquet?")))
    {
        cChannel *bouquet = GetBouquet(Current());
        cChannel *next = (cChannel *) bouquet->Next();
        /* Delete all channels up to the beginning */
        /* of the next bouquet */
        while (next && !next->GroupSep())
        {
            cChannel *p = next;
            next = (cChannel *) next->Next();
            Channels.Del(p);
        }
        /* Delete the bouquet itself */
        Channels.Del(bouquet);
        /* Remove the OSD-item */
        cOsdMenu::Del(Current());
        Propagate();
        if (Current() < -1)
            SetCurrent(0);
        return osContinue;
    }
    return osContinue;
}
Esempio n. 2
0
//------------------------------------------------------------------------------
bool RunSimulator::Execute()
{
   #ifdef DEBUG_SIMULATOR_EXECUTION
      MessageInterface::ShowMessage(wxT("\n\nThe \"%s\" command is running...\n"),
            GetTypeName().c_str());
   #endif

   // Reset the command if called after it has completed execution
   // todo: Debug this piece; reentrance in a For loop doesn't work yet
//   if (commandComplete)
//      TakeAction("Reset");


   // Here we should check to see if the command is currently propagating and
   // finish that first...

   // Respond to the state in the state machine
   Solver::SolverState state = theSimulator->GetState();

   #ifdef DEBUG_SIMULATOR_EXECUTION
      MessageInterface::ShowMessage(wxT("\nSimulator state is %d\n"), state);
   #endif
   switch (state)
   {
      case Solver::INITIALIZING:
         PrepareToSimulate();
         break;

      case Solver::PROPAGATING:
         Propagate();
         break;

      case Solver::CALCULATING:
         Calculate();
         break;

      case Solver::LOCATING:
         // The LOCATING state shouldn't trigger until we have event location
         // implemented, so this case should not fire.
         LocateEvent();
         break;

      case Solver::SIMULATING:
         Simulate();
         break;

      case Solver::FINISHED:
         Finalize();
         break;

      default:
         throw CommandException(wxT("Unknown state ")
               wxT(" encountered in the RunSimulator command"));
   }

   state = theSimulator->AdvanceState();

   return true;
}
Esempio n. 3
0
	/**
	 * @brief Propagates all beacons in the world.
	 *
	 * Should be called everytime someone joins or leaves a team.
	 */
	void PropagateAll()
	{
		for ( gentity_t *ent = nullptr; (ent = G_IterateEntities( ent )); )
		{
			if ( ent->s.eType != ET_BEACON )
				continue;

			Propagate( ent );
		}
	}
Esempio n. 4
0
void Viewport::Init(Interactor* i, Alignment a) {
    SetClassName("Viewport");
    background = nil;
    align = a;
    shape->Rigid(hfil, hfil, vfil, vfil);
    perspective = new Perspective;
    Propagate(false);
    if (i != nil) {
	Insert(i);
    }
}
void
wxMoColourLevelCtrl::SetColourValue( wxColour p_ColourValue, bool propagate ) {

  ///necesarry to map m_ColourValue internally to RGB and HSV
  UpdateColour( p_ColourValue );

  ///internal process of colour
  ProcessColour();

  if (propagate) {
      Propagate();
  }

}
Esempio n. 6
0
void NeuralNetwork::Train(FloatsVector& inputs, FloatsVector& desiredOutputs)
{
    FloatsVector outputs(outputNeuronCount);
    FloatsVector hiddenOutputs(hiddenNeuronCount);
    FloatsVector outputDeltas(outputNeuronCount);
    FloatsVector hiddenDeltas(hiddenNeuronCount);
    const float eta = 0.3;
    
    assert(inputs.size() == inputNeuronCount);
    assert(desiredOutputs.size() == outputNeuronCount);
    
    // Feedforward the current values
    Propagate(inputs, outputs, hiddenOutputs);
    
    // Calculate the deltas from the output
    for (int k = 0; k < outputNeuronCount; k++)
    {
        outputDeltas[k] = desiredOutputs[k] - outputs[k];
    }
    
    // Propagate the deltas back to the hidden layer
    for (int j = 0; j < hiddenNeuronCount; j++)
    {
        for (int k = 0; k < outputNeuronCount; k++) {
            hiddenDeltas[j] += outputWeights[k * hiddenNeuronCount + j] * outputDeltas[k];
        }
    }
    
    // Now update the weights for the input->hidden weights
    for (int i = 0; i < inputNeuronCount; i++)
    {
        for (int j = 0; j < hiddenNeuronCount; j++)
        {
            float deltaWeight = eta * hiddenDeltas[j] * hiddenOutputs[j] * (1.0 - hiddenOutputs[j]);
            inputWeights[j * inputNeuronCount + i] += deltaWeight;
        }
    }
    
    // And update the hidden->output weights
    for (int j = 0; j < hiddenNeuronCount; j++)
    {
        for (int k = 0; k < outputNeuronCount; k++)
        {
            float deltaWeight = eta * outputDeltas[k] * outputs[k] * (1.0 - outputs[k]) * hiddenOutputs[j];
            outputWeights[k * hiddenNeuronCount + j] += deltaWeight;
        }
    }
    
    
}
Esempio n. 7
0
bool PointAlgebraReasoner::Close()
{
  pair<int, int> ij;
  int signal=0;
  while(!Queue.empty())
  {
    ij= Queue.front();
    signal= Propagate(ij.first, ij.second);
    if(! signal) //contradiction (inconsistent network)
      return signal;
    Queue.pop();
  }
  return true;
}
Esempio n. 8
0
Viewport::Viewport (
    Sensor* in, Painter* out, Interactor* i, Alignment a
) : (in, out) {
    Init(i, a);
}

void Viewport::Init (Interactor* i, Alignment a) {
    SetClassName("Viewport");
    align = a;
    shape->Rigid(hfil, hfil, vfil, vfil);
    perspective = new Perspective;
    Propagate(false);
    if (i != nil) {
	Insert(i);
    }
}
Esempio n. 9
0
int main(int argc, char **argv)
{
	MPI_Init(&argc, &argv);
	MPI_Comm_size(MPI_COMM_WORLD, &size);
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);

	GetParam(argc, argv);
	
	if (rank == 0) 
		OutParam();

	MPI_Barrier(MPI_COMM_WORLD);
	
	Allocate();
	Propagate();
	Finalize();

	MPI_Finalize();
}
Esempio n. 10
0
void cMenuBouquetsList::Move(int From, int To)
{
    int CurrentChannelNr = cDevice::CurrentChannel();
    cChannel *CurrentChannel = Channels.GetByNumber(CurrentChannelNr);
    cChannel *FromChannel = GetBouquet(From);
    cChannel *ToChannel = GetBouquet(To);
    if (To > From)
        for (cChannel * channel = (cChannel *) ToChannel->Next();
             channel && !channel->GroupSep(); channel = (cChannel *) channel->Next())
            ToChannel = channel;

    if (FromChannel && ToChannel && FromChannel != ToChannel)
    {
        int FromIndex = FromChannel->Index();
        int ToIndex = ToChannel->Index();
        cChannel *NextFromChannel = NULL;
        while (FromChannel && (!FromChannel->GroupSep() || !NextFromChannel))
        {
            NextFromChannel = (cChannel *) FromChannel->Next();
            Channels.Move(FromChannel, ToChannel);
            if (To > From)
                ToChannel = FromChannel;
            FromChannel = NextFromChannel;
        }

        if (From != To)
        {
            cOsdMenu::Move(From, To);
            Propagate();
            isyslog("bouquet from %d moved to %d", FromIndex, ToIndex);
        }
        if (CurrentChannel && CurrentChannel->Number() != CurrentChannelNr)
        {
            isyslog("CurrentChannelNr = %d; CurrentChannel::number = %d",
                    CurrentChannelNr, CurrentChannel->Number());
            Channels.SwitchTo(CurrentChannel->Number());
        }
    }
}
Esempio n. 11
0
void NeuralNetwork::Propagate(FloatsVector& inputs, FloatsVector& outputs)
{
    std::vector<float> hiddenLayerValues(hiddenNeuronCount);
    Propagate(inputs, outputs, hiddenLayerValues);
}
Esempio n. 12
0
	/**
	 * @brief Tags an entity.
	 */
	void Tag( gentity_t *ent, team_t team, bool permanent )
	{
		int data;
		vec3_t origin, mins, maxs;
		bool dead, player;
		gentity_t *beacon, **attachment;
		team_t targetTeam;

		// Get the beacon attachment owned by the tagging team.
		switch( team ) {
			case TEAM_ALIENS: attachment = &ent->alienTag; break;
			case TEAM_HUMANS: attachment = &ent->humanTag; break;
			default:                                       return;
		}

		// Just refresh existing tags.
		if ( *attachment ) {
			RefreshTag( *attachment, true );
			return;
		}

		switch( ent->s.eType ) {
			case ET_BUILDABLE:
				targetTeam = ent->buildableTeam;
				data       = ent->s.modelindex;
				dead       = G_Dead( ent );
				player     = false;
				BG_BuildableBoundingBox( ent->s.modelindex, mins, maxs );
				break;

			case ET_PLAYER:
				targetTeam = (team_t)ent->client->pers.team;
				dead       = G_Dead( ent );
				player     = true;
				BG_ClassBoundingBox( ent->client->pers.classSelection, mins, maxs, nullptr, nullptr, nullptr );

				// Set beacon data to class (aliens) or weapon (humans).
				switch( targetTeam ) {
					case TEAM_ALIENS: data = ent->client->ps.stats[ STAT_CLASS ];    break;
					case TEAM_HUMANS: data = BG_GetPlayerWeapon( &ent->client->ps ); break;
					default:                                                         return;
				}

				break;

			default:
				return;
		}

		// Don't tag dead targets.
		if ( dead ) return;

		// Set beacon origin to center of target bounding box.
		VectorCopy( ent->s.origin, origin );
		BG_MoveOriginToBBOXCenter( origin, mins, maxs );

		// Create new beacon and attach it.
		beacon = New( origin, BCT_TAG, data, team );
		beacon->tagAttachment = attachment;
		*attachment = beacon;
		beacon->s.bc_target = ent - g_entities;

		// Reset the entity's tag score.
		ent->tagScore = 0;

		// Set flags.
		if( player )             beacon->s.eFlags |= EF_BC_TAG_PLAYER;
		if( team != targetTeam ) beacon->s.eFlags |= EF_BC_ENEMY;

		// Set expiration time.
		if( permanent ) beacon->s.bc_etime = 0;
		else            RefreshTag( beacon, true );

		// Update the base clusterings.
		if ( ent->s.eType == ET_BUILDABLE ) BaseClustering::Update( beacon );

		Propagate( beacon );
	}
Esempio n. 13
0
	/**
	 * @brief Tags an entity.
	 * @todo Don't create a new beacon entity if retagged since that triggers regeneration of base
	 *       clusterings.
	 */
	void Tag( gentity_t *ent, team_t team, int owner, qboolean permanent )
	{
		int i, data;
		vec3_t origin, mins, maxs;
		qboolean dead, player;
		gentity_t *beacon, **attachment;
		team_t targetTeam;

		switch( ent->s.eType )
		{
			case ET_BUILDABLE:
				targetTeam = ent->buildableTeam;
				BG_BuildableBoundingBox( ent->s.modelindex, mins, maxs );
				data = ent->s.modelindex;
				dead = ( ent->health <= 0 );
				player = qfalse;
				break;

			case ET_PLAYER:
				targetTeam = (team_t)ent->client->pers.team;
				BG_ClassBoundingBox( ent->client->pers.classSelection, mins, maxs, NULL, NULL, NULL );
				dead = ( ent->client && ent->client->ps.stats[ STAT_HEALTH ] <= 0 );
				player = qtrue;

				// data is the class (aliens) or the weapon number (humans)
				switch( targetTeam )
				{
					case TEAM_ALIENS:
						data = ent->client->ps.stats[ STAT_CLASS ];
						break;

					case TEAM_HUMANS:
						data = BG_GetPlayerWeapon( &ent->client->ps );
						break;

					default:
						return;
				}

				break;

			default:
				return;
		}

		for( i = 0; i < 3; i++ )
			origin[ i ] = ent->s.origin[ i ] + ( mins[ i ] + maxs[ i ] ) / 2.0;

		switch( team )
		{
			case TEAM_ALIENS:
				attachment = &ent->alienTag;
				break;

			case TEAM_HUMANS:
				attachment = &ent->humanTag;
				break;

			default:
				return;
		}

		if ( *attachment )
			Delete( *attachment );

		beacon = New( origin, BCT_TAG, data, team, owner );
		beacon->tagAttachment = attachment;
		beacon->s.otherEntityNum2 = ent - g_entities;

		ent->tagScore = 0;

		if( player )
			beacon->s.eFlags |= EF_BC_TAG_PLAYER;

		if( team != targetTeam )
			beacon->s.eFlags |= EF_BC_ENEMY;

		if( permanent )
			beacon->s.time2 = 0;
		else
			RefreshTag( beacon, true );

		if( dead )
			Delete( beacon, true );
		else
		{
			*attachment = beacon;
			if ( ent->s.eType == ET_BUILDABLE ) BaseClustering::Update( beacon );
		}

		Propagate( beacon );
	}