Description Usage Arguments Details Value Author(s) See Also Examples
Simulates a diffusion network by creating a random dynamic network and adoption threshold levels.
1 2 3 4 5 6 7  rdiffnet_multiple(R, statistic, ..., ncpus = 1L, cl = NULL)
rdiffnet(n, t, seed.nodes = "random", seed.p.adopt = 0.05,
seed.graph = "scalefree", rgraph.args = list(), rewire = TRUE,
rewire.args = list(), threshold.dist = runif(n),
exposure.args = list(), name = "A diffusion network",
behavior = "Random contagion", stop.no.diff = TRUE)

R 
Integer scalar. Number of simulations to be done. 
statistic 
A Function to be applied to each simulated diffusion network. 
... 
Further arguments to be passed to 
ncpus 
Integer scalar. Number of processors to be used (see details). 
cl 
An object of class 
n 
Integer scalar. Number of vertices. 
t 
Integer scalar. Time length. 
seed.nodes 
Either a character scalar or a vector. Type of seed nodes (see details). 
seed.p.adopt 
Numeric scalar. Proportion of early adopters. 
seed.graph 
Baseline graph used for the simulation (see details). 
rgraph.args 
List. Arguments to be passed to rgraph. 
rewire 
Logical scalar. When TRUE, network slices are generated by rewiring
(see 
rewire.args 
List. Arguments to be passed to 
threshold.dist 
Either a function to be applied via 
exposure.args 
List. Arguments to be passed to 
name 
Character scalar. Passed to 
behavior 
Character scalar. Passed to 
stop.no.diff 
Logical scalar. When 
Instead of randomizing whether an individual adopts the innovation or not, this toy model randomizes threshold levels, seed adopters and network structure, so an individual adopts the innovation in time T iff his exposure is above or equal to his threshold. The simulation is done in the following steps:
Using seed.graph
, a baseline graph is created.
Given the baseline graph, the set of initial adopters is defined
using seed.nodes
.
Afterwards, if rewire=TRUE
t1 slices of the network are created
by iteratively rewiring the baseline graph.
The threshold.dist
function is applied to each node in the graph.
Simulation starts at t=2 assigning adopters in each time period accordingly to each vertex's threshold and exposure.
When seed.nodes
is a character scalar it can be "marginal"
, "central"
or "random"
,
So each of these values sets the initial adopters using the vertices with lowest
degree, with highest degree or completely randomly. The number of early adoptes
is set as seed.p.adopt * n
. Please note that when marginal nodes are
set as seed it may be the case that no diffusion process is attained as the
chosen set of first adopters can be isolated. Any other case will be considered
as an index (via [<
methods), hence the user can manually set the set of initial adopters, for example
if the user sets seed.nodes=c(1, 4, 7)
then nodes 1, 4 and 7 will be
selected as initial adopters.
The argument seed.graph
can be either a function that generates a graph
(Any class of accepted graph format (see netdiffuseRgraphs
)), a
graph itself or a character scalar in which the user sets the algorithm used to
generate the first network (network in t=1), this can be either "scalefree"
(BarabasiAlbert model using the rgraph_ba
function, the default),
"bernoulli"
(ErdosRenyi model using the rgraph_er
function),
or "smallworld"
(WattsStrogatz model using the rgraph_ws
function). The list rgraph.args
passes arguments to the chosen algorithm.
When rewire=TRUE
, the networks that follow t=1 will be generated using the
rewire_graph
function as G(t) = R(G(t1)), where R
is the rewiring algorithm.
If a function, the argument threshold.dist
sets the threshold for each vertex in the graph.
It is applied using sapply
as follows
1  sapply(1:n, threshold.dist)

By default sets the threshold to be random for each node in the graph.
If seed.graph
is provided, no random graph is generated and the simulation
is applied using that graph instead.
rewire.args
has the following default options:
p  .1 
undirected  getOption("diffnet.undirected", FALSE) 
self  getOption("diffnet.self", FALSE)

exposure.args
has the following default options:
outgoing  TRUE 
valued  getOption("diffnet.valued", FALSE) 
normalized  TRUE

The function rdiffnet_multiple
is a wrapper of rdiffnet
wich allows
simulating multiple diffusion networks with the same parameters and apply
the same function to all of them. This function is designed to allow the user
to perform larger simulation studies in which the distribution of a particular
statistic is observed.
When cl
is provided, then simulations are done via
parSapply
. If ncpus
is greater than
1, then the function creates a cluster via makeCluster
which is stopped (removed) once the process is complete.
A random diffnet
class object.
rdiffnet_multiple
returns either a vector or an array depending
on what statistic
is (see sapply
and
parSapply
).
George G. Vega Yon
Other simulation functions: permute_graph
,
rewire_graph
, rgraph_ba
,
rgraph_er
, rgraph_ws
,
ring_lattice
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28  # Asimple example 
set.seed(123)
z < rdiffnet(100,10)
z
summary(z)
# A more complex example: Adopt if at least one neighbor has adopted 
y < rdiffnet(100, 10, threshold.dist=function(x) 1,
exposure.args=list(valued=FALSE, normalized=FALSE))
# Re thinking the Adoption of Tetracycline 
newMI < rdiffnet(seed.graph = medInnovationsDiffNet$graph,
threshold.dist = threshold(medInnovationsDiffNet), rewire=FALSE)
# Simulation study comparing the diffusion with diff sets of seed nodes 
# Random seed nodes
set.seed(1)
ans0 < rdiffnet_multiple(R=50, statistic=function(x) sum(!is.na(x$toa)),
n = 100, t = 4, seed.nodes = "random", stop.no.diff=FALSE)
# Central seed nodes
set.seed(1)
ans1 < rdiffnet_multiple(R=50, statistic=function(x) sum(!is.na(x$toa)),
n = 100, t = 4, seed.nodes = "central", stop.no.diff=FALSE)
boxplot(cbind(Random = ans0, Central = ans1), main="Number of adopters")

Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.