Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Julia 1.0 Programming Cookbook
  • Toc
  • feedback
Julia 1.0 Programming Cookbook

Julia 1.0 Programming Cookbook

By : Kamiński, Szufel
3.3 (4)
close
Julia 1.0 Programming Cookbook

Julia 1.0 Programming Cookbook

3.3 (4)
By: Kamiński, Szufel

Overview of this book

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
Table of Contents (12 chapters)
close
close
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Sections
Get in touch
Free Chapter
1
Installing and Setting Up Julia
Installing and Setting Up Julia
Introduction
Installing Julia from binaries
Julia IDEs
Julia support for text editors
Building Julia from sources on Linux
Running Julia inside the Cloud9 IDE in the AWS cloud
How to customize Julia on startup
Setting up Julia to use multiple cores
Useful options for interaction with Julia
Displaying computation results in Julia
Managing packages
Configuring Julia in Jupyter Notebook
Configuring Julia to work with JupyterLab
Configuring Julia with Jupyter Notebook in Terminal-only cloud environments
2
Data Structures and Algorithms
Data Structures and Algorithms
Introduction
Finding the index of a random minimum element in an array
Fast matrix multiplication
Implementing a custom pseudo-random number generator
Parsing Git logs with regular expressions
Non-standard ways to sort your data
Creating a function preimage - understanding how dictionaries and sets work
Working with UTF-8 strings
3
Data Engineering in Julia
Data Engineering in Julia
Introduction
Managing streams, and reading and writing files
Using IOBuffer to efficiently work with in-memory streams
Fetching data from the internet
Writing a simple RESTful service
Working with JSON data
Working with date and time
Using object serialization in Julia
Running Julia as a background process
Reading and writing Microsoft Excel files
Handling Feather data
Reading CSV and FWF files
4
Numerical Computing with Julia
Numerical Computing with Julia
Introduction
Traversing matrices efficiently
Executing loops efficiently with conditional statements
Generating full factorial designs
Approximating pi using partial series sums
Running Monte Carlo simulations
Analyzing a queuing system
Working with complex numbers
Writing a simple optimization routine
Estimating a linear regression
Understanding broadcasting in Julia
Improving code performance using @inbounds
Creating a matrix from a set of vectors as rows
Using array views to avoid memory allocation
5
Variables, Types, and Functions
Variables, Types, and Functions
Introduction
Understanding subtyping in Julia
Using multiple dispatch to handle branching behavior
Using functions as variables in Julia
Functional programming in Julia
Scope of variables in Julia
Handling exceptions in Julia
Working with NamedTuples
6
Metaprogramming and Advanced Typing
Metaprogramming and Advanced Typing
Introduction
Metaprogramming
Macros and generated functions
Defining your own types - linked list
Defining primitive types
Understanding the structure of Julia numeric types with introspection
Using static arrays
The efficiency of mutable versus immutable types
Ensuring type stability of your code
7
Handling Analytical Data
Handling Analytical Data
Introduction
Converting data between DataFrame and Matrix
Investigating the contents of a data frame
Reading CSV data from the internet
Working with categorical data
Handling missing data
Split-apply-combine in DataFrames
Converting a data frame between wide and narrow formats
Comparing data frames for identity
Transforming rows of DataFrame
Creating pivot tables by chaining transformations of data frames
8
Julia Workflow
chevron up
Julia Workflow
Introduction
Julia development workflow with Revise.jl
Benchmarking code
Profiling Julia code
Setting up logging in your code
Calling Python from Julia
Calling R from Julia
Managing project dependencies
9
Data Science
Data Science
Introduction
Working with databases in Julia
Optimization using JuMP
Estimation using maximum likelihood
Complex plotting with Plots.jl
Building machine learning models with ScikitLearn.jl
10
Distributed Computing
Distributed Computing
Introduction
Multiprocessing in Julia
Sending parameters to remote Julia processes
Multithreading in Julia
Distributed computing with Julia
11
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Setting up logging in your code

In simple workflows, users often use the print family of functions to report the state of their programs, for example, for debugging purposes. However, in Julia 1.0, we have built-in functionality enabling diagnostic messages from a program to be handled using custom loggers.

In this recipe, we will explain how you can use loggers to control what is reported by your application. In particular, we will explain how you can add debugging information to your application, yet only enable it on demand. 

Getting ready

Now, open your favorite terminal to execute the commands.

Note

In the GitHub repository for this recipe, you will find the commands.txt file, which contains the presented sequence of shell and Julia commands.

How to do it...

Here is a list of steps to be followed:

  1. First, load theLoggingmodule and then define a function that performs some operations on sets:
julia> using Logging

julia> function f(x)
           y = Set(x)
           for v in x
        ...
End of Section 8
Next Section
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete