(Ebook) Julia High Performance Programming 1st edition by Ivo Balbaert, Avik Sengupta, Malcolm Sherrington 178712570X 9781787125704

(Ebook) Julia High Performance Programming 1st edition by Ivo Balbaert, Avik Sengupta, Malcolm Sherrington 178712570X 9781787125704

Julia: High Performance Programming 1st edition by Ivo Balbaert, Avik Sengupta, Malcolm Sherrington - Ebook PDF Instant Download/DeliveryISBN:  178712570X, 9781787125704  

Full download Julia: High Performance Programming 1st edition after payment.

Product details:

ISBN-10 :  178712570X  

ISBN-13 : 9781787125704

Author:  Ivo Balbaert, Avik Sengupta, Malcolm Sherrington 

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. It includes content from the following Packt products: • Getting Started with Julia by Ivo Balvaert • Julia High Performance by Avik Sengupta • Mastering Julia by Malcolm Sherrington Style and approach This hands-on manual will give you great explanations of the important concepts related to Julia programming.

Julia: High Performance Programming 1st Table of contents:

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
Installing and updating packages
Publishing a package
Graphics in Julia
Using Gadfly on data
Summary
A. List of Macros and Packages
Macros
List of packages
II. Module 2
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

People also search for Julia: High Performance Programming 1st:

    
julia high performance programming
    
julia high performance programming pdf
    
high performance vs high-performance
    
julia high performance
    
julia high performance pdf

Tags: Julia, High Performance, Programming, Ivo Balbaert, Avik Sengupta, Malcolm Sherrington