Package 'netdiffuseR'

Description

Matrix multiplication methods, including diffnet objects. This function creates a generic method for %*% allowing for multiplying diffnet objects.

Usage

x %*% y

## Default S3 method:
x %*% y

## S3 method for class 'diffnet'
x %*% y

Arguments

Details

This function can be usefult to generate alternative graphs, for example, users could compute the n-steps graph by doing net %*% net (see examples).

Value

In the case of diffnet objects performs matrix multiplication via mapply using x$graph and y$graph as arguments, returnling a diffnet. Otherwise returns the default according to %*%.

See Also

Other diffnet methods: as.array.diffnet(), c.diffnet(), diffnet-arithmetic, diffnet-class, diffnet_index, plot.diffnet(), summary.diffnet()

Examples

# Finding the Simmelian Ties network ----------------------------------------

# Random diffnet graph
set.seed(773)
net <- rdiffnet(100, 4, seed.graph='small-world', rgraph.args=list(k=8))
netsim <- net

# According to Dekker (2006), Simmelian ties can be computed as follows
netsim <- net * t(net) # Keeping mutal
netsim <- netsim * (netsim %*% netsim)

# Checking out differences (netsim should have less)
nlinks(net)
nlinks(netsim)

mapply(`-`, nlinks(net), nlinks(netsim))

Description

Computes approximate geodesic distance matrix using graph powers and keeping the amount of memory used low.

Usage

approx_geodesic(graph, n = 6L, warn = FALSE)

approx_geodist(graph, n = 6L, warn = FALSE)

Arguments

Details

While both igraph and sna offer very good and computationally efficient routines for computing geodesic distances, both functions return dense matrices, i.e. not sparse, which can be troublesome. Furthermore, from the perspective of social network analysis, path lengths of more than 6 steps, for example, may not be meaningful, or at least, relevant for the researcher. In such cases, approx_geodesic serves as a solution to this problem, computing geodesics up to the number of steps, n, desired, hence, if n = 6, once the algorithm finds all paths of 6 or less steps it will stop, returning a sparse matrix with zeros for those pairs of vertices for which it was not able to find a path with less than n steps.

Depending on the graph size and density, approx_geodesic's performance can be compared to that of sna::geodist. Although, as n increases, geodist becomes a better alternative.

The algorithm was implemented using power graphs. At each itereation i the power graph of order i is computed, and its values are compared to the current values of the geodesic matrix (which is initialized in zero).

1. Initialize the output ans(n, n)

2. For i=1 to i < n do

   1. Iterate through the edges of G^i, if ans has a zero value in the corresponding row+column, replace it with i

   2. next

3. Replace all diagonal elements with a zero and return.

This implementation can be more memory efficient that the aforementioned ones, but at the same time it can be significant slower.

approx_geodist is just an allias for approx_geodesic.

Value

A sparse matrix of class dgCMatrix of size nnodes(graph)^2 with geodesic distances up to n.

Examples

# A very simple example -----------------------------------------------------
g <- ring_lattice(10, 3)
approx_geodesic(g, 6)
sna::geodist(as.matrix(g))[[2]]
igraph::distances(
  igraph::graph_from_adjacency_matrix(g, mode = "directed"),
  mode = "out"
)

Description

This helper function allows easy coercion to sparse matrix objects from the Matrix package, dgCMatrix.

Usage

as_dgCMatrix(x, make.dimnames = TRUE, ...)

as.dgCMatrix(x, make.dimnames = TRUE, ...)

as_spmat(x, make.dimnames = TRUE, ...)

## Default S3 method:
as_dgCMatrix(x, make.dimnames = TRUE, ...)

## S3 method for class 'diffnet'
as_dgCMatrix(x, make.dimnames = TRUE, ...)

## S3 method for class 'array'
as_dgCMatrix(x, make.dimnames = TRUE, ...)

## S3 method for class 'igraph'
as_dgCMatrix(x, make.dimnames = TRUE, ...)

## S3 method for class 'network'
as_dgCMatrix(x, make.dimnames = TRUE, ...)

## S3 method for class 'list'
as_dgCMatrix(x, make.dimnames = TRUE, ...)

Arguments

Details

In the case of the igraph and network methods, ... is passed to as_adj and as.matrix.network respectively.

Value

Either a list with dgCMatrix objects or a dgCMatrix object.

Examples

set.seed(1231)
x <- rgraph_er(10)

# From matrix object
as_dgCMatrix(as.matrix(x))

# From a network object
as_dgCMatrix(network::as.network(as.matrix(x)))

# From igraph object
as_dgCMatrix(igraph::graph_from_adjacency_matrix(x))

# From array
myarray <- array(dim=c(10,10,2))
myarray[,,1] <- as.matrix(x)
myarray[,,2] <- as.matrix(x)

myarray
as_dgCMatrix(myarray)

# From a diffnet object
ans <- as_dgCMatrix(medInnovationsDiffNet)
str(ans)

Description

Coerce a diffnet graph into an array

Usage

## S3 method for class 'diffnet'
as.array(x, ...)

Arguments

Details

The function takes the list of sparse matrices stored in x and creates an array with them. Attributes and other elements from the diffnet object are dropped.

dimnames are obtained from the metadata of the diffnet object.

Value

A three-dimensional array of $T$ matrices of size $n\times n$.

See Also

diffnet.

Other diffnet methods: %*%(), c.diffnet(), diffnet-arithmetic, diffnet-class, diffnet_index, plot.diffnet(), summary.diffnet()

Examples

# Creating a random diffnet object
set.seed(84117)
mydiffnet <- rdiffnet(30, 5)

# Coercing it into an array
as.array(mydiffnet)

Description

Fits the Bass Diffusion model. In particular, fits an observed curve of proportions of adopters to $F(t)$, the proportion of adopters at time $t$, finding the corresponding coefficients $p$, Innovation rate, and $q$, imitation rate.

Usage

fitbass(dat, ...)

## S3 method for class 'diffnet'
fitbass(dat, ...)

## Default S3 method:
fitbass(dat, ...)

## S3 method for class 'diffnet_bass'
plot(
  x,
  y = 1:length(x$m$lhs()),
  add = FALSE,
  pch = c(21, 24),
  main = "Bass Diffusion Model",
  ylab = "Proportion of adopters",
  xlab = "Time",
  type = c("b", "b"),
  lty = c(2, 1),
  col = c("black", "black"),
  bg = c("lightblue", "gray"),
  include.legend = TRUE,
  ...
)

bass_F(Time, p, q)

bass_dF(p, q, Time)

bass_f(Time, p, q)

Arguments

Details

The function fits the bass model with parameters $[p, q]$ for values $t = 1, 2, \dots, T$, in particular, it fits the following function:

$F(t) = \frac{1 - \exp{-(p+q)t}}{1 + \frac{q}{p}\exp{-(p+q)t}}$

Which is implemented in the bass_F function. The proportion of adopters at time $t$, $f(t)$ is:

