Book Image

Julia 1.0 Programming. - Second Edition

By : Ivo Balbaert
Book Image

Julia 1.0 Programming. - Second Edition

By: Ivo Balbaert

Overview of this book

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.
Table of Contents (17 chapters)
Title Page
Copyright and Credits
Packt Upsell
Contributors
Preface
Index

Index

A

  • abstract syntax tree (AST)
    • about / Expressions and symbols
    • reference / Expressions and symbols
  • abstract type / Concrete and abstract types
  • anonymous functions / Anonymous functions
  • arrays
    • about / Ranges and arrays
    • creating / Other ways to create arrays
    • functions / Some common functions for arrays
  • automatic type promotion / Type conversions and promotions

B

  • broadcasting / Broadcasting
  • built-in macros
    • about / Built-in macros
    • @assert macro / Testing
    • @test macro / Testing
    • debugging / Debugging
    • benchmarking / Benchmarking
    • task, starting / Starting a task

C

  • C
    • calling / Calling C and Fortran
  • characters / Characters
  • child processes / Running shell commands
  • closures / First-class functions and closures
  • comma-separated file
    • reading / Reading and writing CSV files
    • writing / Reading and writing CSV files
  • comments / Variables, naming conventions, and comments
  • complex numbers / Rational and complex numbers
  • composite types
    • about / User-defined and composite types
    • equal values, checking / When are two values or objects equal or identical?
    • equal objects, checking / When are two values or objects equal or identical?
    • multiple dispatch example / A multiple-dispatch example
  • compound expression / Scope and constants
  • concrete types / Concrete and abstract types
  • conditional evaluation / Conditional evaluation
  • constants / Scope and constants
  • coroutines / Tasks
  • CSV.jl documentation
    • reference / Using DataFrames
  • currying / First-class functions and closures

D

  • databases
    • interacting with / Interacting with databases
  • DataFrames
    • using / Using DataFrames
  • DataFrames.jl
    • reference / Using DataFrames
  • Data Source Name (DSN) / Interacting with databases
  • dates / Dates and times
  • dictionaries
    • about / Dictionaries
    • keys and values / Keys and values – looping
  • domain-specific languages (DSLs) / Defining macros
  • dump function / Expressions and symbols

E

  • editors / Other editors and IDEs
  • elementary mathematical functions / Elementary mathematical functions and operations
  • elementary mathematical operations / Elementary mathematical functions and operations
  • epoch / Dates and times
  • evaluation / Evaluation and interpolation
  • exception handling / Exception handling
  • expression / Expressions and symbols

F

  • Fast Fourier Transformations (FFT) / Digging deeper into the standard library
  • file formats / Other file formats
  • files
    • working with / Working with files
  • filter / Map, filter, and list comprehensions
  • first-class functions / First-class functions and closures
  • floating point numbers / Floating point numbers
  • Fortran
    • calling / Calling C and Fortran
  • functions
    • defining / Defining functions
    • about / functions
    • versus macros / Defining macros

G

  • garbage collector (GC) / How Julia works
  • generated functions / Evaluation and interpolation
  • generic functions / Generic functions and multiple dispatch
  • global scope / Scope revisited

H

  • hygienic macro / Defining macros

I

  • IDEs / Other editors and IDEs
  • IJulia
    • references / Installing and working with IJulia
    • installing / Installing and working with IJulia
    • working with / Installing and working with IJulia
  • inner constructors / Types and collections – inner constructors
  • input/output (I/O) / Basic input and output
  • integer / Integers
  • interpolation / Evaluation and interpolation

