Ejemplo n.º 1
0
void terminal_t::schedule_solve_after(const netlist_time after)
{
	// Nets may belong to railnets which do not have a solver attached
	if (this->has_net())
		if (net().solver() != nullptr)
			net().solver()->update_after(after);
}
Ejemplo n.º 2
0
ATTR_COLD netlist_analog_output_t::netlist_analog_output_t()
	: netlist_output_t(OUTPUT, ANALOG)
{
    net().m_last.Analog = 0.97;
	net().m_cur.Analog = 0.98;
	net().m_new.Analog = 0.99;
}
Ejemplo n.º 3
0
void terminal_t::solve_now()
{
	// Nets may belong to railnets which do not have a solver attached
	if (this->has_net())
		if (net().solver() != nullptr)
			net().solver()->update_forced();
}
Ejemplo n.º 4
0
NetUdpSocket* Net::udpSocket() { //NetTcpSocket on default if
 if ( net().m_defaultIf == NULL )
      return NULL;
  NetUdpSocket* pNetUdpSocket = net().m_defaultIf->udpSocket();
  pNetUdpSocket->m_refs++;
  return pNetUdpSocket;
}
Ejemplo n.º 5
0
/**
  * @return true of the net is selected.
  */
bool CGSegment::selected()
{
	if ( net() != NULL )
	{
		return net()->isSelected();
	}
	return false;
}
Ejemplo n.º 6
0
ATTR_COLD analog_output_t::analog_output_t(core_device_t &dev, const pstring &aname)
	: analog_t(OUTPUT), m_proxied_net(nullptr)
{
	this->set_net(m_my_net);
	set_state(STATE_OUT);

	net().m_cur_Analog = NL_FCONST(0.99);

	analog_t::init_object(dev, aname);
	net().init_object(dev.netlist(), aname + ".net");
	net().register_railterminal(*this);
}
Ejemplo n.º 7
0
int main(void) {

  /* Read network from stdin.  */
  std::auto_ptr<NetType> netPointer(readNet<EdgeData>());
  NetType& net = *netPointer;  // Create a reference for easier handling of net.

  /* strength of each node and average strength  */
  float strengthSum=0;
  for (size_t i=0; i<net.size(); ++i) { 
    std::cout  << net(i).weight() << "\n";
    strengthSum += net(i).weight();
  }
  std::cerr << "\nAverage strength in the network:  " <<  strengthSum / net.size() << "\n\n";

}
Ejemplo n.º 8
0
//unsigned char buffer[STATIC_ALLOCATOR_SIZE];
//StaticAllocator myAlloc(buffer, STATIC_ALLOCATOR_SIZE);
int main() {
  //Alloc::init(&myAlloc);
//  DummyAgent agent;
  QLearningEGreedyPolicy egreedy(0.1f);
  NeuralNetwork net(DIM_OBSERVATIONS + DIM_ACTIONS, N_HIDDEN, 1, 0.1f);
  QLearningAgent agent(&net, DIM_OBSERVATIONS, DIM_ACTIONS, N_ACTIONS,
                       1.0f, 0.1f, &egreedy, false); // lambda = 1.0 => no history
  LibMapperEnvironment env;
  RLQualia qualia(&agent, &env);

  qualia.init();
  qualia.start();

  for (;;) {
//  for (int i=0; i<10; i++) {
    qualia.step();
#if is_computer()
    printf("Current agent action: %d\n", agent.currentAction.conflated());
    printf("Current environment observation: %f %f\n", (double)env.currentObservation.observations[0], (double)env.currentObservation.observations[1]);
#endif
  }

//  if (myAlloc.nLeaks)
//    printf("WARNING: Static Allocator has leaks: %d\n", myAlloc.nLeaks);

  return 0;
}
Ejemplo n.º 9
0
ATTR_COLD netlist_analog_output_t::netlist_analog_output_t()
	: netlist_output_t(OUTPUT, ANALOG), m_proxied_net(NULL)
{
	this->set_net(m_my_net);

	net().as_analog().m_cur_Analog = 0.98;
}
Ejemplo n.º 10
0
QString process_socket_file(const QString &filename, QString *symlink, int sock, F fp) {

	Q_ASSERT(symlink);

	QFile net(filename);
	net.open(QIODevice::ReadOnly | QIODevice::Text);
	if(net.isOpen()) {
		QTextStream in(&net);
		QString line;

		// ditch first line, it is just table headings
		in.readLine();

		// read in the first line we care about
		line = in.readLine();

		// a null string means end of file (but not an empty string!)
		while(!line.isNull()) {

			QString lline(line);
			const QStringList lst = lline.replace(":", " ").split(" ", QString::SkipEmptyParts);

			if(fp(symlink, sock, lst)) {
				break;
			}

			line = in.readLine();
		}
	}
	return *symlink;
}
Ejemplo n.º 11
0
int main(int argc, char* argv[]) { 
  
  struct MarsiliArgs args;
  readMarsiliArgs(args, argc, argv);
  
  RandNumGen<> generator(args.randseed); 
  _NetType net(args.netSize); 

  //time_t starttime = time(NULL);

  // Generate the network
  Marsili(net, args, generator);

  //time_t endtime = time(NULL);
  //std::cerr << "Time taken by generation: " << difftime(endtime, starttime) << " s\n";

  std::auto_ptr<_NetType> netPointer2(findLargestComponent<_NetType>(net)); 
  _NetType& net2 = *netPointer2;  // Create a reference for easier handling of net.

  double avg_clust = 0;
  for (size_t i = 0; i < net2.size(); i++)
      avg_clust += clusteringCoefficient(net2, i);

  size_t edges = numberOfEdges(net2);
  std::cout << net2.size() << " " << (double)2*edges/net2.size() << " " << avg_clust/net2.size() << " " << pearsonCoeff2(net2) << "\n";
}
Ejemplo n.º 12
0
/* Run a regular ring network test, but with an additional variable-sized
 * population of unconnected neurons of a different type.
 *
 * The additional Poisson source neurons should not have any effect on the
 * simulation but should expose errors related to mixing local/global partition
 * indices.
 */
