• Introduction
  • Getting Started
    • Resources
  • Variables
    • Allowed Variable Names
    • Stylistic Conventions
  • Integers and Floating-Point Numbers
    • Integers
    • Floating-Point Numbers
    • Arbitrary Precision Arithmetic
    • Numeric Literal Coefficients
    • Literal zero and one
  • Mathematical Operations and Elementary Functions
    • Arithmetic Operators
    • Bitwise Operators
    • Updating operators
    • Numeric Comparisons
    • Elementary Functions
  • Complex and Rational Numbers
    • Complex Numbers
    • Rational Numbers
  • Strings
    • Characters
    • String Basics
    • Unicode and UTF-8
    • Interpolation
    • Common Operations
    • Non-Standard String Literals
    • Regular Expressions
    • Byte Array Literals
    • Version Number Literals
  • Functions
    • Argument Passing Behavior
    • The return Keyword
    • Operators Are Functions
    • Operators With Special Names
    • Anonymous Functions
    • Multiple Return Values
    • Varargs Functions
    • Optional Arguments
    • Keyword Arguments
    • Evaluation Scope of Default Values
    • Do-Block Syntax for Function Arguments
    • Further Reading
  • Control Flow
    • Compound Expressions
    • Conditional Evaluation
    • Short-Circuit Evaluation
    • Repeated Evaluation: Loops
    • Exception Handling
    • Tasks (aka Coroutines)
  • Scope of Variables
    • For Loops and Comprehensions
    • Constants
  • Types
    • Type Declarations
    • Abstract Types
    • Bits Types
    • Composite Types
    • Immutable Composite Types
    • Declared Types
    • Tuple Types
    • Type Unions
    • Parametric Types
    • Type Aliases
    • Operations on Types
  • Methods
    • Defining Methods
    • Method Ambiguities
    • Parametric Methods
    • Note on Optional and keyword Arguments
  • Constructors
    • Outer Constructor Methods
    • Inner Constructor Methods
    • Incomplete Initialization
    • Parametric Constructors
    • Case Study: Rational
  • Conversion and Promotion
    • Conversion
    • Promotion
  • Modules
    • Summary of module usage
  • Metaprogramming
    • Program representation
    • Expressions and evaluation
    • Macros
    • Code Generation
    • Non-Standard String Literals
  • Multi-dimensional Arrays
    • Arrays
    • Sparse Matrices
  • Linear algebra
    • Matrix factorizations
    • Special matrices
  • Networking and Streams
    • Basic Stream I/O
    • Text I/O
    • Working with Files
    • A simple TCP example
    • Resolving IP Addresses
  • Parallel Computing
    • Code Availability and Loading Packages
    • Data Movement
    • Parallel Map and Loops
    • Synchronization With Remote References
    • Scheduling
    • Distributed Arrays
    • Constructing Distributed Arrays
    • Distributed Array Operations
    • Shared Arrays (Experimental)
    • ClusterManagers
  • Running External Programs
    • Interpolation
    • Quoting
    • Pipelines
  • Calling C and Fortran Code
    • Mapping C Types to Julia
    • Accessing Data through a Pointer
    • Passing Pointers for Modifying Inputs
    • Garbage Collection Safety
    • Non-constant Function Specifications
    • Indirect Calls
    • Calling Convention
    • Accessing Global Variables
    • Passing Julia Callback Functions to C
    • C++
    • Handling Platform Variations
  • Interacting With Julia
    • The different prompt modes
    • Key bindings
    • Tab completion
  • Embedding Julia
    • High-Level Embedding
    • Converting Types
    • Calling Julia Functions
    • Memory Management
    • Working with Arrays
    • Exceptions
  • Packages
    • Package Status
    • Adding and Removing Packages
    • Installing Unregistered Packages
    • Updating Packages
    • Checkout, Pin and Free
  • Package Development
    • Initial Setup
    • Making changes to an existing package
    • Creating a new Package
    • Tagging Package Versions
    • Fixing Package Requirements
    • Requirements Specification
  • Profiling
    • Basic usage
    • Accumulation and clearing
    • Options for controlling the display of profile results
    • Configuration
  • Memory allocation analysis
  • Performance Tips
    • Avoid global variables
    • Measure performance with @time and pay attention to memory allocation
    • Tools
    • Avoid containers with abstract type parameters
    • Type declarations
    • Break functions into multiple definitions
    • Write “type-stable” functions
    • Avoid changing the type of a variable
    • Separate kernel functions
    • Access arrays in memory order, along columns
    • Pre-allocating outputs
    • Avoid string interpolation for I/O
    • Optimize network I/O during parallel execution
    • Fix deprecation warnings
    • Tweaks
    • Performance Annotations
  • Workflow Tips
    • REPL-based workflow
    • Browser-based workflow
  • Style Guide
    • Write functions, not just scripts
    • Avoid writing overly-specific types
    • Handle excess argument diversity in the caller
    • Append ! to names of functions that modify their arguments
    • Avoid strange type Unions
    • Try to avoid nullable fields
    • Avoid elaborate container types
    • Use naming conventions consistent with Julia’s base/
    • Don’t overuse try-catch
    • Don’t parenthesize conditions
    • Don’t overuse ...
    • Don’t use unnecessary static parameters
    • Avoid confusion about whether something is an instance or a type
    • Don’t overuse macros
    • Don’t expose unsafe operations at the interface level
    • Don’t overload methods of base container types
    • Be careful with type equality
    • Do not write x->f(x)
  • Frequently Asked Questions
    • Sessions and the REPL
    • Functions
    • Types, type declarations, and constructors
    • Nothingness and missing values
    • Memory
    • Julia Releases
  • Noteworthy Differences from other Languages
    • Noteworthy differences from MATLAB
    • Noteworthy differences from R
    • Noteworthy differences from Python
  • Unicode Input
  • Essentials
    • Introduction
    • Getting Around
    • All Objects
    • Types
    • Generic Functions
    • Syntax
    • System
    • Errors
    • Events
    • Reflection
    • Internals
  • Collections and Data Structures
    • Iteration
    • General Collections
    • Iterable Collections
    • Indexable Collections
    • Associative Collections
    • Set-Like Collections
    • Dequeues
    • PriorityQueue
    • Heap Functions
  • Mathematics
    • Mathematical Operators
    • Mathematical Functions
    • Statistics
    • Signal Processing
    • Numerical Integration
  • Numbers
    • Standard Numeric Types
    • Data Formats
    • Numbers
    • BigFloats
    • Random Numbers
  • Strings
  • Arrays
    • Basic functions
    • Constructors
    • Mathematical operators and functions
    • Indexing, Assignment, and Concatenation
    • Array functions
    • Combinatorics
    • BitArrays
    • Sparse Matrices
  • Tasks and Parallel Computing
    • Tasks
    • General Parallel Computing Support
    • Distributed Arrays
    • Shared Arrays (Experimental, UNIX-only feature)
  • Linear Algebra
    • Standard Functions
    • BLAS Functions
  • Constants
  • Filesystem
  • I/O and Network
    • General I/O
    • Network I/O
    • Text I/O
    • Multimedia I/O
    • Memory-mapped I/O
  • Punctuation
  • Sorting and Related Functions
    • Sorting Functions
    • Order-Related Functions
    • Sorting Algorithms
  • Package Manager Functions
  • Collections and Data Structures
    • Iteration
    • General Collections
    • Iterable Collections
    • Indexable Collections
    • Associative Collections
    • Set-Like Collections
    • Dequeues
    • PriorityQueue
    • Heap Functions
  • Graphics
    • Geometry
  • Unit and Functional Testing
    • Overview
    • Handlers
    • Macros
    • Functions
  • Testing Base Julia
  • C Interface
  • Profiling
  • Reflection and introspection
  • Documentation of Julia’s Internals
    • Base.Cartesian
    • System Image Building
  • Developing/debugging Julia’s C code
    • Reporting and analyzing crashes (segfaults)
    • gdb debugging tips
 
Julia Language
  • Docs »
  • Julia Documentation
  • View page source

Julia Documentation¶

  • Manual
  • Standard Library
  • Developer Documentation

Manual¶

  • Introduction
  • Getting Started
  • Variables
  • Integers and Floating-Point Numbers
  • Mathematical Operations and Elementary Functions
  • Complex and Rational Numbers
  • Strings
  • Functions
  • Control Flow
  • Scope of Variables
  • Types
  • Methods
  • Constructors
  • Conversion and Promotion
  • Modules
  • Metaprogramming
  • Multi-dimensional Arrays
  • Linear algebra
  • Networking and Streams
  • Parallel Computing
  • Running External Programs
  • Calling C and Fortran Code
  • Interacting With Julia
  • Embedding Julia
  • Packages
  • Package Development
  • Profiling
  • Memory allocation analysis
  • Performance Tips
  • Workflow Tips
  • Style Guide
  • Frequently Asked Questions
  • Noteworthy Differences from other Languages
  • Unicode Input

Standard Library¶

  • Essentials
  • Collections and Data Structures
  • Mathematics
  • Numbers
  • Strings
  • Arrays
  • Tasks and Parallel Computing
  • Linear Algebra
  • Constants
  • Filesystem
  • I/O and Network
  • Punctuation
  • Sorting and Related Functions
  • Package Manager Functions
  • Collections and Data Structures
  • Graphics
  • Unit and Functional Testing
  • Testing Base Julia
  • C Interface
  • Profiling

Developer Documentation¶

  • Reflection and introspection
  • Documentation of Julia’s Internals
    • Base.Cartesian
    • System Image Building
  • Developing/debugging Julia’s C code
    • Reporting and analyzing crashes (segfaults)
    • gdb debugging tips
Next

Sphinx theme provided by Read the Docs