Maintainer: ‘Joan Garriga <jgarriga@ceab.csic.es>’

The Description field contains
  F. (2018), <arXiv:1812.09869>).
Please refer to arXiv e-prints via their arXiv DOI <doi:10.48550/arXiv.YYMM.NNNNN>.
Unknown/obsolate C++14 standard request will be ignored
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Maintainer: ‘Joan Garriga <jgarriga@ceab.csic.es>’

The Description field contains
  F. (2018), <arXiv:1812.09869>).
Please refer to arXiv e-prints via their arXiv DOI <doi:10.48550/arXiv.YYMM.NNNNN>.
Unknown/obsolate C++14 standard request will be ignored
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Unknown/obsolate C++14 standard request will be ignored
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Unknown/obsolate C++14 standard request will be ignored
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Unknown/obsolate C++14 standard request will be ignored
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Specified C++14: please drop specification unless essential
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Specified C++14: please drop specification unless essential
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Specified C++14: please drop specification unless essential
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Specified C++14: please drop specification unless essential
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Specified C++14: please drop specification unless essential
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
Specified C++14: please drop specification unless essential
installed size is  6.2Mb
  sub-directories of 1Mb or more:
    doc       1.8Mb
    extdata   1.9Mb
    libs      2.3Mb
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
GNU make is a SystemRequirements.
Specified C++14: please drop specification unless essential
installed size is  6.3Mb
  sub-directories of 1Mb or more:
    doc       1.8Mb
    extdata   1.9Mb
    libs      2.3Mb
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
GNU make is a SystemRequirements.
Specified C++14: please drop specification unless essential
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                         ^
checkRd: (-1) bdm.ptsne.Rd:47: Lost braces; missing escapes or markup?
    47 | By default the algorithm is structured in \eqn{\sqrt{n}} epochs of \eqn{\sqrt{z}} iterations each, where \var{n} is the dataset size and \var{z} is the thread-size (\eqn{z=n*layers/threads}). The running time of the algorithm is then determined by \eqn{epochs*iters*t_i+ epochs*t_e} where \var{t_{i}} is the running time of a single iteration and \var{t_{e}} is the inter-epoch running time.
       |                                                                                                                                                                                                                                                                                                                                                                   ^
GNU make is a SystemRequirements.