void
testNeuronTypeMixture(backend_t backend, unsigned szOthers, bool izFirst)
{
	const unsigned szRing = 1024;
	boost::scoped_ptr<nemo::Network> net(new nemo::Network());
	if(izFirst) {
		createRing(net.get(), szRing);
	}
	unsigned poisson = net->addNeuronType("PoissonSource");
	float p = 0.001f;
	for(unsigned n=szRing; n<szRing+szOthers; ++n) {
		net->addNeuron(poisson, n, 1, &p);
	}
	if(!izFirst) {
		createRing(net.get(), szRing);
	}

	nemo::Configuration conf = configuration(false, 1024, backend);
	boost::scoped_ptr<nemo::Simulation> sim;
	BOOST_REQUIRE_NO_THROW(sim.reset(nemo::simulation(*net, conf)));

	/* Stimulate a single neuron to get the ring going */
	sim->step(std::vector<unsigned>(1, 0));

	const unsigned duration = 1000;
	for(unsigned ms=1; ms < duration; ++ms) {
		std::vector<unsigned> fired = sim->step();
		BOOST_REQUIRE(fired.size() > 0);
		std::sort(fired.begin(), fired.end());
		BOOST_REQUIRE_EQUAL(fired[0], ms % szRing);
		if(fired.size() > 1) {
			BOOST_REQUIRE(fired[1] >= szRing);
		}
	}
}
Ejemplo n.º 13
0
int main() {
    
    // Construct Network
    Network net("name", Network::Undirected);
    net.populate(10000);
    net.erdos_renyi(5);

    cout << "days_ahead" << "," << "transmissibility1" << "," << "transmissibility2" << "," << "strain1" << "," << "strain2" << endl;

    for (int days_ahead = 0; days_ahead < 20; days_ahead ++){
        for (double transmissibility1 = 0.2; transmissibility1 <=  0.5; transmissibility1 += 0.05){
            for (double transmissibility2 = 0.2; transmissibility2 <= 0.5; transmissibility2 += 0.05){
                int i = 0;
                while ( i < 100){
                    // Choose and run simulation
                    Two_Strain_Percolation_Sim sim(&net);
                    sim.set_transmissibility1(transmissibility1);
                    sim.set_transmissibility2(transmissibility2);
                    sim.rand_infect(5, 0);
                    sim.run_headstart_simulation(days_ahead, 5);

                    if(sim.epidemic_size1() > 50){
                        cout << days_ahead << "," << transmissibility1 << "," << transmissibility2 << "," << sim.epidemic_size1() << "," << sim.epidemic_size2() << endl; 
                        i++;
                    }
                    
                    sim.reset();
                }
            }
        }
    }

    return 0;
}
Ejemplo n.º 14
0
Archivo: daemon.cpp Proyecto: spito/dp
void Daemon::join( InputMessage &message, Channel channel ) {
    NOTE();

    OutputMessage response( MessageType::Control );
    int peerId;
    std::string peerName;

    message >> peerId >> peerName;
    channel->receive( message );

    if ( _state != State::FormingGroup ) {
        response.tag( Code::Refuse );
        channel->send( response );
        return;
    }

    response.tag( Code::OK );
    channel->send( response );

    std::string address( net().peerAddress( *channel ) );
    Line peer = std::make_shared< Peer >(
        peerId,
        std::move( peerName ),
        address.c_str(),
        std::move( channel )
    );

    connections().lockedInsert( peerId, std::move( peer ) );
}
Ejemplo n.º 15
0
network user_settings_io::read_network_from_yaml(const YAML::Node& node)
{
  const YAML::Node& nodes = node[usc::nodes];
  const std::size_t size = nodes.size();
  network net(size);
  node_positions_type node_positions;
  for(std::size_t i = 0; i < size; ++i)
  {
    const point_type& position = nodes[i].as<point_type>();
    net.set_node_position(i, position);
    node_positions.push_back(position);
  }
  settings_.set_node_positions(node_positions);
  if(node[usc::links])
  {
    std::vector<std::pair<std::size_t, std::size_t>> links;
    const YAML::Node& links_node = node[usc::links];
    for(std::size_t i = 0; i < links_node.size(); ++i)
    {
      std::pair<std::size_t, std::size_t> link = links_node[i].as<std::pair<std::size_t, std::size_t>>();
      links.push_back(link);
      net.add_link(link.first, link.second);
    }
    settings_.set_links(links);
  }
  return net;
}
   const Error *Init( Amp &amp, uint16 slot, uint16 numAxes )
   {
      CML_ASSERT( numAxes <= MAX_AXIS );
      if( numAxes > MAX_AXIS ) return &AmpError::BadAxis;
      axisCt = numAxes;

      RefObjLocker<Network> net( amp.GetNetworkRef() );
      if( !net ) return &NodeError::NetworkUnavailable;
      netRef = net->GrabRef();

      const Error *err = SetType( 255 );

      for( int i=0; i<numAxes; i++ )
      {
         uint16 val;
         if( !err ) err = amp.Upld16( OBJID_CONTROL + 0x800*i, 0, val );
         ctrl[i].Write( val );

         if( !err ) err = ctrl[i].Init( OBJID_CONTROL+0x800*i, 0 );
         if( !err ) err = AddVar( ctrl[i] );
      }

      if( !err ) err = amp.PdoSet( slot, *this );

      return err;
   }
