Error(s) in re-building vignettes:
  ...
--- re-building ‘tsna_vignette.Rmd’ using rmarkdown
tsna                   package:tsna                    R Documentation

_T_o_o_l_s _f_o_r _T_e_m_p_o_r_a_l _S_o_c_i_a_l _N_e_t_w_o_r_k _A_n_a_l_y_s_i_s

_D_e_s_c_r_i_p_t_i_o_n:

     Temporal SNA tools for continuous- and discrete-time longitudinal
     networks. having vertex, edge, and attribute dynamics stored in
     the networkDynamic format. This work was supported by grant
     R01HD68395 from the National Institute of Health.

_D_e_t_a_i_l_s:

     This package provides tools for working with longitudinal network
     data in 'networkDynamic-package' format. This data structure is
     essentially a list in the 'network' format in which elements also
     have an attached 'activity.attribute', a matrix of spells
     indicating when vertex or edge is active.  The networkDynamic
     package provides tools ('networkDynamic') for translating
     longitudinal data from various formats (timed edge lists, lists of
     toggles, sets of matrices, etc).

     Currently the package consists of several groups of functions

        • wrappers for 'static' social network analysis metrics and
          apply them at multiple time points

        • functions that construct or use temporal paths through
          networks

        • basic tools for measuring durations of ties, rates of change,
          etc

        • utility functions for plotting, etc

     The sections below provide some additional details.  The package
     vignette ('browseVignettes(package='tsna')') gives additional
     examples and illustrations of key concepts.

     It is the intention that, like the 'networkDynamic' package, tsna
     should support both continuous time and discrete time
     representations of networks.  However, we are prioritizing
     development of discrete time measures suitable for use with
     simulation data (i.e. 'stergm' models) so many of the functions
     are still missing the necessary arguments to facilitate binning.

_S_t_a_n_d_a_r_d '_s_t_a_t_i_c' _S_n_a _m_e_t_r_i_c_s:

     These functions operate by collapsing the dynamic network into a
     static network at a series of regular intervals and returning the
     results as a time series 'ts' object. They can provide general
     description of trends in a network dataset.  Generally assumes
     that vertex set is not substantially changing.

        • 'tErgmStats' - descriptive stats (ergm terms) from the 'ergm'
          package

        • 'tSnaStats' - descriptive stats from the 'sna' package. Both
          graph- and vertex-level measures.  centralities, components,
          reciprocity, betweenness, triad-census, etc.

_T_e_m_p_o_r_a_l _p_a_t_h _b_a_s_e_d _m_e_t_r_i_c_s:

     These functions compute and use temporal paths (network geodesics
     that are constrained by the activity times of edges) through a
     network.

        • 'tPath'

        • 'tReach'

_R_a_t_e_s _a_n_d _D_u_r_a_t_i_o_n:

     These functions can be used to compute distributions of (observed)
     activity durations in a data structure. Note that due to censoring
     (edges that begin before or end after the time observation window
     for the network) the observed durations may be biased away from
     the 'real' values (or model parameters).  The duration estimate
     functions use various types of survival analysis to return
     estimates of these values.

        • 'edgeDuration'

        • 'vertexDuration'

        • 'tiedDuration'

        • 'tEdgeDissolution'

        • 'tEdgeFormation'

        • 'tiedDuration'

_t_s_n_a _U_t_i_l_i_t_i_e_s:

        • 'as.network.tPath'

        • 'plotPaths'

        • 'timeProjectedNetwork'

_D_a_t_a _S_e_t_s:

        • 'moodyContactSim'

        • additional useful datasets provided by the
          'networkDynamicData' and 'networkDynamic' packages

_S_o_u_r_c_e:

     This package is part of the statnet suite of packages <URL:
     http://statnet.org>.  For citation information see
     'citation('tsna')'.


paths                   package:tsna                   R Documentation

_T_e_m_p_o_r_a_l_l_y _R_e_a_c_h_a_b_l_e _P_a_t_h_s _i_n _a _n_e_t_w_o_r_k_D_y_n_a_m_i_c _O_b_j_e_c_t

_D_e_s_c_r_i_p_t_i_o_n:

     Functions to search out the sequence and distances of vertices in
     a 'networkDynamic' object reachable from an initial vertex by
     following paths constrained by edge timing.

_U_s_a_g_e:

     tPath(nd, v, direction=c('fwd','bkwd'), 
                      type=c('earliest.arrive', 'latest.depart'),
                      start, end, active.default = TRUE, graph.step.time = 0)
     
     is.tPath(x)
     
_A_r_g_u_m_e_n_t_s:

      nd: networkDynamic object to be searched for temporal paths

       v: integer id of the vertex to be used as the starting point of
          the search

direction: option indicating the temporal direction in which the
          network should be searched: ''fwd'' means search forwards in
          time and forward along edge directions, ''bkwd'' means search
          backwards in time and backwards along edge directions.

    type: option indicating the type of path (temporal constraint of
          the path) be searched for:

            • ''earliest.arrive'' will find the paths that arrive first
              at the target vertices,

            • ''latest.depart'' will find the paths that leave the
              source vertex at the latest possible time.

          Additional options will be added as implemented.

   start: time at which to begin searching. Edges that terminate before
          this time will not be considered. If not specified, defaults
          to earliest time observed on the network according to
          'get.change.times'.

     end: time to end the path search.  Edges that onset on or after
          this time will not be considered in the path search.

active.default: Boolean, default TRUE. Should edges with no timing
          information be considered active by default?

graph.step.time: numeric.  How much time should be added for each edge
          traversal (graph hop)? Default is 0, meaning that path
          distances returned will be purely temporal and will not
          incorporate graph path distances and 'transmission' can cross
          multiple edges in a single instant.  A value of 1 would
          correspond to counting path distances like a traditional
          centrality score or discrete time simulation.

       x: an object to be tested for inheriting the class ''tPath''

