The purpose of this package is to provide test problems for JuliaNLSolvers packages.

This package provides number datatypes which store their values in type parameters, making them runtime constants.

This package intends to provide a simple RNG with stable streams, suitable for tests in packages which need reproducible streams of random numbers across Julia versions. Indeed, the Julia RNGs provided by default are documented to have non-stable streams (which for example enables some performance improvements).

This package supports representing banded matrices by only the entries on the bands.

Static.jl defines a limited set of statically parameterized types and a common interface that is shared between them.

FilePathsBase.jl provides a type based approach to working with filesystem paths in Julia.

AxisAlgorithms is a collection of filtering and linear algebra algorithms for multidimensional arrays. For algorithms that would typically apply along the columns of a matrix, you can instead pick an arbitrary axis (dimension).

This package provides a Julia interface defining a collection of types (without instances) for implementing conventions about the scientific interpretation of data. This package makes a distinction between the machine type and the scientific type of a Julia object. A machine type refers to the Julia type being used to represent the object, for instance Float64. The scientific type refers to how the object should be interpreted, for instance Continuous or Multiclass3.

This package provides types similar to Julia's Rational type, which make some sacrifices but have better computational performance.

This package allows you to reduce the latency of the first execution of Julia code. It is applicable to both package developers and end users in their personal workflows.

A block array is a partition of an array into blocks or subarrays. This package has two purposes. Firstly, it defines an interface for an AbstractBlockArray block arrays that can be shared among types representing different types of block arrays. The advantage to this is that it provides a consistent API for block arrays. Secondly, it also implements two different type of block arrays that follow the AbstractBlockArray interface. The type BlockArray stores each block contiguously while the type PseudoBlockArray stores the full matrix contiguously. This means that BlockArray supports fast non copying extraction and insertion of blocks while PseudoBlockArray supports fast access to the full matrix to use in in for example a linear solver.

This package defines the Bijection data type. A Bijection data structure behaves similar to a Dict, however it prevents assigning the same value to two different keys.

This package provides tools to help you develop code. Juno is built on the Atom text editor. Juno consists of both Julia and Atom packages in order to add Julia-specific enhancements, such as syntax highlighting, a plot pane, integration with Julia's debugger, a console for running code, and much more.

Consider that the package is “maintenance-only mode” and only receives bug fixes. The Julia IDE effort is pointed to extension for VSCode.

This package make loading packages faster, maybe. It supports specifying glue code in packages which will load automatically when another package is loaded, so that explicit dependencies (and long load times) can be avoided.

This package provides a framework for implementing statically sized arrays in Julia, using the abstract type StaticArraySize,T,N <: AbstractArrayT,N. Subtypes of StaticArray will provide fast implementations of common array and linear algebra operations.

This package provides Julia implementation of C-style interface to CFITSIO functions with following features:

• Function names closely mirror the C interface (e.g., fits_open_file()).

• Functions operate on FITSFile, a thin wrapper for fitsfile C struct (FITSFile has concept of "current HDU", as in CFITSIO).

• Wrapper functions do check the return status from CFITSIO and throw an error with the appropriate message.

This package lazily represents matrices filled with a single entry, as well as identity matrices. This package exports the following types: Eye, Fill, Ones, Zeros, Trues and Falses.

This package provides the type DataValue that is used to represent missing data.

This is a Julia interface to libquadmath, providing a Float128 type corresponding to the IEEE754 binary128 floating point format.

This package provides another JSON package for Julia, with a focus on speed and slick struct mapping.

This package provides an implementation of shifted arrays for Julia.

This package provides a canonical set of default initial values and identity elements for Julia.

This package provides tools to express a design pattern for dealing with large/ nested structures, as in machine learning and optimisation. For large machine learning models it can be cumbersome or inefficient to work with parameters as one big, flat vector, and structs help in managing complexity; but it is also desirable to easily operate over all parameters at once, e.g. for changing precision or applying an optimiser update step.

This package is intended as a lightweight foundation for tensor operations across the Julia ecosystem. Currently it exports three operations: hadamard, tensor, and boxdot.