Numba
0.56

For all users

  • User Manual
    • A ~5 minute guide to Numba
      • How do I get it?
      • Will Numba work for my code?
      • What is nopython mode?
      • How to measure the performance of Numba?
      • How fast is it?
      • How does Numba work?
      • Other things of interest:
        • GPU targets:
    • Overview
    • Installation
      • Compatibility
      • Installing using conda on x86/x86_64/POWER Platforms
      • Installing using pip on x86/x86_64 Platforms
      • Installing on Linux ARMv7 Platforms
      • Installing on Linux ARMv8 (AArch64) Platforms
      • Installing from source
        • Build time environment variables and configuration of optional components
      • Dependency List
      • Version support information
      • Checking your installation
    • Compiling Python code with @jit
      • Basic usage
        • Lazy compilation
        • Eager compilation
      • Calling and inlining other functions
      • Signature specifications
      • Compilation options
        • nopython
        • nogil
        • cache
        • parallel
    • Flexible specializations with @generated_jit
      • Example
      • Compilation options
    • Creating NumPy universal functions
      • The @vectorize decorator
      • The @guvectorize decorator
        • Overwriting input values
      • Dynamic universal functions
      • Dynamic generalized universal functions
    • Compiling Python classes with @jitclass
      • Basic usage
      • Inferred class member types from type annotations with as_numba_type
      • Specifying numba.typed containers as class members explicitly
      • Support operations
        • Supported dunder methods
      • Limitations
      • The decorator: @jitclass
        • jitclass()
    • Creating C callbacks with @cfunc
      • Basic usage
      • Example
      • Dealing with pointers and array memory
      • Handling C structures
        • With CFFI
        • With numba.types.Record.make_c_struct
        • Full example
      • Signature specification
      • Compilation options
    • Compiling code ahead of time
      • Overview
        • Benefits
        • Limitations
      • Usage
        • Standalone example
        • Distutils integration
        • Signature syntax
    • Automatic parallelization with @jit
      • Supported Operations
      • Explicit Parallel Loops
      • Examples
      • Unsupported Operations
      • Diagnostics
        • The parallel diagnostics report sections
      • Scheduling
    • Using the @stencil decorator
      • Basic usage
      • Stencil Parameters
      • Kernel shape inference and border handling
      • Stencil decorator options
        • neighborhood
        • func_or_mode
        • cval
        • standard_indexing
      • StencilFunc
      • Stencil invocation options
        • out
    • Callback into the Python Interpreter from within JIT’ed code
      • The objmode context-manager
        • objmode()
    • Automatic module jitting with jit_module
      • Example usage
      • API
        • jit_module()
    • Performance Tips
      • No Python mode vs Object mode
      • Loops
      • Fastmath
      • Parallel=True
      • Intel SVML
      • Linear algebra
    • The Threading Layers
      • Which threading layers are available?
      • Setting the threading layer
      • Setting the threading layer selection priority
        • Selecting a threading layer for safe parallel execution
        • Selecting a named threading layer
      • Extra notes
      • Setting the Number of Threads
        • Example of Limiting the Number of Threads
      • Getting a Thread ID
        • API Reference
    • Command line interface
      • Usage
      • Help
      • System information
      • Debugging
    • Troubleshooting and tips
      • What to compile
      • My code doesn’t compile
      • My code has a type unification problem
      • My code has an untyped list problem
      • The compiled code is too slow
      • Disabling JIT compilation
      • Debugging JIT compiled code with GDB
        • JIT options for debug
        • Example debug usage
        • Globally override debug setting
      • Using Numba’s direct gdb bindings in nopython mode
        • Set up
        • Basic gdb support
        • Running with gdb enabled
        • Adding breakpoints to code
        • Debugging in parallel regions
        • Using the gdb command language
        • How does the gdb binding work?
      • Debugging CUDA Python code
        • Using the simulator
        • Debug Info
    • Frequently Asked Questions
      • Installation
        • Numba could not be imported
      • Programming
        • Can I pass a function as an argument to a jitted function?
        • Numba doesn’t seem to care when I modify a global variable
        • Can I debug a jitted function?
        • How can I create a Fortran-ordered array?
        • How can I increase integer width?
        • How can I tell if parallel=True worked?
      • Performance
        • Does Numba inline functions?
        • Does Numba vectorize array computations (SIMD)?
        • Why has my loop not vectorized?
        • Why are the typed containers slower when used from the interpreter?
        • Does Numba automatically parallelize code?
        • Can Numba speed up short-running functions?
        • There is a delay when JIT-compiling a complicated function, how can I improve it?
      • GPU Programming
        • How do I work around the CUDA initialized before forking error?
      • Integration with other utilities
        • Can I “freeze” an application which uses Numba?
        • I get errors when running a script twice under Spyder
        • Why does Numba complain about the current locale?
        • How do I get Numba development builds?
      • Miscellaneous
        • Where does the project name “Numba” come from?
        • How do I reference/cite/acknowledge Numba in other work?
        • How do I write a minimal working reproducer for a problem with Numba?
    • Examples
      • Mandelbrot
      • Moving average
      • Multi-threading
    • Talks and Tutorials
      • Talks on Numba
      • Talks on Applications of Numba
      • Tutorials
  • Reference Manual
    • Types and signatures
      • Rationale
      • Signatures
      • Basic types
        • Numbers
        • Arrays
        • Functions
        • Miscellaneous Types
      • Advanced types
        • Inference
        • NumPy scalars
        • Arrays
        • Optional types
        • Type annotations
    • Just-in-Time compilation
      • JIT functions
        • numba.jit()
      • Generated JIT functions
        • numba.generated_jit()
      • Dispatcher objects
        • Dispatcher
      • Vectorized functions (ufuncs and DUFuncs)
        • numba.vectorize()
        • numba.guvectorize()
        • numba.DUFunc
      • C callbacks
        • numba.cfunc()
        • CFunc
    • Ahead-of-Time compilation
      • CC
        • CC.name
        • CC.output_dir
        • CC.output_file
        • CC.target_cpu
        • CC.verbose
        • CC.export()
        • CC.compile()
        • CC.distutils_extension()
    • Utilities
      • Dealing with pointers
        • numba.carray()
        • numba.farray()
    • Environment variables
      • Jit flags
      • Debugging
      • Compilation options
      • Caching options
      • GPU support
      • Threading Control
    • Supported Python features
      • Language
        • Constructs
        • Functions
        • Generators
        • Exception handling
      • Built-in types
        • int, bool
        • float, complex
        • str
        • tuple
        • homogeneous tuples
        • heterogeneous tuples
        • list
        • set
        • Typed Dict
        • Heterogeneous Literal String Key Dictionary
        • None
        • bytes, bytearray, memoryview
      • Built-in functions
        • Hashing
      • Standard library modules
        • array
        • cmath
        • collections
        • ctypes
        • enum
        • math
        • operator
        • functools
        • random
        • heapq
      • Third-party modules
        • cffi
    • Supported NumPy features
      • Scalar types
        • Record subtyping
      • Array types
        • Array access
        • Structured array access
        • Attributes
        • Calculation
        • Other methods
      • Functions
        • Linear algebra
        • Reductions
        • Other functions
        • Literal arrays
      • Modules
        • random
        • stride_tricks
      • Standard ufuncs
        • Limitations
        • Math operations
        • Trigonometric functions
        • Bit-twiddling functions
        • Comparison functions
        • Floating functions
        • Datetime functions
    • Deviations from Python Semantics
      • Bounds Checking
      • Exceptions and Memory Allocation
      • Integer width
      • Boolean inversion
      • Global and closure variables
      • Zero initialization of variables
    • Floating-point pitfalls
      • Precision and accuracy
        • Math library implementations
        • Linear algebra
        • Mixed-types operations
      • Warnings and errors
    • Deprecation Notices
      • Suppressing Deprecation warnings
      • Deprecation of reflection for List and Set types
        • Reason for deprecation
        • Example(s) of the impact
        • Schedule
        • Recommendations
        • Expected Replacement
      • Deprecation of object mode fall-back behaviour when using @jit
        • Reason for deprecation
        • Example(s) of the impact
        • Schedule
        • Recommendations
      • Deprecation of eager compilation of CUDA device functions
        • Schedule
      • Deprecation and removal of numba.core.base.BaseContext.add_user_function()
        • Recommendations
        • Schedule
      • Deprecation and removal of CUDA Toolkits < 10.2 and devices with CC < 5.3
        • Recommendations
        • Schedule

For CUDA users

  • Numba for CUDA GPUs
    • Overview
      • Terminology
      • Programming model
      • Requirements
        • Supported GPUs
        • Software
      • Missing CUDA Features
    • Writing CUDA Kernels
      • Introduction
      • Kernel declaration
      • Kernel invocation
        • Choosing the block size
        • Multi-dimensional blocks and grids
      • Thread positioning
        • Absolute positions
        • Further Reading
    • Memory management
      • Data transfer
        • Device arrays
      • Pinned memory
      • Mapped memory
      • Managed memory
      • Streams
      • Shared memory and thread synchronization
      • Local memory
      • Constant memory
      • Deallocation Behavior
        • defer_cleanup()
    • Writing Device Functions
    • Supported Python features in CUDA Python
      • Language
        • Execution Model
        • Floating Point Error Model
        • Constructs
        • Recursion
      • Built-in types
      • Built-in functions
      • Standard library modules
        • cmath
        • math
        • operator
      • NumPy support
    • CUDA Fast Math
    • Supported Atomic Operations
      • Example
    • Cooperative Groups
      • Supported features
      • Using Grid Groups
      • Cooperative Launches
        • _Kernel.max_cooperative_grid_blocks()
      • Applications and Example
    • Random Number Generation
      • A simple example
      • An example of managing RNG state size and using a 3D grid
    • Device management
      • Device Selection
    • The Device List
      • numba.cuda.cudadrv.devices.gpus
    • Device UUIDs
    • Examples
      • Vector Addition
      • 1D Heat Equation
      • Shared Memory Reduction
      • Dividing Click Data into Sessions
      • JIT Function CPU-GPU Compatibility
      • Monte Carlo Integration
      • Matrix multiplication
    • Debugging CUDA Python with the the CUDA Simulator
      • Using the simulator
      • Supported features
    • GPU Reduction
      • The Reduce class
        • Reduce
    • CUDA Ufuncs and Generalized Ufuncs
      • Example: Basic Example
      • Example: Calling Device Functions
      • Generalized CUDA ufuncs
    • Sharing CUDA Memory
      • Sharing between process
        • Export device array to another process
        • Import IPC memory from another process
    • CUDA Array Interface (Version 3)
      • Python Interface Specification
        • Synchronization
        • Lifetime management
        • Lifetime management in Numba
        • Pointer Attributes
        • Differences with CUDA Array Interface (Version 0)
        • Differences with CUDA Array Interface (Version 1)
        • Differences with CUDA Array Interface (Version 2)
        • Interoperability
    • External Memory Management (EMM) Plugin interface
      • Overview of External Memory Management
        • Effects on Deallocation Strategies
        • Management of other objects
        • Asynchronous allocation and deallocation
      • Implementing an EMM Plugin
        • BaseCUDAMemoryManager
        • The Host-Only CUDA Memory Manager
        • The IPC Handle Mixin
      • Classes and structures of returned objects
        • Memory Pointers
        • Memory Info
        • IPC
      • Setting the EMM Plugin
        • Environment variable
        • Function
    • CUDA Bindings
      • Per-Thread Default Streams
      • Roadmap
    • Calling foreign functions from Python kernels
      • Device function ABI
      • Declaration in Python
        • declare_device()
      • Linking and Calling functions
      • C/C++ Support
      • Complete Example
    • On-disk Kernel Caching
      • Compute capability considerations
    • CUDA Frequently Asked Questions
      • nvprof reports “No kernels were profiled”
  • CUDA Python Reference
    • CUDA Host API
      • Device Management
        • Device detection and enquiry
        • Context management
        • Device management
      • Compilation
        • compile_ptx()
        • compile_ptx_for_current_device()
      • Measurement
        • Profiling
        • Events
      • Stream Management
        • Stream
        • stream()
        • default_stream()
        • legacy_default_stream()
        • per_thread_default_stream()
        • external_stream()
      • Runtime
        • Runtime
        • is_supported_version()
    • CUDA Kernel API
      • Kernel declaration
        • jit()
      • Dispatcher objects
        • CUDADispatcher
      • Intrinsic Attributes and Functions
        • Thread Indexing
        • Memory Management
        • Synchronization and Atomic Operations
        • Cooperative Groups
        • Memory Fences
        • Warp Intrinsics
        • Integer Intrinsics
        • Floating Point Intrinsics
        • 16-bit Floating Point Intrinsics
        • Control Flow Instructions
        • Timer Intrinsics
    • CUDA-Specific Types
      • Vector Types
    • Memory Management
      • to_device()
      • device_array()
      • device_array_like()
      • pinned_array()
      • pinned_array_like()
      • mapped_array()
      • mapped_array_like()
      • managed_array()
      • pinned()
      • mapped()
      • Device Objects
        • DeviceNDArray
        • DeviceRecord
        • MappedNDArray
    • Libdevice functions
      • Wrapped functions
        • abs()
        • acos()
        • acosf()
        • acosh()
        • acoshf()
        • asin()
        • asinf()
        • asinh()
        • asinhf()
        • atan()
        • atan2()
        • atan2f()
        • atanf()
        • atanh()
        • atanhf()
        • brev()
        • brevll()
        • byte_perm()
        • cbrt()
        • cbrtf()
        • ceil()
        • ceilf()
        • clz()
        • clzll()
        • copysign()
        • copysignf()
        • cos()
        • cosf()
        • cosh()
        • coshf()
        • cospi()
        • cospif()
        • dadd_rd()
        • dadd_rn()
        • dadd_ru()
        • dadd_rz()
        • ddiv_rd()
        • ddiv_rn()
        • ddiv_ru()
        • ddiv_rz()
        • dmul_rd()
        • dmul_rn()
        • dmul_ru()
        • dmul_rz()
        • double2float_rd()
        • double2float_rn()
        • double2float_ru()
        • double2float_rz()
        • double2hiint()
        • double2int_rd()
        • double2int_rn()
        • double2int_ru()
        • double2int_rz()
        • double2ll_rd()
        • double2ll_rn()
        • double2ll_ru()
        • double2ll_rz()
        • double2loint()
        • double2uint_rd()
        • double2uint_rn()
        • double2uint_ru()
        • double2uint_rz()
        • double2ull_rd()
        • double2ull_rn()
        • double2ull_ru()
        • double2ull_rz()
        • double_as_longlong()
        • drcp_rd()
        • drcp_rn()
        • drcp_ru()
        • drcp_rz()
        • dsqrt_rd()
        • dsqrt_rn()
        • dsqrt_ru()
        • dsqrt_rz()
        • erf()
        • erfc()
        • erfcf()
        • erfcinv()
        • erfcinvf()
        • erfcx()
        • erfcxf()
        • erff()
        • erfinv()
        • erfinvf()
        • exp()
        • exp10()
        • exp10f()
        • exp2()
        • exp2f()
        • expf()
        • expm1()
        • expm1f()
        • fabs()
        • fabsf()
        • fadd_rd()
        • fadd_rn()
        • fadd_ru()
        • fadd_rz()
        • fast_cosf()
        • fast_exp10f()
        • fast_expf()
        • fast_fdividef()
        • fast_log10f()
        • fast_log2f()
        • fast_logf()
        • fast_powf()
        • fast_sincosf()
        • fast_sinf()
        • fast_tanf()
        • fdim()
        • fdimf()
        • fdiv_rd()
        • fdiv_rn()
        • fdiv_ru()
        • fdiv_rz()
        • ffs()
        • ffsll()
        • finitef()
        • float2half_rn()
        • float2int_rd()
        • float2int_rn()
        • float2int_ru()
        • float2int_rz()
        • float2ll_rd()
        • float2ll_rn()
        • float2ll_ru()
        • float2ll_rz()
        • float2uint_rd()
        • float2uint_rn()
        • float2uint_ru()
        • float2uint_rz()
        • float2ull_rd()
        • float2ull_rn()
        • float2ull_ru()
        • float2ull_rz()
        • float_as_int()
        • floor()
        • floorf()
        • fma()
        • fma_rd()
        • fma_rn()
        • fma_ru()
        • fma_rz()
        • fmaf()
        • fmaf_rd()
        • fmaf_rn()
        • fmaf_ru()
        • fmaf_rz()
        • fmax()
        • fmaxf()
        • fmin()
        • fminf()
        • fmod()
        • fmodf()
        • fmul_rd()
        • fmul_rn()
        • fmul_ru()
        • fmul_rz()
        • frcp_rd()
        • frcp_rn()
        • frcp_ru()
        • frcp_rz()
        • frexp()
        • frexpf()
        • frsqrt_rn()
        • fsqrt_rd()
        • fsqrt_rn()
        • fsqrt_ru()
        • fsqrt_rz()
        • fsub_rd()
        • fsub_rn()
        • fsub_ru()
        • fsub_rz()
        • hadd()
        • half2float()
        • hiloint2double()
        • hypot()
        • hypotf()
        • ilogb()
        • ilogbf()
        • int2double_rn()
        • int2float_rd()
        • int2float_rn()
        • int2float_ru()
        • int2float_rz()
        • int_as_float()
        • isfinited()
        • isinfd()
        • isinff()
        • isnand()
        • isnanf()
        • j0()
        • j0f()
        • j1()
        • j1f()
        • jn()
        • jnf()
        • ldexp()
        • ldexpf()
        • lgamma()
        • lgammaf()
        • ll2double_rd()
        • ll2double_rn()
        • ll2double_ru()
        • ll2double_rz()
        • ll2float_rd()
        • ll2float_rn()
        • ll2float_ru()
        • ll2float_rz()
        • llabs()
        • llmax()
        • llmin()
        • llrint()
        • llrintf()
        • llround()
        • llroundf()
        • log()
        • log10()
        • log10f()
        • log1p()
        • log1pf()
        • log2()
        • log2f()
        • logb()
        • logbf()
        • logf()
        • longlong_as_double()
        • max()
        • min()
        • modf()
        • modff()
        • mul24()
        • mul64hi()
        • mulhi()
        • nearbyint()
        • nearbyintf()
        • nextafter()
        • nextafterf()
        • normcdf()
        • normcdff()
        • normcdfinv()
        • normcdfinvf()
        • popc()
        • popcll()
        • pow()
        • powf()
        • powi()
        • powif()
        • rcbrt()
        • rcbrtf()
        • remainder()
        • remainderf()
        • remquo()
        • remquof()
        • rhadd()
        • rint()
        • rintf()
        • round()
        • roundf()
        • rsqrt()
        • rsqrtf()
        • sad()
        • saturatef()
        • scalbn()
        • scalbnf()
        • signbitd()
        • signbitf()
        • sin()
        • sincos()
        • sincosf()
        • sincospi()
        • sincospif()
        • sinf()
        • sinh()
        • sinhf()
        • sinpi()
        • sinpif()
        • sqrt()
        • sqrtf()
        • tan()
        • tanf()
        • tanh()
        • tanhf()
        • tgamma()
        • tgammaf()
        • trunc()
        • truncf()
        • uhadd()
        • uint2double_rn()
        • uint2float_rd()
        • uint2float_rn()
        • uint2float_ru()
        • uint2float_rz()
        • ull2double_rd()
        • ull2double_rn()
        • ull2double_ru()
        • ull2double_rz()
        • ull2float_rd()
        • ull2float_rn()
        • ull2float_ru()
        • ull2float_rz()
        • ullmax()
        • ullmin()
        • umax()
        • umin()
        • umul24()
        • umul64hi()
        • umulhi()
        • urhadd()
        • usad()
        • y0()
        • y0f()
        • y1()
        • y1f()
        • yn()
        • ynf()

