Function Reference

Constructors

Fastnet.LinkType — Type

LinkType(from,to,dir=2)

Create a LinkType structure that describes the properties of a type of link in the network.

Think of a LinkType as a set of criteria that describe a certain sort of link. The first two arguments specify the states of the nodes at the start and end of the link respectively. The third argument specified if the LinkType can either be 1 or 2, where dir=1 signifies that the link type should be interpreted as directed (unidirectional) and dir=2 signifies that it should be interpreted as undirected (bidirectional).

The state of the node at the start and end of this type of link can be specified in different ways. A value of 0 or * for from or to means that the respective node can be in any state. An integer value corresponding to a node state means that the node must be in the respective state. An Array or Tuple of Ints means that the node must be in one of the states listed.

Examples

julia> using Fastnet

julia> LinkType(3,4)
Links of the form:  (3) --- (4)

julia> LinkType(3,4,1)
Links of the form:  (3) --> (4)

julia> LinkType(3,4,2)
Links of the form:  (3) --- (4)

julia> LinkType("*",4)
Links of the form:  (any) --- (4)

julia> LinkType(4,0)
Links of the form:  (4) --- (any)

julia> LinkType((1,2),3)
Links of the form:  (1/2) --- (3)

julia> LinkType(4,[1,2],1)
Links of the form:  (4) --> (1/2)

Fastnet.FastNet — Type

FastNet(n,k,c,tlist;<keyword arguments>)

Create a FastNet object that represents a network structe.

Memory will be allocated for up to n nodes, up to k links. Nodes can be in one of c different states.

The argument tlist is an array or tuple of LinkType. This list tells the networks which types of links are important for you. For example in an epidemic simulation the we are particularly interested in links between infected and susceptible nodes. FastNet will do the necessary bookkeeping, to enable very fast counting, selection, etc. of the links that are in a state listed in tlist.

Note that the order of elements of tlist is not arbitrary. FastNet will think of links that match the first element of tlist as being in link state 1. The links that match the sceond type in link state 2, and so on.

WARNING: Each link in the network can only be in any one state at any time passing a tlist that contains overlapping link types (e.g. [LinkType([1,2],3),LinkType(3,1)] ) will result in an ArgumentError being thrown.

FastNet supports a number of optional keyword arguments:

nodealias : a vector of strings that will be used as names of node states in outputs
linkalias : a vector of strings that will be used as names of link states in outputs
rng : specifies a custom random number generator

The network will initially be empty (i.e. a null graph)

Examples

julia> using Fastnet

julia> FastNet(10,9,1,[])
Network of 0 nodes and 0 links

julia> FastNet(100,1000,3,[LinkType(1,2),LinkType(3,"*",1)])
Network of 0 nodes and 0 links

julia> using Random

julia> mt = MersenneTwister(1234);

julia> const S=1;

julia> const I=2;

julia> SI_link=LinkType(S,I)
Links of the form:  (1) --- (2)

julia> net=FastNet(10000,60000,2,[SI_link],nodealias=["S","I"],linkalias=["S-I"],rng=mt)
Network of 0 nodes and 0 links

Fastnet.FastSim — Type

FastSim(net,rates!,processes;<keyword arguments>)

Create a FastSim structure, representing a FastNet simulation run.

The first argument net is a FastNet structure that is be used in the simulation.

The second argument is the rates! function of the simulation. The rates function is a function that accepts two arguments. The first of these arguments is an MVector{Float64} (see StaticArrays Documentation for details). The second argument is a the current time in the simulation.

When the rates! function is called it should compute the total rates of at which the different processes occur in the system, given the current state of the network. The rates functions returns these values by filling the array that was passed as the first argument. The rates! should not have a return value.

Note that when rates are time dependent then the rates! function should use the time value passed to it rather than obtaining a time form the simulation structure. The simulation code assumes that the rates will remain constant until the next event. This should be harmless in almost all cases but can cause inaccuracy if your rates depend explicitely on time, the rates are very senstitive to time and events are rare.

