For network creation, Conedy supplies elementary functions which allow you to add single nodes or edges as well as higher-level functions which manipulate or add random networks or lattices to a an already existing network.

All these functions in Conedy accept a parameter which allows you to specify the type of the added node(s). We call this parameter a node template. To add a single node of type `logisticMap`, the following code can be used:

```
N = co.network()
nodeNumber = N.addNode(co.logisticMap())
```

Here `logisticMap` provides the node template, which is directly passed to `addNode`.

Nodes in Conedy are identified by an 32 bit integer, which is returned by `addNode` in case you want to access the node later (e.g. to connect an edge to it).

Most node dynamics depend on certain parameters. For example, the node dynamics *logisticMap* is defined by with as a parameter, which can be assessed by `logisticMap_r` in Conedy.

When a node is added as in the above example, default values for node parameters are used, for example the default value of `logisticMap_r` is 3.58 (as documented in *logisticMap*). In case you want to add different parameters, a full set of parameters can be specified as arguments, e.g.:

```
N = co.network()
N.addNode(co.logisticMap(2.6))
```

To change a parameter after node creation, the `setParam`-function can be used. Just specify node number, parameter name and the new desired new value:

```
N.setParam(nodeNumber, "logisticMap_r", 3.53)
```

Another way to control parameters is to change the default values. For example

```
N = co.network()
for i in range(500):
N.addNode(co.lorenz())
co.set("lorenz_S", 11.0)
co.set("lorenz_r", 25.0)
```

will create a network of 500 nodes, all with *lorenz* dynamics and all with `lorenz_s` = 11 and `lorenz_r` = 25 as well as the third parameter `lorenz_b` equalling its predefined standard value. Since all nodes of the above network use the same memory for the parameters, it makes no difference, whether default values are changed before or after network creation. However, if the parameters of a node have been changed (e.g. by `setParam`), they are stored in a different memory position and will not be affected by a change of the default parameters

```
N = co.network()
nodeNumber = N.addNode(co.logisticMap())
N.setParam(nodeNumber, "logisticMap_r", 1.0)
co.set("logisticMap_r", 3.5)
print N.getParam(nodeNumber, "logisticMap_r") # returns 1.0
```

```
N = co.network()
nodeNumber = N.addNode(co.logisticMap())
co.set("logisticMap_r", 3.5)
print N.getParam(nodeNumber, "logisticMap_r") # returns 3.5
```

Conedy uses the random number generators of the GNU Scientific Library (GSL). Therefore the prefered algorithm can be specified by setting environment variables (see the GSL’s documentation). When importing Conedy, a random seed is created using the system time and written to the console. If you want to have reproducible simulation values—or in case you want to start many simulations at the same time without the risk of identical seeds—, you can set a random seed manually (e.g. to 42) by calling:

```
co.setRandomSeed(42)
```

For the randomization of parameters (or initial conditions) objects are provided, which specify the desired random distribution. The following example will create an object for uniformly distributed random numbers between 0.2 and 0.4:

```
distribution = uniform(0.2,0.4)
```

In addition, the following distributions are available:

`gaussian(m, s)`

Gaussian distributed random numbers with mean m and standard deviation s.

`bimodal(l, u, p)`

Will draw the number l with probability p and the number u with probability 1–p.

`constant(c)`

All drawn numbers have value c. (This can be useful, if you want some states not to be randomized.)

Parameters are randomized with the *randomizeParameter* command. For example, the following line will randomize the parameter `lorenz_b` of all `lorenz` nodes in the network `N` with Gaussian random numbers:

```
N.randomizeParameter("lorenz_b", co.gaussian(2.5,0.5))
```

Before the dynamics is integrated, initial conditions can be set. Otherwise the initial states of all variables default to 0.0. There are two ways to change node states in Conedy (apart from evolving the network). Though you will usually only want to modify node states before evolving, you may use these at any time.

First, the state of each node may be modified directly with the `setState` command. In the following example a `lorenz` node is added to the network, its number is memorized as `nodeNumber` and its state is set to (1.0, 1.0, 1.0):

```
N = co.network()
nodeNumber = N.addNode(co.lorenz())
setState(nodeNumber, 1.0, 1.0, 1.0)
```

Alternatively with the *randomizeStates* command the states all nodes of a certain node type can be randomized. For example, we randomize initial conditions for the first component of 500 `lorenz` nodes and fix the other two components to 1.0:

```
N = co.network()
for i in range(500):
N.addNode(co.lorenz())
N.randomizeStates(co.lorenz(), co.gaussian(1.0, 0.5), co.constant(1.0), co.constant(1.0))
```

Note that here node templates are used in a different way than before, namely to specify the nodes in the network which are manipulated (in this case all nodes of type `lorenz`). To target only nodes with certain parameters, these can be specified. The following command will set uniformly distributed states to all `logisticMap` nodes in the network N, which have a parameter `logisticMap_r` of 3.59:

```
N.randomizeStates(co.lorenz(3.59), uniform (0.0,1.0))
```