Valid HTML 4.0! Valid CSS!
%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.12",
%%%     date            = "09 April 2021",
%%%     time            = "15:28:39 MDT",
%%%     filename        = "julia.bib",
%%%     address         = "University of Utah
%%%                        Department of Mathematics, 110 LCB
%%%                        155 S 1400 E RM 233
%%%                        Salt Lake City, UT 84112-0090
%%%                        USA",
%%%     telephone       = "+1 801 581 5254",
%%%     FAX             = "+1 801 581 4148",
%%%     URL             = "http://www.math.utah.edu/~beebe",
%%%     checksum        = "42021 6073 28448 287530",
%%%     email           = "beebe at math.utah.edu, beebe at acm.org,
%%%                        beebe at computer.org (Internet)",
%%%     codetable       = "ISO/ASCII",
%%%     keywords        = "bibliography; BibTeX; Julia programming
%%%                        language",
%%%     license         = "public domain",
%%%     supported       = "yes",
%%%     docstring       = "This is a bibliography of publications about
%%%                        the Julia programming language.  The language
%%%                        has a Web site at
%%%
%%%                            https://julialang.org/
%%%
%%%                        that offers documentation and downloads.
%%%
%%%                        At version 1.12, the year coverage looked
%%%                        like this:
%%%
%%%                             2012 (   1)    2016 (  19)    2020 (  32)
%%%                             2013 (   0)    2017 (  22)    2021 (   5)
%%%                             2014 (   5)    2018 (  28)
%%%                             2015 (   8)    2019 (  31)
%%%
%%%                             Article:         55
%%%                             Book:            24
%%%                             InCollection:     3
%%%                             InProceedings:   67
%%%                             MastersThesis:    1
%%%                             Proceedings:      1
%%%
%%%                             Total entries:  151
%%%
%%%                        Spelling has been verified with the UNIX
%%%                        spell and GNU ispell programs using the
%%%                        exception dictionary stored in the companion
%%%                        file with extension .sok.
%%%
%%%                        BibTeX citation tags are uniformly chosen as
%%%                        name:year:abbrev, where name is the family
%%%                        name of the first author or editor, year is a
%%%                        4-digit number, and abbrev is a 3-letter
%%%                        condensation of important title
%%%                        words. Citation tags were automatically
%%%                        generated by software developed for the
%%%                        BibNet Project.
%%%
%%%                        In this bibliography, entries are sorted
%%%                        first by ascending year, and within each
%%%                        year, alphabetically by author or editor, and
%%%                        then, if necessary, by the 3-letter
%%%                        abbreviation at the end of the BibTeX
%%%                        citation tag, using the bibsort -byyear
%%%                        utility.  Year order has been chosen to make
%%%                        it easier to identify the most recent work.
%%%
%%%                        The checksum field above contains a CRC-16
%%%                        checksum as the first value, followed by the
%%%                        equivalent of the standard UNIX wc (word
%%%                        count) utility output of lines, words, and
%%%                        characters.  This is produced by Robert
%%%                        Solovay's checksum utility.",
%%%  }
%%% ====================================================================
@Preamble{
  "\hyphenation{
    Ath-ina
    Aus-tin
    Bang-ert
    Gauch-er-and
    Krzysz-tof
    Pat-rick
    Szym-kat
    Tag-li-ani
  }" #
  "\ifx \undefined \booktitle \def \booktitle #1{{{\em #1}}} \fi" #
  "\ifx \undefined \circled   \def \circled #1{(#1)}\fi" #
  "\ifx \undefined \cprime    \def \cprime {$\mathsurround=0pt '$}\fi" #
  "\ifx \undefined \mathbb    \def \mathbb #1{{\bf #1}}\fi" #
  "\ifx \undefined \ocirc     \def \ocirc #1{{\accent'27#1}}\fi" #
  "\ifx \undefined \pkg       \def \pkg #1{{{\tt #1}}} \fi" #
  "\ifx \undefined \reg       \def \reg {\circled{R}}\fi" #
  "\ifx \undefined \TM        \def \TM {${}^{\sc TM}$} \fi" #
  "\def \toenglish #1\endtoenglish{[{\em English\/}: #1\unskip]} "
}

%%% ====================================================================
%%% Acknowledgement abbreviations:
@String{ack-nhfb = "Nelson H. F. Beebe,
                    University of Utah,
                    Department of Mathematics, 110 LCB,
                    155 S 1400 E RM 233,
                    Salt Lake City, UT 84112-0090, USA,
                    Tel: +1 801 581 5254,
                    FAX: +1 801 581 4148,
                    e-mail: \path|beebe@math.utah.edu|,
                            \path|beebe@acm.org|,
                            \path|beebe@computer.org| (Internet),
                    URL: \path|http://www.math.utah.edu/~beebe/|"}

@String{ack-njh =   "Nick Higham,
                    e-mail: \path|higham@vtx.ma.man.ac.uk|"}

%%% ====================================================================
%%% Institution abbreviations:
@String{inst-CSC                = "Center for Scientific Computing,
                                  Department of Mathematics, University of
                                  Utah"}
@String{inst-CSC:adr            = "Salt Lake City, UT 84112, USA"}

@String{inst-MATHWORKS          = "The MathWorks, Inc."}
@String{inst-MATHWORKS:adr      = "3 Apple Hill Drive, Natick, MA 01760-2098,
                                  USA"}

@String{inst-NPL                = "National Physical Laboratory"}
@String{inst-NPL:adr            = "Teddington, Middlesex TW11 0LW, UK"}

@String{inst-U-MANCHESTER       = "University of Manchester"}
@String{inst-U-MANCHESTER:adr   = "Manchester M13 9PL, England"}

@String{inst-MCCM               = "Manchester Centre for Computational Mathematics"}
@String{inst-MCCM:adr           = "Manchester, England"}

%%% ====================================================================
%%% Journal abbreviations:
@String{j-ACM-COMM-COMP-ALGEBRA = "ACM Communications in Computer Algebra"}

@String{j-ADV-ENG-SOFTWARE      = "Advances in Engineering Software"}

@String{j-BIOINFORMATICS        = "Bioinformatics"}

@String{j-COMP-ECONOMICS        = "Computational Economics"}

@String{j-COMP-PHYS-COMM        = "Computer Physics Communications"}

@String{j-COMP-SCI-REV          = "Computer Science Review"}

@String{j-COMPUT-MATH-APPL      = "Computers and Mathematics with Applications"}

@String{j-COMPUT-METH-PROG-BIOMED = "Computer Methods and Programs in
                                  Biomedicine"}

@String{j-COMPUT-SOFTW-BIG-SCI  = "Computing and Software for Big Science"}

@String{j-IEEE-TRANS-PAR-DIST-SYS = "IEEE Transactions on Parallel and
                                    Distributed Systems"}

@String{j-IEEE-TRANS-SOFTW-ENG  = "IEEE Transactions on Software Engineering"}

@String{j-INFORMS-J-COMPUT      = "INFORMS Journal on Computing"}

@String{j-INT-STAT-REV          = "International Statistical Review =
                                   Revue Internationale de Statistique"}

@String{j-J-OPEN-RES-SOFT       = "Journal of Open Research Software"}

@String{j-J-OPEN-SOURCE-SOFT    = "Journal of Open Source Software"}

@String{j-J-PAR-DIST-COMP       = "Journal of Parallel and Distributed
                                  Computing"}

@String{j-J-RES-NATL-INST-STAND-TECHNOL = "Journal of research of the National
                                  Institute of Standards and Technology"}

@String{j-PACMPL                = "Proceedings of the ACM on Programming
                                   Languages (PACMPL)"}

@String{j-PLOS-ONE              = "PLoS One"}

@String{j-SIAM-J-SCI-COMP       = "SIAM Journal on Scientific Computing"}

@String{j-SIAM-REVIEW           = "SIAM Review"}

@String{j-SOFTWAREX             = "SoftwareX"}

@String{j-TOMS                  = "ACM Transactions on Mathematical Software"}

%%% ====================================================================
%%% Publisher abbreviations:
@String{pub-ACADEMIC            = "Academic Press"}
@String{pub-ACADEMIC:adr        = "New York, USA"}

@String{pub-ACM                 = "ACM Press"}
@String{pub-ACM:adr             = "New York, NY 10036, USA"}

@String{pub-APRESS              = "Apress"}
@String{pub-APRESS:adr          = "Berkeley, CA, USA"}

@String{pub-IEEE                = "IEEE Computer Society Press"}
@String{pub-IEEE:adr            = "1109 Spring Street, Suite 300,
                                  Silver Spring, MD 20910, USA"}

@String{pub-ORA-MEDIA           = "O'Reilly Media, Inc."}
@String{pub-ORA-MEDIA:adr       = "1005 Gravenstein Highway North,
                                   Sebastopol, CA 95472, USA"}

@String{pub-PACKT               = "Packt Publishing"}
@String{pub-PACKT:adr           = "Birmingham, UK"}

@String{pub-SV                  = "Spring{\-}er-Ver{\-}lag"}
@String{pub-SV:adr              = "Berlin, Germany~/ Heidelberg,
                                  Germany~/ London, UK~/ etc."}

%%% ====================================================================
%%% Series abbreviations:
@String{ser-LNCS                = "Lecture Notes in Computer Science"}

%%% ====================================================================
%%% Bibliography entries, sorted by year, and then by citation label,
%%% with ``bibsort -byyear'':
@Article{Bezanson:2012:JFD,
  author =       "Jeff Bezanson and Stefan Karpinski and Viral B. Shah
                 and Alan Edelman",
  title =        "{Julia}: a Fast Dynamic Language for Technical
                 Computing",
  journal =      "arXiv.org",
  volume =       "??",
  number =       "??",
  pages =        "1--27",
  day =          "25",
  month =        sep,
  year =         "2012",
  bibdate =      "Thu Apr 08 07:54:32 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://arxiv.org/abs/1209.5145;
                 https://arxiv.org/pdf/1209.5145.pdf",
  abstract =     "Dynamic languages have become popular for scientific
                 computing. They are generally considered highly
                 productive, but lacking in performance. This paper
                 presents Julia, a new dynamic language for technical
                 computing, designed for performance from the beginning
                 by adapting and extending modern programming language
                 techniques. A design based on generic functions and a
                 rich type system simultaneously enables an expressive
                 programming model and successful type inference,
                 leading to good performance for a wide range of
                 programs. This makes it possible for much of the Julia
                 library to be written in Julia itself, while also
                 incorporating best-of-breed C and Fortran libraries.",
  acknowledgement = ack-nhfb,
}

@InProceedings{Bezanson:2014:AOU,
  author =       "Jeff Bezanson and Jiahao Chen and Stefan Karpinski and
                 Viral Shah and Alan Edelman",
  booktitle =    "{Proceedings of ACM SIGPLAN International Workshop on
                 Libraries, Languages, and Compilers for Array
                 Programming}",
  title =        "Array Operators Using Multiple Dispatch",
  publisher =    pub-ACM,
  address =      pub-ACM:adr,
  month =        jun,
  year =         "2014",
  DOI =          "https://doi.org/10.1145/2627373.2627383",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Chen:2014:PPP,
  author =       "J. Chen and A. Edelman",
  booktitle =    "{2014 First Workshop for High Performance Technical
                 Computing in Dynamic Languages}",
  title =        "Parallel Prefix Polymorphism Permits Parallelization,
                 Presentation Proof",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "47--56",
  year =         "2014",
  DOI =          "https://doi.org/10.1109/HPTCDL.2014.9",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Knopp:2014:EMT,
  author =       "T. Knopp",
  booktitle =    "{2014 First Workshop for High Performance Technical
                 Computing in Dynamic Languages}",
  title =        "Experimental Multi-threading Support for the {Julia}
                 Programming Language",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--5",
  year =         "2014",
  DOI =          "https://doi.org/10.1109/HPTCDL.2014.11",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Olver:2014:PFI,
  author =       "S. Olver and A. Townsend",
  booktitle =    "{2014 First Workshop for High Performance Technical
                 Computing in Dynamic Languages}",
  title =        "A Practical Framework for Infinite-Dimensional Linear
                 Algebra",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "57--62",
  year =         "2014",
  DOI =          "https://doi.org/10.1109/HPTCDL.2014.10",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Udell:2014:COJ,
  author =       "M. Udell and K. Mohan and D. Zeng and J. Hong and S.
                 Diamond and S. Boyd",
  booktitle =    "{2014 First Workshop for High Performance Technical
                 Computing in Dynamic Languages}",
  title =        "Convex Optimization in {Julia}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "18--28",
  year =         "2014",
  DOI =          "https://doi.org/10.1109/HPTCDL.2014.5",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Balbaert:2015:GSJ,
  editor =       "Ivo Balbaert and Kevin Colaco and Neeshma Ramakrishnan
                 and Rashmi Sawant",
  title =        "Getting started with {Julia} programming: enter the
                 exciting world of {Julia}, a high-performance language
                 for technical computing",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "214",
  year =         "2015",
  ISBN =         "1-78328-479-X, 1-78328-480-3 (e-book)",
  ISBN-13 =      "978-1-78328-479-5, 978-1-78328-480-1 (e-book)",
  LCCN =         "QA297 .B353 2015eb",
  bibdate =      "Thu Apr 8 10:48:12 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  series =       "Community Experience Distilled",
  URL =          "http://public.ebookcentral.proquest.com/choice/publicfullrecord.aspx?p=1973847;
                 http://site.ebrary.com/id/11025933;
                 http://www.vlebooks.com/vleweb/product/openreader?id=none\%26isbn=9781783284801",
  abstract =     "This book is for you if you are a data scientist or
                 working on any technical or scientific computation
                 projects. The book assumes you have a basic working
                 knowledge of high-level dynamic languages such as
                 MATLAB, R, Python, or Ruby.",
  acknowledgement = ack-nhfb,
  subject =      "Numerical analysis; Computer programs; Mathematical
                 analysis; Reference; Questions and Answers; Computer
                 programs.",
  tableofcontents = "Preface \\
                 The Rationale for Julia \\
                 1: Installing the Julia Platform \\
                 Installing Julia \\
                 Windows version \\
                 usable from Windows XP SP2 onwards \\
                 Ubuntu version \\
                 OS X \\
                 Building from source \\
                 Working with Julia's shell \\
                 Startup options and Julia scripts \\
                 Packages \\
                 Adding a new package \\
                 Installing and working with Julia Studio \\
                 Installing and working with IJulia \\
                 Installing Sublime-IJulia \\
                 Installing Juno \\
                 Other editors and IDEs \\
                 How Julia works \\
                 Summary \\
                 2: Variables, Types, and Operations \\
                 Variables, naming conventions, and comments \\
                 Types \\
                 Integers \\
                 Floating point numbers \\
                 Elementary mathematical functions and operations \\
                 Rational and complex numbers \\
                 Characters \\
                 Strings \\
                 Formatting numbers and strings \\
                 Regular expressions \\
                 Ranges and arrays \\
                 Other ways to create arrays \\
                 Some common functions for arrays \\
                 How to convert an array of chars to a string \\
                 Dates and times \\
                 Scope and constants \\
                 Summary \\
                 3: Functions \\
                 Defining functions \\
                 Optional and keyword arguments \\
                 Anonymous functions \\
                 First-class functions and closures \\
                 Recursive functions \\
                 Map, filter, and list comprehensions \\
                 Generic functions and multiple dispatch \\
                 Summary \\
                 4: Control Flow \\
                 Conditional evaluation \\
                 Repeated evaluation \\
                 The for loop \\
                 The while loop \\
                 The break statement \\
                 The continue statement \\
                 Exception handling \\
                 Scope revisited \\
                 Tasks \\
                 Summary \\
                 5: Collection Types \\
                 Matrices \\
                 Tuples \\
                 Dictionaries \\
                 Keys and values \\
                 looping \\
                 Sets \\
                 Making a set of tuples \\
                 Example project \\
                 word frequency \\
                 Summary \\
                 6: More on Types, Methods, and Modules \\
                 Type annotations and conversions \\
                 Type conversions and promotions \\
                 The type hierarchy \\
                 subtypes and supertypes \\
                 Concrete and abstract types \\
                 User-defined and composite types \\
                 When are two values or objects equal or identical? \\
                 Multiple dispatch example \\
                 Types and collections \\
                 inner constructors \\
                 Type unions \\
                 Parametric types and methods \\
                 Standard modules and paths \\
                 Summary \\
                 7: Metaprogramming in Julia \\
                 Expressions and symbols \\
                 Eval and interpolation \\
                 Defining macros \\
                 Built-in macros \\
                 Testing \\
                 Debugging \\
                 Benchmarking \\
                 Starting a task \\
                 Reflection capabilities \\
                 Summary \\
                 8: I/O, Networking, and Parallel Computing \\
                 Basic input and output \\
                 Working with files \\
                 Reading and writing CSV files \\
                 Using DataFrames \\
                 Other file formats \\
                 Working with TCP sockets and servers \\
                 Interacting with databases \\
                 Parallel operations and computing \\
                 Creating processes \\
                 Using low-level communications \\
                 Parallel loops and maps \\
                 Distributed arrays \\
                 Summary \\
                 9: Running External Programs \\
                 Running shell commands \\
                 Interpolation \\
                 Pipelining \\
                 Calling C and FORTRAN \\
                 Calling Python \\
                 Performance tips \\
                 Tools to use \\
                 Summary \\
                 10: The Standard Library and Packages \\
                 Digging deeper into the standard library \\
                 Julia's package manager",
}

@InProceedings{Dogaru:2015:UPJ,
  author =       "I. Dogaru and R. Dogaru",
  booktitle =    "{2015 20th International Conference on Control Systems
                 and Computer Science}",
  title =        "Using {Python} and {Julia} for Efficient
                 Implementation of Natural Computing and Complexity
                 Related Algorithms",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "599--604",
  year =         "2015",
  DOI =          "https://doi.org/10.1109/CSCS.2015.37",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Edelman:2015:JFA,
  author =       "A. Edelman",
  booktitle =    "{2015 IEEE International Parallel and Distributed
                 Processing Symposium}",
  title =        "{Julia}: a fresh approach to parallel programming",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "517--517",
  year =         "2015",
  DOI =          "https://doi.org/10.1109/IPDPS.2015.122",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Edelman:2015:JI,
  author =       "A. Edelman",
  booktitle =    "{2015 IEEE International Parallel and Distributed
                 Processing Symposium Workshop}",
  title =        "{Julia} Introduction",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1271--1271",
  year =         "2015",
  DOI =          "https://doi.org/10.1109/IPDPSW.2015.181",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Lubin:2015:COR,
  author =       "Miles Lubin and Iain Dunning",
  title =        "Computing in Operations Research Using {Julia}",
  journal =      j-INFORMS-J-COMPUT,
  volume =       "27",
  number =       "2",
  pages =        "238--248",
  month =        "Spring",
  year =         "2015",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1287/ijoc.2014.0623",
  ISSN =         "1091-9856 (print), 1526-5528 (electronic)",
  ISSN-L =       "1091-9856",
  MRclass =      "68N15 (90-04)",
  MRnumber =     "3347876",
  bibdate =      "Mon Apr 9 08:21:37 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/informs-j-comput.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://pubsonline.informs.org/doi/abs/10.1287/ijoc.2014.0623",
  acknowledgement = ack-nhfb,
  ajournal =     "INFORMS J. Comput.",
  fjournal =     "INFORMS Journal on Computing",
  journal-URL =  "https://pubsonline.informs.org/journal/ijoc",
  keywords =     "Julia programming language",
  onlinedate =   "March 16, 2015",
}

@InProceedings{Ovsyak:2015:AMA,
  author =       "V. Ovsyak and O. Ovsyak and D. Bui and J. Petruszka",
  booktitle =    "{2015 IEEE 13th International Scientific Conference on
                 Informatics}",
  title =        "Algebraic models of application of computer systems
                 and information technologies",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "189--194",
  year =         "2015",
  DOI =          "https://doi.org/10.1109/Informatics.2015.7377831",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Przigoda:2015:VDD,
  author =       "N. Przigoda and J. Stoppe and J. Seiter and R. Wille
                 and R. Drechsler",
  booktitle =    "{2015 Euromicro Conference on Digital System Design}",
  title =        "Verification-Driven Design Across Abstraction Levels:
                 a Case Study",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "375--382",
  year =         "2015",
  DOI =          "https://doi.org/10.1109/DSD.2015.88",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Sherrington:2015:MJD,
  author =       "Malcolm Sherrington",
  title =        "Mastering {Julia}: develop your analytical and
                 programming skills further in {Julia} to solve complex
                 data processing problems",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "xiv + 385",
  year =         "2015",
  ISBN =         "1-78355-331-6 (paperback), 1-78355-332-4 (e-book)",
  ISBN-13 =      "978-1-78355-331-0 (paperback), 978-1-78355-332-7
                 (e-book)",
  LCCN =         "QA76.7 .S547 2015; QA76.73.J8 S54 2015",
  bibdate =      "Thu Apr 8 10:58:21 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  abstract =     "This hands-on guide is aimed at practitioners of data
                 science. The book assumes some previous skills with
                 Julia and skills in coding in a scripting language such
                 as Python or R, or a compiled language such as C or
                 Java.",
  acknowledgement = ack-nhfb,
  tableofcontents = "Preface \\
                 1: The Julia Environment \\
                 Introduction \\
                 Philosophy \\
                 Role in data science and big data \\
                 Comparison with other languages \\
                 Features \\
                 Getting started \\
                 Julia sources \\
                 Building from source \\
                 Installing on CentOS \\
                 Mac OS X and Windows \\
                 Exploring the source stack \\
                 Juno \\
                 IJulia \\
                 A quick look at some Julia \\
                 Julia via the console \\
                 Installing some packages \\
                 A bit of graphics creating more realistic graphics with
                 Winston \\
                 My benchmarks \\
                 Package management \\
                 Listing, adding, and removing \\
                 Choosing and exploring packages \\
                 Statistics and mathematics \\
                 Graphics \\
                 Web and networking \\
                 Database and specialist packages \\
                 How to uninstall Julia \\
                 Adding an unregistered package \\
                 What makes Julia special \\
                 Parallel processing \\
                 Multiple dispatch \\
                 Homoiconic macros \\
                 Interlanguage cooperation \\
                 Summary \\
                 2: Developing in Julia \\
                 Integers, bits, bytes, and bools \\
                 Integers \\
                 Logical and arithmetic operators \\
                 Booleans \\
                 Arrays \\
                 Operations on matrices \\
                 Elemental operations \\
                 A simple Markov chain \\
                 cat and mouse \\
                 Char and strings \\
                 Characters \\
                 Strings \\
                 Unicode support \\
                 Regular expressions \\
                 Byte array literals \\
                 Version literals \\
                 An example \\
                 Real, complex, and rational numbers \\
                 Reals \\
                 Operators and built-in functions \\
                 Special values \\
                 BigFloats \\
                 Rationals \\
                 Complex numbers \\
                 Juliasets \\
                 Composite types \\
                 More about matrices \\
                 Vectorized and devectorized code \\
                 Multidimensional arrays \\
                 Broadcasting \\
                 Sparse matrices \\
                 Data arrays and data frames \\
                 Dictionaries, sets, and others \\
                 Dictionaries \\
                 Sets \\
                 Other data structures \\
                 Summary \\
                 3: Types and Dispatch \\
                 Functions \\
                 First-class objects \\
                 Passing arguments \\
                 Default and optional arguments \\
                 Variable argument list \\
                 Named parameters \\
                 Scope \\
                 The Queen's problem \\
                 Julia's type system \\
                 A look at the rational type \\
                 A vehicle datatype \\
                 Typealias and unions \\
                 Enumerations (revisited) \\
                 Multiple dispatch \\
                 Parametric types \\
                 Conversion and promotion \\
                 Conversion \\
                 Promotion \\
                 A fixed vector module \\
                 Summary \\
                 4: Interoperability \\
                 Interfacing with other programming environments \\
                 Calling C and Fortran \\
                 Mapping C types \\
                 Calling a Fortran routine \\
                 Calling curl to retrieve a web page \\
                 Python \\
                 Some others to watch \\
                 The Julia API \\
                 Calling API from C \\
                 Metaprogramming \\
                 Symbols \\
                 Macros \\
                 Testing \\
                 Error handling \\
                 The enum macro \\
                 Tasks \\
                 Parallel operations \\
                 Distributed arrays \\
                 A simple MapReduce \\
                 Executing commands \\
                 Running commands \\
                 Working with the filesystem \\
                 Redirection and pipes \\
                 Perl one-liners \\
                 Summary \\
                 5: Working with Data \\
                 Basic I/O \\
                 Terminal I/O \\
                 Disk files \\
                 Text processing \\
                 Binary files \\
                 Structured datasets \\
                 CSV and DLM files \\
                 HDF5 \\
                 XML files \\
                 DataFrames and RDatasets \\
                 The DataFrames package \\
                 DataFrames \\
                 RDatasets \\
                 Subsetting, sorting, and joining data \\
                 Statistics \\
                 Simple statistics \\
                 Samples and estimations \\
                 Pandas \\
                 Selected topics \\
                 Time series \\
                 Distributions \\
                 Kernel density \\
                 Hypothesis testing \\
                 GLM \\
                 Summary",
}

@Book{Balbaert:2016:JHP,
  author =       "Ivo Balbaert and Avik Sengupta and Malcolm
                 Sherrington",
  title =        "{Julia}: high performance programming: learning path:
                 leverage the power of {Julia} to design and develop
                 high performing programs",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "697",
  year =         "2016",
  ISBN =         "1-78712-570-X, 1-78712-610-2 (e-book)",
  ISBN-13 =      "978-1-78712-570-4, 978-1-78712-610-7 (e-book)",
  LCCN =         "QA76.7 .B353 2016",
  bibdate =      "Thu Apr 8 16:55:30 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  series =       "Learning path",
  abstract =     "Leverage the power of Julia to design and develop high
                 performing programs About This Book Get to know the
                 best techniques to create blazingly fast programs with
                 Julia Stand out from the crowd by developing code that
                 runs faster than your peers' code Complete an extensive
                 data science project through the entire cycle from ETL
                 to analytics and data visualization Who This Book Is
                 For This learning path is for data scientists and for
                 all those who work in technical and scientific
                 computation projects. It will be great for Julia
                 developers who are interested in high-performance
                 technical computing. This learning path assumes that
                 you already have some basic working knowledge of
                 Julia's syntax and high-level dynamic languages such as
                 MATLAB, R, Python, or Ruby. What You Will Learn Set up
                 your Julia environment to achieve the highest
                 productivity Solve your tasks in a high-level dynamic
                 language and use types for your data only when needed
                 Apply Julia to tackle problems concurrently and in a
                 distributed environment Get a sense of the
                 possibilities and limitations of Julia's performance
                 Use Julia arrays to write high performance code Build a
                 data science project through the entire cycle of ETL,
                 analytics, and data visualization Display graphics and
                 visualizations to carry out modeling and simulation in
                 Julia Develop your own packages and contribute to the
                 Julia Community In Detail In this learning path, you
                 will learn to use an interesting and dynamic
                 programming language - Julia! You will get a chance to
                 tackle your numerical and data problems with Julia.
                 You'll begin the journey by setting up a running Julia
                 platform before exploring its various built-in types.
                 We'll then move on to the various functions and
                 constructs in Julia. We'll walk through the two
                 important collection types - arrays and matrices in
                 Julia. You will dive into how Julia uses type
                 information to achieve its performance goals, and how
                 to use multiple dispatch to help the compiler emit high
                 performance machine code. You will see how Julia's
                 design makes code fast, and you'll see its distributed
                 computing capabilities. By the end of this learning
                 path, you will see how data works using simple
                 statistics and analytics, and you'll discover its high
                 and dynamic performance - its real strength, which
                 makes it particularly useful in highly intensive
                 computing tasks. This learning path combines some of
                 the best that Packt has to offer in one complete,
                 curated package.",
  acknowledgement = ack-nhfb,
  keywords =     "Closures and anonymous functions.",
  subject =      "Programming languages; Julia; Computer programming;
                 COMPUTERS; General.; Computer programming.",
  tableofcontents = "Preface \\
                 Table of Contents \\
                 Module 1: Getting Started with Julia \\
                 The Rationale for Julia \\
                 The scope of Julia \\
                 Julia's place among the other programming languages \\
                 A comparison with other languages for the data
                 scientist \\
                 Useful links \\
                 Summary \\
                 1: Installing the Julia Platform \\
                 Installing Julia \\
                 Working with Julia's shell \\
                 Startup options and Julia scripts \\
                 Packages \\
                 Installing and working with Julia Studio \\
                 Installing and working with IJulia \\
                 Installing Sublime-IJulia \\
                 Installing Juno \\
                 Other editors and IDEs \\
                 How Julia works \\
                 Summary \\
                 2: Variables, Types, and Operations \\
                 Variables, naming conventions, and comments \\
                 Types \\
                 Integers \\
                 Floating point numbers \\
                 Elementary mathematical functions and operations \\
                 Rational and complex numbers \\
                 Characters \\
                 Strings \\
                 Regular expressions \\
                 Ranges and arrays \\
                 Dates and times \\
                 Scope and constants \\
                 Summary \\
                 3: Functions \\
                 Defining functions \\
                 Optional and keyword arguments \\
                 Anonymous functions \\
                 First-class functions and closures \\
                 Recursive functions \\
                 Map, filter, and list comprehensions \\
                 Generic functions and multiple dispatch \\
                 Summary \\
                 4: Control Flow \\
                 Conditional evaluation \\
                 Repeated evaluation \\
                 Exception handling \\
                 Scope revisited \\
                 Tasks \\
                 Summary \\
                 5: Collection Types \\
                 Matrices \\
                 Tuples \\
                 Dictionaries \\
                 Sets \\
                 Example project \\
                 word frequency \\
                 Summary \\
                 6: More on Types, Methods, and Modules \\
                 Type annotations and conversions \\
                 The type hierarchy \\
                 subtypes and supertypes \\
                 User-defined and composite types \\
                 Types and collections \\
                 inner constructors \\
                 Type unions \\
                 Parametric types and methods \\
                 Standard modules and paths \\
                 Summary \\
                 7: Metaprogramming in Julia \\
                 Expressions and symbols \\
                 Eval and interpolation \\
                 Defining macros \\
                 Built-in macros \\
                 Reflection capabilities \\
                 Summary \\
                 8: I/O, Networking, and Parallel Computing \\
                 Basic input and output \\
                 Working with files \\
                 Using DataFrames \\
                 Working with TCP sockets and servers \\
                 Interacting with databases \\
                 Parallel operations and computing \\
                 Summary \\
                 9: Running External Programs \\
                 Running shell commands \\
                 Calling C and FORTRAN \\
                 Calling Python \\
                 Performance tips \\
                 Summary \\
                 10: The Standard Library and Packages \\
                 Digging deeper into the standard library \\
                 Julia's package manager \\
                 Publishing a package \\
                 Graphics in Julia \\
                 Using Gadfly on data \\
                 Summary \\
                 Appendix: List of Macros and Packages \\
                 Macros \\
                 List of packages \\
                 Module 2: Julia High Performance \\
                 1: Julia is Fast \\
                 Julia \\
                 fast and dynamic \\
                 Designed for speed \\
                 How fast can Julia be? \\
                 Summary \\
                 2: Analyzing Julia Performance \\
                 Timing Julia code \\
                 The Julia profiler \\
                 Analyzing memory allocation \\
                 Statistically accurate benchmarking \\
                 Summary \\
                 3: Types in Julia \\
                 The Julia type system \\
                 Type-stability \\
                 Kernel methods \\
                 Types in storage locations \\
                 Summary \\
                 4: Functions and Macros \\
                 Structuring Julia Code for High Performance \\
                 Using globals \\
                 Inlining",
}

@InCollection{Bohm:2016:BPC,
  author =       "Janko B{\"o}hm and Wolfram Decker and Claus Fieker and
                 Santiago Laplagne and Gerhard Pfister",
  booktitle =    "{Mathematical Software --- ICMS 2016}",
  title =        "Bad Primes in Computational Algebraic Geometry",
  publisher =    "Springer International Publishing",
  address =      "Cham, Switzerland",
  pages =        "93--101",
  year =         "2016",
  DOI =          "https://doi.org/10.1007/978-3-319-42432-3_12",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Chan:2016:PAB,
  author =       "Jose Juan Mijares Chan and Yuyin Mao and Ying Ying Liu
                 and Parimala Thulasiraman and Ruppa K. Thulasiram",
  booktitle =    "{Parallel Processing and Applied Mathematics}",
  title =        "Parallel Ant Brood Graph Partitioning in {Julia}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2016",
  DOI =          "https://doi.org/10.1007/978-3-319-32152-3_17",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-319-32152-3_17",
  acknowledgement = ack-nhfb,
}

@InProceedings{Chen:2016:JID,
  author =       "Alexander Chen and Alan Edelman and Jeremy Kepner and
                 Vijay Gadepally and Dylan Hutchison",
  booktitle =    "{2016 IEEE High Performance Extreme Computing
                 Conference (HPEC)}",
  title =        "{Julia} implementation of the {Dynamic Distributed
                 Dimensional Data Model}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--7",
  month =        sep,
  year =         "2016",
  DOI =          "https://doi.org/10.1109/hpec.2016.7761626",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Creel:2016:NJM,
  author =       "Michael Creel",
  title =        "A Note on {Julia} and {MPI}, with Code Examples",
  journal =      j-COMP-ECONOMICS,
  volume =       "48",
  number =       "3",
  pages =        "??--??",
  month =        "",
  year =         "2016",
  CODEN =        "CNOMEL",
  DOI =          "https://doi.org/10.1007/s10614-015-9516-5",
  ISSN =         "",
  ISSN-L =       "0927-7099",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/pvm.bib",
  URL =          "http://link.springer.com/article/10.1007/s10614-015-9516-5",
  acknowledgement = ack-nhfb,
  fjournal =     "Computational Economics",
}

@InProceedings{Elmqvist:2016:SMP,
  author =       "Hilding Elmqvist and Toivo Henningsson and Martin
                 Otter",
  booktitle =    "{Leveraging Applications of Formal Methods,
                 Verification and Validation: Discussion, Dissemination,
                 Applications}",
  title =        "Systems Modeling and Programming in a Unified
                 Environment Based on {Julia}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "198--217",
  year =         "2016",
  DOI =          "https://doi.org/10.1007/978-3-319-47169-3_15",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-319-47169-3_15",
  acknowledgement = ack-nhfb,
}

@InProceedings{Fourie:2016:NBS,
  author =       "D. Fourie and J. Leonard and M. Kaess",
  booktitle =    "{2016 IEEE/RSJ International Conference on Intelligent
                 Robots and Systems (IROS)}",
  title =        "A nonparametric belief solution to the {Bayes} tree",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "2189--2196",
  year =         "2016",
  DOI =          "https://doi.org/10.1109/IROS.2016.7759343",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Frost:2016:PGJ,
  author =       "Simon D. W. Frost",
  title =        "\pkg{Gillespie.jl}: Stochastic Simulation Algorithm in
                 {Julia}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "1",
  number =       "3",
  pages =        "42:1--42:1",
  month =        jul,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00042",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00042",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "30 July 2016",
  ORCID-numbers = "Simon DW Frost / 0000-0002-5207-9879",
}