The third argument is a Vector of functions that implements the processes. The processes are functions without arguments when they are called they should implement effect of the respecive process running once. Note that elemets of the process function vector should be in the same order as the corresponding rates computed by the rates! vector.

FastSim supports a number of optional keyword arguments:

saveas : A String specifying the pathname where results should be saved. If unspecified results aren't saved but can be optained using the results function.
output : a boolean variable that specifies if results should be printed on the console, by default this is true. Alternatively also an IOStream can be provided to which results should be written.
repfunc : This argument can be used to specify an alternative function to generate outputs and store results. See custimization for details.

Examples

julia> using Fastnet

julia> const Bored=1; const Excited=2;

julia> net=FastNet(1000,5000,2,[LinkType(Excited,Bored,1)]);

julia> randomgraph!(net);

julia> function rates!(rates,t)
         rates[1]=countlinks(net,1)*0.1
         rates[2]=countnodes(net,Excited)*0.2
         rates[3]=countnodes(net,Bored)*0.001
         end;

julia> function excitement_spreads()
         link=randomlink(net,1)
         nodestate!(net,linkdst(net,link),Excited)
         end;

julia> function get_bored()
         node=randomnode(net,Excited)
         nodestate!(net,node,Bored)
         end;

julia> function great_idea()
         node=randomnode(net,Bored)
         nodestate!(net,node,Excited)
         end;

julia> sim=FastSim(net,rates!,[excitement_spreads,get_bored,great_idea])
Simulation run, currently at time 0.0

Network Setup

Fastnet.nullgraph! — Function

nullgraph!(net)

Remove all nodes and links from the network.

The first argument net is a FastNet structure that is be used in the simulation.

Examples

julia> using Fastnet

julia> net=FastNet(1000,2000,1,[])
Network of 0 nodes and 0 links

julia> randomgraph!(net)
Network of 1000 nodes and 2000 links

julia> nullgraph!(net)
Network of 0 nodes and 0 links

Fastnet.randomgraph! — Function

randomgraph!(net;<keyword arguments>)

Create an ER random graph in the network net.

The network isn't guaranteed to be a simple graph, but in large sparse networks it is simple with high probability.

By default all nodes and links that the network can accommodate will be used and all nodes will be set to state one. This behavior can be controlled by the following keyword arguments:

N : The number of nodes that will be used in the creation of the random graph. All other nodes will be removed from the network.
K : The number of links that will be used in the creation of the random graph. All other links will be removed from the network.
S : The state of the nodes. All nodes will be set to this state.

Examples

julia> using Fastnet

julia> net=FastNet(1000,2000,1,[])
Network of 0 nodes and 0 links

julia> randomgraph!(net)
Network of 1000 nodes and 2000 links

julia> nullgraph!(net)
Network of 0 nodes and 0 links

julia> randomgraph!(net,N=100,K=10)
Network of 100 nodes and 10 links

Node Functions

Fastnet.adjacent — Function

adjacent(net,a,b)
adjacent_f(net,a,b)

Check if nodes with the id's a and b are adjacent in network net. If they are return the id a of the link connecting them. Otherwise return 0.

If multiple links connect the nodes the function will return a link in the direction a->b if such a link exists.

Calling adjacent(net,a,a) will return a self-loop on a if one exists.

The worst case performance of this function scales with the degree of node a. The fast (_f) verions sacrifice some safty checks for better performance. See basic concepts for details.

Examples

julia> using Fastnet

julia> net=FastNet(1000,2000,2,[])
Network of 0 nodes and 0 links

julia> makenodes!(net,100,1);

julia> net
Network of 100 nodes and 0 links

Fastnet.countnodes — Function

countnodes(net)
countnodes(net,s)
countnodes_f(net)
countnodes_f(net,s)

Count the nodes in state s, or, if no state is provided, in the entire network.

Instead of the state s also an Array or Tuple of states can be passed. In this case the total number of nodes in all of the listed states is returned.

All versions of this function run in constant time. The fast (_f) verions sacrifice some safty checks for better performance. See basic concepts for details.

If performance is critical use this function rather than nodecounts.

Link Functions

Fastnet.countlinks — Function

countlinks(net)
countlinks(net,s)
countlinks_f(net)
countlinks_f(net,s)

Count the links in state s, or, if no state is provided, in the entire network.

Instead of the state s also an Array or Tuple of states can be passed. In this case the total number of nodes in all of the listed states is returned.

The links in a sincle class or the entire network are counted in constant time. For the tuples or array arguments the performance scales with the number of elements in the Tulps/Array. The fast (_f) verions sacrifice some safty checks for better performance. See basic concepts for details.

If performance is critical use this function rather than linkcounts.

See also makelink!

Examples

julia> using Fastnet

julia> net=FastNet(1000,2000,2,[])
Network of 0 nodes and 0 links

julia> n1=makenode!(net,1);

julia> n2=makenode!(net,2);

julia> makelink!(net,n1,n2);

julia> net
Network of 2 nodes and 1 links

julia> lnk=randomlink(net);

julia> destroylink!(net,lnk)

julia> net
Network of 2 nodes and 0 links

Fastnet.makelink! — Function

makelink!(net,src,dst)
makelink_f!(net,src,dst)

Create a new link from node src to nodedst in the network net and return it's id.

Worst-case performance of both versions of this function scales only with the number of tracked link states.

The fast (_f) verions sacrifice some safty checks for better performance. See basic concepts for details.

See also makelink!

Examples

julia> using Fastnet

julia> net=FastNet(1000,2000,2,[])
Network of 0 nodes and 0 links

julia> n1=makenode!(net,1);

julia> n2=makenode!(net,2);

julia> k1=makelink!(net,n1,n2);

julia> linkdst(net,k1)==n2
true

Fastnet.linkexists — Function

linkexists(net,kid)
linkexists_f(net,kid)

Return true node with id kid exists in net, false otherwise.

This function runs in constant time. The fast (_f) verions sacrifice some safty checks for better performance. See basic concepts for details.

See also makelink!

Examples

julia> using Fastnet

julia> net=FastNet(1000,2000,2,[])
Network of 0 nodes and 0 links

julia> n1=makenode!(net,1);

julia> n2=makenode!(net,1);

julia> linkexists(net,7)
false

julia> k=makelink!(net,n1,n2);

julia> linkexists(net,k)
true

Fastnet.linksrc — Function

linksrc!(net,kid)
linksrc_f!(net,kid)

Return the id of the node at the source of link kid in net.

All versions of this function run in constant time. The fast (_f) verion sacrifices some safty checks for better performance. See basic concepts for details.

See also makelink!

Examples

julia> using Fastnet

julia> net=FastNet(1000,2000,2,[])
Network of 0 nodes and 0 links

julia> n1=makenode!(net,1);

julia> n2=makenode!(net,2);

julia> k1=makelink!(net,n1,n2);

julia> linksrc(net,k1)==n1
true

Fastnet.linkstate — Function

linkstate(net,kid)
linkstate_f(net,kid)

Return the state of the link with id kid in network net.

Note that the link states are numbered in the order in which they were passed to the FastNet Constructor.

All version of this function run in constant time, but fast (_f) verion sacrifices some safty checks for better performance. See basic concepts for details.

Simulation

Fastnet.simstep! — Function

simstep!(sim)

Simulate the next event in sim.

This function will always advance the sim by exactly one event. If no event is possible it will advance time by one timeunit. Output is generated at start time and directly after the event has occured.

Debug & Analysis

Fastnet.healthcheck — Function

healthcheck(net)

Perform an internal consistencey check on a FastNet net.

To achieve the desired performance Fastnet engages in a certain amount of double bookeeping. In an ideal world the FastNet structures should always stay internally consistent. However, inconsistencies could arise from a number of sources including software bugs, CPU and memeory errors. This function checks the internal data stored in FastNet for consistency to make sure that everything is alright.

The return value is true if all chacks have been passed, false otherwise.