Ejemplo n.º 17
0
int main(int argc, char* argv[]) { 
  
  if ( argc < 4 )
    {
      std::cerr << "\nPlease specify arguments: \n\tN, p, randseed\n\n"; exit(1);
    }

  size_t netSize = atoi(argv[1]);
  float p = atof(argv[2]);
  size_t randseed = atoi(argv[3]);
  
  RandNumGen<> generator(randseed); 
  NetType net(netSize); 

  // Generate the network
  ErdosRenyi2(net, p, generator);

  std::auto_ptr<NetType> netPointer2(findLargestComponent<NetType>(net)); 
  NetType& net2 = *netPointer2;  // Create a reference for easier handling of net.

  // Calculate average clustering coefficient
  double avg_clust = 0;
  for (size_t i = 0; i < net.size(); i++)
      avg_clust += clusteringCoefficient(net, i);

  size_t edges = numberOfEdges(net2);
  std::cout << net2.size() << " " << (double)2*edges/net2.size() << " " << avg_clust/net2.size() << " " << pearsonCoeff(net2) << "\n";
}
Ejemplo n.º 18
0
int main() {
    // Construct Network
    Network net("name", false);
    net.populate(10000);

    // Let's connect the network using an arbitrary degree distribution
    // Out of 10 nodes, none will have degrees 0 or 1, 1 will have degree 2
    // 3 with degree 3, 2 with degree 4, 1 with degree 5, and 3 with degree 3
    vector<double> degree_dist;
    double tmp_array[] = {0, 0, 1, 3, 2, 1, 3};
    degree_dist.assign(tmp_array,tmp_array+7); // 5 == the length of tmp_array

    // Now make those probabilities that sum to 1
    degree_dist = normalize_dist(degree_dist, sum(degree_dist));

    // Finally, connect up the network using that user-defined degree distribution
    // Note that poisson, exponential, and scale-free random network generators are built-in
    net.rand_connect_user(degree_dist);

    // Simulation parameters
    int infectious_period = 10; // 10 days, hours,  whatever 
    double T = 0.05; // per timestep, per outbound edge probability of transmission

    for (int i = 0; i < 10; i++){
        // Choose and run simulation
        ChainBinomial_Sim sim(&net, infectious_period, T);
        sim.rand_infect(1);
        sim.run_simulation();
        cout << sim.epidemic_size() << endl;
        sim.reset();
    }
    return 0;
}
Ejemplo n.º 19
0
int main()
{
	int inputs = 2;
	int outputs = 1;
	int depth = 3;
	int hidden_layer_size = 2;
	double learning_speed = 0.1;
	double momentum = 0.9;
	double error = 0.001;

	neural_network net(inputs, depth, hidden_layer_size, outputs, learning_speed, momentum);
	vector<pair<vector<double>, vector<double> > > tests;
	vector<double> test(2);
	vector<double> ans(1);
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 2; j++)
		{
			test[0] = i;
			test[1] = j;
			ans[0] = (i + j) % 2;
			tests.push_back(make_pair(test, ans));
		}
	}
	net.teach(tests, error);
	for (int i = 0; i < tests.size(); i++)
	{
		vector<double> ans = net.calculate(tests[i].first);
		printf("input: %d %d\n", (int)tests[i].first[0], (int)tests[i].first[1]);
		printf("output: %f\n\n", ans[0]);
	}

	return 0;
}
Ejemplo n.º 20
0
void CttView::ADTFill(const COLORREF color){
	if (m_point.size() <= 2)return;
	CDC* pDC = GetWindowDC();
	CPen pen1(0, 0, color);
	pDC->SelectObject(&pen1);
	int start, end, msz=m_point.size();
	start = 10000;
	end = 0;
	for (int i = 0; i < msz; i++){
		start = min(start, m_point[i].y);
		end = max(end, m_point[i].y);
	}
	vector<EdgeTable> net(end+1);
	net.assign(end + 1, EdgeTable());
	Edge te;
	int miny;
	for (int i = 0; i < msz-1; i++){
		te = Edge(m_point[i], m_point[i + 1], miny);
		net[miny].Add(te);
	}
	te = Edge(m_point[msz-1], m_point[0], miny);
	net[miny].Add(te);
	
	EdgeTable adt = EdgeTable(start);
	for (int i = start; i <= end; i++){
		for (int j = 0; j < net[i].e.size(); j++)
			adt.Add(net[i].e[j]);
		for (int j = 1; j < adt.e.size(); j += 2){
			pDC->MoveTo((int)adt.e[j-1].x0, i);
			pDC->LineTo((int)adt.e[j].x0, i);
		}
		adt.Update();
	}
}
Ejemplo n.º 21
0
double lodDistanceBetweenPos(Vec2i a, Vec2i b, int blockSize)
{
	int baseBlockSize = 8;
	Vec2i net(a.x-b.x, a.y-b.y);

	return std::sqrt(net.x*net.x + net.y*net.y) * blockSize / baseBlockSize;
}
Ejemplo n.º 22
0
void
testCurrentStimulus(backend_t backend)
{
	unsigned ncount = 1500;
	unsigned duration = ncount * 2;

	nemo::Configuration conf = configuration(false, 1024, backend);
	boost::scoped_ptr<nemo::Network> net(createRing(ncount));
	boost::scoped_ptr<nemo::Simulation> sim(nemo::simulation(*net, conf));

	nemo::Simulation::current_stimulus istim;
	// add some noise before and after
	istim.push_back(std::make_pair(5U, 0.001f));
	istim.push_back(std::make_pair(8U, 0.001f));
	istim.push_back(std::make_pair(0U, 1000.0f));
	istim.push_back(std::make_pair(100U, 0.001f));
	istim.push_back(std::make_pair(1U, 0.001f));

	/* Simulate a single neuron to get the ring going */
	sim->step(istim);

	for(unsigned ms=1; ms < duration; ++ms) {
		const std::vector<unsigned>& fired = sim->step();
		BOOST_CHECK_EQUAL(fired.size(), 1U);
		BOOST_REQUIRE_EQUAL(fired.front(), ms % ncount);
	}
}
Ejemplo n.º 23
0
NetworkType Node::GetNetworkType( void )
{
   RefObjLocker<Network> net( GetNetworkRef() );
   if( !net ) return NET_TYPE_INVALID;

   return net->GetNetworkType();
}
Ejemplo n.º 24
0
  BaseBulkRound::BaseBulkRound(const Group &group,
      const PrivateIdentity &ident,
      const Id &round_id,
      const QSharedPointer<Network> &network,
      GetDataCallback &get_data,
      const QSharedPointer<BuddyMonitor> &bm,
      CreateRound create_shuffle) :
    Round(group, ident, round_id, network, get_data, bm),
    _get_shuffle_data(this, &BaseBulkRound::GetShuffleData)
  {
    QVariantHash headers = GetNetwork()->GetHeaders();
    headers["bulk"] = true;
    GetNetwork()->SetHeaders(headers);

    QSharedPointer<Network> net(GetNetwork()->Clone());
    headers["bulk"] = false;
    net->SetHeaders(headers);

    Id sr_id(Hash().ComputeHash(GetRoundId().GetByteArray()));

    _shuffle_round = create_shuffle(GetGroup(), GetPrivateIdentity(), sr_id, net,
        _get_shuffle_data, bm);
    _shuffle_round->SetSink(&_shuffle_sink);

    QObject::connect(_shuffle_round.data(), SIGNAL(Finished()),
        this, SLOT(SlotShuffleFinished()));
  }
Ejemplo n.º 25
0
int main() {
    MTRand mtrand = MTRand();
    for (int i = 0; i < 20; i++ ) {
        cout << i << endl;
        Network net("test", false );
        net.populate(N_NODES);
	    //cout << net.size() << " ";
        //net.erdos_renyi(4);
        net.rand_connect_poisson(10);
//        sleep(5);
        //cout << net.mean_deg() << endl;
        //cout << net.transitivity(net.get_nodes()) << endl;
        //vector<Node*> comp = net.get_major_component();
        //cout << comp.size() << endl;
        //net.graphviz("");
/*	    
	    vector<Node*> my_nodes = net.get_nodes();
	    my_nodes[1] = my_nodes[2];
	    vector<Node*> your_nodes = net.get_nodes();
	    if (my_nodes[1] == your_nodes[2]) cerr << "Yikes!!\n";
	   
	    for (int i = 0; i < N_NODES; i++) {
	        net.get_node(i)->mean_min_path();
	        cout << i << " mean dist: " << setprecision(10) << net.get_node(i)->mean_min_path() << endl;
	        vector<int> distances = net.get_node(i)->min_paths();        
	        cout << i << " to 1 " << distances[1] << endl;
	    }*/
    }
return 0;
}
const Error *Amp::RequestStatUpdt( void )
{
   // For secondary axis objects, do this through the primary axis
   if( primaryAmpRef )
   {
      RefObjLocker<Amp> pri( primaryAmpRef );
      if( !pri ) return &AmpError::NotInit;
      return pri->RequestStatUpdt();
   }

   // Note that 8367 based products don't support remote 
   // requests well, so we use an SDO to request the PDO
   if( (hwType & 0xFF00) != 0x0300 )
   {
      RefObjLocker<Network> net( GetNetworkRef() );
      if( !net ) return &NodeError::NetworkUnavailable;

      if( !statPDO ) 
         return &AmpError::NotInit;

      return statPDO->Request(*net);
   }
   else
      return Dnld8( OBJID_PDOREQUEST, 0, (uint8)0 );
}
Ejemplo n.º 27
0
void
runRing(backend_t backend, unsigned ncount, unsigned delay)
{
	/* Make sure we go around the ring at least a couple of times */
	const unsigned duration = ncount * 5 / 2;

	nemo::Configuration conf = configuration(false, 1024);
	setBackend(backend, conf);
	boost::scoped_ptr<nemo::Network> net(createRing(ncount, 0, false, 1, delay));
	boost::scoped_ptr<nemo::Simulation> sim(nemo::simulation(*net, conf));

	/* Stimulate a single neuron to get the ring going */
	sim->step(std::vector<unsigned>(1, 0));

	for(unsigned ms=1; ms < duration; ++ms) {
		const std::vector<unsigned>& fired = sim->step();
		if(delay == 1) {
			BOOST_CHECK_EQUAL(fired.size(), 1U);
			BOOST_REQUIRE_EQUAL(fired.front(), ms % ncount);
		} else if(ms % delay == 0) {
			BOOST_CHECK_EQUAL(fired.size(), 1U);
			BOOST_REQUIRE_EQUAL(fired.front(), (ms / delay) % ncount);
		} else {
			BOOST_CHECK_EQUAL(fired.size(), 0U);
		}
	}
}
Ejemplo n.º 28
0
void MainWindow::fileNew() {
    if (_sdata)
        if (!_sdata->isSaved())
            maybeSave();
        fileClose();
    // if project exist,
        // if not saved,
            //maybe save?
        // close


    // run wizard
    QMdiSubWindow * world = _mdiArea->addSubWindow(new WorldWidget());
    world->setWindowTitle("*untitled");
    world->setMinimumSize(300, 200);
    world->show();

    _sdata = new SimulationData();
    _sdata->setSaved(false);

    connect(_sdata, SIGNAL(fileNameChanged(QString)), world, SLOT(setWindowTitle(QString)));

    SensorNetwork net(40);
    net.push();
    net.start();

    _fileSaveAsAct->setEnabled(true);
    _fileCloseAct->setEnabled(true);
}
Ejemplo n.º 29
0
int main(int argc, char** argv)
{
    QCoreApplication app(argc, argv);

    QHostAddress dest_addr;
    unsigned int fft_send_interval = 1024;
    if (argc > 1) {
        QHostInfo host_info = QHostInfo::fromName(argv[1]);
        if (host_info.error() != QHostInfo::NoError
            || host_info.addresses().empty())
        {
            qFatal("Could not resolve host: %s: %s", argv[1],
                   host_info.errorString().toUtf8().constData());
            exit(1);
        }
        dest_addr = host_info.addresses().first();
        // Increase the FFT send interval when sending data over the network
        fft_send_interval *= 4;
    } else {
        dest_addr = QHostAddress::LocalHost;
    }

    qDebug() << "Sending FFT data to" << dest_addr << "port" << TRANSMIT_PORT
             << "interval" << fft_send_interval;

    JackClient jc(fft_send_interval);
    Networking net(dest_addr, TRANSMIT_PORT);

    QObject::connect(&jc, SIGNAL(onset_detected()), &net, SLOT(transmit_onset()));
    QObject::connect(&jc, SIGNAL(fft_data(int, float*)), &net, SLOT(transmit_fft_data(int, float*)));
    QObject::connect(&jc, SIGNAL(pitch_data(float,float)), &net, SLOT(transmit_pitch_data(float,float)));

    return app.exec();
}
Ejemplo n.º 30
0
/* Make sure that calling applyStdp gives an error */
void
testInvalidStdpUsage(backend_t backend)
{
	boost::scoped_ptr<nemo::Network> net(createRing(10, 0, true));
	nemo::Configuration conf;
	setBackend(backend, conf);
	BOOST_REQUIRE_THROW(simpleStdpRun(*net, conf), nemo::exception);
}