
Julia 1.0 Programming Complete Reference Guide
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
More details
Other editions
Additional editions

Content
- Cover
- Title Page
- Copyright and Credits
- About Packt
- Contributors
- Table of Contents
- Preface
- Chapter 1: Installing the Julia Platform
- Installing Julia
- Windows OS
- OS X
- Linux OS
- Building from source
- JuliaPro
- Working with Julia's REPL
- Startup options and Julia scripts
- Packages
- Adding a new package
- Installing and working with IJulia
- Installing Juno
- Installing julia-vscode
- Installing Sublime-IJulia
- Other editors and IDEs
- How Julia works
- Summary
- Chapter 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
- Dates and times
- Scope and constants
- Summary
- Chapter 3: Functions
- Defining functions
- Optional and keyword arguments
- Anonymous functions
- First-class functions and closures
- functions
- Broadcasting
- Map, filter, and list comprehensions
- Generic functions and multiple dispatch
- Summary
- Chapter 4: Control Flow
- Conditional evaluation
- Repeated evaluation
- for loops
- while loops
- The break statement
- The continue statement
- Exception handling
- Scope revisited
- Tasks
- Summary
- Chapter 5: Collection Types
- Matrices
- Tuples
- Dictionaries
- Keys and values - looping
- Sets
- An example project - word frequency
- Summary
- Chapter 6: More on Types, Methods, and Modules
- Type annotations
- 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?
- A multiple-dispatch example
- Types and collections - inner constructors
- Type unions
- Parametric types and methods
- Standard modules and paths
- Summary
- Chapter 7: Metaprogramming in Julia
- Expressions and symbols
- Evaluation and interpolation
- Defining macros
- Built-in macros
- Testing
- Debugging
- Benchmarking
- Starting a task
- Reflection capabilities
- Summary
- Chapter 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
- Summary
- Chapter 9: Running External Programs
- Running shell commands
- Interpolation
- Pipelining
- Calling C and Fortran
- Calling Python
- Performance tips
- Tools to use
- Summary
- Chapter 10: The Standard Library and Packages
- Digging deeper into the standard library
- Julia's package manager
- Installing and updating packages
- Graphics in Julia
- Using Plots on data
- Summary
- Chapter 11: 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
- Chapter 12: 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
- Building a DOM representation of the page
- Parsing HTML with Gumbo
- Coding defensively
- The pipe operator
- Handling errors like a pro
- The try...catch statements
- The finally clause
- Throwing exceptions on errors
- Rethrowing exceptions
- Learning about functions
- The return keyword
- Returning multiple values
- Optional arguments
- Keyword arguments
- Documenting functions
- Writing a basic web crawler - take one
- Setting up our project
- Writing a Julia program
- Conditional evaluation of if, elseif, and else statements
- The ternary operator
- Short-circuit evaluation
- Beware of operator precedence
- Carrying on with the crawler's implementation
- Summary
- Chapter 13: Building the Wiki Game Web Crawler
- Technical requirements
- Six Degrees of Wikipedia, the gameplay
- Some additional requirements
- Organizing our code
- Using modules to tame our code
- Defining modules
- Productive REPL sessions with Julia
- Setting up our modules
- Referencing modules
- Setting up the LOAD_PATH
- Loading modules with using
- Loading modules with import
- Loading modules with include
- Nesting modules
- Setting up our game's architecture
- Checking our code
- Building our Wikipedia crawler - take two
- Using blocks
- Implementing the gameplay
- Finishing touches
- One more thing
- Learning about Julia's type system
- Defining our own types
- Constructing types
- Mutable composite types
- Type hierarchy and inheritance
- Type unions
- Using article types
- Inner constructors
- Methods
- Working with relational databases
- Adding MySQL support
- Connecting to the database
- Setting up our Article module
- Adding the persistence and retrieval methods
- Putting it all together
- Summary
- Chapter 14: Adding a Web UI for the Wiki Game
- Technical requirements
- The game plan
- Learning about Julia's web stack
- Beginning with a simple example - Hello World
- Developing the game's web UI
- Defining our routes
- Preparing the landing page
- Starting a new game
- Extracting the difficulty settings from the page URL
- Starting a new game session
- Rendering the first Wikipedia article from the chain
- Setting up in-article navigation
- Displaying information about the game session
- Displaying a Wikipedia article page
- Navigating back up the article chain
- Showing the solution
- Handling any other requests
- Wrapping it up
- Summary
- Chapter 15: Implementing Recommender Systems with Julia
- Technical requirements
- Understanding recommender systems
- Classifying recommender systems
- Learning about non-personalized, stereotyped, and personalized recommendations
- Understanding personalized recommendations
- Explicit and implicit ratings
- Understanding content-based recommender systems
- Beginning with association-based recommendations
- Learning about collaborative filtering
- Understanding user-item CF
- Item-item CF
- Summary
- Chapter 16: Machine Learning for Recommender Systems
- Technical requirements
- Comparing the memory-based versus model-based recommenders
- Learning about the model-based approach
- Understanding our data
- A first look at the data
- Loading the data
- Handling missing data
- Data analysis and preparation
- Training our data models
- Scaling down our dataset
- Training versus testing data
- Machine learning-based recommendations
- Making recommendations with Recommendation
- Setting up the training data
- Building and training the recommender
- Matrix Factorization
- Making recommendations
- Testing the recommendations
- Learning about hybrid recommender systems
- Summary
- Other Books You May Enjoy
- Index
System requirements
File format: ePUB
Copy protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (not Kindle).
The file format ePub works well for novels and non-fiction books – i.e., „flowing” text without complex layout. On an e-reader or smartphone, line and page breaks automatically adjust to fit the small displays.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our ebook Help page.