J

  • Julia
    • installing / Installing Julia
    • installing, on Windows OS / Windows OS
    • installing, on OS X / OS X
    • installing, on Linux OS / Linux OS
    • building, from source / Building from source
    • working / How Julia works
    • types / Types
    • performance tips / Performance tips
    • tools / Tools to use
    • graphics / Graphics in Julia
    • plots, reference / Graphics in Julia
  • Julia's package manager
    • about / Julia's package manager
    • installing / Installing and updating packages
    • updating / Installing and updating packages
  • Julia's REPL
    • working with / Working with Julia's REPL
  • julia-vscode
    • about / Installing julia-vscode
    • installing / Installing julia-vscode
  • JuliaPro / JuliaPro
  • Julia scripts / Startup options and Julia scripts
  • Julia source code
    • reference / Building from source
  • Juno
    • installing / Installing Juno
  • just in time (JIT) compiler / Working with Julia's REPL

K

  • keyword arguments / Optional and keyword arguments

L

  • libraries / Standard modules and paths
  • list comprehensions / Map, filter, and list comprehensions
  • local scope / Scope revisited
  • low-level communications
    • using / Using low-level communications

M

  • macros
    • defining / Defining macros
    • versus functions / Defining macros
  • map / Map, filter, and list comprehensions
  • matrices / Matrices
  • method / Generic functions and multiple dispatch
  • multiple dispatch / Generic functions and multiple dispatch

N

  • naming conventions / Variables, naming conventions, and comments

O

  • object-oriented (OO) languages / Generic functions and multiple dispatch
  • Open Database Connectivity (ODBC) / Interacting with databases
  • operators / First-class functions and closures
  • optional positional arguments / Optional and keyword arguments
  • overloading / Generic functions and multiple dispatch

P

  • package
    • about / Packages
    • adding / Adding a new package
  • parallel computing
    • about / Parallel operations and computing
    • processes, creating / Creating processes
    • low-level communications, using / Using low-level communications
  • parallel operations / Parallel operations and computing
  • parametric type / Rational and complex numbers, Parametric types and methods
  • performance tips, Julia
    • reference / Tools to use
  • Plots
    • using, on data / Using Plots on data
  • profiler tool
    • about / Tools to use
    • reference / Tools to use
  • Python
    • calling / Calling Python

Q

  • quote / Expressions and symbols

R

  • ranges / Ranges and arrays
  • rational numbers / Rational and complex numbers
  • Read Evaluate Print Loop (REPL) / Windows OS
  • reflection
    • capabilities / Reflection capabilities
  • regular expressions / Regular expressions
  • repeated evaluation
    • about / Repeated evaluation
    • for loops / for loops
    • while loops / while loops
    • break statement / The break statement
    • continue statement / The continue statement

S

  • scope / Scope and constants, Scope revisited
  • sets / Sets
  • shell commands
    • executing / Running shell commands
    • interpolation / Interpolation
    • pipelining / Pipelining
  • single dispatch / Generic functions and multiple dispatch
  • slices / Matrices
  • splice operator / Some common functions for arrays
  • standard input (stdin) / Basic input and output
  • standard library / Digging deeper into the standard library
  • standard modules / Standard modules and paths
  • standard output (stdout) / Basic input and output
  • strings
    • about / Strings
    • formatting / Formatting numbers and strings
    • numbers, formatting / Formatting numbers and strings
  • Sublime-IJulia
    • installing / Installing Sublime-IJulia
    • about / Installing Sublime-IJulia
  • subtypes / The type hierarchy – subtypes and supertypes
  • supertype function / The type hierarchy – subtypes and supertypes
  • symbols / Expressions and symbols

T

  • tasks / Tasks
  • TCP servers
    • working with / Working with TCP sockets and servers
  • TCP sockets
    • working with / Working with TCP sockets and servers
  • times / Dates and times
  • Transmission Control Protocol / Internet Protocol (TCP/IP) / Working with TCP sockets and servers
  • tuples / Tuples
  • type annotations
    • about / Type annotations
    • type conversions / Type conversions and promotions
    • promotions / Type conversions and promotions
  • type unions / Type unions

U

  • user-defined type / User-defined and composite types

V

  • variables / Variables, naming conventions, and comments
  • vector / Ranges and arrays

W

  • word frequency / An example project – word frequency