For advanced users & developers

  • Extending Numba
    • High-level extension API
      • Implementing functions
      • Implementing methods
        • overload_method()
      • Implementing classmethods
        • overload_classmethod()
      • Implementing attributes
      • Importing Cython Functions
      • Implementing intrinsics
      • Implementing mutable structures
        • Defining a StructRef
        • Defining a method on StructRef
        • numba.experimental.structref API Reference
      • Determining if a function is already wrapped by a jit family decorator
        • extending.is_jitted()
    • Low-level extension API
      • Typing
        • typeof_impl.register()
        • type_callable()
        • as_numba_type.register()
        • as_numba_type.register()
      • Lowering
        • Native operations
        • Constants
        • Boxing and unboxing
    • Example: an interval type
      • Extending the typing layer
        • Creating a new Numba type
        • Type inference for Python values
        • Type inference for Python annotations
        • Type inference for operations
      • Extending the lowering layer
        • Defining the data model for native intervals
        • Exposing data model attributes
        • Exposing a property
        • Implementing the constructor
        • Boxing and unboxing
      • Using it
      • Conclusion
    • A guide to using @overload
      • Concrete Example
      • Implementing @overload for NumPy functions
    • Registering Extensions with Entry Points
      • Adding Support for the “Init” Entry Point
      • Testing your Entry Point
  • Developer Manual
    • Contributing to Numba
      • Communication
        • Real-time Chat
        • Weekly Meetings
        • Bug tracker
      • Getting set up
        • Build environment
        • Building Numba
        • Running tests
        • Running coverage
      • Development rules
        • Code reviews
        • Coding conventions
        • Stability
        • Platform support
        • Continuous integration testing
        • Type annotation and runtime type checking
        • Things that help with pull requests
        • Why is my pull request/issue seemingly being ignored?
      • Documentation
        • Main documentation
        • Web site homepage
    • Numba Release Process
      • Primary Release Candidate Checklist
      • Subsequent Release Candidates, Final Releases and Patch Releases
    • A Map of the Numba Repository
      • Support Files
        • Build and Packaging
        • Continuous Integration
        • Documentation
      • Numba Source Code
        • Public API
        • Dispatching
        • Compiler Pipeline
        • Type Management
        • Compiled Extensions
        • Misc Support
        • Core Python Data Types
        • Math
        • ParallelAccelerator
        • Stencil
        • Debugging Support
        • Type Signatures (CPU)
        • Target Implementations (CPU)
        • Ufunc Compiler and Runtime
        • Unit Tests (CPU)
        • Command Line Utilities
        • CUDA GPU Target
    • Numba architecture
      • Introduction
      • Compiler architecture
      • Contexts
      • Compiler stages
        • Stage 1: Analyze bytecode
        • Stage 2: Generate the Numba IR
        • Stage 3: Rewrite untyped IR
        • Stage 4: Infer types
        • Stage 5a: Rewrite typed IR
        • Stage 5b: Perform Automatic Parallelization
        • Stage 6a: Generate nopython LLVM IR
        • Stage 6b: Generate object mode LLVM IR
        • Stage 7: Compile LLVM IR to machine code
    • Polymorphic dispatching
      • Requirements
        • Compile-time vs. run-time
      • Type resolution
        • Typecodes
        • Hard-coded fast paths
        • Fingerprint-based typecode cache
        • Summary
      • Specialization selection
        • Implicit conversion rules
        • Candidates and best match
        • Implementation
        • Summary
      • Miscellaneous
    • Notes on generators
      • Terminology
      • Function analysis
      • The generator structure
        • Layout
        • Allocation
      • Compiling to native code
        • The next() function
    • Notes on Numba Runtime
      • Memory Management
        • Cooperating with CPython
        • Compiler-side Cooperation
        • Optimizations
        • Important assumptions
        • Quirks of the old optimization pass
        • Debugging Leaks
        • Debugging Leaks in C
      • Recursion Support
      • Using the NRT from C code
      • Future Plan
    • Using the Numba Rewrite Pass for Fun and Optimization
      • Overview
      • Rewriting Passes
        • The Rewrite Base Class
        • Subclassing Rewrite
        • Overloading Rewrite.match()
        • Overloading Rewrite.apply()
      • The Rewrite Registry
      • Case study: Array Expressions
        • The RewriteArrayExprs.match() method
        • The RewriteArrayExprs.apply() method
        • The _lower_array_expr() function
      • Conclusions and Caveats
    • Live Variable Analysis
      • Notes on behavior of the live variable analysis
        • Variable deleted before definition
    • Listings
      • New style listings
        • Listings for builtins
        • Listings for math
        • Listings for cmath
        • Listings for numpy
      • Old style listings
        • Lowering Listing
    • Notes on stencils
      • The stencil decorator
      • Handling the three modes
        • Outside jit context
        • Jit without parallel=True
        • Jit with parallel=True
      • Creating the stencil function
      • Exceptions raised
    • Customizing the Compiler
      • Implementing a compiler pass
        • Compiler pass classes
      • Debugging compiler passes
        • Observing IR Changes
        • Pass execution times
    • Notes on Inlining
      • Example using numba.jit()
      • Example using numba.extending.overload()
      • Using a function to limit the inlining depth of a recursive function
    • Environment Object
      • The Implementation
        • Serialization
        • Usage
    • Notes on Hashing
      • The Implementation
        • Unicode hash cache differences
        • The accommodation of PYTHONHASHSEED
    • Notes on Caching
      • The Implementation
        • Requirements for Cacheability
        • Features Compatible with Caching
        • Caching Limitations
        • Cache Sharing
        • Cache Clearing
        • Related Environment Variables
    • Notes on Numba’s threading implementation
      • Thread masking
        • Programming model
        • The Implementation
        • Caveats
        • Use in Code Generation
        • Parallel Chunksize Details
    • Notes on Literal Types
      • Literal Type
        • Literal
        • literal()
        • unliteral()
        • maybe_literal()
      • Specifying for Literal Typing
        • literally()
        • Code Example
        • Internal Details
      • Inside Extensions
        • SentryLiteralArgs
        • BoundLiteralArgs
        • sentry_literal_args()
    • Notes on timing LLVM
      • Getting LLVM Pass Timings
        • Code Example
        • API for custom analysis
    • Notes on Debugging
      • Memcheck
    • Event API
      • Event
        • Event.data
        • Event.is_end
        • Event.is_failed
        • Event.is_start
        • Event.kind
        • Event.status
      • EventStatus
      • Listener
        • Listener.notify()
        • Listener.on_end()
        • Listener.on_start()
      • RecordingListener
        • RecordingListener.on_end()
        • RecordingListener.on_start()
      • TimingListener
        • TimingListener.done
        • TimingListener.duration
        • TimingListener.on_end()
        • TimingListener.on_start()
      • broadcast()
      • end_event()
      • install_listener()
      • install_recorder()
      • install_timer()
      • register()
      • start_event()
      • trigger_event()
      • unregister()
    • Notes on Target Extensions
      • Inheriting compiler flags from the caller
        • ConfigStack
        • Compiler flags
    • Numba Mission Statement
      • Introduction
      • Background
      • Project Goals
  • Numba Enhancement Proposals
    • Implemented proposals
      • NBEP 1: Changes in integer typing
        • Current semantics
        • Proposal: predictable width-conserving typing
        • Proposal impact
      • NBEP 7: CUDA External Memory Management Plugins
        • Background and goals
        • Requirements
        • Interface for Plugin developers
        • Example implementation - A RAPIDS Memory Manager (RMM) Plugin
        • Numba internal changes
        • Prototyping / experimental implementation
    • Other proposals
      • NBEP 2: Extension points
        • High-level API
        • Typing
        • Code generation
      • NBEP 3: JIT Classes
        • Introduction
        • Proposal: jit-classes
      • NBEP 4: Defining C callbacks
        • Basic usage
        • Passing array data
        • Error handling
        • Deferred topics
      • NBEP 5: Type Inference
        • Introduction
        • Numba Type Semantic
        • Type Inference
      • NBEP 6: Typing Recursion
        • Introduction
        • The Current State
        • The Solution
        • Limitations
  • Glossary
  • Release Notes
    • Version 0.56.4 (3 November, 2022)
    • Version 0.56.3 (13 October, 2022)
    • Version 0.56.2 (1 September, 2022)
    • Version 0.56.1 (1 September, 2022)
    • Version 0.56.0 (25 July, 2022)
    • Version 0.55.2 (25 May, 2022)
    • Version 0.55.1 (27 January, 2022)
    • Version 0.55.0 (13 January, 2022)
    • Version 0.54.1 (7 October, 2021)
    • Version 0.54.0 (19 August, 2021)
    • Version 0.53.1 (25 March, 2021)
    • Version 0.53.0 (11 March, 2021)
    • Version 0.52.0 (30 November, 2020)
    • Version 0.51.2 (September 2, 2020)
    • Version 0.51.1 (August 26, 2020)
    • Version 0.51.0 (August 12, 2020)
    • Version 0.50.1 (Jun 24, 2020)
    • Version 0.50.0 (Jun 10, 2020)
    • Version 0.49.1 (May 7, 2020)
    • Version 0.49.0 (Apr 16, 2020)
    • Version 0.48.0 (Jan 27, 2020)
    • Version 0.47.0 (Jan 2, 2020)
    • Version 0.46.0
    • Version 0.45.1
    • Version 0.45.0
    • Version 0.44.1
    • Version 0.44.0
    • Version 0.43.1
    • Version 0.43.0
    • Version 0.42.1
    • Version 0.42.0
    • Version 0.41.0
    • Version 0.40.1
    • Version 0.40.0
    • Version 0.39.0
    • Version 0.38.1
    • Version 0.38.0
    • Version 0.37.0
    • Version 0.36.2
    • Version 0.36.1
    • Version 0.35.0
    • Version 0.34.0
    • Version 0.33.0
    • Version 0.32.0
    • Version 0.31.0
    • Version 0.30.1
    • Version 0.30.0
    • Version 0.29.0
    • Version 0.28.1
    • Version 0.28.0
    • Version 0.27.0
    • Version 0.26.0
    • Version 0.25.0
    • Version 0.24.0
    • Version 0.23.1
    • Version 0.23.0
    • Version 0.22.1
    • Version 0.22.0
    • Version 0.21.0
    • Version 0.20.0
    • Version 0.19.2
    • Version 0.19.1
    • Version 0.19.0
    • Version 0.18.2
    • Version 0.18.1
    • Version 0.17.0
    • Version 0.16.0
    • Version 0.15.1
    • Version 0.15
    • Version 0.14
    • Version 0.13.4
    • Version 0.13.3
    • Version 0.13.2
    • Version 0.13.1
    • Version 0.13
    • Version 0.12.2
    • Version 0.12.1
    • Version 0.12
    • Version 0.11
    • Version 0.10
    • Version 0.9
    • Version 0.8
    • Version 0.7.2
    • Version 0.7.1
    • Version 0.7
    • Version 0.6.1
    • Version 0.6
    • Version 0.5
    • Version 0.4
    • Version 0.3.2
    • Version 0.3
    • Version 0.2
Numba
  • Search

© Copyright 2012-2023, Anaconda, Inc. and others.

Built with Sphinx using a theme provided by Read the Docs.