@Article{Gonzalez:2016:CMC,
  author =       "J. D. Gonzalez and E. F. Lavia and S. Blanc",
  title =        "A Computational Method to Calculate the Exact Solution
                 for Acoustic Scattering by Fluid Spheroids",
  journal =      "{Acta Acustica} united with {Acustica}",
  volume =       "102",
  number =       "6",
  pages =        "1061--1071",
  month =        nov,
  year =         "2016",
  DOI =          "https://doi.org/10.3813/aaa.919019",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Joshi:2016:JDS,
  author =       "Anshul Joshi",
  title =        "{Julia} for data science: explore the world of data
                 science from scratch with {Julia} by your side",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "339",
  year =         "2016",
  ISBN =         "1-78355-386-3 (e-book), 1-78528-969-1",
  ISBN-13 =      "978-1-78355-386-0 (e-book), 978-1-78528-969-9",
  LCCN =         "QA76.73.J8; T55.4-60.8",
  bibdate =      "Fri Apr 9 05:20:49 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  abstract =     "Explore the world of data science from scratch with
                 Julia by your side About This Book An in-depth
                 exploration of Julia's growing ecosystem of packages
                 Work with the most powerful open-source libraries for
                 deep learning, data wrangling, and data visualization
                 Learn about deep learning using \pkg{Mocha.jl} and give
                 speed and high performance to data analysis on large
                 data sets Who This Book Is For This book is aimed at
                 data analysts and aspiring data scientists who have a
                 basic knowledge of Julia or are completely new to it.
                 The book also appeals to those competent in R and
                 Python and wish to adopt Julia to improve their skills
                 set in Data Science. It would be beneficial if the
                 readers have a good background in statistics and
                 computational mathematics. What You Will Learn Apply
                 statistical models in Julia for data-driven decisions
                 Understanding the process of data munging and data
                 preparation using Julia Explore techniques to visualize
                 data using Julia and D3 based packages Using Julia to
                 create self-learning systems using cutting edge machine
                 learning algorithms Create supervised and unsupervised
                 machine learning systems using Julia. Also, explore
                 ensemble models Build a recommendation engine in Julia
                 Dive into Julia's deep learning framework and build a
                 system using Mocha.jl In Detail Julia is a fast and
                 high performing language that's perfectly suited to
                 data science with a mature package ecosystem and is now
                 feature complete. It is a good tool for a data science
                 practitioner. There was a famous post at Harvard
                 Business Review that Data Scientist is the sexiest job
                 of the 21st century.
                 (https://hbr.org/2012/10/data-scientist-the-sexiest-job-of-the-21st-century).
                 This book will help you get familiarised with Julia's
                 rich ecosystem, which is continuously evolving,
                 allowing you to stay on top of your game. This book
                 contains the essentials of data science and gives a
                 high-level overview of advanced statistics and
                 techniques. You will dive in and will work on
                 generating insights by performing inferential
                 statistics, and will reveal hidden patterns and trends
                 using data mining. This has the practical coverage of
                 statistics and machine learning. You will develop
                 knowledge to build statistical models and machine
                 learning systems in Julia with attractive
                 visualizations. You will then delve into the world of
                 Deep learning in Julia and will understand the
                 framework, \pkg{Mocha.jl} with which you can create
                 artificial neural networks and implement deep
                 learning.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Data structures
                 (Computer science); Information visualization;
                 COMPUTERS / Data Modeling and Design; Data structures
                 (Computer science); Information visualization; Julia
                 (Computer program language)",
  tableofcontents = "Preface \\
                 1: The Groundwork \\
                 Julia's Environment \\
                 Julia is different \\
                 Setting up the environment \\
                 Installing Julia (Linux) \\
                 Installing Julia (Mac) \\
                 Installing Julia (Windows) \\
                 Exploring the source code \\
                 Using REPL \\
                 Using Jupyter Notebook \\
                 Package management \\
                 Pkg.status() \\
                 package status \\
                 Pkg.add() -{\`E}adding packages \\
                 Working with unregistered packages \\
                 Pkg.update() -{\`E}package update \\
                 METADATA repository \\
                 Developing packages \\
                 Creating a new package \\
                 Parallel computation using Julia \\
                 Julia's key feature \\
                 multiple dispatch \\
                 Methods in multiple dispatch \\
                 Ambiguities \\
                 method definitions \\
                 Facilitating language interoperability \\
                 Calling Python code in Julia \\
                 Summary \\
                 References \\
                 2: Data Munging \\
                 What is data munging? \\
                 The data munging process \\
                 What is a DataFrame? \\
                 The NA data type and its importance \\
                 DataArray series-like data structure \\
                 DataFrames tabular data structures \\
                 Installation and using DataFrames.jl \\
                 Writing the data to a file \\
                 Working with DataFrames \\
                 Understanding DataFrames joins \\
                 The Split-Apply-Combine strategy \\
                 Reshaping the data \\
                 Sorting a datasetFormula \\
                 a special data type for mathematical expressions \\
                 Pooling data \\
                 Web scraping \\
                 Summary \\
                 References \\
                 3: Data Exploration \\
                 Sampling \\
                 Population \\
                 Weight vectors \\
                 Inferring column types \\
                 Basic statistical summaries \\
                 Calculating the mean of the array or dataframe \\
                 Scalar statistics \\
                 Standard deviations and variances \\
                 Measures of variation \\
                 Z-scores \\
                 Entropy \\
                 Quantiles \\
                 Modes \\
                 Summary of datasets \\
                 Scatter matrix and covariance \\
                 Computing deviations \\
                 Rankings \\
                 Counting functions \\
                 Histograms \\
                 Correlation analysis \\
                 Summary \\
                 References \\
                 4: Deep Dive into Inferential Statistics \\
                 Installation \\
                 Understanding the sampling distribution \\
                 Understanding the normal distribution \\
                 Parameter estimation \\
                 Type hierarchy in \pkg{Distributions.jl} \\
                 Understanding Sampleable \\
                 Representing probabilistic distributions \\
                 Univariate distributions \\
                 Retrieving parameters \\
                 Statistical functions \\
                 Evaluation of probability \\
                 Sampling in Univariate distributions \\
                 Understanding Discrete Univariate distributions and
                 types \\
                 Bernoulli distribution \\
                 Binomial distribution \\
                 Continuous distributions \\
                 Cauchy distribution \\
                 Chi distribution \\
                 Chi-square distribution \\
                 Truncated distributions \\
                 Truncated normal distributions \\
                 Understanding multivariate distributions \\
                 Multinomial distribution \\
                 Multivariate normal distribution \\
                 Dirichlet distribution \\
                 Understanding matrixvariate distributions \\
                 Wishart distribution \\
                 Inverse-Wishart distribution \\
                 Distribution fitting \\
                 Distribution selection \\
                 Symmetrical distributions \\
                 Skew distributions to the right \\
                 Skew distributions to the left \\
                 Maximum Likelihood Estimation \\
                 Sufficient statistics \\
                 Maximum-a-Posteriori estimation \\
                 Confidence interval \\
                 Interpreting the confidence intervals \\
                 Usage \\
                 Understanding z-score",
}

@Book{Kwon:2016:JPO,
  author =       "Changhyun Kwon",
  title =        "{Julia} programming for operations research: a primer
                 on computing",
  publisher =    "CreateSpace Independent Publishing Platform",
  address =      "North Charleston, SC, USA",
  pages =        "x + 236",
  year =         "2016",
  ISBN =         "1-5333-2879-X, 1-63462-196-4",
  ISBN-13 =      "978-1-5333-2879-3, 978-1-63462-196-0",
  LCCN =         "QA76.73.J85 K86 2016",
  bibdate =      "Thu Apr 8 16:52:30 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  abstract =     "This book is neither a textbook in numerical methods,
                 a comprehensive introductory book to Julia programming,
                 a textbook on numerical optimization, a complete manual
                 of optimization solvers, nor an introductory book to
                 computational science and engineering --- it is a
                 little bit of all.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Mathematical
                 models; Computer simulation; Julia (Computer program
                 language); Object-oriented programming (Computer
                 science); Computer simulation.; Dynamic programming.",
  tableofcontents = "1. Introduction and installation \\
                 2. Simple linear optimization \\
                 3. Basics of the Julia language \\
                 4. Selected topics in numerical methods \\
                 5. The simplex method \\
                 6. Network optimization problems \\
                 7. General optimization problems \\
                 8. Monte Carlo methods \\
                 9. Lagrangian relaxation \\
                 10. Parameters in optimization solvers \\
                 11. Useful and related packages",
}

@InProceedings{Maidens:2016:PDP,
  author =       "J. Maidens and A. Packard and M. Arcak",
  booktitle =    "{2016 IEEE 55th Conference on Decision and Control
                 (CDC)}",
  title =        "Parallel dynamic programming for optimal experiment
                 design in nonlinear systems",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "2894--2899",
  year =         "2016",
  DOI =          "https://doi.org/10.1109/CDC.2016.7798700w",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{OMalley:2016:TJH,
  author =       "D. O'Malley and V. V. Vesselinov",
  booktitle =    "{2016 IEEE High Performance Extreme Computing
                 Conference (HPEC)}",
  title =        "{ToQ.jl}: a high-level programming language for
                 {D-Wave} machines based on {Julia}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--7",
  year =         "2016",
  DOI =          "https://doi.org/10.1109/HPEC.2016.7761616",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Rohit:2016:JC,
  author =       "Jalem Raj Rohit",
  title =        "{Julia} Cookbook",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "v + 157",
  year =         "2016",
  ISBN =         "1-78588-201-5, 1-78588-363-1 (e-book)",
  ISBN-13 =      "978-1-78588-201-2, 978-1-78588-363-7 (e-book)",
  LCCN =         "QA76.73.J8; T55.4-60.8",
  bibdate =      "Thu Apr 8 11:05:21 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://sbiproxy.uqac.ca/login?url=https://international.scholarvox.com/book/88843406",
  abstract =     "Over 40 recipes to get you up and running with
                 programming using Julia. About This Book Follow a
                 practical approach to learn Julia programming the easy
                 way Get an extensive coverage of Julia's packages for
                 statistical analysis This recipe-based approach will
                 help you get familiar with the key concepts in Julia.
                 Who This Book Is For: This book is for data scientists
                 and data analysts who are familiar with the basics of
                 the Julia language. Prior experience of working with
                 high-level languages such as MATLAB, Python, R, or Ruby
                 is expected. What You Will Learn Extract and handle
                 your data with Julia Uncover the concepts of
                 metaprogramming in Julia Conduct statistical analysis
                 with \pkg{StatsBase.jl} and \pkg{Distributions.jl}.
                 Build your data science models Find out how to
                 visualize your data with Gadfly Explore big data
                 concepts in Julia. In Detail Want to handle everything
                 that Julia can throw at you and get the most of it
                 every day? This practical guide to programming with
                 Julia for performing numerical computation will make
                 you more productive and able work with data more
                 efficiently. The book starts with the main features of
                 Julia to help you quickly refresh your knowledge of
                 functions, modules, and arrays. We'll also show you how
                 to utilize the Julia language to identify, retrieve,
                 and transform data sets so you can perform data
                 analysis and data manipulation. Later on, you'll see
                 how to optimize data science programs with parallel
                 computing and memory allocation. You'll get familiar
                 with the concepts of package development and networking
                 to solve numerical problems using the Julia platform.
                 This book includes recipes on identifying and
                 classifying data science problems, data modelling, data
                 analysis, data manipulation, meta-programming,
                 multidimensional arrays, and parallel computing. By the
                 end of the book, you will acquire the skills to work
                 more effectively with your data. Style and approach
                 This book has a recipe-based approach to help you grasp
                 the concepts of Julia programming.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Programming
                 languages (Electronic computers); Julia (Computer
                 program language); Programming languages (Electronic
                 computers)",
  tableofcontents = "About the Author \\
                 About the Reviewer \\
                 www.PacktPub.com \\
                 Table of Contents \\
                 Preface \\
                 1: Extracting and Handling Data \\
                 Introduction \\
                 Why should we use Julia for data science? \\
                 Handling data with CSV files \\
                 Getting ready \\
                 How to do it and Handling data with TSV files \\
                 Getting ready \\
                 How to do it and Working with databases in Julia \\
                 Getting ready \\
                 How to do it and MySQL \\
                 PostgreSQL \\
                 There's more and MySQL \\
                 PostgreSQL \\
                 SQLite \\
                 Interacting with the Web \\
                 Getting ready \\
                 How to do it and GET request \\
                 There's more and \ldots{} \\
                 2: Metaprogramming \\
                 Introduction \\
                 Representation of a Julia program \\
                 Getting ready \\
                 How to do it and How it works \\
                 There's more \\
                 Symbols and expressions \\
                 Symbols \\
                 Getting ready \\
                 How to do it and How it works \\
                 There's more \\
                 Quoting \\
                 How to do it and How it works \\
                 Interpolation \\
                 How to do it and How it works \\
                 There's more \\
                 The Eval function \\
                 Getting ready \\
                 How to do it and How it works \\
                 Macros \\
                 Getting ready \\
                 How to do it and How it works \\
                 Metaprogramming with DataFrames \\
                 Getting ready \\
                 How to do it and How it works \\
                 3: Statistics with Julia \\
                 Introduction \\
                 Basic statistics concepts \\
                 Getting ready \\
                 How to do it and How it works \\
                 Descriptive statistics \\
                 Getting ready \\
                 How to do it and How it works \\
                 Deviation metrics \\
                 Getting ready \\
                 How to do it and How it works \\
                 Sampling \\
                 Getting ready \\
                 How to do it and How it works \\
                 Correlation analysis \\
                 Getting ready \\
                 How to do it and How it works \\
                 4: Building Data Science Models \\
                 Introduction \\
                 Dimensionality reduction \\
                 Getting ready \\
                 How to do it and How it works \\
                 Linear discriminant analysis \\
                 Getting ready \\
                 How to do it and How it works \\
                 Data preprocessing \\
                 Getting ready \\
                 How to do it and How it works \\
                 Linear regression \\
                 Getting ready \\
                 How to do it and How it works \\
                 Classification Getting ready \\
                 How to do it and How it works \\
                 Performance evaluation and model selection \\
                 Getting ready \\
                 How to do it and How it works \\
                 Cross validation \\
                 Getting ready \\
                 How to do it and How it works \\
                 Distances \\
                 Getting ready \\
                 How to do it and How it works \\
                 Distributions \\
                 Getting ready \\
                 How to do it and How it works \\
                 Time series analysis \\
                 Getting ready \\
                 How to do it and How it works \\
                 5: Working with Visualizations \\
                 Introduction \\
                 Plotting basic arrays \\
                 Getting ready \\
                 How to do it and How it works \\
                 Plotting dataframes \\
                 Getting ready \\
                 How to do it and How it works \\
                 Plotting functions \\
                 Getting ready \\
                 How to do it and how it works \\
                 Exploratory data analytics through plots \\
                 Getting ready \\
                 How to do it and How it works \\
                 Line plots \\
                 Getting ready \\
                 How to do it and How it works \\
                 Scatter plots \\
                 Getting ready \\
                 How to do it and How it works \\
                 Histograms \\
                 Getting ready \\
                 How to do it and How it works \\
                 Aesthetic customizations \\
                 Getting ready \\
                 How to do it and How it works \\
                 6: Parallel Computing \\
                 Introduction \\
                 Basic concepts of parallel computing \\
                 Getting ready \\
                 How to do it and How it works \\
                 Data movement \\
                 Getting ready \\
                 How to do it and How it works \\
                 Parallel maps and loop operations \\
                 Getting ready",
}

@InProceedings{Rong:2016:SCD,
  author =       "H. Rong and J. Park and L. Xiang and T. A. Anderson
                 and M. Smelyanskiy",
  booktitle =    "{2016 International Conference on Parallel
                 Architecture and Compilation Techniques (PACT)}",
  title =        "{Sparso}: Context-driven optimizations of sparse
                 linear algebra",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "247--259",
  year =         "2016",
  DOI =          "https://doi.org/10.1145/2967938.2967943",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Sengupta:2016:JHP,
  author =       "Avik Sengupta",
  title =        "{Julia} high performance: design and develop high
                 performing programs with {Julia}",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "115",
  year =         "2016",
  ISBN =         "1-78588-091-8, 1-78588-782-3 (e-book)",
  ISBN-13 =      "978-1-78588-091-9, 978-1-78588-782-6 (e-book)",
  LCCN =         "QA76.76.D47",
  bibdate =      "Fri Apr 9 05:31:56 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  series =       "Community experience distilled",
  URL =          "http://proquest.tech.safaribooksonline.de/9781785880919",
  abstract =     "Design and develop high performing programs with
                 Julia. About This Book Learn to code high reliability
                 and high performance programs Stand out from the crowd
                 by developing code that runs faster than your peers'
                 codes This book is intended for developers who are
                 interested in high performance technical programming.
                 Who This Book Is For This book is for beginner and
                 intermediate Julia programmers who are interested in
                 high performance technical computing. You will have a
                 basic familiarity with Julia syntax, and have written
                 some small programs in the language. What You Will
                 Learn Discover the secrets behind Julia's speed Get a
                 sense of the possibilities and limitations of Julia's
                 performance Analyze the performance of Julia programs
                 Measure the time and memory taken by Julia programs
                 Create fast machine code using Julia's type information
                 Define and call functions without compromising Julia's
                 performance Understand number types in Julia Use Julia
                 arrays to write high performance code Get an overview
                 of Julia's distributed computing capabilities. In
                 Detail Julia is a high performance, high-level dynamic
                 language designed to address the requirements of
                 high-level numerical and scientific computing. Julia
                 brings solutions to the complexities faced by
                 developers while developing elegant and high performing
                 code. Julia High Performance will take you on a journey
                 to understand the performance characteristics of your
                 Julia programs, and enables you to utilize the promise
                 of near C levels of performance in Julia. You will
                 learn to analyze and measure the performance of Julia
                 code, understand how to avoid bottlenecks, and design
                 your program for the highest possible performance. In
                 this book, you will also see how Julia uses type
                 information to achieve its performance goals, and how
                 to use multiple dispatch to help the compiler to emit
                 high performance machine code. Numbers and their arrays
                 are obviously the key structures in scientific
                 computing --- you will see how Julia's design makes
                 them fast. The last chapter will give you a taste of
                 Julia's distributed computing capabilities. Style and
                 approach This is a hands-on manual that will give you
                 good explanations about the important concepts related
                 to Julia programming.",
  acknowledgement = ack-nhfb,
  subject =      "Application software; Programming languages
                 (Electronic computers); Development; Programming
                 languages (Electronic computers); Application software;
                 Programming languages (Electronic computers)",
  tableofcontents = "Preface \\
                 1: Julia is Fast \\
                 Julia \\
                 fast and dynamic \\
                 Designed for speed \\
                 JIT and LLVM \\
                 Types \\
                 How fast can Julia be? \\
                 Summary \\
                 2: Analyzing Julia Performance \\
                 Timing Julia code \\
                 Tic and Toc \\
                 The @time macro \\
                 The @timev macro \\
                 The Julia profiler \\
                 Using the profiler \\
                 ProfileView \\
                 Analyzing memory allocation \\
                 Using the memory allocation tracker \\
                 Statistically accurate benchmarking \\
                 Using Benchmarks.jl \\
                 Summary \\
                 3: Types in Julia \\
                 The Julia type system \\
                 Using types \\
                 Multiple dispatch \\
                 Abstract types \\
                 Julia's type hierarchy \\
                 Composite and immutable types \\
                 Type parameters \\
                 Type inference \\
                 Type-stability \\
                 Definitions \\
                 Fixing type-instability \\
                 Performance pitfalls \\
                 Identifying type-stability \\
                 Loop variables \\
                 Kernel methods \\
                 Types in storage locations \\
                 Arrays \\
                 Composite types \\
                 Parametric composite types \\
                 Summary \\
                 4: Functions and Macros \\
                 Structuring Julia Code for High Performance \\
                 Using globals \\
                 The trouble with globals \\
                 Fixing performance issues with globals \\
                 Inlining \\
                 Default inlining \\
                 Controlling inlining \\
                 Disabling inlining \\
                 Closures and anonymous functions \\
                 FastAnonymous \\
                 Using macros for performance \\
                 The Julia compilation process \\
                 Using macros \\
                 Evaluating a polynomial \\
                 Horner's method \\
                 The Horner macro \\
                 Generated functions \\
                 Using generated functions \\
                 Using generated functions for performance \\
                 Using named parameters \\
                 Summary \\
                 5: Fast Numbers \\
                 Numbers in Julia \\
                 Integers \\
                 Integer overflow \\
                 BigInt \\
                 The floating point \\
                 Unchecked conversions for unsigned integers \\
                 Trading performance for accuracy \\
                 The fastmath macro \\
                 The K-B-N summation \\
                 Subnormal numbers \\
                 Subnormal numbers to zero \\
                 Summary \\
                 6: Fast Arrays \\
                 Array internals in Julia \\
                 Array representation and storage \\
                 Column-wise storage \\
                 Bound checking \\
                 Removing the cost of bound checking \\
                 Configuring bound checks at startup \\
                 Allocations and in-place operations \\
                 Preallocating function output \\
                 Mutating versions \\
                 Array views \\
                 SIMD parallelization \\
                 Yeppp! \\
                 Writing generic library functions with arrays \\
                 Summary \\
                 7: Beyond the Single Processor \\
                 Parallelism in Julia \\
                 Starting a cluster \\
                 Communication between Julia processes \\
                 Programming parallel tasks \\
                 @everywhere \\
                 @spawn \\
                 Parallel for \\
                 Parallel map \\
                 Distributed arrays \\
                 Shared arrays \\
                 Threading \\
                 Summary \\
                 Index",
}

@InProceedings{Spoto:2016:JSA,
  author =       "Fausto Spoto",
  booktitle =    "{Static Analysis}",
  title =        "The {Julia} Static Analyzer for {Java}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2016",
  DOI =          "https://doi.org/10.1007/978-3-662-53413-7_3",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-662-53413-7_3",
  acknowledgement = ack-nhfb,
}

@InProceedings{Vidhyaa:2016:HED,
  author =       "V. G. Vidhyaa and S. A. Rajalakshmi and R. Raghavan
                 and G. S. V. {Venu Gopal} and R. Gandhiraj",
  booktitle =    "{2016 International Conference on Communication and
                 Signal Processing (ICCSP)}",
  title =        "{Huffman} encoding and decoding algorithm using
                 {IJulia}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "0587--0591",
  year =         "2016",
  DOI =          "https://doi.org/10.1109/ICCSP.2016.7754207",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Voulgaris:2016:JDS,
  author =       "Zacharias Voulgaris",
  title =        "{Julia} for data science",
  publisher =    "Technics Publications LLC",
  address =      "Basking Ridge, NJ, USA",
  pages =        "x + 350",
  year =         "2016",
  ISBN =         "1-63462-130-1 (print), 1-63462-131-X (Kindle),
                 1-63462-132-8 (ePub)",
  ISBN-13 =      "978-1-63462-130-4 (print), 978-1-63462-131-1 (Kindle),
                 978-1-63462-132-8 (ePub)",
  LCCN =         "QA76.73.J8 V68 2016",
  bibdate =      "Thu Apr 8 10:55:28 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Programming
                 languages (Electronic computers); Application software;
                 Development; Development; Julia (Computer program
                 language); Programming languages (Electronic
                 computers)",
}

@Article{Bassen:2017:JCM,
  author =       "David M. Bassen and Michael Vilkhovoy and Mason Minot
                 and Jonathan T. Butcher and Jeffrey D. Varner",
  title =        "{JuPOETs}: a constrained multiobjective optimization
                 approach to estimate biochemical model ensembles in the
                 {Julia} programming language",
  journal =      "{BMC} Systems Biology",
  volume =       "11",
  number =       "1",
  month =        jan,
  year =         "2017",
  CODEN =        "BSBMCC",
  DOI =          "https://doi.org/10.1186/s12918-016-0380-2",
  ISSN =         "1752-0509",
  ISSN-L =       "1752-0509",
  bibdate =      "Thu Apr 8 11:13:46 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/article/10.1186/s12918-016-0380-2",
  acknowledgement = ack-nhfb,
}

@Article{Bezanson:2017:JFA,
  author =       "Jeff Bezanson and Alan Edelman and Stefan Karpinski
                 and Viral B. Shah",
  title =        "{Julia}: a Fresh Approach to Numerical Computing",
  journal =      j-SIAM-REVIEW,
  volume =       "59",
  number =       "1",
  pages =        "65--98",
  month =        "????",
  year =         "2017",
  CODEN =        "SIREAD",
  DOI =          "https://doi.org/10.1137/141000671",
  ISSN =         "0036-1445 (print), 1095-7200 (electronic)",
  ISSN-L =       "0036-1445",
  bibdate =      "Fri Mar 10 06:16:32 MST 2017",
  bibsource =    "http://epubs.siam.org/toc/siread/59/1;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/siamreview.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "SIAM Review",
  journal-URL =  "http://epubs.siam.org/sirev",
  onlinedate =   "January 2017",
}

@InProceedings{Blas:2017:STD,
  author =       "M. J. Blas and F. Hauque and S. Re and M. Castellaro",
  booktitle =    "{2017 XLIII Latin American Computer Conference
                 (CLEI)}",
  title =        "A support tool designed as didactic material for
                 teaching and learning programming",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--10",
  year =         "2017",
  DOI =          "https://doi.org/10.1109/CLEI.2017.8226382",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Datseris:2017:PDJ,
  author =       "George Datseris",
  title =        "\pkg{DynamicalBilliards.jl}: An easy-to-use, modular
                 and extendable {Julia} package for {Dynamical Billiard}
                 systems in two dimensions",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "2",
  number =       "19",
  pages =        "458:1--458:4",
  month =        nov,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00458",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00458",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "19 November 2017",
  ORCID-numbers = "George Datseris / 0000-0002-6427-2385",
}

@Article{Dunning:2017:JML,
  author =       "Iain Dunning and Joey Huchette and Miles Lubin",
  title =        "{JuMP}: a Modeling Language for Mathematical
                 Optimization",
  journal =      j-SIAM-REVIEW,
  volume =       "59",
  number =       "2",
  pages =        "295--320",
  month =        jan,
  year =         "2017",
  CODEN =        "SIREAD",
  DOI =          "https://doi.org/10.1137/15m1020575",
  ISSN =         "0036-1445 (print), 1095-7200 (electronic)",
  ISSN-L =       "0036-1445",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "SIAM Review",
  journal-URL =  "http://epubs.siam.org/sirev",
  keywords =     "Julia programming language",
}

@InProceedings{Edelman:2017:MOE,
  author =       "A. Edelman",
  booktitle =    "{2017 IEEE International Conference on Big Data (Big
                 Data)}",
  title =        "A more open efficient future for {AI} development and
                 data science with an introduction to {Julia}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "2--2",
  year =         "2017",
  DOI =          "https://doi.org/10.1109/BigData.2017.8257901",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Fieker:2017:NH,
  author =       "Claus Fieker and William Hart and Tommy Hofmann and
                 Fredrik Johansson",
  booktitle =    "{Proceedings of the 2017 ACM on International
                 Symposium on Symbolic and Algebraic Computation}",
  title =        "{Nemo\slash Hecke}",
  publisher =    pub-ACM,
  address =      pub-ACM:adr,
  month =        jul,
  year =         "2017",
  DOI =          "https://doi.org/10.1145/3087604.3087611",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Heirendt:2017:PDJ,
  author =       "Laurent Heirendt and Ines Thiele and Ronan M. T.
                 Fleming",
  title =        "\pkg{DistributedFBA.jl}: High-level, high-performance
                 flux balance analysis in {Julia}",
  journal =      j-BIOINFORMATICS,
  pages =        "1--3",
  month =        jan,
  year =         "2017",
  DOI =          "https://doi.org/10.1093/bioinformatics/btw838",
  ISSN =         "1367-4803 (print), 1367-4811 (electronic)",
  ISSN-L =       "1367-4803",
  bibdate =      "Fri Apr 9 06:05:36 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://doi.org/10.1093/bioinformatics/btw838",
  acknowledgement = ack-nhfb,
  fjournal =     "Bioinformatics",
  journal-URL =  "http://bioinformatics.oxfordjournals.org/",
}

@InProceedings{Hylton:2017:PEC,
  author =       "A. Hylton and G. Henselman-Petrusek and J. Sang and R.
                 Short",
  booktitle =    "{2017 IEEE 36th International Performance Computing
                 and Communications Conference (IPCCC)}",
  title =        "Performance enhancement of a computational persistent
                 homology package",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--8",
  year =         "2017",
  DOI =          "https://doi.org/10.1109/PCCC.2017.8280468",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Jacobsen:2017:GSJ,
  author =       "Robert Dahl Jacobsen and Morten Nielsen and Morten
                 Grud Rasmussen",
  title =        "Generalized Sampling in {Julia}",
  journal =      j-J-OPEN-RES-SOFT,
  volume =       "5",
  number =       "1",
  pages =        "12--??",
  day =          "20",
  month =        apr,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.5334/jors.157",
  ISSN =         "2049-9647",
  ISSN-L =       "2049-9647",
  bibdate =      "Sat Sep 8 10:03:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/jors.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://openresearchsoftware.metajnl.com/articles/10.5334/jors.157/",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Research Software",
  journal-URL =  "https://openresearchsoftware.metajnl.com/issue/archive/",
}

@Article{Lauwens:2017:PRC,
  author =       "Ben Lauwens",
  title =        "\pkg{ResumableFunctions}: {C\#} sharp style generators
                 for {Julia}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "2",
  number =       "18",
  pages =        "400:1--400:2",
  month =        oct,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00400",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/csharp.bib;
                 http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00400",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "31 October 2017",
  ORCID-numbers = "Ben Lauwens / 0000-0003-0761-6265",
}

@InProceedings{Milechin:2017:DED,
  author =       "Lauren Milechin and Vijay Gadepally and Siddharth
                 Samsi and Jeremy Kepner and Alexander Chen and Dylan
                 Hutchison",
  booktitle =    "{2017 IEEE High Performance Extreme Computing
                 Conference (HPEC)}",
  title =        "{D4M 3.0}: Extended database and language
                 capabilities",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--6",
  month =        sep,
  year =         "2017",
  DOI =          "https://doi.org/10.1109/hpec.2017.8091083",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Moore:2017:ITI,
  author =       "D. G. Moore and G. Valentini and S. I. Walker and M.
                 Levin",
  booktitle =    "{2017 IEEE Symposium Series on Computational
                 Intelligence (SSCI)}",
  title =        "{Inform}: a toolkit for information-theoretic analysis
                 of complex systems",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--8",
  year =         "2017",
  DOI =          "https://doi.org/10.1109/SSCI.2017.8285197",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Nagar:2017:BJP,
  author =       "Sandeep Nagar",
  title =        "Beginning {Julia} Programming: For Engineers and
                 Scientists",
  publisher =    pub-APRESS,
  address =      pub-APRESS:adr,
  pages =        "xxi + 351 + 20 + 18",
  year =         "2017",
  DOI =          "https://doi.org/10.1007/978-1-4842-3171-5",
  ISBN =         "1-4842-3170-8, 1-4842-3171-6",
  ISBN-13 =      "978-1-4842-3170-8, 978-1-4842-3171-5",
  LCCN =         "QA76.7-76.73; QA76.76.C65",
  bibdate =      "Thu Apr 8 10:39:19 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://www.springerlink.com/content/978-1-4842-3171-5",
  abstract =     "Get started with Julia for engineering and numerical
                 computing, especially data science, machine learning,
                 and scientific computing applications. This book
                 explains how Julia provides the functionality,
                 ease-of-use and intuitive syntax of R, Python, MATLAB,
                 SAS, or Stata combined with the speed, capacity, and
                 performance of C, C++, or Java. You'll learn the OOP
                 principles required to get you started, then how to do
                 basic mathematics with Julia. Other core functionality
                 of Julia that you'll cover, includes working with
                 complex numbers, rational and irrational numbers,
                 rings, and fields. Beginning Julia Programming takes
                 you beyond these basics to harness Julia's powerful
                 features for mathematical functions in Julia, arrays
                 for matrix operations, plotting, and more. Along the
                 way, you also learn how to manage strings, write
                 functions, work with control flows, and carry out I/O
                 to implement and leverage the mathematics needed for
                 your data science and analysis projects. ``Julia walks
                 like Python and runs like C''. This phrase explains why
                 Julia is quickly growing as the most favored option for
                 data analytics and numerical computation. After reading
                 and using this book, you'll have the essential
                 knowledge and skills to build your first Julia-based
                 application. You will: Obtain core skills in Julia
                 Apply Julia in engineering and science applications
                 Work with mathematical functions in Julia Use arrays,
                 strings, functions, control flow, and I/O in Julia
                 Carry out plotting and display basic graphics .",
  acknowledgement = ack-nhfb,
  subject =      "Computer science; Computer programming; Programming
                 languages (Electronic computers); Mathematical logic;
                 Programming Languages, Compilers, Interpreters;
                 Mathematical Logic and Formal Languages; Big Data;
                 Programming Techniques; Inform{\'a}tica; Logic,
                 Symbolic and mathematical; Computer programming;
                 Computer science.; Logic, Symbolic and mathematical;
                 Programming languages (Electronic computers)",
  tableofcontents = "1. Introduction \\
                 2. Object Oriented Programming \\
                 3. Basic Mathematics with Julia \\
                 4. Complex Numbers \\
                 5. Rational and Irrational numbers \\
                 6. Mathematical Functions \\
                 7. Arrays \\
                 8. Arrays for Matrix Operations \\
                 9. Strings \\
                 10. Functions \\
                 11. Control Flow \\
                 12. Input Output \\
                 13. Plotting",
}

@InProceedings{Nagar:2017:BMJ,
  author =       "Sandeep Nagar",
  booktitle =    "{Beginning Julia Programming}",
  title =        "Basic Math with {Julia}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2017",
  DOI =          "https://doi.org/10.1007/978-1-4842-3171-5_3",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-1-4842-3171-5_3",
  acknowledgement = ack-nhfb,
}

@Article{Pastell:2017:PWJ,
  author =       "Matti Pastell",
  title =        "\pkg{Weave.jl}: Scientific Reports Using {Julia}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "2",
  number =       "11",
  pages =        "204:1--204:1",
  month =        mar,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00204",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/litprog.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00204",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "22 March 2017",
  ORCID-numbers = "Matti Pastell / 0000-0002-5810-4801",
}

@InProceedings{Poulding:2017:ART,
  author =       "S. Poulding and R. Feldt",
  booktitle =    "{2017 IEEE International Conference on Software
                 Testing, Verification and Validation (ICST)}",
  title =        "Automated Random Testing in Multiple Dispatch
                 Languages",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "333--344",
  year =         "2017",
  DOI =          "https://doi.org/10.1109/ICST.2017.37",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Rackauckas:2017:PDJ,
  author =       "Christopher Rackauckas and Qing Nie",
  title =        "\pkg{DifferentialEquations.jl} --- A Performant and
                 Feature-Rich Ecosystem for Solving Differential
                 Equations in {Julia}",
  journal =      j-J-OPEN-RES-SOFT,
  volume =       "5",
  number =       "1",
  pages =        "15--??",
  day =          "25",
  month =        may,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.5334/jors.151",
  ISSN =         "2049-9647",
  ISSN-L =       "2049-9647",
  bibdate =      "Sat Sep 8 10:03:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/jors.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://openresearchsoftware.metajnl.com/articles/10.5334/jors.151/",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Research Software",
  journal-URL =  "https://openresearchsoftware.metajnl.com/issue/archive/",
}

@Article{Ruthotto:2017:JFJ,
  author =       "Lars Ruthotto and Eran Treister and Eldad Haber",
  title =        "{jInv} --- a Flexible {Julia} Package for {PDE}
                 Parameter Estimation",
  journal =      j-SIAM-J-SCI-COMP,
  volume =       "39",
  number =       "5",
  pages =        "S702--S722",
  month =        "????",
  year =         "2017",
  CODEN =        "SJOCE3",
  DOI =          "https://doi.org/10.1137/16M1081063",
  ISSN =         "1064-8275 (print), 1095-7197 (electronic)",
  ISSN-L =       "1064-8275",
  bibdate =      "Fri Jan 12 07:30:22 MST 2018",
  bibsource =    "http://epubs.siam.org/toc/sjoce3/39/5;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/siamjscicomput.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "SIAM Journal on Scientific Computing",
  journal-URL =  "http://epubs.siam.org/sisc",
  onlinedate =   "January 2017",
}

@InProceedings{Serrano:2017:MIP,
  author =       "E. Serrano and J. G. Blas and J. Carretero and M.
                 Abella and M. Desco",
  booktitle =    "{2017 17th IEEE/ACM International Symposium on
                 Cluster, Cloud and Grid Computing (CCGRID)}",
  title =        "Medical Imaging Processing on a Big Data Platform
                 Using {Python}: Experiences with Heterogeneous and
                 Homogeneous Architectures",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "830--837",
  year =         "2017",
  DOI =          "https://doi.org/10.1109/CCGRID.2017.56",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Sinaie:2017:PMP,
  author =       "Sina Sinaie and Viet Ha Nguyen and Chi Thanh Nguyen
                 and St{\'e}phane Bordas",
  title =        "Programming the material point method in {Julia}",
  journal =      j-ADV-ENG-SOFTWARE,
  volume =       "105",
  number =       "??",
  pages =        "17--29",
  month =        mar,
  year =         "2017",
  CODEN =        "AESODT",
  DOI =          "https://doi.org/10.1016/j.advengsoft.2017.01.008",
  ISSN =         "0965-9978 (print), 0141-1195 (electronic)",
  ISSN-L =       "0965-9978",
  bibdate =      "Fri Apr 09 05:58:14 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0965997816302769",
  abstract =     "This article presents the implementation of the
                 material point method (MPM) using Julia. Julia is an
                 open source, multi-platform, high-level,
                 high-performance dynamic programming language for
                 technical computing, with syntax that is familiar to
                 Matlab and Python programmers. MPM is a hybrid
                 particle-grid approach that combines the advantages of
                 Eulerian and Lagrangian methods and is suitable for
                 complex solid mechanics problems involving contact,
                 impact and large deformations. We will show that a
                 Julia based MPM code, which is short, compact and
                 readable and uses only Julia built in features,
                 performs much better (with speed up of up to 8) than a
                 similar Matlab based MPM code for large strain solid
                 mechanics simulations. We share our experiences of
                 implementing MPM in Julia and demonstrate that Julia is
                 a very interesting platform for rapid development in
                 the field of scientific computing.",
  acknowledgement = ack-nhfb,
  fjournal =     "Advances in Engineering Software",
  journal-URL =  "https://www.sciencedirect.com/journal/advances-in-engineering-software",
  keywords =     "Julia, Material point method (MPM), High-performance
                 dynamic programming language, Technical computing",
}

@InProceedings{Thankachan:2017:IPO,
  author =       "R. V. Thankachan and E. R. Hein and B. P. Swenson and
                 J. P. Fairbanks",
  booktitle =    "{2017 IEEE High Performance Extreme Computing
                 Conference (HPEC)}",
  title =        "Integrating productivity-oriented programming
                 languages with high-performance data structures",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--8",
  year =         "2017",
  DOI =          "https://doi.org/10.1109/HPEC.2017.8091068",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Balbaert:2018:JP,
  author =       "Ivo Balbaert",
  title =        "{Julia 1.0} Programming",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "iv + 184",
  year =         "2018",
  ISBN =         "1-78899-909-6",
  ISBN-13 =      "978-1-78899-909-0",
  LCCN =         "QA76.73.J85 2018",
  bibdate =      "Thu Apr 8 11:10:55 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://international.scholarvox.com/book/88863229",
  abstract =     "Enter the exciting world of Julia, a high-performance
                 language for technical computing Key Features Leverage
                 Julia's high speed and efficiency for your applications
                 Work with Julia in a multi-core, distributed, and
                 networked environment Apply Julia to tackle problems
                 concurrently and in a distributed environment Book
                 Description The release of Julia 1.0 is now ready to
                 change the technical world by combining the high
                 productivity and ease of use of Python and R with the
                 lightning-fast speed of C++. Julia 1.0 programming
                 gives you a head start in tackling your numerical and
                 data problems. You will begin by learning how to set up
                 a running Julia platform, before exploring its various
                 built-in types. With the help of practical examples,
                 this book walks you through two important collection
                 types: arrays and matrices. In addition to this, you
                 will be taken through how type conversions and
                 promotions work. In the course of the book, you will be
                 introduced to the homo-iconicity and metaprogramming
                 concepts in Julia. You will understand how Julia
                 provides different ways to interact with an operating
                 system, as well as other languages, and then you'll
                 discover what macros are. Once you have grasped the
                 basics, you'll study what makes Julia suitable for
                 numerical and scientific computing, and learn about the
                 features provided by Julia. By the end of this book,
                 you will also have learned how to run external
                 programs. This book covers all you need to know about
                 Julia in order to leverage its high speed and
                 efficiency for your applications. What you will learn
                 Set up your Julia environment to achieve high
                 productivity Create your own types to extend the
                 built-in type system Visualize your data in Julia with
                 plotting packages Explore the use of built-in macros
                 for testing and debugging, among other uses Apply Julia
                 to tackle problems concurrently Integrate Julia with
                 other languages such as C, Python, and MATLAB Who this
                 book is for Julia 1.0 Programming is for you if you are
                 a statistician or data scientist who wants a crash
                 course in the Julia programming language while building
                 big data applications. A basic knowledge of mathematics
                 is needed to understand the various methods that are
                 used or created during the course of the book to
                 exploit the capabilities that Julia is designed with.
                 Downloading the example code for this book You can
                 download the example code files for all Packt books you
                 have purchased from your account at
                 http://www.PacktPub.com.",
  acknowledgement = ack-nhfb,
}

@Article{Bezanson:2018:JDP,
  author =       "Jeff Bezanson and Jiahao Chen and Benjamin Chung and
                 Stefan Karpinski and Viral B. Shah and Jan Vitek and
                 Lionel Zoubritzky",
  title =        "{Julia}: dynamism and performance reconciled by
                 design",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "120:1--120:23",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276490",
  ISSN =         "2475-1421",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276490",
  abstract =     "Julia is a programming language for the scientific
                 community that combines features of productivity
                 languages, such as Python or MATLAB, with
                 characteristics of performance-oriented languages, such
                 as C++ or Fortran. Julia's productivity features
                 include: dynamic typing, automatic memory management,
                 rich type annotations, and multiple dispatch. At the
                 same time, Julia allows programmers to control memory
                 layout and leverages a specializing just-in-time
                 compiler to eliminate much of the overhead of those
                 features. This paper details the design choices made by
                 the creators of Julia and reflects on the implications
                 of those choices for performance and usability.",
  acknowledgement = ack-nhfb,
  articleno =    "120",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@InProceedings{Biel:2018:DSA,
  author =       "M. Biel and M. Johansson",
  booktitle =    "{2018 IEEE/ACM Parallel Applications Workshop,
                 Alternatives To MPI (PAW-ATM)}",
  title =        "Distributed {L}-shaped Algorithms in {Julia}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "57--69",
  year =         "2018",
  DOI =          "https://doi.org/10.1109/PAW-ATM.2018.00011",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Blankrot:2018:PPS,
  author =       "Boaz Blankrot and Clemens Heitzinger",
  title =        "\pkg{ParticleScattering}: Solving and optimizing
                 multiple-scattering problems in {Julia}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "3",
  number =       "25",
  pages =        "691:1--691:3",
  month =        may,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00691",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00691",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "14 May 2018",
  ORCID-numbers = "Boaz Blankrot / 0000-0003-3364-9298; Clemens
                 Heitzinger / 0000-0003-1613-5164",
}

@Book{Bornemann:2018:NLA,
  author =       "Folkmar Bornemann",
  title =        "Numerical Linear Algebra: a Concise Introduction with
                 {MATLAB} and {Julia}",
  publisher =    "Springer International Publishing",
  address =      "Cham, Switzerland",
  pages =        "x + 153",
  year =         "2018",
  DOI =          "https://doi.org/10.1007/978-3-319-74222-9",
  ISBN =         "3-319-74221-3, 3-319-74222-1 (e-book)",
  ISBN-13 =      "978-3-319-74221-2 (print), 978-3-319-74222-9
                 (e-book)",
  ISSN =         "1615-2085",
  LCCN =         "QA184-205; QA297-299.4",
  bibdate =      "Thu Apr 8 17:01:32 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/matlab.bib",
  series =       "Springer Undergraduate Mathematics Series",
  abstract =     "This book offers an introduction to the
                 algorithmic-numerical thinking using basic problems of
                 linear algebra. By focusing on linear algebra, it
                 ensures a stronger thematic coherence than is otherwise
                 found in introductory lectures on numerics. The book
                 highlights the usefulness of matrix partitioning
                 compared to a component view, leading not only to a
                 clearer notation and shorter algorithms, but also to
                 significant runtime gains in modern computer
                 architectures. The algorithms and accompanying
                 numerical examples are given in the programming
                 environment MATLAB, and additionally - in an appendix -
                 in the future-oriented, freely accessible programming
                 language Julia. This book is suitable for a two-hour
                 lecture on numerical linear algebra from the second
                 semester of a bachelor's degree in mathematics.",
  acknowledgement = ack-nhfb,
  subject =      "Mathematics; Matrix theory; Algebra; Numerical
                 analysis; Linear and Multilinear Algebras, Matrix
                 Theory; Matem{\'a}ticas; Algebra.; Mathematics.;
                 Numerical analysis.",
  tableofcontents = "Intro \\
                 Preface \\
                 Student's Laboratory \\
                 Contents \\
                 I: Computing with Matrices \\
                 1 What is Numerical Analysis? \\
                 2 Matrix Calculus \\
                 3 MATLAB \\
                 4 Execution Times \\
                 5 Triangular Matrices \\
                 6 Unitary Matrices \\
                 II: Matrix Factorization \\
                 7 Triangular Decomposition \\
                 8 Cholesky Decomposition \\
                 9 QR Decomposition \\
                 III: Error Analysis \\
                 10 Error Measures \\
                 11 Conditioning of a Problem \\
                 12 Machine Numbers \\
                 13 Stability of an Algorithm \\
                 14 Three Exemplary Error Analyses \\
                 15 Error Analysis of Linear Systems of Equations \\
                 IV: Least Squares \\
                 16 Normal Equation17 Orthogonalization \\
                 V: Eigenvalue Problems \\
                 18 Basic Concepts \\
                 19 Perturbation Theory \\
                 20 Power Iteration \\
                 21 QR Algorithm \\
                 Appendix \\
                 A MATLAB: A Very Short Introduction \\
                 General Commands \\
                 Matrices \\
                 Functions \\
                 Control Flow \\
                 Logic Functions \\
                 Componentwise Operations \\
                 B Julia: A Modern Alternative to MATLAB \\
                 C Norms: Recap and Supplement \\
                 D The Householder Method for QR Decomposition \\
                 E For the Curious, the Connoisseur, and the Capable \\
                 Model Backwards Analysis of Iterative Refinement \\
                 Global Convergence of the QR Algorithm without Shifts
                 \\
                 Local Convergence of the QR Algorithm with Shifts \\
                 A Stochastic Upper Bound of the Spectral Norm \\
                 F More Exercises \\
                 Computer Matrices \\
                 Matrix Factorization \\
                 Error Analysis \\
                 Least Squares \\
                 Elgenvalue Problems \\
                 Notation \\
                 Index",
}

@InProceedings{Breiding:2018:PHJ,
  author =       "Paul Breiding and Sascha Timme",
  booktitle =    "{Mathematical Software ICMS 2018}",
  title =        "\pkg{HomotopyContinuation.jl}: a Package for Homotopy
                 Continuation in {Julia}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2018",
  DOI =          "https://doi.org/10.1007/978-3-319-96418-8_54",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-319-96418-8_54",
  acknowledgement = ack-nhfb,
}

@InProceedings{Coffrin:2018:PJO,
  author =       "C. Coffrin and R. Bent and K. Sundar and Y. Ng and M.
                 Lubin",
  booktitle =    "{2018 Power Systems Computation Conference (PSCC)}",
  title =        "{PowerModels}. {JL}: An Open-Source Framework for
                 Exploring Power Flow Formulations",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--8",
  year =         "2018",
  DOI =          "https://doi.org/10.23919/PSCC.2018.8442948",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Dan:2018:LJE,
  author =       "Toomey Dan",
  title =        "Learning {Jupyter 5}: explore interactive computing
                 using {Python}, {Java}, {JavaScript}, {R}, {Julia}, and
                 {JupyterLab}",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "282",
  year =         "2018",
  ISBN =         "1-78913-740-3, 1-78913-744-6",
  ISBN-13 =      "978-1-78913-740-8, 978-1-78913-744-6",
  LCCN =         "Q183.9; QA76.9.I52 .T666 2018",
  bibdate =      "Fri Apr 9 05:38:17 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/s-plus.bib",
  acknowledgement = ack-nhfb,
  tableofcontents = "Preface \\
                 1: Introduction to Jupyter \\
                 First look at Jupyter \\
                 Installing Jupyter \\
                 Notebook structure \\
                 Notebook workflow \\
                 Basic Notebook operations \\
                 File operations \\
                 Duplicate \\
                 Rename \\
                 Delete \\
                 Upload \\
                 New text file \\
                 New folder \\
                 New Python 3 \\
                 Security in Jupyter \\
                 Security digest \\
                 Trust options \\
                 Configuration options for Jupyter \\
                 Summary \\
                 2: Jupyter Python Scripting \\
                 Basic Python in Jupyter \\
                 Python data access in Jupyter \\
                 Python pandas in Jupyter \\
                 Python graphics in Jupyter \\
                 Python random numbers in Jupyter \\
                 Summary \\
                 3: Jupyter R Scripting \\
                 Adding R scripting to your installation \\
                 Adding R scripts to Jupyter on macOS \\
                 Adding R scripts to Jupyter on Windows \\
                 Adding R packages to Jupyter \\
                 R limitations in Jupyter \\
                 Basic R in Jupyter \\
                 R dataset access \\
                 R visualizations in Jupyter \\
                 R 3D graphics in Jupyter \\
                 R 3D scatterplot in Jupyter \\
                 R cluster analysis \\
                 R forecasting \\
                 R machine learning \\
                 Dataset \\
                 Summary \\
                 4: Jupyter Julia Scripting \\
                 Adding Julia scripting to your installation \\
                 Adding Julia scripts to Jupyter \\
                 Adding Julia packages to Jupyter \\
                 Basic Julia in Jupyter \\
                 Julia limitations in Jupyter \\
                 Standard Julia capabilities \\
                 Julia visualizations in Jupyter \\
                 Julia Gadfly scatterplot \\
                 Julia Gadfly histogram \\
                 Julia Winston plotting \\
                 Julia Vega plotting \\
                 Julia PyPlot plotting \\
                 Julia parallel processing \\
                 Julia control flow \\
                 Julia regular expressions \\
                 Julia unit testing \\
                 Summary \\
                 5: Jupyter Java Coding \\
                 Adding the Java kernel to your installation \\
                 Installing Java 9 or later \\
                 A Jupyter environment is required \\
                 Configuring IJava \\
                 Downloading the IJava project from GitHub \\
                 Building and installing the kernel \\
                 Available options \\
                 Jupyter Java console \\
                 Jupyter Java output \\
                 Java Optional \\
                 Java compiler errors \\
                 Java lambdas \\
                 Java Collections \\
                 Java streams \\
                 Java summary statistics \\
                 Summary \\
                 6: Jupyter JavaScript Coding \\
                 Adding JavaScript scripting to your installation \\
                 Adding JavaScript scripts to Jupyter on macOS or
                 Windows \\
                 JavaScript Hello World Jupyter Notebook \\
                 Adding JavaScript packages to Jupyter \\
                 Basic JavaScript in Jupyter \\
                 JavaScript limitations in Jupyter \\
                 Node.js d3 package \\
                 Node.js stats-analysis package \\
                 Node.js JSON handling \\
                 Node.js canvas package \\
                 Node.js plotly package \\
                 Node.js asynchronous threadsNode.js decision-tree
                 package \\
                 Summary \\
                 7: Jupyter Scala \\
                 Installing the Scala kernel \\
                 Scala data access in Jupyter \\
                 Scala array operations \\
                 Scala random numbers in Jupyter \\
                 Scala closures \\
                 Scala higher-order functions \\
                 Scala pattern matching \\
                 Scala case classes \\
                 Scala immutability \\
                 Scala collections \\
                 Named arguments \\
                 Scala traits \\
                 Summary \\
                 8: Jupyter and Big Data \\
                 Apache Spark \\
                 Installing Spark on macOS \\
                 Windows install \\
                 First Spark script \\
                 Spark word count \\
                 Sorted word count \\
                 Estimate pi \\
                 Log file examination \\
                 Spark primes \\
                 Spark text file analysis",
}

@Article{Datseris:2018:PDJ,
  author =       "George Datseris",
  title =        "\pkg{DynamicalSystems.jl}: A {Julia} software library
                 for chaos and nonlinear dynamics",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "3",
  number =       "23",
  pages =        "598:1--598:5",
  month =        mar,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.5334/jors.151",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00598",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "14 March 2018",
  ORCID-numbers = "George Datseris / 0000-0002-6427-2385",
}

@Article{Gawron:2018:PQJ,
  author =       "Piotr Gawron and Dariusz Kurzyk and {\L}ukasz Pawela",
  editor =       "Nicholas Chancellor",
  title =        "\pkg{QuantumInformation.jl} --- a {Julia} package for
                 numerical computation in quantum information theory",
  journal =      j-PLOS-ONE,
  volume =       "13",
  number =       "12",
  pages =        "e0209358",
  month =        dec,
  year =         "2018",
  CODEN =        "POLNCL",
  DOI =          "https://doi.org/10.1371/journal.pone.0209358",
  ISSN =         "1932-6203",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "PLoS One",
  journal-URL =  "http://www.plosone.org/",
  keywords =     "Julia programming language",
}

@Article{Hoffimann:2018:PGJ,
  author =       "J{\'u}lio Hoffimann",
  title =        "\pkg{GeoStats.jl} -- High-performance geostatistics in
                 {Julia}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "3",
  number =       "24",
  pages =        "692:1--692:4",
  month =        apr,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00692",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00692",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "25 April 2018",
  ORCID-numbers = "J{\'u}lio Hoffimann / 0000-0003-2789-297X",
}

@InCollection{Humenberger:2018:AJT,
  author =       "Andreas Humenberger and Maximilian Jaroschek and Laura
                 Kov{\'a}cs",
  booktitle =    "{Lecture Notes in Computer Science}",
  title =        "\pkg{Aligator.jl} --- a {Julia} Package for Loop
                 Invariant Generation",
  publisher =    "Springer International Publishing",
  address =      "Cham, Switzerland",
  pages =        "111--117",
  year =         "2018",
  DOI =          "https://doi.org/10.1007/978-3-319-96812-4_10",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Humenberger:2018:PAJ,
  author =       "Andreas Humenberger and Maximilian Jaroschek and Laura
                 Kov{\'a}cs",
  booktitle =    "{Intelligent Computer Mathematics}",
  title =        "\pkg{Aligator.jl} -- a {Julia} Package for Loop
                 Invariant Generation",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2018",
  DOI =          "https://doi.org/10.1007/978-3-319-96812-4_10",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-319-96812-4_10",
  acknowledgement = ack-nhfb,
}

@Article{Innes:2018:PFE,
  author =       "Mike Innes",
  title =        "\pkg{Flux}: Elegant machine learning with {Julia}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "3",
  number =       "25",
  pages =        "602:1--602:1",
  month =        may,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00602",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00602",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "03 May 2018",
  ORCID-numbers = "Mike Innes / 0000-0003-0788-0242",
}

@Book{Kaminski:2018:JPC,
  author =       "Bogumi{\l} Kami{\'n}ski and Przemys{\l}aw Szufel",
  title =        "{Julia 1.0} Programming Cookbook: over 100 numerical
                 and distributed computing recipes for your daily data
                 science workflow",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "xiii + 439",
  year =         "2018",
  ISBN =         "1-78899-836-7 (paperback)",
  ISBN-13 =      "978-1-78899-836-9 (paperback)",
  LCCN =         "QA76.73.J85",
  bibdate =      "Thu Apr 8 10:52:14 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  abstract =     "Discover the new features and widely used packages in
                 Julia to solve complex computational problems in your
                 statistical applications. Key Features Address the core
                 problems of programming in Julia with the most popular
                 packages for common tasks Tackle issues while working
                 with Databases and Parallel data processing with Julia
                 Explore advanced features such as metaprogramming,
                 functional programming, and user defined types Book
                 Description Julia, with its dynamic nature and
                 high-performance, provides comparatively minimal time
                 for the development of computational models with
                 easy-to-maintain computational code. This book will be
                 your solution-based guide as it will take you through
                 different programming aspects with Julia. Starting with
                 the new features of Julia 1.0, each recipe addresses a
                 specific problem, providing a solution and explaining
                 how it works. You will work with the powerful Julia
                 tools and data structures along with the most popular
                 Julia packages. You will learn to create vectors,
                 handle variables, and work with functions. You will be
                 introduced to various recipes for numerical computing,
                 distributed computing, and achieving high performance.
                 You will see how to optimize data science programs with
                 parallel computing and memory allocation. We will look
                 into more advanced concepts such as metaprogramming and
                 functional programming. Finally, you will learn how to
                 tackle issues while working with databases and data
                 processing, and will learn about on data science
                 problems, data modeling, data analysis, data
                 manipulation, parallel processing, and cloud computing
                 with Julia. By the end of the book, you will have
                 acquired the skills to work more effectively with your
                 data What you will learn Boost your code's performance
                 using Julia's unique features Organize data in to
                 fundamental types of collections: arrays and
                 dictionaries Organize data science processes within
                 Julia and solve related problems Scale Julia
                 computations with cloud computing Write data to IO
                 streams with Julia and handle web transfer Define your
                 own immutable and mutable types Speed up the
                 development process using metaprogramming Who this book
                 is for This book is for developers who would like to
                 enhance their Julia programming skills and would like
                 to get some quick solutions to their common programming
                 problems. Basic Julia programming knowledge is assumed.
                 Downloading the example code for this book. \ldots{}",
  acknowledgement = ack-nhfb,
}

@Article{Kemmer:2018:PNJ,
  author =       "Thomas Kemmer and Sergej Rjasanow and Andreas
                 Hildebrandt",
  title =        "\pkg{NESSie.jl}: Efficient and intuitive finite
                 element and boundary element methods for nonlocal
                 protein electrostatics in the {Julia} language",
  journal =      "Journal of Computational Science",
  volume =       "28",
  pages =        "193--203",
  year =         "2018",
  DOI =          "https://doi.org/10.1016/j.jocs.2018.08.008",
  ISSN =         "1877-7503",
  bibdate =      "Fri Apr 9 15:22:25 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S187775031730738X",
  abstract =     "The development of scientific software can be
                 generally characterized by an initial phase of rapid
                 prototyping and the subsequent transition to
                 computationally efficient production code.
                 Unfortunately, most programming languages are not
                 well-suited for both tasks at the same time, commonly
                 resulting in a considerable extension of the
                 development time. The cross-platform and open-source
                 Julia language aims at closing the gap between
                 prototype and production code by providing a usability
                 comparable to Python or MATLAB alongside
                 high-performance capabilities known from C and C++ in a
                 single programming language. In this paper, we present
                 efficient protein electrostatics computations as a
                 showcase example for Julia. More specifically, we
                 present both finite element and boundary element
                 solvers for computing electrostatic potentials of
                 proteins in structured solvents. By modeling the latter
                 in an implicit but nonlocal fashion, we account for
                 correlation of molecular polarization due to the
                 solvent structure around the solute and sustain
                 accuracy without suffering from infeasible runtimes as
                 compared to the explicit case. In this context, we show
                 that our implementation is on par with optimized C code
                 and highlight the components of the implementation that
                 can be transferred to more general tasks.",
  acknowledgement = ack-nhfb,
  keywords =     "Protein electrostatics, Finite element method,
                 Boundary element method, Julia language",
}

@Article{Kieffer:2018:IBC,
  author =       "Jean Kieffer and Luca {De Feo}",
  title =        "Isogeny-based cryptography in {Julia\slash Nemo}: a
                 case study",
  journal =      j-ACM-COMM-COMP-ALGEBRA,
  volume =       "52",
  number =       "4",
  pages =        "130--132",
  month =        dec,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3338637.3338643",
  ISSN =         "1932-2232 (print), 1932-2240 (electronic)",
  ISSN-L =       "1932-2232",
  bibdate =      "Wed Oct 23 07:34:18 MDT 2019",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsam.bib",
  abstract =     "The Couveignes--Rostovtsev--Stolbunov key-exchange
                 protocol based on isogenies of elliptic curves is of
                 interest because it may resist quantum attacks, but its
                 efficient implementation remains a challenge. We
                 briefly present the computations involved, and
                 efficient algorithms to achieve the critical steps,
                 with timing results for our implementations in Sage and
                 Julia\slash Nemo.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Communications in Computer Algebra",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1000",
}

@Article{Kramer:2018:PQJ,
  author =       "Sebastian Kr{\"a}mer and David Plankensteiner and
                 Laurin Ostermann and Helmut Ritsch",
  title =        "\pkg{QuantumOptics.jl}: a {Julia} framework for
                 simulating open quantum systems",
  journal =      j-COMP-PHYS-COMM,
  volume =       "227",
  number =       "??",
  pages =        "109--116",
  month =        jun,
  year =         "2018",
  CODEN =        "CPHCBZ",
  DOI =          "https://doi.org/10.1016/j.cpc.2018.02.004",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Fri Mar 16 13:51:08 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0010465518300328",
  abstract =     "We present an open source computational framework
                 geared towards the efficient numerical investigation of
                 open quantum systems written in the Julia programming
                 language. Built exclusively in Julia and based on
                 standard quantum optics notation, the toolbox offers
                 speed comparable to low-level statically typed
                 languages, without compromising on the accessibility
                 and code readability found in dynamic languages. After
                 introducing the framework, we highlight its features
                 and showcase implementations of generic quantum models.
                 Finally, we compare its usability and performance to
                 two well-established and widely used numerical quantum
                 libraries. Program summary Program Title:
                 QuantumOptics.jl Program Files doi:
                 https://doi.org/10.17632/3696r5jhm4.1 Licensing
                 provisions: MIT Programming language: Julia
                 Supplementary material: Full list of functions (API) as
                 html Nature of problem: Dynamics of open quantum
                 systems Solution method: Numerically solving the
                 Schr{\"o}dinger or master equation or a Monte Carlo
                 wave-function approach. Additional comments including
                 Restrictions and Unusual features: The framework may be
                 used for problems that fulfill the necessary conditions
                 such that they can be described by a Schr{\"o}dinger or
                 master equation. Furthermore, the aim is to efficiently
                 and easily simulate systems of moderate size rather
                 than pushing the limits of what is possible
                 numerically.",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
  keywords =     "Julia programming language; Numerics; Quantum
                 mechanics; Quantum optics",
}

@InCollection{Kroger:2018:JOS,
  author =       "Ole Kr{\"o}ger and Carleton Coffrin and Hassan Hijazi
                 and Harsha Nagarajan",
  booktitle =    "{Integration of Constraint Programming, Artificial
                 Intelligence, and Operations Research}",
  title =        "{Juniper}: an Open-Source Nonlinear Branch-and-Bound
                 Solver in {Julia}",
  publisher =    "Springer International Publishing",
  address =      "Cham, Switzerland",
  pages =        "377--386",
  year =         "2018",
  DOI =          "https://doi.org/10.1007/978-3-319-93031-2_27",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-319-93031-2_27",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Lage-Freitas:2018:ADS,
  author =       "A. Lage-Freitas and R. P. Ribeiro and N. D. C.
                 Oliveira and A. C. Frery",
  booktitle =    "{IGARSS 2018 --- 2018 IEEE International Geoscience
                 and Remote Sensing Symposium}",
  title =        "An Automatic Deployment Support for Processing Remote
                 Sensing Data in the Cloud",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "2054--2057",
  year =         "2018",
  DOI =          "https://doi.org/10.1109/IGARSS.2018.8518964",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Infra.jl; Julia Master/Worker programming; Julia
                 programming language",
}

@Article{Landeros:2018:PBJ,
  author =       "Alfonso Landeros and Timothy Stutz and Kevin L. Keys
                 and Alexander Alekseyenko and Janet S. Sinsheimer and
                 Kenneth Lange and Mary E. Sehl",
  title =        "\pkg{BioSimulator.jl}: Stochastic simulation in
                 {Julia}",
  journal =      j-COMPUT-METH-PROG-BIOMED,
  volume =       "167",
  pages =        "23--35",
  month =        dec,
  year =         "2018",
  CODEN =        "CMPBEK",
  DOI =          "https://doi.org/10.1016/j.cmpb.2018.09.009",
  ISSN =         "0169-2607 (print), 1872-7565 (electronic)",
  ISSN-L =       "0169-2607",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0169260718301822",
  abstract =     "Background and Objectives: Biological systems with
                 intertwined feedback loops pose a challenge to
                 mathematical modeling efforts. Moreover, rare events,
                 such as mutation and extinction, complicate system
                 dynamics. Stochastic simulation algorithms are useful
                 in generating time-evolution trajectories for these
                 systems because they can adequately capture the
                 influence of random fluctuations and quantify rare
                 events. We present a simple and flexible package,
                 BioSimulator.jl, for implementing the Gillespie
                 algorithm, -leaping, and related stochastic simulation
                 algorithms. The objective of this work is to provide
                 scientists across domains with fast, user-friendly
                 simulation tools. Methods: We used the high-performance
                 programming language Julia because of its emphasis on
                 scientific computing. Our software package implements a
                 suite of stochastic simulation algorithms based on
                 Markov chain theory. We provide the ability to (a)
                 diagram Petri Nets describing interactions, (b) plot
                 average trajectories and attached standard deviations
                 of each participating species over time, and (c)
                 generate frequency distributions of each species at a
                 specified time. Results: BioSimulator.jl's interface
                 allows users to build models programmatically within
                 Julia. A model is then passed to the simulate routine
                 to generate simulation data. The built-in tools allow
                 one to visualize results and compute summary
                 statistics. Our examples highlight the broad
                 applicability of our software to systems of varying
                 complexity from ecology, systems biology, chemistry,
                 and genetics. Conclusion: The user-friendly nature of
                 BioSimulator.jl encourages the use of stochastic
                 simulation, minimizes tedious programming efforts, and
                 reduces errors during model specification.",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Methods and Programs in Biomedicine",
  keywords =     "-leaping; Gillespie algorithm; Julia programming
                 language; Stochastic simulation; Systems biology",
}

@Book{McNicholas:2018:DSJ,
  author =       "Paul D. McNicholas and Peter A. Tait",
  title =        "Data Science with {Julia}",
  publisher =    "Taylor and Francis, CRC Press",
  address =      "Boca Raton, FL, USA",
  pages =        "241",
  year =         "2018",
  DOI =          "https://doi.org/10.1201/9781351013673",
  ISBN =         "1-138-49998-6 (paperback), 1-351-01364-5 (e-book:
                 Mobipocket), 1-351-01365-3 (e-book), 1-351-01366-1
                 (e-book: PDF), 1-351-01367-X (e-book)",
  ISBN-13 =      "978-1-138-49998-0 (paperback), 978-1-351-01364-2
                 (e-book: Mobipocket), 978-1-351-01365-9 (e-book),
                 978-1-351-01366-6 (e-book: PDF), 978-1-351-01367-3
                 (e-book)",
  LCCN =         "QA76.73.J85 M37 2018",
  bibdate =      "Sat Sep 7 07:35:13 MDT 2019",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  abstract =     "``This book is a great way to both start learning data
                 science through the promising Julia language and to
                 become an efficient data scientist.''- Professor
                 Charles Bouveyron, INRIA Chair in Data Science,
                 Universitae Caote d'Azur, Nice, France. Julia, an
                 open-source programming language, was created to be as
                 easy to use as languages such as R and Python while
                 also as fast as C and Fortran. An accessible,
                 intuitive, and highly efficient base language with
                 speed that exceeds R and Python, makes Julia a
                 formidable language for data science. Using well known
                 data science methods that will motivate the reader,
                 Data Science with Julia will get readers up to speed on
                 key features of the Julia language and illustrate its
                 facilities for data science and machine learning work.
                 Features: Covers the core components of Julia as well
                 as packages relevant to the input, manipulation and
                 representation of data. Discusses several important
                 topics in data science including supervised and
                 unsupervised learning. Reviews data visualization using
                 the Gadfly package, which was designed to emulate the
                 very popular ggplot2 package in R. Readers will learn
                 how to make many common plots and how to visualize
                 model results. Presents how to optimize Julia code for
                 performance. Will be an ideal source for people who
                 already know R and want to learn how to use Julia
                 (though no previous knowledge of R or any other
                 programming language is required). The advantages of
                 Julia for data science cannot be understated. Besides
                 speed and ease of use, there are already over 1,900
                 packages available and Julia can interface (either
                 directly or through packages) with libraries written in
                 R, Python, Matlab, C, C++ or Fortran. The book is for
                 senior undergraduates, beginning graduate students, or
                 practicing data scientists who want to learn how to use
                 Julia for data science.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Data structures
                 (Computer science); COMPUTERS / Data Modeling and
                 Design; BUSINESS and ECONOMICS / Statistics;
                 MATHEMATICS / Probability and Statistics / General;
                 Data structures (Computer science); Julia (Computer
                 program language)",
  tableofcontents = "Cover \\
                 Half Title \\
                 Title Page \\
                 Copyright Page \\
                 Dedication \\
                 Table of Contents \\
                 Foreword \\
                 Preface \\
                 About the Authors \\
                 1: Introduction \\
                 1.1 DATA SCIENCE \\
                 1.2 BIG DATA \\
                 1.3 JULIA \\
                 1.4 JULIA AND R PACKAGES \\
                 1.5 DATASETS \\
                 1.5.1 Overview \\
                 1.5.2 Beer Data \\
                 1.5.3 Coffee Data \\
                 1.5.4 Leptograpsus Crabs Data \\
                 1.5.5 Food Preferences Data \\
                 1.5.6 x2 Data \\
                 1.5.7 Iris Data \\
                 1.6 OUTLINE OF THE CONTENTS OF THIS MONOGRAPH \\
                 2: Core Julia \\
                 2.1 VARIABLE NAMES \\
                 2.2 OPERATORS \\
                 2.3 TYPES \\
                 2.3.1 Numeric \\
                 2.3.2 Floats \\
                 2.3.3 Strings \\
                 2.3.4 Tuples \\
                 2.4 DATA STRUCTURES \\
                 2.4.1 Arrays \\
                 2.4.2 Dictionaries \\
                 2.5 CONTROL FLOW \\
                 2.5.1 Compound Expressions \\
                 2.5.2 Conditional Evaluation \\
                 2.5.3 Loops \\
                 2.5.3.1 Basics \\
                 2.5.3.2 Loop termination \\
                 2.5.3.3 Exception handling \\
                 2.6 FUNCTIONS \\
                 3: Working with Data \\
                 3.1 DATAFRAMES \\
                 3.2 CATEGORICAL DATA \\
                 3.3 INPUT/OUTPUT \\
                 3.4 USEFUL DATAFRAME FUNCTIONS \\
                 3.5 SPLIT-APPLY-COMBINE STRATEGY \\
                 3.6 QUERY. JL \\
                 4: Visualizing Data \\
                 4.1 GADFLY. JL \\
                 4.2 VISUALIZING UNIVARIATE DATA \\
                 4.3 DISTRIBUTIONS \\
                 4.4 VISUALIZING BIVARIATE DATA \\
                 4.5 ERROR BARS \\
                 4.6 FACETS \\
                 4.7 SAVING PLOTS \\
                 5: Supervised Learning \\
                 5.1 INTRODUCTION \\
                 5.2 CROSS-VALIDATION \\
                 5.2.1 Overview \\
                 5.2.2 K-Fold Cross-Validation \\
                 5.3 K-NEAREST NEIGHBOURS CLASSIFICATION \\
                 5.4 CLASSIFICATION AND REGRESSION TREES \\
                 5.4.1 Overview \\
                 5.4.2 Classification Trees \\
                 5.4.3 Regression Trees \\
                 5.4.4 Comments \\
                 5.5 BOOTSTRAP \\
                 5.6 RANDOM FORESTS \\
                 5.7 GRADIENT BOOSTING \\
                 5.7.1 Overview \\
                 5.7.2 Beer Data \\
                 5.7.3 Food Data \\
                 5.8 COMMENTS \\
                 6: Unsupervised Learning \\
                 6.1 INTRODUCTION \\
                 6.2 PRINCIPAL COMPONENTS ANALYSIS \\
                 6.3 PROBABILISTIC PRINCIPAL COMPONENTS ANALYSIS \\
                 6.4 EM ALGORITHM FOR PPCA \\
                 6.4.1 Background: EM Algorithm \\
                 6.4.2 E-step \\
                 6.4.3 M-step \\
                 6.4.4 Woodbury Identity \\
                 6.4.5 Initialization \\
                 6.4.6 Stopping Rule \\
                 6.4.7 Implementing the EM Algorithm for PPCA \\
                 6.4.8 Comments \\
                 6.5 K-MEANS CLUSTERING \\
                 6.6 MIXTURE OF PROBABILISTIC PRINCIPAL COMPONENTS
                 ANALYZERS \\
                 6.6.1 Model \\
                 6.6.2 Parameter Estimation \\
                 6.6.3 Illustrative Example: Coffee Data \\
                 6.7 COMMENTS \\
                 7: R Interoperability \\
                 7.1 ACCESSING R DATASETS \\
                 7.2 INTERACTING WITH R \\
                 7.3 EXAMPLE: CLUSTERING AND DATA REDUCTION FOR THE
                 COFFEE DATA \\
                 7.3.1 Coffee Data \\
                 7.3.2 PGMM Analysis \\
                 7.3.3 VSCC Analysis \\
                 7.4 EXAMPLE: FOOD DATA \\
                 7.4.1 Overview \\
                 7.4.2 Random Forests \\
                 APPENDIX A: Julia and R Packages Used Herein \\
                 APPENDIX B: Variables for Food Data \\
                 APPENDIX C: Useful Mathematical Results \\
                 C.1 BRIEF OVERVIEW OF EIGENVALUES \\
                 C.2 SELECTED LINEAR ALGEBRA RESULTS \\
                 C.3 MATRIX CALCULUS RESULTS \\
                 APPENDIX D: Performance Tips \\
                 D.1 FLOATING POINT NUMBERS \\
                 D.1.1 Do Not Test for Equality \\
                 D.1.2 Use Logarithms for Division \\
                 D.1.3 Subtracting Two Nearly Equal Numbers \\
                 D.2 JULIA PERFORMANCE \\
                 D.2.1 General Tips \\
                 D.2.2 Array Processing \\
                 D.2.3 Separate Core Computations \\
                 APPENDIX E: Linear Algebra Functions \\
                 E.1 VECTOR OPERATIONS \\
                 E.2 MATRIX OPERATIONS \\
                 E.3 MATRIX DECOMPOSITIONS \\
                 References \\
                 Index",
}

@Article{Mogensen:2018:POM,
  author =       "Patrick K. Mogensen and Asbj{\o}rn N. Riseth",
  title =        "\pkg{Optim}: A mathematical optimization package for
                 {Julia}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "3",
  number =       "24",
  pages =        "615:1--615:3",
  month =        apr,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00615",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/joss.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00615",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "04 April 2018",
  ORCID-numbers = "Patrick K. Mogensen / 0000-0002-4910-1932; Asbj{\o}rn
                 N. Riseth / 0000-0002-5861-7885",
}

@Article{Nardelli:2018:JSR,
  author =       "Francesco Zappa Nardelli and Julia Belyakova and Artem
                 Pelenitsyn and Benjamin Chung and Jeff Bezanson and Jan
                 Vitek",
  title =        "{Julia} subtyping: a rational reconstruction",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "113:1--113:27",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276483",
  ISSN =         "2475-1421",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276483",
  abstract =     "Programming languages that support multiple dispatch
                 rely on an expressive notion of subtyping to specify
                 method applicability. In these languages, type
                 annotations on method declarations are used to select,
                 out of a potentially large set of methods, the one that
                 is most appropriate for a particular tuple of
                 arguments. Julia is a language for scientific computing
                 built around multiple dispatch and an expressive
                 subtyping relation. This paper provides the first
                 formal definition of Julia's subtype relation and
                 motivates its design. We validate our specification
                 empirically with an implementation of our definition
                 that we compare against the existing Julia
                 implementation on a collection of real-world programs.
                 Our subtype implementation differs on 122 subtype tests
                 out of 6,014,476. The first 120 differences are due to
                 a bug in Julia that was fixed once reported; the
                 remaining 2 are under discussion.",
  acknowledgement = ack-nhfb,
  articleno =    "113",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@InProceedings{Regier:2018:CVU,
  author =       "J. Regier and K. Pamnany and K. Fischer and A. Noack
                 and M. Lam and J. Revels and S. Howard and R. Giordano
                 and D. Schlegel and J. McAuliffe and R. Thomas and .
                 Prabhat",
  booktitle =    "{2018 IEEE International Parallel and Distributed
                 Processing Symposium (IPDPS)}",
  title =        "Cataloging the Visible Universe Through {Bayesian}
                 Inference at Petascale",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "44--53",
  year =         "2018",
  DOI =          "https://doi.org/10.1109/IPDPS.2018.00015",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  abstract =     "Astronomical catalogs derived from wide-field imaging
                 surveys are an important tool for understanding the
                 Universe. We construct an astronomical catalog from 55
                 TB of imaging data using Celeste, a Bayesian
                 variational inference code written entirely in the
                 high-productivity programming language Julia. Using
                 over 1.3 million threads on 650,000 Intel Xeon Phi
                 cores of the Cori Phase II supercomputer, Celeste
                 achieves a peak rate of 1.54 DP PFLOP/s. Celeste is
                 able to jointly optimize parameters for 188M stars and
                 galaxies, loading and processing 178 TB across 8192
                 nodes in 14.6 minutes. To achieve this, Celeste
                 exploits parallelism at multiple levels (cluster, node,
                 and thread) and accelerates I/O through Cori's Burst
                 Buffer. Julia's native performance enables Celeste to
                 employ high-level constructs without resorting to
                 hand-written or generated low-level code
                 (C/C++/Fortran), and yet achieve petascale
                 performance.",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Salceanu:2018:JPP,
  author =       "Adrian Salceanu",
  title =        "{Julia} programming projects: learn {Julia 1.x} by
                 building apps for data analysis, visualization, machine
                 learning, and the {Web}",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "ix + 482",
  year =         "2018",
  ISBN =         "1-78829-725-3",
  ISBN-13 =      "978-1-78829-274-0, 978-1-78829-725-7 (e-book)",
  LCCN =         "QA76.73.J85",
  bibdate =      "Thu Apr 8 10:45:11 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://proquest.safaribooksonline.com/?fpi=9781788292740",
  abstract =     "A step-by-step guide that demonstrates how to build
                 simple-to-advanced applications through examples in
                 Julia Lang 1.x using modern tools Key Features Work
                 with powerful open-source libraries for data wrangling,
                 analysis, and visualization Develop full-featured,
                 full-stack web applications Learn to perform supervised
                 and unsupervised machine learning and time series
                 analysis with Julia Book Description Julia is a new
                 programming language that offers a unique combination
                 of performance and productivity. Its powerful features,
                 friendly syntax, and speed are attracting a growing
                 number of adopters from Python, R, and Matlab,
                 effectively raising the bar for modern general and
                 scientific computing. After six years in the making,
                 Julia has reached version 1.0. Now is the perfect time
                 to learn it, due to its large-scale adoption across a
                 wide range of domains, including fintech, biotech,
                 education, and AI. Beginning with an introduction to
                 the language, Julia Programming Projects goes on to
                 illustrate how to analyze the Iris dataset using
                 DataFrames. You will explore functions and the type
                 system, methods, and multiple dispatch while building a
                 web scraper and a web app. Next, you'll delve into
                 machine learning, where you'll build a books
                 recommender system. You will also see how to apply
                 unsupervised machine learning to perform clustering on
                 the San Francisco business database. After
                 metaprogramming, the final chapters will discuss dates
                 and time, time series analysis, visualization, and
                 forecasting. We'll close with package development,
                 documenting, testing and benchmarking. By the end of
                 the book, you will have gained the practical knowledge
                 to build real-world applications in Julia. What you
                 will learn Leverage Julia's strengths, its top
                 packages, and main IDE options Analyze and manipulate
                 datasets using Julia and DataFrames Write complex code
                 while building real-life Julia applications Develop and
                 run a web app using Julia and the HTTP package Build a
                 recommender system using supervised machine learning
                 Perform exploratory data analysis Apply unsupervised
                 machine learning algorithms Perform time series data
                 analysis, visualization, and forecasting Who this book
                 is for Data scientists, statisticians, business
                 analysts, and developers who are interested in learning
                 how to use Julia to crunch numbers, analyze data and
                 build apps will find this book useful. A basic
                 knowledge of programming is assumed.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Application
                 software; Development; Computer programs; COMPUTERS /
                 Programming Languages / General; Computer programs;
                 Julia (Computer program language)",
  tableofcontents = "Cover \\
                 Title Page \\
                 Copyright and Credits \\
                 Dedication \\
                 About Packt \\
                 Contributors \\
                 Table of Contents \\
                 Preface \\
                 1: Getting Started with Julia Programming \\
                 Technical requirements \\
                 Why Julia? \\
                 Good performance \\
                 Concise, readable, and intuitive syntax \\
                 Powerful and productive dynamic type system \\
                 Designed for parallelism and distributed computation
                 \\
                 Efficient intercommunication with other languages \\
                 Powerful REPL and shell-like capabilities \\
                 And more \ldots{} \\
                 Installing Julia \\
                 Windows \\
                 Official Windows installer \\
                 Using Chocolatey \\
                 Windows Subsystem for Linux \\
                 macOS \\
                 Official image \\
                 HomebrewLinux and FreeBSDDocker \\
                 JuliaPro \\
                 JuliaBox \\
                 Choosing an IDE \\
                 Juno (Atom) \\
                 Visual Studio Code \\
                 IJulia (JuliaBox) \\
                 Other options \\
                 Getting started with Julia \\
                 The Julia REPL \\
                 Interacting with the REPL \\
                 The ans variable \\
                 Prompt pasting \\
                 Tab completion \\
                 Cleaning the REPL scope \\
                 Additional REPL modes \\
                 Accessing the documentation with the help mode \\
                 Shell mode \\
                 Search modes \\
                 The startup.jl file \\
                 REPL hooks \\
                 Exiting the REPL \\
                 The package system \\
                 Adding a package \\
                 OhMyREPL \\
                 Custom package installation \\
                 Revise \\
                 Checking the package status \\
                 Using packages \\
                 One more step \\
                 Updating packages \\
                 Pinning packages \\
                 Removing packages \\
                 Discovering packages \\
                 Registered versus unregistered \\
                 Summary \\
                 2: Creating Our First Julia App \\
                 Technical requirements \\
                 Defining variables \\
                 Constants \\
                 Why are constants important? \\
                 Comments \\
                 Strings \\
                 Triple-quoted strings \\
                 Concatenating strings \\
                 Interpolating strings \\
                 Manipulating strings \\
                 Unicode and UTF-8 \\
                 Regular expressions \\
                 Raw string literals \\
                 Numbers \\
                 Integers \\
                 Overflow behavior \\
                 Floating-point numbers \\
                 Rational numbers \\
                 Numerical operators \\
                 Vectorized dot operators \\
                 There's more to it \\
                 Tuples \\
                 Named tuples \\
                 Ranges \\
                 Arrays \\
                 Iteration \\
                 Mutating arrays \\
                 Comprehensions \\
                 Generators \\
                 Exploratory data analysis with Julia \\
                 The Iris flower dataset \\
                 Using the RDatasets package \\
                 Using simple statistics to better understand our data
                 \\
                 Visualizing the Iris flowers data \\
                 Loading and saving our data \\
                 Saving and loading using tabular file formats \\
                 Working with Feather files \\
                 Saving and loading with MongoDB \\
                 Summary \\
                 3: Setting Up the Wiki Game \\
                 Technical requirements \\
                 Data harvesting through web scraping \\
                 How the web works \\
                 a crash course \\
                 Making HTTP requests \\
                 Learning about HTTP methods \\
                 Understanding HTTPS \\
                 Understanding HTML documents \\
                 HTML selectors \\
                 Learning about the HTML attributes \\
                 Learning about CSS and JavaScript selectors \\
                 Understanding the structure of a link \\
                 Accessing the internet from Julia \\
                 Making requests with the HTTP package \\
                 Handling HTTP responses \\
                 HTTP status codes \\
                 Learning about HTTP headers \\
                 The HTTP message body \\
                 Understanding HTTP responses \\
                 The status code \\
                 The headers \\
                 The message body \\
                 Learning about pairs \\
                 Dictionaries \\
                 Constructing dictionaries \\
                 Ordered dictionaries \\
                 Working with dictionaries \\
                 Using the HTTP response \\
                 Manipulating the response body",
}

@InProceedings{Srivastava:2018:PEE,
  author =       "P. Srivastava and M. Kang and S. K. Gonugondla and S.
                 Lim and J. Choi and V. Adve and N. S. Kim and N.
                 Shanbhag",
  booktitle =    "{2018 ACM/IEEE 45th Annual International Symposium on
                 Computer Architecture (ISCA)}",
  title =        "{PROMISE}: An End-to-End Design of a Programmable
                 Mixed-Signal Accelerator for Machine-Learning
                 Algorithms",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "43--56",
  year =         "2018",
  DOI =          "https://doi.org/10.1109/ISCA.2018.00015",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Voulgaris:2018:J,
  author =       "Zacharias Voulgaris",
  booktitle =    "{Encyclopedia of Big Data Technologies}",
  title =        "{Julia}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2018",
  DOI =          "https://doi.org/10.1007/978-3-319-63962-8_268-2",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/referenceworkentry/10.1007/978-3-319-63962-8_268-2",
  acknowledgement = ack-nhfb,
}

@Article{Amores:2019:ACB,
  author =       "V{\'\i}ctor Jes{\'u}s Amores and Jos{\'e} Mar{\'\i}a
                 Ben{\'\i}tez and Francisco Javier Mont{\'a}ns",
  title =        "Average-chain behavior of isotropic incompressible
                 polymers obtained from macroscopic experimental data.
                 {A} simple structure-based {WYPiWYG} model in {Julia}
                 language",
  journal =      j-ADV-ENG-SOFTWARE,
  volume =       "130",
  pages =        "41--57",
  year =         "2019",
  CODEN =        "AESODT",
  DOI =          "https://doi.org/10.1016/j.advengsoft.2019.01.004",
  ISSN =         "0965-9978 (print), 0141-1195 (electronic)",
  ISSN-L =       "0965-9978",
  bibdate =      "Fri Apr 9 15:22:25 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0965997818310779",
  abstract =     "Elastomeric materials and soft biological tissues are
                 made up of synthetic and protein fibers, respectively.
                 The uncoiling of these fibers during loading produces a
                 non-linear elastic macroscopic behavior in the regime
                 of finite strains. Many hyperelastic models have been
                 developed to reproduce this behavior assuming the
                 existence of a strain energy function. In
                 structure-based models, the analytical energy function
                 is obtained from the stored energy of all the material
                 constituents. This stored energy is given frequently by
                 the entropy of the chain network obtained from Langevin
                 statistical treatment of the possible configurations
                 adopted by the chains, and a representative cell for
                 their spatial distribution. One of the most used models
                 is the eight chain model, being its salient feature
                 that it reproduces the overall response of isotropic
                 hyperelastic materials with only two material
                 parameters obtained from a tensile test. On the other
                 hand, in WYPiWYG hyperelasticity the stored energies
                 are numerical instead of analytical and capture, to any
                 precision, the experimental tests on the material.
                 However, due to their phenomenological nature, their
                 determination requires more tests. In this work, we
                 develop a microstructure-based WYPiWYG hyperelastic
                 model in which the average chain behavior is obtained
                 from macroscopic tests through a simple automatic
                 inverse procedure. We show that, without assuming a
                 probability distribution function nor any particular
                 chain arrangement, we obtain, at the same computational
                 cost, better predictions than the 8-chain model. Code
                 of the model and of the examples in the Julia
                 programming language are included.",
  acknowledgement = ack-nhfb,
  fjournal =     "Advances in Engineering Software (1978)",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01411195",
  keywords =     "Eight chain model, WYPiWYG hyperelasticity,
                 Micromechanics, Julia",
}

@Book{Balbaert:2019:JPC,
  author =       "Ivo Balbaert and Adrian Salceanu",
  title =        "{Julia 1.0} programming complete reference guide:
                 discover {Julia}, a high-performance language for
                 technical computing",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "viii + 451",
  year =         "2019",
  ISBN =         "1-83882-467-7",
  ISBN-13 =      "978-1-83882-224-8, 978-1-83882-467-9",
  LCCN =         "QA76.73.J84",
  bibdate =      "Thu Apr 8 11:03:56 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  series =       "Learning path",
  URL =          "http://proquest.safaribooksonline.com/?fpi=9781838822248",
  abstract =     "Learn dynamic programming with Julia to build apps for
                 data analysis, visualization, machine learning, and the
                 web Key Features Leverage Julia's high speed and
                 efficiency to build fast, efficient applications
                 Perform supervised and unsupervised machine learning
                 and time series analysis Tackle problems concurrently
                 and in a distributed environment Book Description Julia
                 offers the high productivity and ease of use of Python
                 and R with the lightning-fast speed of C++. There's
                 never been a better time to learn this language, thanks
                 to its large-scale adoption across a wide range of
                 domains, including fintech, biotech and artificial
                 intelligence (AI). You will begin by learning how to
                 set up a running Julia platform, before exploring its
                 various built-in types. This Learning Path walks you
                 through two important collection types: arrays and
                 matrices. You'll be taken through how type conversions
                 and promotions work, and in further chapters you'll
                 study how Julia interacts with operating systems and
                 other languages. You'll also learn about the use of
                 macros, what makes Julia suitable for numerical and
                 scientific computing, and how to run external programs.
                 Once you have grasped the basics, this Learning Path
                 goes on to how to analyze the Iris dataset using
                 DataFrames. While building a web scraper and a web app,
                 you'll explore the use of functions, methods, and
                 multiple dispatches. In the final chapters, you'll
                 delve into machine learning, where you'll build a book
                 recommender system. By the end of this Learning Path,
                 you'll be well versed with Julia and have the skills
                 you need to leverage its high speed and efficiency for
                 your applications. This Learning Path includes content
                 from the following Packt products: Julia 1.0
                 Programming - Second Edition by Ivo Balbaert Julia
                 Programming Projects by Adrian Salceanu What you will
                 learn Create your own types to extend the built-in type
                 system Visualize your data in Julia with plotting
                 packages Explore the use of built-in macros for testing
                 and debugging Integrate Julia with other languages such
                 as C, Python, and MATLAB Analyze and manipulate
                 datasets using Julia and DataFrames Develop and run a
                 web app using Julia and the HTTP package Build a
                 recommendation system using supervised machine learning
                 Who this book is for If you are a statistician or data
                 scientist who wants a quick course in the Julia
                 programming language while building big data
                 applications, this Learning Path is for you.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Application
                 software; Development; Development; Julia (Computer
                 program language)",
}

@Article{Besard:2019:EEP,
  author =       "Tim Besard and Christophe Foket and Bjorn {De
                 Sutter}",
  title =        "Effective Extensible Programming: Unleashing {Julia}
                 on {GPUs}",
  journal =      j-IEEE-TRANS-PAR-DIST-SYS,
  volume =       "30",
  number =       "4",
  pages =        "827--841",
  month =        apr,
  year =         "2019",
  CODEN =        "ITDSEO",
  DOI =          "https://doi.org/10.1109/TPDS.2018.2872064",
  ISSN =         "1045-9219 (print), 1558-2183 (electronic)ITDSEO",
  ISSN-L =       "1045-9219",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/ieeetranspardistsys.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://ieeexplore.ieee.org/document/8471188/",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Parallel and Distributed
                 Systems",
  journal-URL =  "https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=71",
  keywords =     "Julia programming language",
}

@Article{Biel:2019:PPJ,
  author =       "Martin Biel and Arda Aytekin and Mikael Johansson",
  title =        "\pkg{POLO.jl}: Policy-based optimization algorithms in
                 {Julia}",
  journal =      j-ADV-ENG-SOFTWARE,
  volume =       "136",
  pages =        "102695",
  year =         "2019",
  CODEN =        "AESODT",
  DOI =          "https://doi.org/10.1016/j.advengsoft.2019.102695",
  ISSN =         "0965-9978 (print), 0141-1195 (electronic)",
  ISSN-L =       "0965-9978",
  bibdate =      "Fri Apr 9 15:22:25 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0965997818311049",
  abstract =     "We present POLO.jl a Julia package that helps
                 algorithm developers and machine-learning practitioners
                 design and use state-of-the-art parallel optimization
                 algorithms in a flexible and efficient way. POLO.jl
                 extends our C++ library POLO, which has been designed
                 and implemented with the same intentions. POLO.jl not
                 only wraps selected algorithms in POLO and provides an
                 easy mechanism to use data manipulation facilities and
                 loss function definitions in Julia together with the
                 underlying compiled C++ library, but it also uses the
                 policy-based design technique in a Julian way to help
                 users prototype optimization algorithms from their own
                 building blocks. In our experiments, we observe that
                 there is little overhead when using the compiled C++
                 code directly within Julia. We also notice that the
                 performance of algorithms implemented in pure Julia is
                 comparable with that of their C++ counterparts. Both
                 libraries are hosted on
                 GitHub11https://github.com/pologrpunder the free MIT
                 license, and can be used easily by pulling the
                 pre-built 64-bit architecture Docker
                 images.22https://hub.docker.com/r/pologrp/polo-julia/",
  acknowledgement = ack-nhfb,
  fjournal =     "Advances in Engineering Software (1978)",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01411195",
}

@InProceedings{Bogomolov:2019:J,
  author =       "Sergiy Bogomolov and Marcelo Forets and Goran Frehse
                 and Kostiantyn Potomkin and Christian Schilling",
  booktitle =    "{Proceedings of the 22nd ACM International Conference
                 on Hybrid Systems: Computation and Control}",
  title =        "{JuliaReach}",
  publisher =    pub-ACM,
  address =      pub-ACM:adr,
  month =        apr,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3302504.3311804",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Caraiani:2019:IQM,
  author =       "Petre Caraiani",
  title =        "Introduction to Quantitative Macroeconomics Using
                 {Julia}: From Basic to State-of-the-Art Computational
                 Techniques",
  publisher =    pub-ACADEMIC,
  address =      pub-ACADEMIC:adr,
  year =         "2019",
  DOI =          "https://doi.org/10.1016/B978-0-12-812219-8.00008-2",
  ISBN =         "0-12-812219-6, 0-12-813512-3 (e-book)",
  ISBN-13 =      "978-0-12-812219-8, 978-0-12-813512-9 (e-book)",
  LCCN =         "HB172.5",
  bibdate =      "Thu Apr 8 16:44:48 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/B9780128122198000082",
  abstract =     "\booktitle{Introduction to Quantitative Macroeconomics
                 Using Julia: From Basic to State-of-the-Art
                 Computational Techniques} facilitates access to
                 fundamental techniques in computational and
                 quantitative macroeconomics. It focuses on the recent
                 and very promising software, Julia, which offers a
                 MATLAB-like language at speeds comparable to C/Fortran,
                 also discussing modeling challenges that make
                 quantitative macroeconomics dynamic, a key feature that
                 few books on the topic include for macroeconomists who
                 need the basic tools to build, solve and simulate
                 macroeconomic models. This book neatly fills the gap
                 between intermediate macroeconomic books and modern
                 DSGE models used in research. Combines an introduction
                 to Julia, with the specific needs of macroeconomic
                 students who are interested in DSGE models and PhD
                 students and researchers interested in building DSGE
                 models Teaches fundamental techniques in quantitative
                 macroeconomics by introducing theoretical elements of
                 key macroeconomic models and their potential
                 algorithmic implementations. Exposes researchers
                 working in macroeconomics to state-of-the-art
                 computational techniques for simulating and solving
                 DSGE models''",
  acknowledgement = ack-nhfb,
  keywords =     "Julia Language, IDE, Type System, Multiple Dispatch,
                 Vectorization",
  subject =      "Macroeconomics; Computer simulation; Julia (Computer
                 program language); BUSINESS and ECONOMICS / Economics /
                 Macroeconomics; POLITICAL SCIENCE / Economic
                 Conditions; Julia (Computer program language); Computer
                 simulation.",
  tableofcontents = "Introduction to Julia \\
                 Basic numerical techniques \\
                 Solving and simulating DSGE models \\
                 Dynamic programming \\
                 Advanced numerical techniques \\
                 Heterogeneous agents models",
}

@InProceedings{Congedo:2019:JPM,
  author =       "M. Congedo and S. Jain",
  booktitle =    "{2019 IEEE International Conference on Systems, Man
                 and Cybernetics (SMC)}",
  title =        "A {Julia} Package for manipulating Brain--Computer
                 Interface Data in the Manifold of Positive Definite
                 Matrices",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "211--216",
  year =         "2019",
  DOI =          "https://doi.org/10.1109/SMC.2019.8914223",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Cunningham:2019:PPJ,
  author =       "Nathan Cunningham and Jim E. Griffin and David L. Wild
                 and Anthony Lee",
  booktitle =    "{Bayesian Statistics and New Generations}",
  title =        "\pkg{particleMDI}: a {Julia} Package for the
                 Integrative Cluster Analysis of Multiple Datasets",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2019",
  DOI =          "https://doi.org/10.1007/978-3-030-30611-3_7",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-030-30611-3_7",
  acknowledgement = ack-nhfb,
}

@Book{Downey:2019:TJ,
  author =       "Allen B. Downey and Ben Lauwens",
  title =        "Think Julia",
  publisher =    pub-ORA-MEDIA,
  address =      pub-ORA-MEDIA:adr,
  year =         "2019",
  ISBN =         "1-4920-4500-4 (e-book), 1-4920-4503-9",
  ISBN-13 =      "978-1-4920-4500-7 (e-book), 978-1-4920-4503-8",
  LCCN =         "QA76.73.J85 L38 2019",
  bibdate =      "Thu Apr 8 16:41:21 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/unicode.bib",
  abstract =     "If you're just learning how to program, Julia is an
                 excellent JIT-compiled, dynamically-typed language with
                 a clean syntax. This hands-on guide uses Julia (version
                 1.0) to walk you through programming one step at a
                 time, beginning with basic programming concepts before
                 moving on to more advanced capabilities, such as
                 creating new types and multiple dispatch. Designed from
                 the beginning for high performance, Julia is a
                 general-purpose language not only ideal for numerical
                 analysis and computational science, but also for web
                 programming or scripting. Through exercises in each
                 chapter, you'll try out programming concepts as you
                 learn them. Think Julia is ideal for students at the
                 high school or college level, as well as self-learners,
                 home-schooled students, and professionals who need to
                 learn programming basics. Start with the basics,
                 including language syntax and semantics Get a clear
                 definition of each programming concept Learn about
                 values, variables, statements, functions, and data
                 structures in a logical progression Discover how to
                 work with files and databases Understand types,
                 methods, and multiple dispatch Use debugging techniques
                 to fix syntax, runtime, and semantic errors Explore
                 interface design and data structures through case
                 studies.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Computer
                 programming; Data structures (Computer science);
                 Object-oriented programming (Computer science);
                 COMPUTERS; Programming Languages; General; Computer
                 programming; Data structures (Computer science); Julia
                 (Computer program language); Object-oriented
                 programming (Computer science)",
  tableofcontents = "The way of the program \\
                 Variables, expressions, and statements \\
                 Functions \\
                 Case study: interface design \\
                 Conditionals and recursion \\
                 Fruitful functions \\
                 Iteration \\
                 Strings \\
                 Case study: word play \\
                 Arrays \\
                 Dictionaries \\
                 Tuples \\
                 Case study: data structure selection \\
                 Files \\
                 Structs and objects \\
                 Structs and functions \\
                 Multiple dispatch \\
                 Subtyping \\
                 The goodies: syntax \\
                 The goodies: base and standard library \\
                 Debugging \\
                 Unicode input \\
                 JuliaBox",
}

@InProceedings{Farhana:2019:SPE,
  author =       "E. Farhana and N. Imtiaz and A. Rahman",
  booktitle =    "{2019 IEEE International Conference on Software
                 Maintenance and Evolution (ICSME)}",
  title =        "Synthesizing Program Execution Time Discrepancies in
                 {Julia} Used for Scientific Software",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "496--500",
  year =         "2019",
  DOI =          "https://doi.org/10.1109/ICSME.2019.00083",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Fischer:2019:BRD,
  author =       "Daniel Fischer",
  title =        "Book Review: {{\booktitle{Data Science with Julia}},
                 Paul D. McNicholas and Peter A. Tait, CRC Press, 2019,
                 220 pages, \pounds 37.59, paperback, ISBN:
                 978-1-138-49998-0}",
  journal =      j-INT-STAT-REV,
  volume =       "87",
  number =       "2",
  pages =        "445--446",
  month =        aug,
  year =         "2019",
  CODEN =        "ISTRDP",
  DOI =          "https://doi.org/10.1111/insr.12345",
  ISSN =         "0306-7734 (print), 1751-5823 (electronic)",
  ISSN-L =       "0306-7734",
  bibdate =      "Sat Sep 7 07:31:05 MDT 2019",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/intstatrev.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "International Statistical Review",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1111/(ISSN)1751-5823;
                 http://www.jstor.org/journals/03067734.html",
  onlinedate =   "13 August 2019",
}

@InProceedings{Gevorkyan:2019:SSC,
  author =       "Migran N. Gevorkyan and Anna V. Korolkova and Dmitry
                 S. Kulyabov and Konstantin P. Lovetskiy",
  booktitle =    "{Numerical Methods and Applications}",
  title =        "Statistically Significant Comparative Performance
                 Testing of {Julia} and {Fortran} Languages in Case of
                 {Runge -Kutta} Methods",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2019",
  DOI =          "https://doi.org/10.1007/978-3-030-10692-8_45",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/fortran3.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-030-10692-8_45",
  acknowledgement = ack-nhfb,
}

@InProceedings{Gjersvik:2019:PSA,
  author =       "A. Gjersvik and R. J. Moss",
  booktitle =    "{2019 IEEE High Performance Extreme Computing
                 Conference (HPEC)}",
  title =        "A Parallel Simulation Approach to {ACAS X}
                 Development",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--6",
  year =         "2019",
  DOI =          "https://doi.org/10.1109/HPEC.2019.8916301",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  abstract =     "With a rapidly growing and evolving National Airspace
                 System (NAS), ACAS X is intended to be the
                 nextgeneration airborne collision avoidance system that
                 can meet the demands its predecessor could not. The
                 ACAS X algorithms are developed in the Julia
                 programming language and are exercised in simulation
                 environments tailored to test different characteristics
                 of the system. Massive parallelization of these
                 simulation environments has been implemented on the
                 Lincoln Laboratory Supercomputing Center cluster in
                 order to expedite the design and performance
                 optimization of the system. This work outlines the
                 approach to parallelization of one of our simulation
                 tools and presents the resulting simulation speedups as
                 well as a discussion on how it will enhance system
                 characterization and design. Parallelization has made
                 our simulation environment 33 times faster, which has
                 greatly sped up the development process of ACAS X.",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Glos:2019:PQJ,
  author =       "Adam Glos and Jaros{\l}aw Adam Miszczak and Mateusz
                 Ostaszewski",
  title =        "\pkg{QSWalk.jl}: {Julia} package for quantum
                 stochastic walks analysis",
  journal =      j-COMP-PHYS-COMM,
  volume =       "235",
  number =       "??",
  pages =        "414--421",
  month =        feb,
  year =         "2019",
  CODEN =        "CPHCBZ",
  DOI =          "https://doi.org/10.1016/j.cpc.2018.09.001",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0010465518303151",
  abstract =     "The paper describes QSWalk.jl package for Julia
                 programming language, developed for the purpose of
                 simulating the evolution of open quantum systems. The
                 package enables the study of quantum procedures
                 developed using stochastic quantum walks on arbitrary
                 directed graphs. We provide a detailed description of
                 the implemented functions, along with a number of usage
                 examples. The package is compared with the existing
                 software offering a similar functionality. Program
                 summary Program Title: QSWalk.jl Program Files doi:
                 https://doi.org/10.17632/6x37kcvvrp.1 Licensing
                 provisions: MIT Programming language: Julia Nature of
                 problem: The package implements functions for
                 simulating quantum stochastic walks, including local
                 regime, global regime, and nonmoralizing global regime
                 (Julia documentation, 2018). It can be used for
                 arbitrary quantum continuous evolution based on GKSL
                 master equation on arbitrary graphs. Solution method:
                 We utilize Expokit routines for fast sparse matrix
                 exponentials on vectors. For dense matrices,
                 exponentiation is computed separately, which is faster
                 for small matrices. Restrictions: Currently package
                 requires Julia v0.6 or higher. [1] K. Domino, A. Glos,
                 M. Ostaszewski, Superdiffusive quantum stochastic walk
                 definable of arbitrary directed graph, Quantum Inform.
                 Comput 17 (11-12) (2017) 973 986.",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
  keywords =     "Directed graph; Julia programming language; Moral
                 graph; Open quantum system; Quantum walk",
}

@InProceedings{Huang:2019:PCJ,
  author =       "R. Huang and W. Xu and Y. Wang and S. Liverani and A.
                 E. Stapleton",
  booktitle =    "{2019 IEEE International Conference on Big Data (Big
                 Data)}",
  title =        "Performance Comparison of {Julia} Distributed
                 Implementations of {Dirichlet} Process Mixture Models",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "3350--3354",
  year =         "2019",
  DOI =          "https://doi.org/10.1109/BigData47090.2019.9005453",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Koolen:2019:JRS,
  author =       "T. Koolen and R. Deits",
  booktitle =    "{2019 International Conference on Robotics and
                 Automation (ICRA)}",
  title =        "{Julia} for robotics: simulation and real-time control
                 in a high-level programming language",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "604--611",
  year =         "2019",
  DOI =          "https://doi.org/10.1109/ICRA.2019.8793875",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Kwon:2019:JPO,
  author =       "Changhyun Kwon",
  title =        "{Julia} programming for operations research",
  publisher =    "Independently published",
  address =      "North Charleston, SC, USA",
  edition =      "Second",
  pages =        "x + 250",
  year =         "2019",
  ISBN =         "1-79820-547-5",
  ISBN-13 =      "978-1-79820-547-1",
  LCCN =         "QA76.73.J85 K8-62-019",
  bibdate =      "Thu Apr 8 16:47:14 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  abstract =     "This book is neither a textbook in numerical methods,
                 a comprehensive introductory book to Julia programming,
                 a textbook on numerical optimization, a complete manual
                 of optimization solvers, nor an introductory book to
                 computational science and engineering --- it is a
                 little bit of all.",
  acknowledgement = ack-nhfb,
  remark =       "Now Julia v1.0 and JuMP v0.19 have been released.
                 There were major upgrades in both Julia and JuMP
                 including many breaking changes. The second edition of
                 this book has been updated to reflect these changes. In
                 addition, new chapters for ``Interior Point Methods''
                 and ``Complementarity Problems'' are added.",
  subject =      "Operations Research.; Programmierung.; Julia
                 (Programmiersprache)",
  tableofcontents = "1. Introduction and installation \\
                 2. Simple linear optimization \\
                 3. Basics of the Julia language \\
                 4. Selected topics in numerical methods \\
                 5. The simplex method \\
                 6. Network optimization problems \\
                 7. Interior point methods \\
                 8. Nonlinear optimization problems \\
                 9. Monte Carlo methods \\
                 10. Lagrangian relaxation \\
                 11. Complementary problems \\
                 12. Parameters in optimization solvers",
}

@Book{Kwong:2019:HDP,
  author =       "Tom Kwong",
  title =        "Hands-on design patterns with {Julia 1.0}: a
                 comprehensive guide to build robust, reusable, and
                 easily maintainable applications",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "532",
  year =         "2019",
  ISBN =         "1-83864-661-2, 1-83864-661-2 (PDF)",
  ISBN-13 =      "978-1-83864-661-5, 978-1-83864-661-5 (PDF)",
  LCCN =         "QA76.73.J85",
  bibdate =      "Thu Apr 8 17:04:42 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  abstract =     "Design and develop high-performance, reusable, and
                 maintainable applications using traditional and modern
                 Julia patterns with this comprehensive guide. Key
                 Features Explore useful design patterns along with
                 object-oriented programming in Julia 1.0. Implement
                 macros and metaprogramming techniques to make your code
                 faster, concise, and efficient Develop the skills
                 necessary to implement design patterns for creating
                 robust and maintainable applications Book Description
                 Design patterns are fundamental techniques for
                 developing reusable and maintainable code. They provide
                 a set of proven solutions that allow developers to
                 solve problems in software development quickly. This
                 book will demonstrate how to leverage design patterns
                 with real-world applications. . Starting with an
                 overview of design patterns and best practices in
                 application design, you'll learn about some of the most
                 fundamental Julia features such as modules, data types,
                 functions\slash interfaces, and metaprogramming. You'll
                 then get to grips with the modern Julia design patterns
                 for building large-scale applications with a focus on
                 performance, reusability, robustness, and
                 maintainability. The book also covers anti-patterns and
                 how to avoid common mistakes and pitfalls in
                 development. You'll see how traditional object-oriented
                 patterns can be implemented differently and more
                 effectively in Julia. Finally, you'll explore various
                 use cases and examples, such as how expert Julia
                 developers use design patterns in their open source
                 packages. By the end of this Julia programming book,
                 you'll have learned methods to improve software design,
                 extensibility, and reusability, and be able to use
                 design patterns efficiently to overcome common
                 challenges in software development. What you will learn
                 Master the Julia language features that are key to
                 developing large-scale software applications Discover
                 design patterns to improve overall application
                 architecture and design. Develop reusable programs that
                 are modular, extendable, performant, and easy to
                 maintain. Weigh up the pros and cons of using different
                 design patterns for use cases. Explore methods for
                 transitioning from object-oriented programming to using
                 equivalent or more advanced Julia techniques Who this
                 book is for This book is for beginner to
                 intermediate-level Julia programmers who want to
                 enhance their skills in designing and developing
                 large-scale applications.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Computer software;
                 Development; Development; Julia (Computer program
                 language)",
}

@Book{Lauwens:2019:TJH,
  author =       "Ben Lauwens and Allen Downey",
  title =        "Think {Julia}: how to think like a computer
                 scientist",
  publisher =    pub-ORA-MEDIA,
  address =      pub-ORA-MEDIA:adr,
  pages =        "xviii + 276",
  year =         "2019",
  ISBN =         "1-4920-4503-9",
  ISBN-13 =      "978-1-4920-4503-8",
  LCCN =         "QA76.73.J85",
  bibdate =      "Thu Apr 8 17:09:12 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://proquest.safaribooksonline.com/?fpi=9781492045021",
  abstract =     "If you're just learning how to program, Julia is an
                 excellent JIT-compiled, dynamically-typed language with
                 a clean syntax. This hands-on guide uses Julia (version
                 1.0) to walk you through programming one step at a
                 time, beginning with basic programming concepts before
                 moving on to more advanced capabilities, such as
                 creating new types and multiple dispatch. Designed from
                 the beginning for high performance, Julia is a
                 general-purpose language not only ideal for numerical
                 analysis and computational science, but also for web
                 programming or scripting. Through exercises in each
                 chapter, you'll try out programming concepts as you
                 learn them. Think Julia is ideal for students at the
                 high school or college level, as well as self-learners,
                 home-schooled students, and professionals who need to
                 learn programming basics. Start with the basics,
                 including language syntax and semantics Get a clear
                 definition of each programming concept Learn about
                 values, variables, statements, functions, and data
                 structures in a logical progression Discover how to
                 work with files and databases Understand types,
                 methods, and multiple dispatch Use debugging techniques
                 to fix syntax, runtime, and semantic errors Explore
                 interface design and data structures through case
                 studies.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Dynamic
                 programming; Dynamic programming.; Julia (Computer
                 program language)",
}

@InProceedings{Lobianco:2019:IJO,
  author =       "Antonello Lobianco",
  booktitle =    "{Julia Quick Syntax Reference}",
  title =        "Interfacing {Julia} with Other Languages",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2019",
  DOI =          "https://doi.org/10.1007/978-1-4842-5190-4_7",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-1-4842-5190-4_7",
  acknowledgement = ack-nhfb,
}

@Book{Lobianco:2019:JQS,
  author =       "Antonello Lobianco",
  title =        "{Julia} quick syntax reference: a pocket guide for
                 data science programming",
  publisher =    pub-APRESS,
  address =      pub-APRESS:adr,
  pages =        "xvii + 216 + 66",
  year =         "2019",
  DOI =          "https://doi.org/10.1007/978-1-4842-5190-4",
  ISBN =         "1-4842-5189-X, 1-4842-5190-3 (e-book)",
  ISBN-13 =      "978-1-4842-5189-8, 978-1-4842-5190-4 (e-book)",
  LCCN =         "QA76.73.J85",
  bibdate =      "Thu Apr 8 11:08:50 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/book/10.1007/978-1-4842-5190-4",
  abstract =     "This quick Julia programming language guide is a
                 condensed code and syntax reference to the Julia 1.x
                 programming language, updated with the latest features
                 of the Julia APIs, libraries, and packages. It presents
                 the essential Julia syntax in a well-organized format
                 that can be used as a handy reference. This book
                 provides an introduction that reveals basic Julia
                 structures and syntax; discusses data types, control
                 flow, functions, input/output, exceptions,
                 metaprogramming, performance, and more. Additionally,
                 you'll learn to interface Julia with other programming
                 languages such as R for statistics or Python. You will
                 learn how to use Julia packages for data analysis,
                 numerical optimization and symbolic computation, and
                 how to disseminate your results in dynamic documents or
                 interactive web pages. In this book, the focus is on
                 providing important information as quickly as possible.
                 It is packed with useful information and is a must-have
                 for any Julia programmer. What You Will Learn Set up
                 the software needed to run Julia and your first Hello
                 World example Work with types and the different
                 containers that Julia makes available for rapid
                 application development Use vectorized, classical
                 loop-based code, logical operators, and blocks Explore
                 Julia functions by looking at arguments, return values,
                 polymorphism, parameters, anonymous functions, and
                 broadcasts Build custom structures in Julia Interface
                 Julia with other languages such as C/C++, Python, and R
                 Program a richer API, modifying the code before it is
                 executed using expressions, symbols, macros, quote
                 blocks, and more Maximize your code's performance Who
                 This Book Is For Experienced programmers new to Julia,
                 as well as existing Julia coders new to the now stable
                 Julia version 1.0 release.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Computer
                 programming; Handbooks, manuals, etc; Computer
                 programming; Julia (Computer program language)",
  tableofcontents = "Part 1. Language Core \\
                 1. Getting Started \\
                 2. Data Types and Structures \\
                 3. Control Flow and Functions \\
                 4. Custom Types \\
                 5. Input? Output \\
                 6. Metaprogramming and Macros \\
                 7. Interfacing Julia with Other Languages \\
                 8. Efficiently Write Efficient Code \\
                 Part 2. Packages Ecosystem \\
                 9. Working with Data \\
                 10. Mathematical Libraries \\
                 11. Utilities",
}

@InProceedings{Medeiros:2019:USP,
  author =       "Johannes D. {Medeiros, Jr.} and Eduardo T. Costa",
  booktitle =    "{XXVI Brazilian Congress on Biomedical Engineering}",
  title =        "Ultrasound Signal Processing Using the {Julia}
                 Programming Language",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2019",
  DOI =          "https://doi.org/10.1007/978-981-13-2517-5_77",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-981-13-2517-5_77",
  acknowledgement = ack-nhfb,
}

@Article{Moille:2019:PFU,
  author =       "Gregory Moille and Qing Li and Lu Xiyuan and Kartik
                 Srinivasan",
  title =        "{pyLLE}: a Fast and User Friendly {Lugiato--Lefever}
                 Equation Solver",
  journal =      j-J-RES-NATL-INST-STAND-TECHNOL,
  volume =       "124",
  month =        may,
  year =         "2019",
  CODEN =        "JRITEF",
  DOI =          "https://doi.org/10.6028/jres.124.012",
  ISSN =         "1044-677X (print), 2165-7254 (electronic)",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of research of the National Institute of
                 Standards and Technology",
  journal-URL =  "http://www.nist.gov/nvl/jres.cfm",
  keywords =     "Julia programming language",
}

@InProceedings{Moura:2019:UJP,
  author =       "R. A. R. Moura and M. A. O. Schroeder and S. J. S.
                 Silva and E. G. Nepomuceno and P. H. N. Vieira and A.
                 C. S. Lima",
  booktitle =    "{2019 International Symposium on Lightning Protection
                 (XV SIPDA)}",
  title =        "The Usage of {Julia} Programming in Grounding Grids
                 Simulations : An alternative to {MATLAB} and {Python}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--4",
  year =         "2019",
  DOI =          "https://doi.org/10.1109/SIPDA47030.2019.8951702",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@MastersThesis{Plankensteiner:2019:CDS,
  author =       "David Plankensteiner",
  title =        "Collective dynamics and spectroscopy of coupled
                 quantum emitters",
  type =         "{M.Sc.} thesis",
  school =       "Universit{\"a}t Innsbruck",
  address =      "Innsbruck, Austria",
  pages =        "ix + 193",
  month =        may,
  year =         "2019",
  bibdate =      "Thu Apr 08 16:33:38 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://data.onb.ac.at/rec/AC15419096",
  acknowledgement = ack-nhfb,
  keywords =     "\pkg{QuantumOptics.jl}: a Julia framework for
                 simulating open quantum systems",
}

@Article{Regier:2019:CVU,
  author =       "Jeffrey Regier and Keno Fischer and Kiran Pamnany and
                 Andreas Noack and Jarrett Revels and Maximilian Lama
                 and Steve Howard and Ryan Giordano and David Schlegel
                 and Jon McAuliffe and Rollin Thomas and Prabhat",
  title =        "Cataloging the visible universe through {Bayesian}
                 inference in {Julia} at petascale",
  journal =      j-J-PAR-DIST-COMP,
  volume =       "127",
  number =       "??",
  pages =        "89--104",
  month =        may,
  year =         "2019",
  CODEN =        "JPDCER",
  DOI =          "https://doi.org/10.1016/j.jpdc.2018.12.008",
  ISSN =         "0743-7315 (print), 1096-0848 (electronic)",
  ISSN-L =       "0743-7315",
  bibdate =      "Thu Mar 14 15:55:59 MDT 2019",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/jpardistcomp.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0743731518304672",
  abstract =     "A key task in astronomy is to locate astronomical
                 objects in images and to characterize them according to
                 physical parameters such as brightness, color, and
                 morphology. This task, known as cataloging, is
                 challenging for several reasons: many astronomical
                 objects are much dimmer than the sky background,
                 labeled data is generally unavailable, overlapping
                 astronomical objects must be resolved collectively, and
                 the datasets are enormous terabytes now, petabytes
                 soon. In this work, we infer an astronomical catalog
                 from 55 TB of imaging data using Celeste, a Bayesian
                 variational inference code written entirely in the
                 high-productivity programming language Julia. Using
                 over 1.3 million threads on 650,000 Intel Xeon Phi
                 cores of the Cori Phase II supercomputer, Celeste
                 achieves a peak rate of 1.54 DP PFLOP/s. Celeste is
                 able to jointly optimize parameters for 188 M stars and
                 galaxies, loading and processing 178 TB across 8192
                 nodes in 14.6 min. To achieve this, Celeste exploits
                 parallelism at multiple levels (cluster, node, and
                 thread) and accelerates I/O through Cori's burst
                 buffer. Julia's native performance enables Celeste to
                 employ high-level constructs without resorting to
                 hand-written or generated low-level code
                 (C/C++/Fortran) while still achieving petascale
                 performance.",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Parallel and Distributed Computing",
  journal-URL =  "http://www.sciencedirect.com/science/journal/07437315",
  keywords =     "Astronomy, Bayesian, Distributed optimization,
                 Variational inference, Julia, High-performance
                 computing",
}

@InProceedings{Reinhardt:2019:DAB,
  author =       "O. Reinhardt and A. M. Uhrmacher and M. Hinsch and J.
                 Bijak",
  booktitle =    "{2019 Winter Simulation Conference (WSC)}",
  title =        "Developing Agent-Based Migration Models in Pairs",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "2713--2724",
  year =         "2019",
  DOI =          "https://doi.org/10.1109/WSC40007.2019.9004946",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Roughan:2019:PSS,
  author =       "Matthew Roughan",
  title =        "Practically surreal: {Surreal} arithmetic in {Julia}",
  journal =      j-SOFTWAREX,
  volume =       "9",
  number =       "??",
  pages =        "293--298",
  month =        jan # "\slash " # jun,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.softx.2019.03.005",
  ISSN =         "2352-7110",
  ISSN-L =       "2352-7110",
  bibdate =      "Mon Oct 14 09:45:43 MDT 2019",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/softwarex.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S2352711018302152",
  abstract =     "This paper presents an implementation of arithmetic on
                 Conway's surreal numbers. It also provides tools for
                 visualising complicated surreals in the form of graph
                 visualisations, and illustrates their use through
                 several examples, and a small contribution to the
                 theory of surreals.",
  acknowledgement = ack-nhfb,
  fjournal =     "SoftwareX",
  journal-URL =  "https://www.sciencedirect.com/journal/softwarex/issues",
  keywords =     "Conway's surreal numbers",
}

@Book{Sengupta:2019:JHP,
  author =       "Avik Sengupta",
  title =        "{Julia} high performance optimizations, distributed
                 computing, multithreading, and {GPU} programming with
                 {Julia 1.0} and beyond",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  edition =      "Second",
  pages =        "218",
  year =         "2019",
  ISBN =         "1-78829-230-8, 1-78829-811-X",
  ISBN-13 =      "978-1-78829-230-6, 978-1-78829-811-7",
  LCCN =         "????",
  bibdate =      "Thu Apr 8 16:49:31 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://portal.igpublish.com/iglibrary/search/PACKT0005341.html",
  abstract =     "Julia is a high-level, high-performance dynamic
                 programming language for numerical computing. This book
                 will help you understand the performance
                 characteristics of your Julia programs and achieve
                 near-C levels of performance in Julia.",
  acknowledgement = ack-nhfb,
  subject =      "Julia (Computer program language); Application
                 software; Development; Development.; Julia (Computer
                 program language)",
  tableofcontents = "Foreword \\
                 Contributors \\
                 Table of Contents \\
                 Preface \\
                 1: Julia is Fast \\
                 Julia \\
                 fast and dynamic \\
                 Designed for speed \\
                 JIT and LLVM \\
                 Types, type inference, and code specialization \\
                 How fast can Julia be? \\
                 Summary \\
                 2: Analyzing Performance \\
                 Timing Julia functions \\
                 The @time macro \\
                 Other time macros \\
                 The Julia profiler \\
                 Using the profiler \\
                 ProfileView \\
                 Using Juno for profiling \\
                 Using TimerOutputs \\
                 Analyzing memory allocation \\
                 Using the memory allocation tracker \\
                 Statistically accurate benchmarking \\
                 Using \pkg{BenchmarkTools.jl} \\
                 Summary \\
                 3: Types, Type Inference, and Stability \\
                 The Julia type system \\
                 Using types \\
                 Multiple dispatch \\
                 Abstract types \\
                 Julia's type hierarchy \\
                 Composite and immutable types \\
                 Type parameters \\
                 Type inference \\
                 Type-stability \\
                 Definitions \\
                 Fixing type instability \\
                 The performance pitfalls \\
                 Identifying type stability \\
                 Loop variables \\
                 Kernel methods and function barriers \\
                 Types in storage locations \\
                 Arrays \\
                 Composite types \\
                 Parametric composite types \\
                 Summary \\
                 4: Making Fast Function Calls \\
                 Using globals \\
                 The trouble with globals \\
                 Fixing performance issues with globals \\
                 Inlining \\
                 Default inlining \\
                 Controlling inlining \\
                 Disabling inlining \\
                 Constant propagation \\
                 Using macros for performance \\
                 The Julia compilation process \\
                 Using macros \\
                 Evaluating a polynomial \\
                 Horner's method \\
                 The Horner macro \\
                 Generated functions \\
                 Using generated functions \\
                 Using generated functions for performance \\
                 Using keyword arguments \\
                 Summary \\
                 5: Fast Numbers \\
                 Numbers in Julia, their layout, and storage \\
                 Integers \\
                 Integer overflow \\
                 BigInt \\
                 The floating point \\
                 Floating point accuracy \\
                 Unsigned integers \\
                 Trading performance for accuracy \\
                 The @fastmath macro \\
                 The K-B-N summation \\
                 Subnormal numbers \\
                 Subnormal numbers to zero \\
                 Summary \\
                 6: Using Arrays \\
                 Array internals in Julia \\
                 Array representation and storage \\
                 Column-wise storage \\
                 Adjoints \\
                 Array initialization \\
                 Bounds checking \\
                 Removing the cost of bounds checking \\
                 Configuring bound checks at startup \\
                 Allocations and in-place operations \\
                 Preallocating function output \\
                 sizehint! \\
                 Mutating functions \\
                 Broadcasting \\
                 Array views \\
                 SIMD parallelization (AVX2, AVX512) \\
                 SIMD.jl \\
                 Specialized array types \\
                 Static arrays \\
                 Structs of arrays \\
                 Yeppp!Writing generic library functions with arrays \\
                 Summary \\
                 7: Accelerating Code with the GPU \\
                 Technical requirements \\
                 Getting started with GPUs \\
                 CUDA and Julia \\
                 CuArrays \\
                 Monte Carlo simulation on the GPU \\
                 Writing your own kernels \\
                 Measuring GPU performance \\
                 Performance tips \\
                 Scalar iteration \\
                 Combining kernels \\
                 Processing more data \\
                 Deep learning on the GPU \\
                 ArrayFire \\
                 Summary \\
                 8: Concurrent Programming with Tasks \\
                 Tasks \\
                 Using tasks \\
                 The task life cycle \\
                 task\_local\_storage \\
                 Communicating between tasks \\
                 Task iteration \\
                 High-performance I/O",
}

@InProceedings{Voulgaris:2019:J,
  author =       "Zacharias Voulgaris",
  booktitle =    "{Encyclopedia of Big Data Technologies}",
  title =        "{Julia}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2019",
  DOI =          "https://doi.org/10.1007/978-3-319-77525-8_268",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/referenceworkentry/10.1007/978-3-319-77525-8_268",
  acknowledgement = ack-nhfb,
}

@Article{Zhang:2019:SSE,
  author =       "Zhiping Zhang and Jeffrey D. Varner",
  title =        "{SEML}: a Simplified {English} Modeling Language for
                 Constructing Biological Models in {Julia}",
  journal =      "IFAC-PapersOnLine",
  volume =       "52",
  number =       "26",
  pages =        "121--128",
  year =         "2019",
  DOI =          "https://doi.org/10.1016/j.ifacol.2019.12.246",
  ISSN =         "2405-8963",
  bibdate =      "Fri Apr 9 15:22:25 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  note =         "8th Conference on Foundations of Systems Biology in
                 Engineering FOSBE 2019",
  URL =          "https://www.sciencedirect.com/science/article/pii/S2405896319321299",
  abstract =     "Many markup languages can be used to encode biological
                 networks, each with strengths and weaknesses. Model
                 specifications written in these languages can then
                 used, in conjunction with proprietary software packages
                 e.g., MATLAB, or open community alternatives, to
                 simulate the behavior of biological systems. In this
                 study, we present the Simplified English Modeling
                 Language (SEML) and associated compiler, as an
                 alternative to existing approaches. SEML supports the
                 specification of biological reaction systems in a
                 simple natural language like syntax. Models encoded in
                 SEML are transformed into executable code using a
                 compiler written in the open-source Julia programming
                 language. The compiler performs a sequence of
                 operations, including tokenization, syntactic and
                 semantic error checking, to convert SEML into an
                 intermediate representation (IR). From the intermediate
                 representation, the compiler then generates executable
                 code in one of three programming languages: Julia,
                 Python or MATLAB. Currently, SEML supports both kinetic
                 and constraint based model generation for signal
                 transduction and metabolic modeling. In this study, we
                 demonstrate SEML by modeling two proof-of-concept
                 prototypical networks: a constraint-based model solved
                 using flux balance analysis (FBA) and a kinetic model
                 encoded as Ordinary Differential Equations (ODEs). SEML
                 is a promising tool for encoding and sharing
                 human-readable biological models, however it is still
                 in its infancy. With further development, SEML has the
                 potential to handle more unstructured natural language
                 inputs, generate more complex models types and convert
                 its natural language markup to currently used model
                 interchange formats such systems biology markup
                 language.",
  acknowledgement = ack-nhfb,
  keywords =     "simplified English modeling language, markup language,
                 biological modeling, compiler, Julia",
}

@Article{Amores:2020:DDS,
  author =       "V{\'{\i}}ctor Jes{\'u}s Amores and Jos{\'e}
                 Mar{\'{\i}}a Ben{\'{\i}}tez and Francisco Javier
                 Mont{\'a}ns",
  title =        "Data-driven, structure-based hyperelastic manifolds: a
                 macro--micro--macro approach to reverse-engineer the
                 chain behavior and perform efficient simulations of
                 polymers",
  journal =      "Computers {\&} Structures",
  volume =       "231",
  pages =        "106209",
  month =        apr,
  year =         "2020",
  DOI =          "https://doi.org/10.1016/j.compstruc.2020.106209",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Asaeikheybari:2020:PHH,
  author =       "G. Asaeikheybari and C. Hughart and D. Gupta and A.
                 Avery and M. M. Step and J. M. Smith and J. Kratz and
                 J. Briggs and M. -C. Huang",
  booktitle =    "{2020 Second International Conference on
                 Transdisciplinary AI (TransAI)}",
  title =        "Precision {HIV} Health App, Positive Peers, Powered by
                 Data Harnessing, {AI}, and Learning",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "108--112",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/TransAI49837.2020.00024",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Barros:2020:ALS,
  author =       "D. A. Barros and C. Bentes",
  booktitle =    "{2020 IEEE 32nd International Symposium on Computer
                 Architecture and High Performance Computing
                 (SBAC-PAD)}",
  title =        "Analyzing the Loop Scheduling Mechanisms on {Julia}
                 Multithreading",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "257--264",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/SBAC-PAD49847.2020.00043",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Book{Battig:2020:AMM,
  author =       "Daniel B{\"a}ttig",
  title =        "{Angewandte Mathematik 1 mit MATLAB und Julia: Ein
                 anwendungs- und beispielorientierter Einstieg f{\"u}r
                 technische Studieng{\"a}nge}. ({German}) [{Applied
                 Mathematics 1} with {MATLAB} and {Julia}: an
                 application and example-oriented introduction to
                 technical courses]",
  publisher =    "Springer Vieweg",
  address =      "Berlin and Heidelberg, Germany",
  pages =        "xiii + 254",
  year =         "2020",
  ISBN =         "3-662-60951-7 (print), 3-662-60952-5 (ePub)",
  ISBN-13 =      "978-3-662-60951-4 (print), 978-3-662-60952-1 (ePub)",
  LCCN =         ">>>>",
  bibdate =      "Thu Apr 8 11:26:54 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  language =     "German",
  subject =      "Engineering; Applied mathematics; Engineering
                 mathematics; Computer science; Mathematics;
                 Mathematical analysis; Analysis (Mathematics);
                 Algebras, Linear; Maths for scientists; Calculus and
                 mathematical analysis; Algebra; Maths for engineers;
                 Computers; Computer Science; Mathematical Analysis;
                 Algebra; Linear; Technology and Engineering;
                 Engineering (General); Algebras, Linear; Mathematics;
                 Engineering; Engineering mathematics; Mathematical
                 analysis.",
  tableofcontents = "Zahlensysteme: Mathematik und Computer, \\
                 Vektoren und Programmieren von Schleifen \\
                 Vektoren, Geometrie und Mechanik, \\
                 Lineare Gleichungssysteme und Matrizes \\
                 Input-Output: Funktionen \\
                 Spezielle mathematische Funktionen \\
                 {\"U}berbestimmte Systeme, affine Funktionen und die
                 Methode der kleinsten Quadrate \\
                 Die Ableitung einer Funktion \\
                 Anwendungen der Ableitung \\
                 Literaturverzeichnis \\
                 Sachverzeichnis",
}

@Article{Bauer:2020:FSD,
  author =       "Carsten Bauer",
  title =        "Fast and stable determinant quantum {Monte Carlo}",
  journal =      "{SciPost} Physics Core",
  volume =       "2",
  number =       "2",
  month =        jun,
  year =         "2020",
  DOI =          "https://doi.org/10.21468/scipostphyscore.2.2.011",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Belyakova:2020:WAJ,
  author =       "Julia Belyakova and Benjamin Chung and Jack Gelinas
                 and Jameson Nash and Ross Tate and Jan Vitek",
  title =        "World age in {Julia}: optimizing method dispatch in
                 the presence of eval",
  journal =      j-PACMPL,
  volume =       "4",
  number =       "OOPSLA",
  pages =        "207:1--207:26",
  month =        nov,
  year =         "2020",
  DOI =          "https://doi.org/10.1145/3428275",
  ISSN =         "2475-1421",
  bibdate =      "Tue Mar 30 08:10:50 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3428275",
  abstract =     "Dynamic programming languages face semantic and
                 performance challenges in the presence of features,
                 such as eval, that can inject new code into a running
                 program. The Julia programming language introduces the
                 novel concept of world age to insulate optimized code
                 from one of the most disruptive side-effects of eval:
                 changes to the definition of an existing function. This
                 paper provides the first formal semantics of world age
                 in a core calculus named juliette, and shows how world
                 age enables compiler optimizations, such as inlining,
                 in the presence of eval. While Julia also provides
                 programmers with the means to bypass world age, we
                 found that this mechanism is not used extensively: a
                 static analysis of over 4,000 registered Julia packages
                 shows that only 4--9\% of packages bypass world age.
                 This suggests that Julia's semantics aligns with
                 programmer expectations.",
  acknowledgement = ack-nhfb,
  articleno =    "207",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@InProceedings{Burbach:2020:NVJ,
  author =       "Laura Burbach and Poornima Belavadi and Patrick
                 Halbach and Lilian Kojan and Nils Plettenberg and
                 Johannes Nakayama and Martina Ziefle and Andr{\'e}
                 Calero Valdez",
  booktitle =    "{Digital Human Modeling and Applications in Health,
                 Safety, Ergonomics and Risk Management. Human
                 Communication, Organization and Work}",
  title =        "{Netlogo} vs. {Julia}: Evaluating Different Options
                 for the Simulation of Opinion Dynamics",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2020",
  DOI =          "https://doi.org/10.1007/978-3-030-49907-5_1",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-030-49907-5_1",
  acknowledgement = ack-nhfb,
}

@InProceedings{Chaber:2020:PCC,
  author =       "B. Chaber",
  booktitle =    "{2020 IEEE 21st International Conference on
                 Computational Problems of Electrical Engineering
                 (CPEE)}",
  title =        "Particle-in-Cell code for gas discharge simulations",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--4",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/CPEE50798.2020.9238682",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Coleman:2020:MPJ,
  author =       "Chase Coleman and Spencer Lyon and Lilia Maliar and
                 Serguei Maliar",
  title =        "{Matlab}, {Python}, {Julia}: What to Choose in
                 Economics?",
  journal =      j-COMP-ECONOMICS,
  volume =       "",
  number =       "",
  pages =        "??--??",
  month =        "",
  year =         "2020",
  CODEN =        "CNOMEL",
  DOI =          "https://doi.org/10.1007/s10614-020-09983-3",
  ISSN =         "",
  ISSN-L =       "0927-7099",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  URL =          "http://link.springer.com/article/10.1007/s10614-020-09983-3",
  acknowledgement = ack-nhfb,
  fjournal =     "Computational Economics",
}

@InProceedings{Drakopoulos:2020:ODC,
  author =       "G. Drakopoulos and E. Kafeza",
  booktitle =    "{2020 5th South-East Europe Design Automation,
                 Computer Engineering, Computer Networks and Social
                 Media Conference (SEEDA-CECNSM)}",
  title =        "One Dimensional Cross-Correlation Methods for
                 Deterministic and Stochastic Graph Signals with a
                 {Twitter} Application in {Julia}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--8",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/SEEDA-CECNSM49515.2020.9221815",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Fathurrahman:2020:PJJ,
  author =       "Fadjar Fathurrahman and Mohammad Kemal Agusta and
                 Adhitya Gandaryus Saputro and Hermawan Kresno
                 Dipojono",
  title =        "{PWDFT.jl} : a {Julia} package for electronic
                 structure calculation using density functional theory
                 and plane wave basis",
  journal =      j-COMP-PHYS-COMM,
  volume =       "256",
  number =       "??",
  pages =        "Article 107372",
  month =        nov,
  year =         "2020",
  CODEN =        "CPHCBZ",
  DOI =          "https://doi.org/10.1016/j.cpc.2020.107372",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Sat Mar 13 08:21:39 MST 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/compphyscomm2020.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465520301600",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
}

@Article{Fathurrahman:2020:PPJ,
  author =       "Fadjar Fathurrahman and Mohammad Kemal Agusta and
                 Adhitya Gandaryus Saputro and Hermawan Kresno
                 Dipojono",
  title =        "\pkg{PWDFT.jl}: a {Julia} package for electronic
                 structure calculation using density functional theory
                 and plane wave basis",
  journal =      j-COMP-PHYS-COMM,
  volume =       "256",
  pages =        "107372",
  year =         "2020",
  CODEN =        "CPHCBZ",
  DOI =          "https://doi.org/10.1016/j.cpc.2020.107372",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Fri Apr 9 15:22:25 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0010465520301600",
  abstract =     "We describe the implementation of PWDFT.jl, a package
                 for electronic structure calculations written in Julia
                 programming language using plane wave basis set and
                 pseudopotentials. In this package, a typical Kohn Sham
                 density functional theory (KSDFT) is divided into three
                 steps: initializing the molecular or crystalline
                 structure, constructing the Kohn Sham Hamiltonian, and
                 solving the Kohn Sham problem using self-consistent
                 field (SCF) calculation. To facilitate various tasks
                 involved in these steps, we provide several custom data
                 types which are transparent and easy to be modified.
                 Basic operations such as wave function
                 orthogonalization, action of kinetic and potential
                 operators to wave functions and iterative
                 diagonalization of Hamiltonian have been implemented in
                 pure Julia. Several algorithms to solve the Kohn Sham
                 problems such as self-consistent field and direct
                 energy minimization have also been implemented in
                 PWDFT.jl. To assess the validity of our implementation,
                 we present the results of total energy calculations
                 against the well-established ABINIT package. We also
                 show how one can use PWDFT.jl to write a simple
                 self-consistent field implementation. Program summary
                 Program Title: PWDFT.jl CPC Library link to program
                 files: https://doi.org/10.17632/b87xzmzm2z.1 Licensing
                 provisions: GPL-v2 Programming language: Julia Nature
                 of problem: Electronic structure of interacting
                 electrons in material Solution method: Kohn Sham
                 density functional theory, using plane wave basis set
                 and pseudopotentials Additional comments including
                 restrictions and unusual features: Due to the
                 precompilation step, the program may appear to be slow
                 at the first call. Parallelization is not yet
                 considered.",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
  keywords =     "Density functional theory, Pseudopotential plane wave
                 method, Julia programming language",
}

@Article{Frison:2020:BAB,
  author =       "Gianluca Frison and Tommaso Sartor and Andrea Zanelli
                 and Moritz Diehl",
  title =        "The {BLAS API} of {BLASFEO}",
  journal =      j-TOMS,
  volume =       "46",
  number =       "2",
  pages =        "1--36",
  month =        jun,
  year =         "2020",
  CODEN =        "ACMSCU",
  DOI =          "https://doi.org/10.1145/3378671",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  ISSN-L =       "0098-3500",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Transactions on Mathematical Software",
  journal-URL =  "http://dl.acm.org/pub.cfm?id=J782",
  keywords =     "Julia programming language",
}

@Article{Gao:2020:JLM,
  author =       "Kaifeng Gao and Gang Mei and Francesco Piccialli and
                 Salvatore Cuomo and Jingzhi Tu and Zenan Huo",
  title =        "{Julia} language in machine learning: Algorithms,
                 applications, and open issues",
  journal =      j-COMP-SCI-REV,
  volume =       "37",
  pages =        "100254",
  month =        aug,
  year =         "2020",
  DOI =          "https://doi.org/10.1016/j.cosrev.2020.100254",
  ISSN =         "1574-0137 (print), 1876-7745 (electronic)",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S157401372030071X",
  abstract =     "Machine learning is driving development across many
                 fields in science and engineering. A simple and
                 efficient programming language could accelerate
                 applications of machine learning in various fields.
                 Currently, the programming languages most commonly used
                 to develop machine learning algorithms include Python,
                 MATLAB, and C/C ++. However, none of these languages
                 well balance both efficiency and simplicity. The Julia
                 language is a fast, easy-to-use, and open-source
                 programming language that was originally designed for
                 high-performance computing, which can well balance the
                 efficiency and simplicity. This paper summarizes the
                 related research work and developments in the
                 applications of the Julia language in machine learning.
                 It first surveys the popular machine learning
                 algorithms that are developed in the Julia language.
                 Then, it investigates applications of the machine
                 learning algorithms implemented with the Julia
                 language. Finally, it discusses the open issues and the
                 potential future directions that arise in the use of
                 the Julia language in machine learning.",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Science Review",
  journal-URL =  "http://www.sciencedirect.com/science/journal/15740137",
  keywords =     "Julia programming language; Machine learning; Supervised learning;
                 Unsupervised learning; Deep learning; Artificial neural
                 networks",
}

@InProceedings{Geth:2020:CVF,
  author =       "F. Geth and S. Claeys and G. Deconinck",
  booktitle =    "{2020 8th Workshop on Modeling and Simulation of
                 Cyber-Physical Energy Systems}",
  title =        "Current-Voltage Formulation of the Unbalanced Optimal
                 Power Flow Problem",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--6",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/MSCPES49613.2020.9133699",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language; PowerModels.jl;
                 PowerModelsDistribution.jl",
}

@InProceedings{Goualard:2020:GRF,
  author =       "Fr{\'e}d{\'e}ric Goualard",
  title =        "Generating Random Floating-Point Numbers by Dividing
                 Integers: a Case Study",
  crossref =     "Krzhizhanovskaya:2020:CSI",
  pages =        "15--28",
  year =         "2020",
  DOI =          "https://doi.org/10.1007/978-3-030-50417-5_2",
  bibdate =      "Thu Jun 25 07:31:47 2020",
  bibsource =    "http://www.math.utah.edu/pub/bibnet/authors/d/dongarra-jack-j.bib;
                 http://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 http://www.math.utah.edu/pub/tex/bib/prng.bib",
  acknowledgement = ack-nhfb,
  keywords =     "error analysis; floating-point number; GMP; Julia;
                 Matlab; Mersenne Twister; PRNG; pseudo-random numbers;
                 random number",
}

@InProceedings{Hernandez:2020:IJS,
  author =       "M. Hernandez and D. Valles and D. C. Wierschem and R.
                 M. Koldenhoven and G. Koutitas and F. A. Mendez and S.
                 Aslan and J. Jimenez",
  booktitle =    "{2020 11th IEEE Annual Information Technology,
                 Electronics and Mobile Communication Conference
                 (IEMCON)}",
  title =        "An Initial {Julia} Simulation Approach to Material
                 Handling Operations from Motion Captured Data",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "0718--0722",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/IEMCON51383.2020.9284829",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Hunold:2020:BJC,
  author =       "S. Hunold and S. Steiner",
  booktitle =    "{2020 IEEE/ACM Performance Modeling, Benchmarking and
                 Simulation of High Performance Computer Systems
                 (PMBS)}",
  title =        "Benchmarking {Julia}'s Communication Performance: Is
                 {Julia HPC} ready or Full {HPC?}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "20--25",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/PMBS51919.2020.00008",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Huo:2020:DEP,
  author =       "Zenan Huo and Gang Mei and Giampaolo Casolla and Fabio
                 Giampaolo",
  title =        "Designing an efficient parallel spectral clustering
                 algorithm on multi-core processors in {Julia}",
  journal =      j-J-PAR-DIST-COMP,
  volume =       "138",
  number =       "??",
  pages =        "211--221",
  month =        apr,
  year =         "2020",
  CODEN =        "JPDCER",
  DOI =          "https://doi.org/10.1016/j.jpdc.2020.01.003",
  ISSN =         "0743-7315 (print), 1096-0848 (electronic)",
  ISSN-L =       "0743-7315",
  bibdate =      "Wed Mar 18 09:26:11 MDT 2020",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/jpardistcomp.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0743731519308743",
  abstract =     "Spectral clustering is widely used in data mining,
                 machine learning and other fields. It can identify the
                 arbitrary shape of a sample space and converge to the
                 global optimal solution. Compared with the traditional
                 k-means algorithm, the spectral clustering algorithm
                 has stronger adaptability to data and better clustering
                 results. However, the computation of the algorithm is
                 quite expensive. In this paper, an efficient parallel
                 spectral clustering algorithm on multi-core processors
                 in the Julia language is proposed, and we refer to it
                 as juPSC. The Julia language is a high-performance,
                 open-source programming language. The juPSC is composed
                 of three procedures: (1) calculating the affinity
                 matrix, (2) calculating the eigenvectors, and (3)
                 conducting k-means clustering. Procedures (1) and (3)
                 are computed by the efficient parallel algorithm, and
                 the COO format is used to compress the affinity matrix.
                 Two groups of experiments are conducted to verify the
                 accuracy and efficiency of the juPSC. Experimental
                 results indicate that (1) the juPSC achieves speedups
                 of approximately 14 $ \times $--18 $ \times $ on a
                 24-core CPU and that (2) the serial version of the
                 juPSC is faster than the Python version of
                 scikit-learn. Moreover, the structure and functions of
                 the juPSC are designed considering modularity, which is
                 convenient for combination and further optimization
                 with other parallel computing platforms.",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Parallel and Distributed Computing",
  journal-URL =  "http://www.sciencedirect.com/science/journal/07437315",
  keywords =     "Clustering algorithm, Spectral clustering, Parallel
                 algorithm, Multi-core processors, Julia language",
}

@InProceedings{Khan:2020:COF,
  author =       "H. Khan and H. Issa and J. K. Tar",
  booktitle =    "{2020 IEEE 20th International Symposium on
                 Computational Intelligence and Informatics (CINTI)}",
  title =        "Comparison of the Operation of Fixed Point
                 Iteration-based Adaptive and Robust {VS\slash SM}-type
                 Solutions for Controlling Two Coupled Fluid Tanks",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "29--34",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/CINTI51262.2020.9305827",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Kyesswa:2020:NJB,
  author =       "M. Kyesswa and P. Schmurr and H. K. {\c{C}}akmak and
                 U. K{\"u}hnapfel and V. Hagenmeyer",
  booktitle =    "{2020 IEEE/ACM 24th International Symposium on
                 Distributed Simulation and Real Time Applications
                 (DS-RT)}",
  title =        "A New Julia-Based Parallel Time-Domain Simulation
                 Algorithm for Analysis of Power System Dynamics",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--9",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/DS-RT50469.2020.9213602",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Langer:2020:OHE,
  author =       "Lissy Langer and Thomas Volling",
  title =        "An optimal home energy management system for
                 modulating heat pumps and photovoltaic systems",
  journal =      "Applied Energy",
  volume =       "278",
  pages =        "115661",
  month =        nov,
  year =         "2020",
  DOI =          "https://doi.org/10.1016/j.apenergy.2020.115661",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Lau:2020:DSC,
  author =       "S. Lau and I. Drosos and J. M. Markel and P. J. Guo",
  booktitle =    "{2020 IEEE Symposium on Visual Languages and
                 Human-Centric Computing (VL/HCC)}",
  title =        "The Design Space of Computational Notebooks: An
                 Analysis of 60 Systems in Academia and Industry",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--11",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/VL/HCC50065.2020.9127201",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Merrell:2020:ISP,
  author =       "David Merrell and Anthony Gitter",
  title =        "Inferring signaling pathways with probabilistic
                 programming",
  journal =      j-BIOINFORMATICS,
  volume =       "36",
  number =       "Supplement\_2",
  pages =        "i822--i830",
  month =        dec,
  year =         "2020",
  DOI =          "https://doi.org/10.1093/bioinformatics/btaa861",
  ISSN =         "1367-4803 (print), 1367-4811 (electronic)",
  ISSN-L =       "1367-4803",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Bioinformatics",
  journal-URL =  "http://bioinformatics.oxfordjournals.org/",
  keywords =     "Julia programming language",
}

@Article{PadmasudhaKannan:2020:AHO,
  author =       "G. {Padmasudha Kannan} and T. V. Smitha and K. V.
                 Nagaraja",
  title =        "Automated high-order curved mesh generator with
                 high-level dynamic programming language {Julia} for
                 photonic applications",
  journal =      "Materials Today: Proceedings",
  year =         "2020",
  DOI =          "https://doi.org/10.1016/j.matpr.2020.09.706",
  ISSN =         "2214-7853",
  bibdate =      "Fri Apr 9 15:22:25 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S2214785320374319",
  abstract =     "A powerful automated high-order unstructured curved
                 mesh generator is proposed in this work with a
                 high-level dynamic programming language Julia. This
                 generator uses higher-order one-sided curved triangular
                 finite elements for the domains having curved borders
                 with parabolic arcs. The proposed approach of the mesh
                 generator can be successfully applied for solving
                 several industrial problems inclusive of photonics with
                 the finite element method. The use of the parabolic
                 arcs method to obtain node relations for the curved
                 geometry enhances the performance of the technique with
                 the subparametric mappings. The mesh generator
                 suggested is based on the prominent Gmsh mesh
                 generator. For all geometry, the presented technique
                 can be implemented. The methodology is applied in this
                 paper to illustrate a few photonic crystal domains.",
  acknowledgement = ack-nhfb,
  keywords =     "Higher-order triangular finite element, Julia, Mesh
                 generation, Subparametric mapping, Curved elements,
                 Parabolic arc",
}

@InProceedings{Sells:2020:JPL,
  author =       "R. Sells",
  booktitle =    "{2020 IEEE Aerospace Conference}",
  title =        "{Julia} Programming Language Benchmark Using a Flight
                 Simulation",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--8",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/AERO47225.2020.9172277",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@InProceedings{Smith:2020:DPJ,
  author =       "Einar Smith",
  booktitle =    "{Introduction to the Tools of Scientific Computing}",
  title =        "Distributed Processing in {Julia}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2020",
  DOI =          "https://doi.org/10.1007/978-3-030-60808-8_13",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-030-60808-8_13",
  acknowledgement = ack-nhfb,
}

@InProceedings{Smith:2020:J,
  author =       "Einar Smith",
  booktitle =    "{Introduction to the Tools of Scientific Computing}",
  title =        "{Julia}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "??--??",
  year =         "2020",
  DOI =          "https://doi.org/10.1007/978-3-030-60808-8_8",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-030-60808-8_8",
  acknowledgement = ack-nhfb,
}

@InProceedings{Suslov:2020:SHM,
  author =       "S. Suslov and M. Schiek and M. Robens and C. Grewing
                 and S. {van Waasen}",
  booktitle =    "{2020 IEEE/ACM 24th International Symposium on
                 Distributed Simulation and Real Time Applications
                 (DS-RT)}",
  title =        "Simulating Heterogeneous Models on Multi-Core
                 Platforms using {Julia}'s Computing Language Parallel
                 Potential",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1--4",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/DS-RT50469.2020.9213527",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Xiong:2020:PMM,
  author =       "Hao Xiong and Zhen-Yu Yin and Fran{\c{c}}ois Nicot",
  title =        "Programming a micro-mechanical model of granular
                 materials in {Julia}",
  journal =      j-ADV-ENG-SOFTWARE,
  volume =       "145",
  pages =        "102816",
  year =         "2020",
  CODEN =        "AESODT",
  DOI =          "https://doi.org/10.1016/j.advengsoft.2020.102816",
  ISSN =         "0965-9978 (print), 0141-1195 (electronic)",
  ISSN-L =       "0965-9978",
  bibdate =      "Fri Apr 9 15:22:25 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0965997820301071",
  abstract =     "Modelling the mechanical behaviour of granular
                 materials using the insight of physics, such as
                 discrete element method (DEM), usually costs a lot of
                 computing resources as a result of the storing and
                 transferring of a large amount of particle and contact
                 information. Unlike DEM, the micro-mechanical (MM)
                 model, based on statistics of directional
                 inter-particle contacts of a representative volume of
                 an element, imposes a much lower computational demand
                 while retaining granular physics. This paper presents
                 such a kinematic hypothesis-based MM modelling
                 framework, programmed by a dynamic coding language,
                 Julia. The directional local law of a recently
                 developed model is selected as an example of the
                 implementation. The entire code of the MM model
                 programmed by Julia is structured into several
                 functions by which multilevel loops are called in an
                 order. Moreover, a global mixed-loading control method
                 is proposed in this study by which the stress control
                 and strain control can be achieved simultaneously.
                 Using this method, conventional triaxial tests and
                 proportional strain tests are simulated to calibrate
                 the model according to experimental data. The same
                 experiments are also simulated by DEM for comparison
                 with the MM model to estimate the computational
                 efficiency and accuracy, which demonstrates a
                 significant advantage of the MM model. This study can
                 be directly used for modelling other materials by
                 changing the directional local law and provides helpful
                 guidance for programming of similar multiscale
                 approaches.",
  acknowledgement = ack-nhfb,
  fjournal =     "Advances in Engineering Software (1978)",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01411195",
  keywords =     "Julia language, High-performance dynamic programming,
                 Micromechanics, Granular materials, Multiscale,
                 Microstructure",
}

@InProceedings{Ziyatdinova:2020:EES,
  author =       "J. Ziyatdinova and O. Oleynikova and E. Valeeva",
  booktitle =    "{2020 IEEE Global Engineering Education Conference
                 (EDUCON)}",
  title =        "Engaging Engineering Students in Cultural Diversity
                 and Unity Studies",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "1164--1167",
  year =         "2020",
  DOI =          "https://doi.org/10.1109/EDUCON45650.2020.9125305",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Cheli:2021:PMJ,
  author =       "Alessandro Cheli",
  title =        "\pkg{Metatheory.jl}: Fast and Elegant Algebraic
                 Computation in {Julia} with Extensible Equality
                 Saturation",
  journal =      "Journal of Open Source Software",
  volume =       "6",
  number =       "59",
  pages =        "3078",
  month =        mar,
  year =         "2021",
  DOI =          "https://doi.org/10.21105/joss.03078",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Dowson:2021:PSJ,
  author =       "Oscar Dowson and Lea Kapelevich",
  title =        "\pkg{SDDP.jl}: A {Julia} Package for Stochastic Dual
                 Dynamic Programming",
  journal =      j-INFORMS-J-COMPUT,
  volume =       "33",
  number =       "1",
  pages =        "27--33",
  month =        "Winter",
  year =         "2021",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1287/ijoc.2020.0987",
  ISSN =         "1091-9856 (print), 1526-5528 (electronic)",
  ISSN-L =       "1091-9856",
  bibdate =      "Sat Feb 6 14:48:57 MST 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/informs-j-comput.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://pubsonline.informs.org/doi/pdf/10.1287/ijoc.2020.0987",
  acknowledgement = ack-nhfb,
  ajournal =     "INFORMS J. Comput.",
  fjournal =     "INFORMS Journal on Computing",
  journal-URL =  "https://pubsonline.informs.org/journal/ijoc",
  onlinedate =   "31 August 2020",
}

@Article{Huo:2021:JJB,
  author =       "Zenan Huo and Gang Mei and Nengxiong Xu",
  title =        "{juSFEM}: a {Julia}-based open-source package of
                 parallel {Smoothed Finite Element Method (S-FEM)} for
                 elastic problems",
  journal =      j-COMPUT-MATH-APPL,
  volume =       "81",
  number =       "??",
  pages =        "459--477",
  day =          "1",
  month =        jan,
  year =         "2021",
  CODEN =        "CMAPDK",
  DOI =          "https://doi.org/10.1016/j.camwa.2020.01.027",
  ISSN =         "0898-1221 (print), 1873-7668 (electronic)",
  ISSN-L =       "0898-1221",
  bibdate =      "Thu Apr 8 08:02:29 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/computmathappl2020.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0898122120300523",
  acknowledgement = ack-nhfb,
  fjournal =     "Computers and Mathematics with Applications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/08981221",
  keywords =     "Julia programming language",
}

@Article{Huo:2021:PJJ,
  author =       "Zenan Huo and Gang Mei and Nengxiong Xu",
  title =        "\pkg{juSFEM}: a {Julia}-based open-source package of
                 parallel {Smoothed Finite Element Method (S-FEM)} for
                 elastic problems",
  journal =      j-COMPUT-MATH-APPL,
  volume =       "81",
  pages =        "459--477",
  year =         "2021",
  CODEN =        "CMAPDK",
  DOI =          "https://doi.org/10.1016/j.camwa.2020.01.027",
  ISSN =         "0898-1221 (print), 1873-7668 (electronic)",
  ISSN-L =       "0898-1221",
  bibdate =      "Fri Apr 9 15:22:25 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/julia.bib",
  note =         "Development and Application of Open-source Software
                 for Problems with Numerical PDEs",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0898122120300523",
  abstract =     "The Smoothed Finite Element Method (S-FEM) proposed by
                 Liu G.R. can achieve more accurate results than the
                 conventional FEM. Currently, much commercial software
                 and many open-source packages have been developed to
                 analyze various science and engineering problems using
                 the FEM. However, there is little work focusing on
                 designing and developing software or packages for the
                 S-FEM. In this paper, we design and implement an
                 open-source package of the parallel S-FEM for elastic
                 problems by utilizing the Julia language on multi-core
                 CPU. The Julia language is a fast, easy-to-use, and
                 open-source programming language that was originally
                 designed for high-performance computing. We term our
                 package as juSFEM. To the best of the authors
                 knowledge, juSFEM is the first package of parallel
                 S-FEM developed with the Julia language. To verify the
                 correctness and evaluate the efficiency of juSFEM, two
                 groups of benchmark tests are conducted. The benchmark
                 results show that (1) juSFEM can achieve accurate
                 results when compared to commercial FEM software
                 ABAQUS, and (2) juSFEM only requires 543 s to calculate
                 the displacements of a 3D elastic cantilever beam model
                 which is composed of approximately 2 million
                 tetrahedral elements, while in contrast the commercial
                 FEM software needs 930 s for the same calculation
                 model; (3) the parallel juSFEM executed on the 24-core
                 CPU is approximately 20$ \times $ faster than the
                 corresponding serial version. Moreover, the structure
                 and function of juSFEM are easily modularized, and the
                 code in juSFEM is clear and readable, which is
                 convenient for further development.",
  acknowledgement = ack-nhfb,
  fjournal =     "Computers and Mathematics with Applications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/08981221",
  keywords =     "Smoothed Finite Element Method (S-FEM), Parallel
                 algorithm, Julia language, Computational efficiency,
                 Computational accuracy",
}

@Article{Stanitzki:2021:PJH,
  author =       "Marcel Stanitzki and Jan Strube",
  title =        "Performance of {Julia} for High Energy Physics
                 Analyses",
  journal =      j-COMPUT-SOFTW-BIG-SCI,
  volume =       "5",
  number =       "1",
  pages =        "??--??",
  month =        dec,
  year =         "2021",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1007/s41781-021-00053-3",
  ISSN =         "2510-2036 (print), 2510-2044 (electronic)",
  ISSN-L =       "2510-2036",
  bibdate =      "Fri Apr 9 06:38:19 MDT 2021",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/computsoftwbigsci.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "https://link.springer.com/article/10.1007/s41781-021-00053-3",
  acknowledgement = ack-nhfb,
  articleno =    "10",
  fjournal =     "Computing and Software for Big Science",
  journal-URL =  "https://www.springer.com/journal/41781",
  online-date =  "Published: 09 April 2021 Article: 10",
}


%%% ====================================================================
%%% Cross-referenced entries must come last.  They are sorted by year
%%% and by citation label with ``bibsort -byyear'':
@Proceedings{Krzhizhanovskaya:2020:CSI,
  editor =       "Valeria V. Krzhizhanovskaya and G{\'a}bor
                 Z{\'a}vodszky and Michael H. Lees and Jack J. Dongarra
                 and Peter M. A. Sloot and S{\'e}rgio Brissos and
                 Jo{\~a}o Teixeira",
  booktitle =    "{Computational Science --- ICCS 2020 20th
                 International Conference, Amsterdam, The Netherlands,
                 June 3--5, 2020, Proceedings, Part II}",
  title =        "{Computational Science --- ICCS 2020 20th
                 International Conference, Amsterdam, The Netherlands,
                 June 3--5, 2020, Proceedings, Part II}",
  volume =       "12138",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "xix + 697",
  year =         "2020",
  DOI =          "https://doi.org/10.1007/978-3-030-50417-5",
  ISBN =         "3-030-50416-6, 3-030-50417-4 (e-book)",
  ISBN-13 =      "978-3-030-50416-8, 978-3-030-50417-5 (e-book)",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  bibdate =      "Thu Jun 25 08:21:10 2020",
  bibsource =    "http://www.math.utah.edu/pub/bibnet/authors/d/dongarra-jack-j.bib;
                 http://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 http://www.math.utah.edu/pub/tex/bib/julia.bib;
                 http://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 http://www.math.utah.edu/pub/tex/bib/prng.bib",
  series =       ser-LNCS,
  URL =          "https://link.springer.com/book/10.1007/978-3-030-50417-5",
  acknowledgement = ack-nhfb,
  tableofcontents = "Front Matter / / i--xix \\
                 Modified Binary Tree in the Fast PIES for 2D Problems
                 with Complex Shapes / Andrzej Ku{\.z}elewski, Eugeniusz
                 Zieniuk, Agnieszka Bo{\l}tu{\'c}, Krzystof Szersze{\'n}
                 / 1--14 \\
                 Generating Random Floating--Point Numbers by Dividing
                 Integers: A Case Study / Fr{\'e}d{\'e}ric Goualard /
                 15--28 \\
                 An Effective Stable Numerical Method for Integrating
                 Highly Oscillating Functions with a Linear Phase /
                 Leonid A. Sevastianov, Konstantin P. Lovetskiy, Dmitry
                 S. Kulyabov / 29--43 \\
                 Fitting Penalized Logistic Regression Models Using QR
                 Factorization / Jacek Klimaszewski, Marcin Korze{\'n} /
                 44--57 \\
                 Uncertainty Quantification in Fractional Stochastic
                 Integro--Differential Equations Using Legendre Wavelet
                 Collocation Method / Abhishek Kumar Singh, Mani Mehra /
                 58--71 \\
                 A Direct High--Order Curvilinear Triangular Mesh
                 Generation Method Using an Advancing Front Technique /
                 Fariba Mohammadi, Shusil Dangi, Suzanne M. Shontz,
                 Cristian A. Linte / 72--85 \\
                 Data--Driven Partial Differential Equations Discovery
                 Approach for the Noised Multi--dimensional Data /
                 Mikhail Maslyaev, Alexander Hvatov, Anna Kalyuzhnaya /
                 86--100 \\
                 Preconditioning Jacobian Systems by Superimposing
                 Diagonal Blocks / M. Ali Rostami, H. Martin B{\"u}cker
                 / 101--115 \\
                 NURBS Curves in Parametric Integral Equations System
                 for Modeling and Solving Boundary Value Problems in
                 Elasticity / Marta Kapturczak, Eugeniusz Zieniuk,
                 Andrzej Ku{\.z}elewski / 116--123 \\
                 Parameterizations and Lagrange Cubics for Fitting
                 Multidimensional Data / Ryszard Kozera, Lyle Noakes,
                 Magdalena Wilko{\l}azka / 124--140 \\
                 Loop Aggregation for Approximate Scientific Computing /
                 June Sallou, Alexandre Gauvain, Johann Bourcier, Benoit
                 Combemale, Jean--Raynald de Dreuzy / 141--155 \\
                 Numerical Computation for a Flow Caused by a
                 High--Speed Traveling Train and a Stationary Overpass /
                 Shotaro Hamato, Masashi Yamakawa, Yongmann M. Chung,
                 Shinichi Asao / 156--169 \\
                 B{\'e}zier Surfaces for Modeling Inclusions in PIES /
                 Agnieszka Bo{\l}tu{\'c}, Eugeniusz Zieniuk, Krzysztof
                 Szersze{\'n}, Andrzej Ku{\.z}elewski / 170--183 \\
                 Impact of Water on Methane Adsorption in Nanopores: A
                 Hybrid GCMC--MD Simulation Study / Ji Zhou, Wenbin
                 Jiang, Mian Lin, Lili Ji, Gaohui Cao / 184--196 \\
                 A Stable Discontinuous Galerkin Based Isogeometric
                 Residual Minimization for the Stokes Problem / Marcin
                 {\L}o{\'s}, Sergio Rojas, Maciej Paszy{\'n}ski, Ignacio
                 Muga, Victor M. Calo / 197--211 \\
                 Numerical Modeling of the Two--Phase Flow of Water with
                 Ice in the Tom River / Vladislava Churuksaeva,
                 Alexander Starchenko / 212--224 \\
                 Remarks on Kaczmarz Algorithm for Solving Consistent
                 and Inconsistent System of Linear Equations / Xinyin
                 Huang, Gang Liu, Qiang Niu / 225--236 \\
                 Investigating the Benefit of FP16--Enabled
                 Mixed--Precision Solvers for Symmetric Positive
                 Definite Matrices Using GPUs / Ahmad Abdelfattah, Stan
                 Tomov, Jack Dongarra / 237--250 \\
                 Simulation Versus an Ordered Fuzzy--Numbers--Driven
                 Approach to the Multi--depot Vehicle Cyclic Routing and
                 Scheduling Problem / Grzegorz Bocewicz, Zbigniew
                 Banaszak, Czeslaw Smutnicki, Katarzyna Rudnik, Marcin
                 Witczak, Robert W{\'o}jcik / 251--266 \\
                 Epigenetic Modification of Genetic Algorithm / Kornel
                 Chrominski, Magdalena Tkacz, Mariusz Boryczka /
                 267--278 \\
                 ITP--KNN: Encrypted Video Flow Identification Based on
                 the Intermittent Traffic Pattern of Video and
                 $K$-Nearest Neighbors Classification / Youting Liu, Shu
                 Li, Chengwei Zhang, Chao Zheng, Yong Sun, Qingyun Liu /
                 279--293 \\
                 DeepAD: A Joint Embedding Approach for Anomaly
                 Detection on Attributed Networks / Dali Zhu, Yuchen Ma,
                 Yinlong Liu / 294--307 \\
                 SciNER: Extracting Named Entities from Scientific
                 Literature / Zhi Hong, Roselyne Tchoua, Kyle Chard, Ian
                 Foster / 308--321 \\
                 GPU--Embedding of kNN--Graph Representing Large and
                 High--Dimensional Data / Bartosz Minch, Mateusz Nowak,
                 Rafa{\l} Wcis{\l}o, Witold Dzwinel / 322--336 \\
                 Evolving Long Short--Term Memory Networks / Vicente
                 Coelho Lobo Neto, Leandro Aparecido Passos, Jo{\~a}o
                 Paulo Papa / 337--350 \\
                 Personality Recognition from Source Code Based on
                 Lexical, Syntactic and Semantic Features / Miko{\l}aj
                 Biel, Marcin Kuta, Jacek Kitowski / 351--363 \\
                 Data Fitting by Exponential Sums with Equal Weights /
                 Petr Chunaev, Ildar Safiullin / 364--371 \\
                 A Combination of Moment Descriptors, Fourier Transform
                 and Matching Measures for Action Recognition Based on
                 Shape / Katarzyna Go{\'s}ciewska, Dariusz Frejlichowski
                 / 372--386 \\
                 Improving Accuracy and Speeding Up Document Image
                 Classification Through Parallel Systems / Javier
                 Ferrando, Juan Luis Dom{\'\i}nguez, Jordi Torres,
                 Ra{\'u}l Garc{\'\i}a, David Garc{\'\i}a, Daniel Garrido
                 et al. / 387--400 \\
                 Computation of the Airborne Contaminant Transport in
                 Urban Area by the Artificial Neural Network / Anna
                 Wawrzynczak, Monika Berendt--Marchel / 401--413 \\
                 Exploring Musical Structure Using Tonnetz Lattice
                 Geometry and LSTMs / Manuchehr Aminian, Eric Kehoe,
                 Xiaofeng Ma, Amy Peterson, Michael Kirby / 414--424 \\
                 Modeling of Anti--tracking Network Based on
                 Convex--Polytope Topology / Changbo Tian, Yongzheng
                 Zhang, Tao Yin / 425--438 \\
                 A Workload Division Differential Privacy Algorithm to
                 Improve the Accuracy for Linear Computations / Jun Li,
                 Huan Ma, Guangjun Wu, Yanqin Zhang, Bingnan Ma, Zhen
                 Hui et al. / 439--452 \\
                 On the Automated Assessment of Open--Source Cyber
                 Threat Intelligence Sources / Andrea Tundis, Samuel
                 Ruppert, Max M{\"u}hlh{\"a}user / 453--467 \\
                 Malicious Domain Detection Based on K--means and SMOTE
                 / Qing Wang, Linyu Li, Bo Jiang, Zhigang Lu, Junrong
                 Liu, Shijie Jian / 468--481 \\
                 Microservice Disaster Crash Recovery: A Weak Global
                 Referential Integrity Management / Maude Manouvrier,
                 Cesare Pautasso, Marta Rukoz / 482--495 \\
                 Hashing Based Prediction for Large--Scale Kernel
                 Machine / Lijing Lu, Rong Yin, Yong Liu, Weiping Wang /
                 496--509 \\
                 Picking Peaches or Squeezing Lemons: Selecting
                 Crowdsourcing Workers for Reducing Cost of Redundancy /
                 Paulina Adamska, Marta Ju{\'z}win, Adam Wierzbicki /
                 510--523 \\
                 Are $n$-gram Categories Helpful in Text Classification?
                 / Jakub Kruczek, Paulina Kruczek, Marcin Kuta /
                 524--537 \\
                 Calculating Reactive Power Compensation for
                 Large--Scale Street Lighting / Sebastian Ernst, Leszek
                 Kotulski, Tomasz Lerch, Micha{\l} Rad, Adam
                 S{\k{e}}dziwy, Igor Wojnicki / 538--550 \\
                 Developing a Decision Support App for Computational
                 Agriculture / Andrew Lewis, Marcus Randall, Ben
                 Stewart--Koster / 551--561 \\
                 Optimal Location of Sensors for Early Detection of
                 Tsunami Waves / Angelie R. Ferrolino, Jose Ernie C.
                 Lope, Renier G. Mendoza / 562--575 \\
                 A Novel Formulation for Inverse Distance Weighting from
                 Weighted Linear Regression / Leonardo Ramos
                 Emmendorfer, Gra{\c{c}}aliz Pereira Dimuro / 576--589
                 \\
                 Addressing the Robustness of Resource Allocation in the
                 Presence of Application and System Irregularities via
                 PEPA Based Modeling / Srishti Srivastava, Ioana
                 Banicescu, William S. Sanders / 590--603 \\
                 An Adaptive Computational Network Model for Strange
                 Loops in Political Evolution in Society / Julia Anten,
                 Jordan Earle, Jan Treur / 604--617 \\
                 Joint Entity Linking for Web Tables with Hybrid
                 Semantic Matching / Jie Xie, Yuhai Lu, Cong Cao,
                 Zhenzhen Li, Yangyang Guan, Yanbing Liu / 618--631 \\
                 A New Coefficient of Rankings Similarity in
                 Decision--Making Problems / Wojciech Sa abun, Karol
                 Urbaniak / 632--645 \\
                 Innovativeness Analysis of Scholarly Publications by
                 Age Prediction Using Ordinal Regression / Pavel Savov,
                 Adam Jatowt, Radoslaw Nielek / 646--660 \\
                 Advantage of Using Spherical over Cartesian Coordinates
                 in the Chromosome Territories 3D Modeling / Magdalena
                 A. Tkacz, Kornel Chromi{\'n}ski / 661--673 \\
                 Adaptive and Efficient Transfer for Online Remote
                 Visualization of Critical Weather Applications / Preeti
                 Malakar, Vijay Natarajan, Sathish S. Vadhiyar /
                 674--693 \\
                 Back Matter / / 695--697",
}