_D_e_t_a_i_l_s:

     A _temporal path_ in a dynamic network is a sequence of vertices
     and edges such that the onset times of successive elements are
     greater than or equal than those of the previous. In other words,
     the path is a directed traversal of the network that respects the
     constraints of edge activity spells and permits 'waiting' at
     intermediate vertices for 'future' edges to form.

     When set to use 'direction='fwd'' , 'type='earliest.arrive''
     'tPath' performs a time-minimizing Dijkstra's style Depth First
     Search to find the set of vertices reachable on a _forward
     temporal path_ from the initial seed vertex 'v' while respecting
     the constraints of edge timing.The path found is a _earliest
     arriving_ (in contrast to the _earliest leaving_ or _quickest_ or
     _latest arriving_ path). When there are multiple equivalent paths
     only a single one will be arbitrarily returned.  NOTE THAT THE
     PATH-FINDING ALGORITHM WILL NOT GIVE CORRECT RESULTS IF ANY SPELLS
     CONTAIN VALUES LESS THAN 0.

     When set to 'direction='bkwd'' and 'type='latest.depart'' the path
     will be found by searching backwards in time from the 'end' point.
     In other words, it returns the set of vertices that can reach 'v',
     along with latest possible departure times from those vertices.
     Note that in this case the elapsed time values returned for
     'tdist' will be negative, indicating time measured backwards from
     the 'end' bound.

     When set to 'type='fewest.steps'' the path returned will be a
     'shortest' (fewest steps/graph hops) time-respecting path.  This
     would not be necessiairly the quickest or earliest route, but
     would pass across the fewest possible number of edges (requires
     the fewest number of transmission steps).

     The 'graph.step.time' parmeter allows specifying an explicit
     duration for edge traversals.  In this case the algorithm
     considers both the onset and terminus times of activity spells to
     ensure that suffecient time remains for an edge traversal to be
     made.  If 'graph.step.time' > the remaining duration of an edge's
     activity spell, the edge is considered non-traverseable. The
     primary use case for this parameter is to align the paths
     discovered with those that might be found by a discrete time
     transmission simulation in which a path can only spread a single
     graph hop per model timestep.

     Vertex activity is currently ignored, and it is assumed that once
     a path reaches a vertex, all future edges from the vertex are
     accessible.  The path search can be constrained in time using the
     'start' and 'end' parameters to bound the time span to be explored
     by the path search.

     ''bwkd'' ''latest.depart'' is essentially the inverse of fwd
     earliest arrive.  It finds the latest time paths backwards from
     the initial seed vertex. This is the _latest-leaving_ time. Note
     that the distance returned are positive, but represent the latest
     distance back in time from the 'end' parameter time at which a
     vertex can reach 'v'.

     The 'is.tPath' function checks if an object has the class 'tPath'.

_V_a_l_u_e:

     Currently an object of class 'tPath' which is essentially list
     with several elements providing information on the path found.

   tdist: A numeric vector with length equal to network size in which
          each element contains the earliest/latest _temporal_ distance
          at which the corresponding vertex could reach / be reached
          from the seed vertex. Values are elapsed time, as measured
          from the 'start' parameter. Unreachable vertices are marked
          with 'Inf'

previous: A numeric vector with length equal to network size in which
          each element indicates the previous vertex along (a possible)
          reachable path. Can be used to reconstruct the path tree. The
          initial vertex and unreachable vertices are marked with '0'

  gsteps: A numeric vector (of length equal to network size) in which
          each element indicates the number of steps in the path
          (number of graph hops) to the vertex along the temporal path
          found starting at the seed vertex.

   start: the numeric start value that was used as the earliest bound
          for the path calculation (may not have been explicitly set)

     end: the numerid end value that was used as the latest bound for
          the path calculation (may not have been explicitly set)

direction: The direction ''fwd'' or ''bkwd'' of the path

    type: The type of temporal constraint for the path

_N_o_t_e:

     Temporal distances are in terms of time measured from the 'start'
     parameter, so to recover the model times at which each vertex was
     reached for forward paths use '$tdist+start' and backward paths
     with 'end- $tdist'. This is an early draft of the function, its
     name and arguments are subject to change before release.

_A_u_t_h_o_r(_s):

     Skye Bender-deMoll

_R_e_f_e_r_e_n_c_e_s:

     Unpublished discussions with James Moody and Martina Morris and
     the statnet team.

     Useful background information (for a slightly different algorithm)
     can be found in: B. Bui Xuan, Afonso Ferreira, Aubin Jarry.
     "Computing shortest, fastest, and foremost journeys in dynamic
     networks." RR-4589, 2002.
     https://hal.inria.fr/inria-00071996/document

     B. Bui Xuan, Afonso Ferreira, Aubin Jarry. Evolving graphs and
     least cost journeys in dynamic networks. WiOpt'03: Modeling and
     Optimization in Mobile, Ad Hoc and Wireless Networks, Mar 2003,
     Sophia Antipolis, France. 10 p., 2003
     https://hal.inria.fr/inria-00466676/document

_E_x_a_m_p_l_e_s:

     require(networkDynamicData)
     data(hospital_contact)
     hosPath<-tPath(hospital,v=1)
     

Quitting from lines 461-463 (tsna_vignette.Rmd) 
Error: processing vignette 'tsna_vignette.Rmd' failed with diagnostics:
'summary.statistics.formula' is not an exported object from 'namespace:ergm'
--- failed re-building ‘tsna_vignette.Rmd’

SUMMARY: processing the following file failed:
  ‘tsna_vignette.Rmd’

Error: Vignette re-building failed.
Execution halted