$f(t) = \left\{\begin{array}{ll} F(t), & t = 1 \\ F(t) - F(t-1), & t > 1 \end{array}\right.$

and it's implemented in the bass_f function.

For testing purposes only, the gradient of $F$ with respect to $p$ and $q$ is implemented in bass_dF.

The estimation is done using nls.

Value

An object of class nls and diffnet_bass. For more details, see nls in the stats package.

Author(s)

George G. Vega Yon

References

Bass's Basement Institute Institute. The Bass Model. (2010). Available at: https://web.archive.org/web/20220331222618/http://www.bassbasement.org/BassModel/. (accessed live for the last time on March 29th, 2017.)

See Also

Other statistics: classify_adopters(), cumulative_adopt_count(), dgr(), ego_variance(), exposure(), hazard_rate(), infection(), moran(), struct_equiv(), threshold(), vertex_covariate_dist()

Examples

# Fitting the model for the Brazilian Farmers Data --------------------------
data(brfarmersDiffNet)
ans <- fitbass(brfarmersDiffNet)

# All the methods that work for the -nls- object work here
ans
summary(ans)
coef(ans)
vcov(ans)

# And the plot method returns both, fitted and observed curve
plot(ans)

Description

Implements the bootstrapping method described in Snijders and Borgatti (1999). This function is essentially a wrapper of boot.

Usage

resample_graph(graph, self = NULL, useR = FALSE, ...)

bootnet(graph, statistic, R, resample.args = list(self = FALSE), ...)

## S3 method for class 'diffnet_bootnet'
c(..., recursive = FALSE)

## S3 method for class 'diffnet_bootnet'
print(x, ...)

## S3 method for class 'diffnet_bootnet'
hist(
  x,
  main = "Empirical Distribution of Statistic",
  xlab = expression(Values ~ of ~ t),
  breaks = 20,
  annotated = TRUE,
  b0 = expression(atop(plain("") %up% plain("")), t[0]),
  b = expression(atop(plain("") %up% plain("")), t[]),
  ask = TRUE,
  ...
)

## S3 method for class 'diffnet_bootnet'
plot(x, y, ...)

Arguments

Details

Just like the boot function of the boot package, the statistic that is passed must have as arguments the original data (the graph in this case), and a vector of indicides. In each repetition, the graph that is passed is a resampled version generated as described in Snijders and Borgatti (1999).

When self = FALSE, for pairs of individuals that haven been drawn more than once the algorithm, in particular, resample_graph, takes care of filling these pseudo autolinks that are not in the diagonal of the network. By default it is assumed that these pseudo-autolinks depend on whether the original graph had any, hence, if the diagonal has any non-zero value the algorithm assumes that self = TRUE, skiping the 'filling algorithm'. It is important to notice that, in order to preserve the density of the original network, when assigning an edge value to a pair of the form $(i,i)$ (pseudo-autolinks), such is done with probabilty proportional to the density of the network, in other words, before choosing from the existing list of edge values, the algorithm decides whether to set a zero value first.

The vector of indices that is passed to statistic, an integer vector with range 1 to $n$, corresponds to the drawn sample of nodes, so the user can, for example, use it to get a subset of a data.frame that will be used with the graph.

The 'plot.diffnet_bootnet' method is a wrapper for the 'hist' method.

Value

A list of class diffnet_bootnet containing the following:

References

Snijders, T. A. B., & Borgatti, S. P. (1999). Non-Parametric Standard Errors and Tests for Network Statistics. Connections, 22(2), 1–10. Retrieved from https://www.stats.ox.ac.uk/~snijders/Snijders_Borgatti.pdf

See Also

Other Functions for inference: moran(), struct_test()

Examples

# Computing edgecount -------------------------------------------------------
set.seed(13)
g <- rgraph_ba(t=99)

ans <- bootnet(g, function(w, ...) length(w@x), R=100)
ans

# Generating

Description

From Valente (1995) “In the mid-1960s, Rogers and others conducted an ambitious ‘three country study’ to determine influences on adoption of farm practices in Nigeria, India and Brazil. [...] Only in Brazil, and only for hybrid corn, did adoption of the innovation reach more than a small proportion of the farmers.”

Usage

brfarmers

Format

A data frame with 692 rows and 148 columns:

village

village number

idold

respondent id

age

respondent's age

liveout

Lived outside of community

visits

# of visits to large city

contact

# of contacts with relatives

coop

membership in coop

orgs

membership in organizations

patry

Patriarchalism score

liter

Literate

news1

# of newspapers or mags pr mon

subs

subscribe to news

radio1

Own radio

radio2

Frequency radio listening

radio3

program preference

tv

frequency Tv viewing

movie

freq movie attendance

letter

freq letter writing

source

total # of sources used for ag

practA

Ever used practice A

practB

Ever used practice B

practC

Ever used practice C

practD

Ever used practice D

practE

Ever used practice E

practF

Ever used practice F

practG

Ever used practice G

practH

Ever used practice H

practI

Ever used practice I

practJ

Ever used practice J

practK

Ever used practice K

practL

Ever used practice L

yrA

A year of adoption

yrB

B year of adoption

yrC

C year of adoption

yrD

D year of adoption

yrE

E year of adoption

yrF

F year of adoption

yrG

G year of adoption

yrH

H year of adoption

yrI

I year of adoption

yrJ

J year of adoption

yrK

K year of adoption

yrL

L year of adoption

curA

A Current use

curB

B Current use

curC

C Current use

curD

D Current use

curE

E Current use

curF

F Current use

curG

G Current use

curH

H Current use

curI

I Current use

curJ

J Current use

curK

K Current use

curL

L Current use

srce1

Source of aware in A

timeA

Years ago 1st aware

src2

Source of more info on A

src3

Most influential source

use

use during trial stage

total

total # of practices adopted

futatt

Future attitude

achiev

Achievement Score

attcred

Attitude toward credit

littest

Score on functional literacy t

acarcomm

Communication with ACAR repres

econk

Economic knowledge

caact

recognize any change agent act

hfequip

# of home & farm equips owned

politk

political knowledge score

income

income

land1

total land area in pasture

land2

total land area planted

cows

# of cows giving milk

land3

total land owned

respf

respondent named as friend

respa

respondent named as ag adv

resppa

respondent named for practic A

resppb

respondent named for practic B

resppc

respondent named for practic C

poly

polymorphic OL for 3 practices

respl

respondent named for loan

resppi

resp named for price info

repsccp

resp named for coop comm proj

counter

counterfactuality score

opinion

opinionness score

school

years of schooling by resp

pk1

political know 1

pk2

political know 2

pk3

political know 3

pk4

political know 4

pk5

political know 5

innovtim

innovativeness time

adoptpct

adoption percent

discon

# of practices discontinued

mmcred

Mass media credibility

trust

Trust

stusincn

Status inconsistency

nach

N achievement motivation

attcred2

Attitude toward credit

risk

Risk taking

socpart

Social participate

patriarc

patriarchy

crdit2

attit to credit for product

visicit

visitin cities

nondep

non-dependence on farming

oltotal

OL total 7 items t-score

innov

overall innovativeness score

icosmo

cosmo index

immexp

mass media exposure index

iempath

empathy index

iach5

achievement motivation index 5

iach7

achievement motivation index 7

ipk

political knowledge index

immc

mass media credibililty index

iol

OL index

yr

Actual Year of Adoption

fs

— MISSING INFO —

ado

Time of Adoption

tri

Triangular values used as appro

hlperc

high low percent of diffusion

hlperc1

— MISSING INFO —

new

new or old villages

card1

card number

sour1

Source: radio

sour2

Source: TV

sour3

Source: Newpaper

sour4

Source: Magazine

sour5

Source: ACAR Bulletin

sour6

Source: Agronomist

sour7

Source: Neighbor

sourc6

— MISSING INFO —

adopt

— MISSING INFO —

net31

nomination friend 1

net32

nomination friend 2

net33

nomination friend 3

net21

nomination influential 1

net22

nomination influential 2

net23

nomination influential 3

net11

nomination practice A

net12

nomination practice B

net13

nomination practice C

net41

nomination coop comm proj

id

— MISSING INFO —

commun

Number of community

toa

Time of Adoption

test

— MISSING INFO —

study

Number of study in Valente (1995)

Details

The dataset has 692 respondents (farmers) from 11 communities. Collected during 1966, it spans 20 years of farming pracitices.

Source

The Brazilian Farmers data were collected as part of a USAID-funded study of farming practicing in the three countries, India, Nigeria, and Brazil. There was only one wave of data that contained survey questions regarding social networks, and only in Brazil did diffusion of the studied farming innovations reach an appreciable saturation level- that was for hybrid seed corn. The data were stored along with hundreds of other datasets by the University of Wisconsin library and I, Tom Valente, paid a fee to have the disks mailed to me in the early 1990s.

References

Rogers, E. M., Ascroft, J. R., & Röling, N. (1970). Diffusion of Innovation in Brazil, Nigeria, and India. Unpublished Report. Michigan State University, East Lansing.

Valente, T. W. (1995). Network models of the diffusion of innovations (2nd ed.). Cresskill N.J.: Hampton Press.

See Also

Other diffusion datasets: brfarmersDiffNet, diffusion-data, fakeDynEdgelist, fakeEdgelist, fakesurveyDyn, fakesurvey, kfamilyDiffNet, kfamily, medInnovationsDiffNet, medInnovations

Description

A directed dynamic graph with 692 vertices and 21 time periods. The attributes in the graph are static and described in brfarmers.

Format

A diffnet class object.

See Also

Other diffusion datasets: brfarmers, diffusion-data, fakeDynEdgelist, fakeEdgelist, fakesurveyDyn, fakesurvey, kfamilyDiffNet, kfamily, medInnovationsDiffNet, medInnovations

Description

Combining diffnet objects that share time periods and attributes names, but vertices ids (only valid for diffnet objects that have an empty intersection between vertices ids).

Usage

## S3 method for class 'diffnet'
c(..., recursive = FALSE)

Arguments

Details

The diffnet objects in ... must fulfill the following conditions:

1. Have the same time range,

2. have the same vertex attributes, and

3. have an empty intersection of vertices ids,

The meta data regarding undirected, value, and multiple are set to TRUE if any of the concatenating diffnet objects has that meta equal to TRUE.

The resulting diffnet object's columns in the vertex attributes ordering (both dynamic and static) will coincide with the first diffnet's ordering.

Value

A new diffnet object with as many vertices as the sum of each concatenated diffnet objects' number of vertices.

See Also

Other diffnet methods: %*%(), as.array.diffnet(), diffnet-arithmetic, diffnet-class, diffnet_index, plot.diffnet(), summary.diffnet()

Examples

# Calculate structural equivalence exposure by city -------------------------
data(medInnovationsDiffNet)

# Subsetting diffnets
city1 <- medInnovationsDiffNet[medInnovationsDiffNet[["city"]] == 1]
city2 <- medInnovationsDiffNet[medInnovationsDiffNet[["city"]] == 2]
city3 <- medInnovationsDiffNet[medInnovationsDiffNet[["city"]] == 3]
city4 <- medInnovationsDiffNet[medInnovationsDiffNet[["city"]] == 4]

# Computing exposure in each one
city1[["expo_se"]] <- exposure(city1, alt.graph="se", valued=TRUE)
city2[["expo_se"]] <- exposure(city2, alt.graph="se", valued=TRUE)
city3[["expo_se"]] <- exposure(city3, alt.graph="se", valued=TRUE)
city4[["expo_se"]] <- exposure(city4, alt.graph="se", valued=TRUE)

# Concatenating all
diffnet <- c(city1, city2, city3, city4)
diffnet

Description

Adopters are classified as in Valente (1995). In general, this is done depending on the distance in terms of standard deviations from the mean of Time of Adoption and Threshold.

Usage

classify_adopters(...)

classify(...)

## S3 method for class 'diffnet'
classify_adopters(graph, include_censored = FALSE, ...)

## Default S3 method:
classify_adopters(
  graph,
  toa,
  t0 = NULL,
  t1 = NULL,
  expo = NULL,
  include_censored = FALSE,
  ...
)

## S3 method for class 'diffnet_adopters'
ftable(x, as.pcent = TRUE, digits = 2, ...)

## S3 method for class 'diffnet_adopters'
as.data.frame(x, row.names = NULL, optional = FALSE, ...)

## S3 method for class 'diffnet_adopters'
plot(x, y = NULL, ftable.args = list(), table.args = list(), ...)

Arguments

Details

Classifies (only) adopters according to time of adoption and threshold as described in Valente (1995). In particular, the categories are defined as follow:

For Time of Adoption, with toa as the vector of times of adoption:

• Early Adopters: toa[i] <= mean(toa) - sd(toa),

• Early Majority: mean(toa) - sd(toa) < toa[i] <= mean(toa) ,

• Late Majority: mean(toa) < toa[i] <= mean(toa) + sd(toa) , and

• Laggards: mean(toa) + sd(toa) < toa[i] .

For Threshold levels, with thr as the vector of threshold levels:

• Very Low Thresh.: thr[i] <= mean(thr) - sd(thr),

• Low Thresh.: mean(thr) - sd(thr) < thr[i] <= mean(thr) ,

• High Thresh.: mean(thr) < thr[i] <= mean(thr) + sd(thr) , and

• Very High. Thresh.: mean(thr) + sd(thr) < thr[i] .

By default threshold levels are not computed for left censored data. These will have a NA value in the thr vector.

The plot method, plot.diffnet_adopters, is a wrapper for the plot.table method. This generates a mosaicplot plot.

Value

A list of class diffnet_adopters with the following elements:

Author(s)

George G. Vega Yon

References

Valente, T. W. (1995). "Network models of the diffusion of innovations" (2nd ed.). Cresskill N.J.: Hampton Press.

See Also

Other statistics: bass, cumulative_adopt_count(), dgr(), ego_variance(), exposure(), hazard_rate(), infection(), moran(), struct_equiv(), threshold(), vertex_covariate_dist()

Examples

# Classifying brfarmers -----------------------------------------------------

x <- brfarmersDiffNet
diffnet.toa(x)[x$toa==max(x$toa, na.rm = TRUE)] <- NA
out <- classify_adopters(x)

# This is one way
round(
with(out, ftable(toa, thr, dnn=c("Time of Adoption", "Threshold")))/
  nnodes(x[!is.na(x$toa)])*100, digits=2)

# This is other
ftable(out)

# Can be coerced into a data.frame, e.g. ------------------------------------
 str(classify(brfarmersDiffNet))
 ans <- cbind(
 as.data.frame(classify(brfarmersDiffNet)), brfarmersDiffNet$toa
 )
 head(ans)

# Creating a mosaic plot with the medical innovations -----------------------
x <- classify(medInnovationsDiffNet)
plot(x)

Description

Analyze an R object to identify the class of graph (if any)

Usage

classify_graph(graph)

Arguments

Details

This function analyzes an R object and tries to classify it among the accepted classes in netdiffuseR. If the object fails to fall in one of the types of graphs the function returns with an error indicating what (and when possible, where) the problem lies.

The function was designed to be used with as_diffnet.

Value

Whe the object fits any of the accepted graph formats, a list of attributes including

Otherwise returns with error.

Author(s)

George G. Vega Yon

See Also

as_diffnet, netdiffuseR-graphs

Description

For each time period, calculates the number of adopters, the proportion of adopters, and the adoption rate.

Usage

cumulative_adopt_count(obj)

Arguments

Details

The rate of adoption–returned in the 3rd row out the resulting matrix–is calculated as

$\frac{q_t - q_{t-1}}{q_{t-1}}$

where $q_i$ is the number of adopters in time $t$. Note that it is only calculated fot $t>1$.

Value

A $3\times T$ matrix, where its rows contain the number of adoptes, the proportion of adopters and the rate of adoption respectively, for earch period of time.

Author(s)

George G. Vega Yon & Thomas W. Valente

See Also

Other statistics: bass, classify_adopters(), dgr(), ego_variance(), exposure(), hazard_rate(), infection(), moran(), struct_equiv(), threshold(), vertex_covariate_dist()

Description

Computes the requested degree measure for each node in the graph.

Usage

dgr(
  graph,
  cmode = "degree",
  undirected = getOption("diffnet.undirected", FALSE),
  self = getOption("diffnet.self", FALSE),
  valued = getOption("diffnet.valued", FALSE)
)

## S3 method for class 'diffnet_degSeq'
plot(
  x,
  breaks = min(100L, nrow(x)/5),
  freq = FALSE,
  y = NULL,
  log = "xy",
  hist.args = list(),
  slice = ncol(x),
  xlab = "Degree",
  ylab = "Freq",
  ...
)

Arguments

Value

A numeric matrix of size $n\times T$. In the case of plot, returns an object of class histogram.

Author(s)

George G. Vega Yon

See Also

Other statistics: bass, classify_adopters(), cumulative_adopt_count(), ego_variance(), exposure(), hazard_rate(), infection(), moran(), struct_equiv(), threshold(), vertex_covariate_dist()

Other visualizations: diffusionMap(), drawColorKey(), grid_distribution(), hazard_rate(), plot_adopters(), plot_diffnet2(), plot_diffnet(), plot_infectsuscep(), plot_threshold(), rescale_vertex_igraph()

Examples

# Comparing degree measurements ---------------------------------------------
# Creating an undirected graph
graph <- rgraph_ba()
graph

data.frame(
   In=dgr(graph, "indegree", undirected = FALSE),
   Out=dgr(graph, "outdegree", undirected = FALSE),
   Degree=dgr(graph, "degree", undirected = FALSE)
 )

# Testing on Korean Family Planning (weighted graph) ------------------------
data(kfamilyDiffNet)
d_unvalued <- dgr(kfamilyDiffNet, valued=FALSE)
d_valued   <- dgr(kfamilyDiffNet, valued=TRUE)

any(d_valued!=d_unvalued)

# Classic Scale-free plot ---------------------------------------------------
set.seed(1122)
g <- rgraph_ba(t=1e3-1)
hist(dgr(g))

# Since by default uses logscale, here we suppress the warnings
# on points been discarded for <=0.
suppressWarnings(plot(dgr(g)))

Description

Creates a square matrix suitable for spatial statistics models.

Usage

diag_expand(...)

## S3 method for class 'list'
diag_expand(graph, self = is_self(graph), valued = is_valued(graph), ...)

## S3 method for class 'diffnet'
diag_expand(graph, self = is_self(graph), valued = is_valued(graph), ...)

## S3 method for class 'matrix'
diag_expand(graph, nper, self = is_self(graph), valued = is_valued(graph), ...)

## S3 method for class 'array'
diag_expand(graph, self = is_self(graph), valued = is_valued(graph), ...)

## S3 method for class 'dgCMatrix'
diag_expand(graph, nper, self = is_self(graph), valued = is_valued(graph), ...)

Arguments

Value

A square matrix of class dgCMatrix of size (nnode(g)*nper)^2

Examples

# Simple example ------------------------------------------------------------
set.seed(23)
g <- rgraph_er(n=10, p=.5, t=2,undirected=TRUE)

# What we've done: A list with 2 bernoulli graphs
g

# Expanding to a 20*20 matrix with structural zeros on the diagonal
# and on cell 'off' adjacency matrix
diag_expand(g)

Description

Intended for internal use only, this function is used in diffnet_index methods.

Usage

diffnet_check_attr_class(value, meta)

Arguments

Value

The value object either as a data frame (if static) or as a list of data frames (if dynamic). If value does not follows the permitted types of diffnet_index, then returns with error.

Description

Access and assign (replace) elements from the adjacency matrices or the vertex attributes data frames.

Usage

## S3 method for class 'diffnet'
x[[name, as.df = FALSE]]

## S3 replacement method for class 'diffnet'
x[[i, j]] <- value

## S3 method for class 'diffnet'
x[i, j, k, drop = FALSE]

## S3 replacement method for class 'diffnet'
x[i, j, k] <- value

Arguments

Details

The [[.diffnet methods provides access to the diffnet attributes data frames, static and dynamic. By providing the name of the corresponding attribute, depending on whether it is static or dynamic the function will return either a data frame–static attributes–or a list of these–dynamic attributes. For the assigning method, ⁠[[<-.diffnet⁠, the function will infer what kind of attribute is by analyzing the dimensions of value, in particular we have the following possible cases:

*: With $n\times 1$ data.frame/matrix or $n$ length vector.

Other cases will return with error.

In the case of the slices index k, either an integer vector with the positions, a character vector with the labels of the time periods or a logical vector of length T can be used to specify which slices to retrieve. Likewise, indexing vertices works in the same way with the only difference that, instead of time period labels and a logical vector of length T, vertices ids labels and a logical vector of length n should be provided.

When subsetting slices, the function modifies the toa vector as well as the adopt and cumadopt matrices collapsing network tinmming. For example, if a network goes from time 1 to 20 and we set k=3:10, all individuals who adopted prior to time 3 will be set as adopters at time 3, and all individuals who adopted after time 10 will be set as adopters at time 10, changing the adoption and cumulative adoption matrices. Importantly, k have no gaps, and it should be within the graph time period range.

Value

In the case of the assigning methods, a diffnet object. Otherwise, for [[.diffnet a vector extracted from one of the attributes data frames, and for [.diffnet a list of length length(k) with the corresponding [i,j] elements from the adjacency matrix.

Author(s)

George G. Vega Yon

See Also

Other diffnet methods: %*%(), as.array.diffnet(), c.diffnet(), diffnet-arithmetic, diffnet-class, plot.diffnet(), summary.diffnet()

Examples

# Creating a random diffusion network ---------------------------------------
set.seed(111)
graph <- rdiffnet(50,4)

# Accessing to a static attribute
graph[["real_threshold"]]

# Accessing to subsets of the adjacency matrix
graph[1,,1:3, drop=TRUE]
graph[,,1:3, drop=TRUE][[1]]

# ... Now, as diffnet objects (the default)
graph[1,,1:3, drop=FALSE]
graph[,,1:3, drop=FALSE]

# Changing values in the adjacency matrix
graph[1, , , drop=TRUE]
graph[1,,] <- -5
graph[1, , , drop=TRUE]

# Adding attributes (dynamic) -----------------------------------------------
# Preparing the data
set.seed(1122)
x <- rdiffnet(30, 4, seed.p.adopt=.15)

# Calculating exposure, and storing it diffe
expoM <- exposure(x)
expoL <- lapply(seq_len(x$meta$nper), function(x) expoM[,x,drop=FALSE])
expoD <- do.call(rbind, expoL)

# Adding data (all these are equivalent)
x[["expoM"]] <- expoM
x[["expoL"]] <- expoL
x[["expoD"]] <- expoD

# Lets compare
identical(x[["expoM"]], x[["expoL"]]) # TRUE
identical(x[["expoM"]], x[["expoD"]]) # TRUE

Description

Addition, subtraction, network power of diffnet and logical operators such as & and | as objects

Usage

## S3 method for class 'diffnet'
x ^ y

graph_power(x, y, valued = getOption("diffnet.valued", FALSE))

## S3 method for class 'diffnet'
y / x

## S3 method for class 'diffnet'
x - y

## S3 method for class 'diffnet'
x * y

## S3 method for class 'diffnet'
x & y

## S3 method for class 'diffnet'
x | y

Arguments

Details

Using binary operators, ease data management process with diffnet.

By default the binary operator ^ assumes that the graph is valued, hence the power is computed using a weighted edges. Otherwise, if more control is needed, the user can use graph_power instead.

Value

A diffnet class object

See Also

Other diffnet methods: %*%(), as.array.diffnet(), c.diffnet(), diffnet-class, diffnet_index, plot.diffnet(), summary.diffnet()

Examples

# Computing two-steps away threshold with the Brazilian farmers data --------
data(brfarmersDiffNet)

expo1 <- threshold(brfarmersDiffNet)
expo2 <- threshold(brfarmersDiffNet^2)

# Computing correlation
cor(expo1,expo2)

# Drawing a qqplot
qqplot(expo1, expo2)

# Working with inverse ------------------------------------------------------
brf2_step <- brfarmersDiffNet^2
brf2_step <- 1/brf2_step

# Removing the first 3 vertex of medInnovationsDiffnet ----------------------
data(medInnovationsDiffNet)

# Using a diffnet object
first3Diffnet <- medInnovationsDiffNet[1:3,,]
medInnovationsDiffNet - first3Diffnet

# Using indexes
medInnovationsDiffNet - 1:3

# Using ids
medInnovationsDiffNet - as.character(1001:1003)

Description

diffnet objects contain difussion networks. With adjacency matrices and time of adoption (toa) vector as its main components, most of the package's functions have methods for this class of objects.

Usage

as_diffnet(graph, ...)

## Default S3 method:
as_diffnet(graph, ...)

## S3 method for class 'networkDynamic'
as_diffnet(graph, toavar, ...)

new_diffnet(
  graph,
  toa,
  t0 = min(toa, na.rm = TRUE),
  t1 = max(toa, na.rm = TRUE),
  vertex.dyn.attrs = NULL,
  vertex.static.attrs = NULL,
  id.and.per.vars = NULL,
  graph.attrs = NULL,
  undirected = getOption("diffnet.undirected"),
  self = getOption("diffnet.self"),
  multiple = getOption("diffnet.multiple"),
  name = "Diffusion Network",
  behavior = "Unspecified"
)

## S3 method for class 'diffnet'
as.data.frame(
  x,
  row.names = NULL,
  optional = FALSE,
  attr.class = c("dyn", "static"),
  ...
)

diffnet.attrs(
  graph,
  element = c("vertex", "graph"),
  attr.class = c("dyn", "static"),
  as.df = FALSE
)

diffnet.attrs(graph, element = "vertex", attr.class = "static") <- value

diffnet.toa(graph)

diffnet.toa(graph, i) <- value

## S3 method for class 'diffnet'
print(x, ...)

nodes(graph)

diffnetLapply(graph, FUN, ...)

## S3 method for class 'diffnet'
str(object, ...)

## S3 method for class 'diffnet'
dimnames(x)

## S3 method for class 'diffnet'
t(x)

## S3 method for class 'diffnet'
dim(x)

is_undirected(x)

## S3 method for class 'diffnet'
is_undirected(x)

## Default S3 method:
is_undirected(x)

is_self(x)

## S3 method for class 'diffnet'
is_self(x)

## Default S3 method:
is_self(x)

is_multiple(x)

## S3 method for class 'diffnet'
is_multiple(x)

## Default S3 method:
is_multiple(x)

is_valued(x)

## S3 method for class 'diffnet'
is_valued(x)

## Default S3 method:
is_valued(x)

Arguments

Details

diffnet objects hold both, static and dynamic vertex attributes. When creating diffnet objects, these can be specified using the arguments vertex.static.attrs and vertex.dyn.attrs; depending on whether the attributes to specify are static or dynamic, netdiffuseR currently supports the following objects:

The last column, Check sorting, lists the variables that the user should specify if he wants the function to check the order of the rows of the attributes (notice that this is not possible for the case of vectors). By providing the name of the vertex id variable, id, and the time period id variable, per, the function makes sure that the attribute data is presented in the right order. See the example below. If the user does not provide the names of the vertex id and time period variables then the function does not check the way the rows are sorted, further it assumes that the data is in the correct order.

The function 'is_undirected' returns TRUE if the network is marked as undirected. In the case of 'diffnet' objects, this information is stored in the 'meta' element as 'undirected'. The default method is to try to find an attribute called 'undirected', i.e., 'attr(x, "undirected")', if no attribute is found, then the function returns 'FALSE'.

The functions 'is_self', 'is_valued', and 'is_multiple' work exactly the same as 'is_undirected'. 'diffnet' networks are not valued.

Value

A list of class diffnet with the following elements:

Auxiliary functions

diffnet.attrs Allows retriving network attributes. In particular, by default returns a list of length $T$ with data frames with the following columns:

1. per Indicating the time period to which the observation corresponds.

2. toa Indicating the time of adoption of the vertex.

3. Further columns depending on the vertex and graph attributes.

Each vertex static attributes' are repeated $T$ times in total so that these can be binded (rbind) to dynamic attributes.

When as.df=TRUE, this convenience function is useful as it can be used to create event history (panel data) datasets used for model fitting.

Conversely, the replacement method allows including new vertex or graph attributes either dynamic or static (see examples below).

diffnet.toa(graph) works as an alias of graph$toa. The replacement method, diffnet.toa<- used as diffnet.toa(graph)<-..., is the right way of modifying times of adoption as when doing so it performs several checks on the time ranges, and recalculates adoption and cumulative adoption matrices using toa_mat.

nodes(graph) is an alias for graph$meta$ids.

Author(s)

George G. Vega Yon

See Also

Default options are listed at netdiffuseR-options

Other diffnet methods: %*%(), as.array.diffnet(), c.diffnet(), diffnet-arithmetic, diffnet_index, plot.diffnet(), summary.diffnet()

Other data management functions: edgelist_to_adjmat(), egonet_attrs(), isolated(), survey_to_diffnet()

Examples

# Creating a random graph
set.seed(123)
graph <- rgraph_ba(t=9)
graph <- lapply(1:5, function(x) graph)

# Pretty TOA
names(graph) <- 2001L:2005L
toa <- sample(c(2001L:2005L,NA), 10, TRUE)

# Creating diffnet object
diffnet <- new_diffnet(graph, toa)
diffnet
summary(diffnet)

# Plotting slice 4
plot(diffnet, t=4)

# ATTRIBUTES ----------------------------------------------------------------

# Retrieving attributes
diffnet.attrs(diffnet, "vertex", "static")

# Now as a data.frame (only static)
diffnet.attrs(diffnet, "vertex", "static", as.df = TRUE)

# Now as a data.frame (all of them)
diffnet.attrs(diffnet, as.df = TRUE)
as.data.frame(diffnet) # This is a wrapper

# Unsorted data -------------------------------------------------------------
# Loading example data
data(fakesurveyDyn)

# Creating a diffnet object
fs_diffnet <- survey_to_diffnet(
   fakesurveyDyn, "id", c("net1", "net2", "net3"), "toa", "group",
   timevar = "time", keep.isolates=TRUE, warn.coercion=FALSE)

# Now, we extract the graph data and create a diffnet object from scratch
graph <- fs_diffnet$graph
ids <- fs_diffnet$meta$ids
graph <- Map(function(g) {
  dimnames(g) <- list(ids,ids)
  g
  }, g=graph)
attrs <- diffnet.attrs(fs_diffnet, as.df=TRUE)
toa   <- diffnet.toa(fs_diffnet)

# Lets apply a different sorting to the data to see if it works
n <- nrow(attrs)
attrs <- attrs[order(runif(n)),]

# Now, recreating the old diffnet object (notice -id.and.per.vars- arg)
fs_diffnet_new <- new_diffnet(graph, toa=toa, vertex.dyn.attrs=attrs,
   id.and.per.vars = c("id", "per"))

# Now, retrieving attributes. The 'new one' will have more (repeated)
attrs_new <- diffnet.attrs(fs_diffnet_new, as.df=TRUE)
attrs_old <- diffnet.attrs(fs_diffnet, as.df=TRUE)

# Comparing elements!
tocompare <- intersect(colnames(attrs_new), colnames(attrs_old))
all(attrs_new[,tocompare] == attrs_old[,tocompare], na.rm = TRUE) # TRUE!

# diffnetLapply -------------------------------------------------------------

data(medInnovationsDiffNet)
diffnetLapply(medInnovationsDiffNet, function(x, cumadopt, ...) {sum(cumadopt)})

Description

A wrapper of glm, this function estimates a lagged regression model of adoption as a function of exposure and other controls as especified by the user.

Usage

diffreg(model, type = c("logit", "probit"))

Arguments

Details

The model must be in the following form:

<diffnet object> ~ exposure + covariate1 + covariate2 + ...

Where exposure can be especified either as a simple term, or as a call to the exposure function, e.g. to compute exposure with a lag of length 2, the formula could be:

<diffnet object> ~ exposure(lags = 2) + covariate1 + covariate2 + ...

When no argument is passed to exposure, the function sets a lag of length 1 by default (see the Lagged regression section).

This is a wrapper of glm. The function does the following steps:

1. Compute exposure by calling exposure on the LHS (dependent variable).

2. Modify the formula so that the model is on adoption as a function of exposure and whatever covariates the user specifies.

3. Selects either "probit" or "logit" and prepares the call to glm. This includes passing the following line:

    subset = ifelse(is.na(toa), TRUE, toa >= per)
    

   This results in including observations that either did not adopted or up to the time of adoption.

4. Estimates the model.

The data passed to glm is obtained by using as.data.frame.diffnet.

Value

An object of class glm.

Lagged regression

The model estimated is a lagged regression model that has two main assumptions:

1. The network is exogenous to the behavior (no selection effect)

2. The influence effect (diffusion) happens in a lagged fasion, hence, exposure is computed lagged.

If either of these two assumptions is not met, then the model becomes endogenous, ans so inference becomes invalid.

In the case of the first assumption, the user can overcome the non-exogeneity problem by providing an alternative network. This can be done by especifying alt.graph in the exposure function so that the network becomes exogenous to the adoption.

Examples

data("medInnovationsDiffNet")

# Default model
ans <- diffreg(
  medInnovationsDiffNet ~ exposure + factor(city) + proage + per)
summary(ans)

Description

Diffusion Network Datasets

Details

The three classic network diffusion datasets included in netdiffuseR are the medical innovation data originally collected by Coleman, Katz & Menzel (1966); the Brazilian Farmers collected as part of the three country study implemented by Everett Rogers (Rogers, Ascroft, & Röling, 1970), and Korean Family Planning data collected by researchers at the Seoul National University's School of Public (Rogers & Kincaid, 1981). The table below summarizes the three datasets:

All datasets include a column called study which is coded as (1) Medical Innovation (2) Brazilian Farmers, (3) Korean Family Planning.

Value

No return value (this manual entry only provides information).

Right censored data

By convention, non-adopting actors are coded as one plus the last observed time of adoption. Prior empirical event history approaches have used this approach (Valente, 2005; Marsden and Podolny, 1990) and studies have shown that omitting such observations leads to biased results (van den Bulte & Iyengar, 2011).

Author(s)

Thomas W. Valente

References

Burt, R. S. (1987). "Social Contagion and Innovation: Cohesion versus Structural Equivalence". American Journal of Sociology, 92(6), 1287–1335. doi:10.1086/228667

Coleman, J., Katz, E., & Menzel, H. (1966). Medical innovation: A diffusion study (2nd ed.). New York: Bobbs-Merrill

Granovetter, M., & Soong, R. (1983). Threshold models of diffusion and collective behavior. The Journal of Mathematical Sociology, 9(October 2013), 165–179. doi:10.1080/0022250X.1983.9989941

Rogers, E. M., Ascroft, J. R., & Röling, N. (1970). Diffusion of Innovation in Brazil, Nigeria, and India. Unpublished Report. Michigan State University, East Lansing.

Everett M. Rogers, & Kincaid, D. L. (1981). Communication Networks: Toward a New Paradigm for Research. (C. Macmillan, Ed.). New York; London: Free Press.

Mardsen, P., & Podolny, J. (1990). Dynamic Analysis of Network Diffusion Processes, J. Weesie, H. Flap, eds. Social Networks Through Time, 197–214.

Marsden, P. V., & Friedkin, N. E. (1993). Network Studies of Social Influence. Sociological Methods & Research, 22(1), 127–151. doi:10.1177/0049124193022001006

Van den Bulte, C., & Iyengar, R. (2011). Tricked by Truncation: Spurious Duration Dependence and Social Contagion in Hazard Models. Marketing Science, 30(2), 233–248. doi:10.1287/mksc.1100.0615

Valente, T. W. (1991). Thresholds and the critical mass: Mathematical models of the diffusion of innovations. University of Southern California.

Valente, T. W. (1995). "Network models of the diffusion of innovations" (2nd ed.). Cresskill N.J.: Hampton Press.

Valente, T. W. (2005). Network Models and Methods for Studying the Diffusion of Innovations. In Models and Methods in Social Network Analysis, Volume 28 of Structural Analysis in the Social Sciences (pp. 98–116). New York: Cambridge University Press.

See Also

Other diffusion datasets: brfarmersDiffNet, brfarmers, fakeDynEdgelist, fakeEdgelist, fakesurveyDyn, fakesurvey, kfamilyDiffNet, kfamily, medInnovationsDiffNet, medInnovations

Description

Using bi-dimensional kernel smoothers, creates a heatmap based on a graph layout and colored accordingly to x. This visualization technique is intended to be used with large graphs.

Usage

diffusionMap(graph, ...)

diffmap(graph, ...)

## Default S3 method:
diffusionMap(
  graph,
  x,
  x.adj = round_to_seq,
  layout = NULL,
  jitter.args = list(),
  kde2d.args = list(n = 100),
  sharp.criter = function(x, w) {
     wvar(x, w) > (max(x, na.rm = TRUE) - min(x, na.rm
    = TRUE))^2/12
 },
  ...
)

## S3 method for class 'diffnet'
diffusionMap(graph, slice = nslices(graph), ...)

## S3 method for class 'diffnet_diffmap'
image(x, ...)

## S3 method for class 'diffnet_diffmap'
print(x, ...)

## S3 method for class 'diffnet_diffmap'
plot(x, y = NULL, ...)

Arguments

Details

The image is created using the function kde2d from the MASS package. The complete algorithm follows:

1. x is coerced into integer and the range is adjusted to start from 1. NA are replaced by zero.

2. If no layout is passed, layout is computed using layout_nicely from igraph

3. Then, a kde2d map is computed for each level of x. The resulting matrices are added up as a weighted sum. This only holds if at the cell level the function sharp.criter returns FALSE.

4. The jitter function is applied to the repeated coordinates.

5. 2D kernel is computed using kde2d over the coordinates.

The function sharp.criter must take two values, a vector of levels and a vector of weights. It must return a logical scalar with value equal to TRUE when a randomization at the cell level must be done, in which case the final value of the cell is chosen using sample(x, 1, prob=w).

The resulting matrix can be passed to image or similar.

The argument x.adj uses by default the function round_to_seq which basically maps x to a fix length sequence of numbers such that x.adj(x) resembles an integer sequence.

Value

A list of class diffnet_diffmap

Author(s)

George G. Vega Yon

References

Vega Yon, George G., and Valente, Thomas W., Visualizing Large Annotated Networks as Heatmaps using Weighted Averages based on Kernel Smoothers (Working paper).

See Also

Other visualizations: dgr(), drawColorKey(), grid_distribution(), hazard_rate(), plot_adopters(), plot_diffnet2(), plot_diffnet(), plot_infectsuscep(), plot_threshold(), rescale_vertex_igraph()

Examples

# Example with a random graph --------------------------------------------------

set.seed(1231)

# Random scale-free diffusion network
x <- rdiffnet(500, 4, seed.graph="scale-free", seed.p.adopt = .025,
                           rewire = FALSE, seed.nodes = "central",
                           rgraph.arg=list(self=FALSE, m=4),
                           threshold.dist = function(id) runif(1,.2,.4))

# Diffusion map (no random toa)
dm0 <- diffusionMap(x, kde2d.args=list(n=150, h=.5), layout=igraph::layout_with_fr)

# Random
diffnet.toa(x) <- sample(x$toa, size = nnodes(x))

# Diffusion map (random toa)
dm1 <- diffusionMap(x, layout = dm0$coords, kde2d.args=list(n=150, h=.5))

oldpar <- par(no.readonly = TRUE)
col <- colorRampPalette(blues9)(100)
par(mfrow=c(1,2), oma=c(1,0,0,0))
image(dm0, col=col, main="Non-random Times of Adoption\nAdoption from the core.")
image(dm1, col=col, main="Random Times of Adoption")
par(mfrow=c(1,1))
mtext("Both networks have the same distribution on times of adoption", 1,
      outer = TRUE)
par(oldpar)

# Example with Brazilian Farmers --------------------------------------------
dn <- brfarmersDiffNet

# Setting last TOA as NA
diffnet.toa(dn)[dn$toa == max(dn$toa)] <-
  NA

# Coordinates
coords <- sna::gplot.layout.fruchtermanreingold(
  as.matrix(dn$graph[[1]]), layout.par=NULL
)

# Plotting diffusion
plot_diffnet2(dn, layout=coords, vertex.size = 300)

# Adding diffusion map
out <- diffusionMap(dn, layout=coords, kde2d.args=list(n=100, h=50))
col <- adjustcolor(colorRampPalette(c("white","lightblue", "yellow", "red"))(100),.5)
with(out$map, .filled.contour(x,y,z,pretty(range(z), 100),col))

Description

Draw a color key in the current device

Usage

drawColorKey(
  x,
  tick.marks = pretty_within(x),
  labels = tick.marks,
  main = NULL,
  key.pos = c(0.925, 0.975, 0.05, 0.95),
  pos = 2,
  nlevels = length(tick.marks),
  color.palette = viridisLite::viridis(nlevels),
  tick.width = c(0.01, 0.0075),
  add.box = TRUE,
  na.col = NULL,
  na.height = 0.1,
  na.lab = "n/a",
  ...
)

Arguments

Value

Invisible NULL.

Author(s)

George G. Vega Yon

See Also

Other visualizations: dgr(), diffusionMap(), grid_distribution(), hazard_rate(), plot_adopters(), plot_diffnet2(), plot_diffnet(), plot_infectsuscep(), plot_threshold(), rescale_vertex_igraph()

Examples

set.seed(166)
x <- rnorm(100)
col <- colorRamp(c("lightblue", "yellow", "red"))((x - min(x))/(max(x) - min(x)))
col <- rgb(col, maxColorValue = 255)
plot(x, col=col, pch=19)
drawColorKey(x, nlevels = 100, border="transparent",
 main="Key\nLike A\nBoss")

Description

Generates adjacency matrix from an edgelist and vice versa.

Usage

edgelist_to_adjmat(
  edgelist,
  w = NULL,
  t0 = NULL,
  t1 = NULL,
  t = NULL,
  simplify = TRUE,
  undirected = getOption("diffnet.undirected"),
  self = getOption("diffnet.self"),
  multiple = getOption("diffnet.multiple"),
  keep.isolates = TRUE,
  recode.ids = TRUE
)

adjmat_to_edgelist(
  graph,
  undirected = getOption("diffnet.undirected", FALSE),
  keep.isolates = getOption("diffnet.keep.isolates", TRUE)
)

Arguments

Details

When converting from edglist to adjmat the function will recode the edgelist before starting. The user can keep track after the recording by checking the resulting adjacency matrices' row.names. In the case that the user decides skipping the recoding (because wants to keep vertices index numbers, implying that the resulting graph will have isolated vertices), he can override this by setting recode.ids=FALSE (see example).

When multiple edges are included, multiple=TRUE,each vertex between $\{i,j\}$ will be counted as many times it appears in the edgelist. So if a vertex $\{i,j\}$ appears 2 times, the adjacency matrix element (i,j) will be 2.

Edges with incomplete information (missing data on w or times) are not included on the graph. Incomplete cases are tagged using complete.cases and can be retrieved by the user by accessing the attribute incomplete.

Were the case that either ego or alter are missing (i.e. NA values), the function will either way include the non-missing vertex. See below for an example of this.

The function performs several checks before starting to create the adjacency matrix. These are:

• Dimensions of the inputs, such as number of columns and length of vectors

• Having complete cases. If anly edge has a non-numeric value such as NAs or NULL in either times or w, it will be removed. A full list of such edges can be retrieved from the attribute incomplete

• Nodes and times ids coding

recode.ids=FALSE is useful when the vertices ids have already been coded. For example, after having use adjmat_to_edgelist, ids are correctly encoded, so when going back (using edgelist_to_adjmat) recode.ids should be FALSE.

Value

In the case of edgelist_to_adjmat either an adjacency matrix (if times is NULL) or an array of these (if times is not null). For adjmat_to_edgelist the output is an edgelist with the following columns:

Author(s)

George G. Vega Yon & Thomas W. Valente

See Also

Other data management functions: diffnet-class, egonet_attrs(), isolated(), survey_to_diffnet()

Examples

# Base data
set.seed(123)
n <- 5
edgelist <- rgraph_er(n, as.edgelist=TRUE, p=.2)[,c("ego","alter")]
times <- sample.int(3, nrow(edgelist), replace=TRUE)
w <- abs(rnorm(nrow(edgelist)))

# Simple example
edgelist_to_adjmat(edgelist)
edgelist_to_adjmat(edgelist, undirected = TRUE)

# Using w
edgelist_to_adjmat(edgelist, w)
edgelist_to_adjmat(edgelist, w, undirected = TRUE)

# Using times
edgelist_to_adjmat(edgelist, t0 = times)
edgelist_to_adjmat(edgelist, t0 = times, undirected = TRUE)

# Using times and w
edgelist_to_adjmat(edgelist, t0 = times, w = w)
edgelist_to_adjmat(edgelist, t0 = times, undirected = TRUE, w = w)

# Not recoding ----------------------------------------------------
# Notice that vertices 3, 4 and 5 are not present in this graph.
graph <- matrix(c(
 1,2,6,
 6,6,7
), ncol=2)

# Generates an adjmat of size 4 x 4
edgelist_to_adjmat(graph)

# Generates an adjmat of size 7 x 7
edgelist_to_adjmat(graph, recode.ids=FALSE)

# Dynamic with spells -------------------------------------------------------
edgelist <- rbind(
   c(1,2,NA,1990),
   c(2,3,NA,1991),
   c(3,4,1991,1992),
   c(4,1,1992,1993),
   c(1,2,1993,1993)
)

graph <- edgelist_to_adjmat(edgelist[,1:2], t0=edgelist[,3], t1=edgelist[,4])

# Creating a diffnet object with it so we can apply the plot_diffnet function
diffnet <- as_diffnet(graph, toa=1:4)
plot_diffnet(diffnet, label=rownames(diffnet))

# Missing alter in the edgelist ---------------------------------------------
data(fakeEdgelist)

# Notice that edge 202 is isolated
fakeEdgelist

# The function still includes vertex 202
edgelist_to_adjmat(fakeEdgelist[,1:2])

edgelist

Description

Given a graph, vertices' positions and sizes, calculates the absolute positions of the endpoints of the edges considering the plot's aspect ratio.

Usage

edges_coords(
  graph,
  toa,
  x,
  y,
  vertex_cex,
  undirected = TRUE,
  no_contemporary = TRUE,
  dev = as.numeric(c()),
  ran = as.numeric(c()),
  curved = as.logical(c())
)

Arguments

Details

In order to make the plot's visualization more appealing, this function provides a straight forward way of computing the tips of the edges considering the aspect ratio of the axes range. In particular, the following corrections are made at the moment of calculating the egdes coords:

• Instead of using the actual distance between ego and alter, a relative one is calculated as follows

  $d'=\left[(x_0-x_1)^2 + (y_0' - y_1')^2\right]^\frac{1}{2}$

  where $y_i'=y_i\times\frac{\max x - \min x}{\max y - \min y}$

• Then, for the relative elevation angle, alpha, the relative distance $d'$ is used, $\alpha'=\arccos\left( (x_0 - x_1)/d' \right)$

• Finally, the edge's endpoint's (alter) coordinates are computed as follows:

  $x_1' = x_1 + \cos(\alpha')\times v_1$

  $y_1' = y_1 -+ \sin(\alpha')\times v_1 \times\frac{\max y - \min y}{\max x - \min x}$

  Where $v_1$ is alter's size in terms of the x-axis, and the sign of the second term in $y_1'$ is negative iff $y_0 < y_1$.

The same process (with sign inverted) is applied to the edge starting piont. The resulting values, $x_1',y_1'$ can be used with the function arrows. This is the workhorse function used in plot_threshold.

The dev argument provides a reference to rescale the plot accordingly to the device, and former, considering the size of the margins as well (this can be easily fetched via par("pin"), plot area in inches).

On the other hand, ran provides a reference for the adjustment according to the range of the data, this is range(x)[2] - range(x)[1] and range(y)[2] - range(y)[1] respectively.

Value

A numeric matrix of size $m\times 5$ with the following columns:

With $m$ as the number of resulting edges.

Examples

# --------------------------------------------------------------------------
data(medInnovationsDiffNet)
library(sna)

# Computing coordinates
set.seed(79)
coords <- sna::gplot(as.matrix(medInnovationsDiffNet$graph[[1]]))

# Getting edge coordinates
vcex <- rep(1.5, nnodes(medInnovationsDiffNet))
ecoords <- edges_coords(
  medInnovationsDiffNet$graph[[1]],
  diffnet.toa(medInnovationsDiffNet),
  x = coords[,1], y = coords[,2],
  vertex_cex = vcex,
  dev = par("pin")
  )

ecoords <- as.data.frame(ecoords)

# Plotting
symbols(coords[,1], coords[,2], circles=vcex,
  inches=FALSE, xaxs="i", yaxs="i")

with(ecoords, arrows(x0,y0,x1,y1, length=.1))

Description

Computes variance of $Y$ at ego level

Usage

ego_variance(graph, Y, funname, all = FALSE)

Arguments

Details

For each vertex $i$ the variance is computed as follows

$(\sum_j a_{ij})^{-1}\sum_j a_{ij} \left[f(y_i,y_j) - f_i\right]^2$

Where $a_{ij}$ is the ij-th element of graph, $f$ is the function specified in funname, and, if all=FALSE $f_i = \sum_j a_{ij}f(y_i,y_j)^2/\sum_ja_{ij}$, otherwise $f_i = f_j = \frac{1}{n^2}\sum_{i,j}f(y_i,y_j)$

This is an auxiliary function for struct_test. The idea is to compute an adjusted measure of disimilarity between vertices, so the closest in terms of $f$ is $i$ to its neighbors, the smaller the relative variance.

Value

A numeric vector of length $n$.

See Also

struct_test

Other statistics: bass, classify_adopters(), cumulative_adopt_count(), dgr(), exposure(), hazard_rate(), infection(), moran(), struct_equiv(), threshold(), vertex_covariate_dist()

Description

For a given set of vertices V, retrieves each vertex's alter's attributes. This function enables users to calculate exposure on variables other than the attribute that is diffusing. Further, it enables the specification of alternative functions to use to characterize ego's personal network including calculating the mean, maximum, minimum, median, or sum of the alters' attributes. These measures may be static or dynamic over the interval of diffusion and they may be binary or valued.

Usage

egonet_attrs(
  graph,
  attrs,
  V = NULL,
  direction = "outgoing",
  fun = function(x) x,
  as.df = FALSE,
  self = getOption("diffnet.self"),
  valued = getOption("diffnet.valued"),
  ...
)

Arguments

Details

By indexing inner/outer edges, this function retrieves ego network attributes for all $v \in V$, which by default is the complete set of vertices in the graph.

When as.df=TRUE the function returns a data.frame of size $(|V|\times T)\times k$ where $T$ is the number of time periods and $k$ is the number of columns generated by the function.

The function can be used to create network effects as those in the RSiena package. The difference here is that the definition of the statistic directly relies on the user. For example, in the RSiena package, the dyadic covariate effect 37. covariate (centered) main effect (X)

$s_{i37}(x) = \sum_j x_{ij}(w_{ij}-\bar w)$

Which, having a diffnet object with attributes named x and w, can be calculated as

    egonet_attrs(diffnet, as.df=TRUE, fun=function(dat) {
     sum(dat[, "x"]*(dat[, "w"] - mean(dat[, "w"])))
    })
    

Furthermore, we could use the median centered instead, for example

    egonet_attrs(diffnet, as.df=TRUE, fun=function(dat) {
     sum(dat[, "x"]*(dat[, "w"] - median(dat[, "w"])))
    })
    

Where for each $i$, dat will be a matrix with as many rows as individuals in his egonetwork. Such matrix holds the column names of the attributes in the network.

When self = TRUE, it will include ego's attributes, regardless the network has loops or not.

Value

A list with ego alters's attributes. By default, if the graph is static, the output is a list of length length(V) with matrices having the following columns:

On the other hand, if graph is dynamic, the output is list of length $T$ of lists of length length(V) with data frames having the following columns:

Author(s)

George G. Vega Yon

See Also

Other data management functions: diffnet-class, edgelist_to_adjmat(), isolated(), survey_to_diffnet()

Examples

# Simple example with diffnet -----------------------------------------------
set.seed(1001)
diffnet <- rdiffnet(150, 5, seed.graph="small-world")

# Adding attributes
indeg <- dgr(diffnet, cmode="indegree")
head(indeg)
diffnet[["indegree"]] <- indeg

# Retrieving egonet's attributes (vertices 1 and 20)
egonet_attrs(diffnet, V=c(1,20))

# Example with a static network ---------------------------------------------

set.seed(1231)
n <- 20
net <- rgraph_ws(n = n, k = 4, p = .5)
someattr <- matrix(rnorm(n * 2), ncol= 2, dimnames = list(NULL, c("a", "b")))

# Maximum of -a- in ego network
ans <- egonet_attrs(net, someattr, fun = function(x) max(x[,"a"]))
ans

# checking it worked, taking a look at node 1, 2, and 3
max(someattr[which(net[1,] == 1),"a"]) == ans[1] # TRUE
max(someattr[which(net[2,] == 1),"a"]) == ans[2] # TRUE
max(someattr[which(net[3,] == 1),"a"]) == ans[3] # TRUE

Description

Calculates exposure to adoption over time via multiple different types of weight matrices. The basic model is exposure to adoption by immediate neighbors (outdegree) at the time period prior to ego’s adoption. This exposure can also be based on (1) incoming ties, (2) structural equivalence, (3) indirect ties, (4) attribute weighted (5) network-metric weighted (e.g., central nodes have more influence), and attribute-weighted (e.g., based on homophily or tie strength).

Usage

exposure(
  graph,
  cumadopt,
  attrs = NULL,
  alt.graph = NULL,
  outgoing = getOption("diffnet.outgoing", TRUE),
  valued = getOption("diffnet.valued", FALSE),
  normalized = TRUE,
  groupvar = NULL,
  self = getOption("diffnet.self"),
  lags = 0L,
  ...
)

Arguments

Details

Exposure is calculated as follows:

$E_t = \left(S_t \times \left[x_t \circ A_t\right]\right) / (S_t \times x_t)$

Where $S_t$ is the graph in time $t$, $x_t$ is an attribute vector of size $n$ at time $t$, $A_t$ is the t-th column of the cumulative adopters matrix (a vector of length $n$ with $a_{ti}=1$ if $i$ has adopted at or prior to $t$), $\circ$ is the kronecker product (element-wise), and $\times$ is the matrix product.

By default the graph used for this calculation, $S$, is the social network. Alternatively, in the case of diffnet objects, the user can provide an alternative graph using alt.graph. An example of this would be using $1/SE$, the element-wise inverse of the structural equivalence matrix (see example below). Furthermore, if alt.graph="se", the inverse of the structural equivalence is computed via struct_equiv and used instead of the provided graph. Notice that when using a valued graph the option valued should be equal to TRUE, this check is run automatically when running the model using structural equivalence.

If the alt.graph is static, then the function will warn about it and will recycle the graph to compute exposure at each time point.

An important remark is that when calculating structural equivalence the function assumes that this is to be done to the entire graph regardless of disconnected communities (as in the case of the medical innovations data set). Hence, structural equivalence for individuals for two different communites may not be zero. If the user wants to calculate structural equivalence separately by community, he should create different diffnet objects and do so (see example below). Alternatively, for the case of diffnet objects, by using the option groupvar (see struct_equiv), the user can provide the function with the name of a grouping variable–which should one in the set of static vertex attributes–so that the algorithm is done by group (or community) instead of in an aggregated way.

If the user does not specifies a particular weighting attribute in attrs, the function sets this as a matrix of ones. Otherwise the function will return an attribute weighted exposure. When graph is of class diffnet, attrs can be a character scalar specifying the name of any of the graph's attributes, both dynamic and static. See the examples section for a demonstration using degree.

When outgoing=FALSE, $S$ is replaced by its transposed, so in the case of a social network exposure will be computed based on the incoming ties.

If normalize=FALSE then denominator, $S_t \times x_t$, is not included. This can be useful when, for example, exposure needs to be computed as a count instead of a proportion. A good example of this can be found at the examples section of the function rdiffnet.