proxy.golang.org: gonum.org/v1/gonum

Gonum is a set of packages designed to make writing numerical and scientific algorithms productive, performant, and scalable.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 8 months ago)
• Last Synced: 2026-08-12T02:01:41.868Z (1 day ago)
• Versions: 19
• Dependent Packages: 7,386
• Dependent Repositories: 25,546
• Docker Downloads: 8,714,526,635
• Rankings:
  • Dependent packages count: 0.026%
  • Dependent repos count: 0.038%
  • Docker downloads count: 0.041%
  • Average: 0.427%
  • Stargazers count: 0.801%
  • Forks count: 1.232%

proxy.golang.org: gonum.org/v1/gonum/internal/math32

Package math32 provides float32 versions of standard library math package routines used by gonum/blas/native.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/internal/math32#section-documentation
• Licenses: BSD-3-Clause
• Latest release: (published 3 months ago)
• Last Synced: 2026-08-12T02:01:41.319Z (1 day ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Stargazers count: 0.852%
  • Forks count: 1.318%
  • Average: 2.998%
  • Dependent packages count: 4.751%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/blas

Package blas provides interfaces for the BLAS linear algebra standard. All methods must perform appropriate parameter checking and panic if provided parameters that do not conform to the requirements specified by the BLAS standard. Quick Reference Guide to the BLAS from http://www.netlib.org/lapack/lug/node145.html This version is modified to remove the "order" option. All matrix operations are on row-order matrices. Level 1 BLAS Level 2 BLAS Level 3 BLAS Meaning of prefixes Matrix types Options For real matrices, Trans and ConjTrans have the same meaning. For Hermitian matrices, trans = Trans is not allowed. For complex symmetric matrices, trans = ConjTrans is not allowed.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/blas#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:41.498Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Stargazers count: 0.852%
  • Forks count: 1.318%
  • Average: 2.998%
  • Dependent packages count: 4.751%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/internal/cmplx64

Package cmplx64 provides complex64 versions of standard library math/cmplx package routines used by gonum/blas.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/internal/cmplx64#section-documentation
• Licenses: BSD-3-Clause
• Latest release: (published 3 months ago)
• Last Synced: 2026-08-12T02:01:43.612Z (1 day ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Stargazers count: 0.852%
  • Forks count: 1.318%
  • Average: 2.998%
  • Dependent packages count: 4.751%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/floats

Package floats provides a set of helper routines for dealing with slices of float64. The functions avoid allocations to allow for use within tight loops without garbage collection overhead. The convention used is that when a slice is being modified in place, it has the name dst.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/floats#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:43.086Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Stargazers count: 0.852%
  • Forks count: 1.318%
  • Average: 2.998%
  • Dependent packages count: 4.751%
  • Dependent repos count: 5.07%

proxy.golang.org: github.com/gonum/gonum

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/github.com/gonum/gonum#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 8 months ago)
• Last Synced: 2026-08-12T02:01:40.752Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 6
• Rankings:
  • Stargazers count: 0.822%
  • Forks count: 1.297%
  • Dependent repos count: 2.128%
  • Average: 3.175%
  • Dependent packages count: 8.453%

proxy.golang.org: gonum.org/v1/gonum/lapack/gonum

Package gonum is a pure-go implementation of the LAPACK API. The LAPACK API defines a set of algorithms for advanced matrix operations. The function definitions and implementations follow that of the netlib reference implementation. See http://www.netlib.org/lapack/explore-html/ for more information, and http://www.netlib.org/lapack/explore-html/d4/de1/_l_i_c_e_n_s_e_source.html for more license information. Slice function arguments frequently represent vectors and matrices. The data layout is identical to that found in https://pkg.go.dev/gonum.org/v1/gonum/blas/gonum. Most LAPACK functions are built on top the routines defined in the BLAS API, and as such the computation time for many LAPACK functions is dominated by BLAS calls. Here, BLAS is accessed through the blas64 package (https://pkg.go.dev/gonum.org/v1/gonum/blas/blas64). In particular, this implies that an external BLAS library will be used if it is registered in blas64. The full LAPACK capability has not been implemented at present. The full API is very large, containing approximately 200 functions for double precision alone. Future additions will be focused on supporting the Gonum matrix package (https://pkg.go.dev/gonum.org/v1/gonum/mat), though pull requests with implementations and tests for LAPACK function are encouraged.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/lapack/gonum#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:46.589Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.748%
  • Average: 4.908%
  • Dependent repos count: 5.067%

proxy.golang.org: gonum.org/v1/gonum/lapack/lapack64

Package lapack64 provides a set of convenient wrapper functions for LAPACK calls, as specified in the netlib standard (www.netlib.org). The native Go routines are used by default, and the Use function can be used to set an alternative implementation. If the type of matrix (General, Symmetric, etc.) is known and fixed, it is used in the wrapper signature. In many cases, however, the type of the matrix changes during the call to the routine, for example the matrix is symmetric on entry and is triangular on exit. In these cases the correct types should be checked in the documentation. The full set of Lapack functions is very large, and it is not clear that a full implementation is desirable, let alone feasible. Please open up an issue if there is a specific function you need and/or are willing to implement.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/lapack/lapack64#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:45.741Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.748%
  • Average: 4.908%
  • Dependent repos count: 5.067%

proxy.golang.org: gonum.org/v1/gonum/stat

Package stat provides generalized statistical functions.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/stat#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:42.598Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.748%
  • Average: 4.908%
  • Dependent repos count: 5.067%

proxy.golang.org: gonum.org/v1/gonum/mat

Package mat provides implementations of float64 and complex128 matrix structures and linear algebra operations on them. This section provides a quick overview of the mat package. The following sections provide more in depth commentary. mat provides: In the documentation below, we use "matrix" as a short-hand for all of the FooDense types implemented in this package. We use "Matrix" to refer to the Matrix interface. A matrix may be constructed through the corresponding New function. If no backing array is provided the matrix will be initialized to all zeros. If a backing data slice is provided, the matrix will have those elements. All matrices are stored in row-major format and users should consider this when expressing matrix arithmetic to ensure optimal performance. Operations involving matrix data are implemented as functions when the values of the matrix remain unchanged and are implemented as methods when the operation modifies the receiver. Note that the input arguments to most functions and methods are interfaces rather than concrete types `func Trace(Matrix)` rather than `func Trace(*Dense)` allowing flexible use of internal and external Matrix types. When a matrix is the destination or receiver for a function or method, the operation will panic if the matrix is not the correct size. An exception to this is when the destination is empty (see below). An empty matrix is one that has zero size. Empty matrices are used to allow the destination of a matrix operation to assume the correct size automatically. This operation will re-use the backing data, if available, or will allocate new data if necessary. The IsEmpty method returns whether the given matrix is empty. The zero-value of a matrix is empty, and is useful for easily getting the result of matrix operations. The Reset method can be used to revert a matrix to an empty matrix. Reset should not be used when multiple different matrices share the same backing data slice. This can cause unexpected data modifications after being resized. An empty matrix can not be sliced even if it does have an adequately sized backing data slice, but can be expanded using its Grow method if it exists. The Matrix interface is the common link between the concrete types of real matrices. The Matrix interface is defined by three functions: Dims, which returns the dimensions of the Matrix, At, which returns the element in the specified location, and T for returning a Transpose (discussed later). All of the matrix types can perform these behaviors and so implement the interface. Methods and functions are designed to use this interface, so in particular the method constructs a *Dense from the result of a multiplication with any Matrix types, not just *Dense. Where more restrictive requirements must be met, there are also additional interfaces like Symmetric and Triangular. For example, in the Symmetric interface guarantees a symmetric result. The CMatrix interface plays the same role for complex matrices. The difference is that the CMatrix type has the H method instead T, for returning the conjugate transpose. (Conjugate) Transposes The T method is used for transposition on real matrices, and H is used for conjugate transposition on complex matrices. For example, c.Mul(a.T(), b) computes c = aᵀ * b. The mat types implement this method implicitly — see the Transpose and Conjugate types for more details. Note that some operations have a transpose as part of their definition, as in *SymDense.SymOuterK. Matrix factorizations, such as the LU decomposition, typically have their own specific data storage, and so are each implemented as a specific type. The factorization can be computed through a call to Factorize The elements of the factorization can be extracted through methods on the factorized type, for example *LU.UTo. The factorization types can also be used directly, as in *Cholesky.SolveTo. Some factorizations can be updated directly, without needing to update the original matrix and refactorize, for example with *LU.RankOne. BLAS and LAPACK are the standard APIs for linear algebra routines. Many operations in mat are implemented using calls to the wrapper functions in gonum/blas/blas64 and gonum/lapack/lapack64 and their complex equivalents. By default, blas64 and lapack64 call the native Go implementations of the routines. Alternatively, it is possible to use C-based implementations of the APIs through the respective cgo packages and the wrapper packages' "Use" functions. The Go implementation of LAPACK makes calls through blas64, so if a cgo BLAS implementation is registered, the lapack64 calls will be partially executed in Go and partially executed in C. The Matrix abstraction enables efficiency as well as interoperability. Go's type reflection capabilities are used to choose the most efficient routine given the specific concrete types. For example, in if a and b both implement RawMatrixer, that is, they can be represented as a blas64.General, blas64.Gemm (general matrix multiplication) is called, while instead if b is a RawSymmetricer blas64.Symm is used (general-symmetric multiplication), and if b is a *VecDense blas64.Gemv is used. There are many possible type combinations and special cases. No specific guarantees are made about the performance of any method, and in particular, note that an abstract matrix type may be copied into a concrete type of the corresponding value. If there are specific special cases that are needed, please submit a pull-request or file an issue. Matrix input arguments to package functions are never directly modified. If an operation changes Matrix data, the mutated matrix will be the receiver of a method, or will be the first, dst, argument to a method named with a To suffix. For convenience, a matrix may be used as both a receiver and as an input, e.g. though in many cases this will cause an allocation (see Element Aliasing). An exception to this rule is Copy, which does not allow a.Copy(a.T()). Most methods in mat modify receiver data. It is forbidden for the modified data region of the receiver to overlap the used data area of the input arguments. The exception to this rule is when the method receiver is equal to one of the input arguments, as in the a.Pow(a, 6) call above, or its implicit transpose. This prohibition is to help avoid subtle mistakes when the method needs to read from and write to the same data region. There are ways to make mistakes using the mat API, and mat functions will detect and complain about those. There are many ways to make mistakes by excursion from the mat API via interaction with raw matrix values. If you need to read the rest of this section to understand the behavior of your program, you are being clever. Don't be clever. If you must be clever, blas64 and lapack64 may be used to call the behavior directly. mat will use the following rules to detect overlap between the receiver and one of the inputs: If such an overlap is detected, the method will panic. The following cases will not panic: mat will not attempt to detect element overlap if the input does not implement a Raw method. Method behavior is undefined if there is undetected overlap. This example shows how simple user types can be constructed to implement basic vector functionality within the mat package.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/mat#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:39.783Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.748%
  • Average: 4.908%
  • Dependent repos count: 5.067%

proxy.golang.org: gonum.org/v1/gonum/internal/asm/c64

Package c64 provides complex64 vector primitives.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/internal/asm/c64#section-documentation
• Licenses: BSD-3-Clause
• Latest release: (published 3 months ago)
• Last Synced: 2026-08-12T02:01:40.961Z (1 day ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/lapack

Package lapack provides interfaces for the LAPACK linear algebra standard.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/lapack#section-documentation
• Licenses: BSD-3-Clause
• Latest release: (published 3 months ago)
• Last Synced: 2026-08-12T02:01:40.858Z (1 day ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/internal/asm/c128

Package c128 provides complex128 vector primitives.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/internal/asm/c128#section-documentation
• Licenses: BSD-3-Clause
• Latest release: (published 3 months ago)
• Last Synced: 2026-08-12T02:01:44.705Z (1 day ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/internal/asm/f32

Package f32 provides float32 vector primitives.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/internal/asm/f32#section-documentation
• Licenses: BSD-3-Clause
• Latest release: (published 3 months ago)
• Last Synced: 2026-08-12T02:01:43.637Z (1 day ago)
• Versions: 0
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/blas/gonum

Package gonum is a Go implementation of the BLAS API. This implementation panics when the input arguments are invalid as per the standard, for example if a vector increment is zero. Note that the treatment of NaN values is not specified, and differs among the BLAS implementations. gonum.org/v1/gonum/blas/blas64 provides helpful wrapper functions to the BLAS interface. The rest of this text describes the layout of the data for the input types. Note that in the function documentation, x[i] refers to the i^th element of the vector, which will be different from the i^th element of the slice if incX != 1. See http://www.netlib.org/lapack/explore-html/d4/de1/_l_i_c_e_n_s_e_source.html for more license information. Vector arguments are effectively strided slices. They have two input arguments, a number of elements, n, and an increment, incX. The increment specifies the distance between elements of the vector. The actual Go slice may be longer than necessary. The increment may be positive or negative, except in functions with only a single vector argument where the increment may only be positive. If the increment is negative, s[0] is the last element in the slice. Note that this is not the same as counting backward from the end of the slice, as len(s) may be longer than necessary. So, for example, if n = 5 and incX = 3, the elements of s are where ∗ elements are never accessed. If incX = -3, the same elements are accessed, just in reverse order (4, 3, 2, 1, 0). Dense matrices are specified by a number of rows, a number of columns, and a stride. The stride specifies the number of entries in the slice between the first element of successive rows. The stride must be at least as large as the number of columns but may be longer. Thus, dense[i*ld + j] refers to the {i, j}th element of the matrix. Symmetric and triangular matrices (non-packed) are stored identically to Dense, except that only elements in one triangle of the matrix are accessed. Packed symmetric and packed triangular matrices are laid out with the entries condensed such that all of the unreferenced elements are removed. So, the upper triangular matrix and the lower-triangular matrix will both be compacted as [1 2 3 4 5 6]. The (i, j) element of the original dense matrix can be found at element i*n - (i-1)*i/2 + j for upper triangular, and at element i * (i+1) /2 + j for lower triangular. Banded matrices are laid out in a compact format, constructed by removing the zeros in the rows and aligning the diagonals. For example, the matrix implicitly becomes (∗ entries are never accessed) which is given to the BLAS routine as [∗ 1 2 3 4 ...]. See http://www.crest.iu.edu/research/mtl/reference/html/banded.html for more information

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/blas/gonum#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:43.525Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/floats/scalar

Package scalar provides a set of helper routines for dealing with float64 values.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/floats/scalar#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:41.996Z (1 day ago)
• Versions: 15
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/blas/blas64

Package blas64 provides a simple interface to the float64 BLAS API.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/blas/blas64#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:44.394Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/internal/asm/f64

Package f64 provides float64 vector primitives.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/internal/asm/f64#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:44.366Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

proxy.golang.org: gonum.org/v1/gonum/blas/cblas128

Package cblas128 provides a simple interface to the complex128 BLAS API.

• Homepage: https://github.com/gonum/gonum
• Documentation: https://pkg.go.dev/gonum.org/v1/gonum/blas/cblas128#section-documentation
• Licenses: BSD-3-Clause
• Latest release: v0.17.0 (published 3 months ago)
• Last Synced: 2026-08-12T02:01:40.226Z (1 day ago)
• Versions: 19
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent packages count: 4.751%
  • Average: 4.91%
  • Dependent repos count: 5.07%

ubuntu-24.10: golang-gonum-v1-gonum

• Homepage: https://github.com/gonum/gonum
• Licenses: bsd-3-clause
• Latest release: 0.15.0-2 (published 6 months ago)
• Last Synced: 2026-03-08T17:40:22.977Z (5 months ago)
• Versions: 1
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent repos count: 0.0%
  • Dependent packages count: 0.0%
  • Average: 100%

ubuntu-23.04: golang-gonum-v1-gonum

• Homepage: https://github.com/gonum/gonum
• Licenses: bsd-3-clause
• Latest release: 0.12.0-1 (published 6 months ago)
• Last Synced: 2026-03-12T07:04:52.716Z (5 months ago)
• Versions: 1
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent repos count: 0.0%
  • Dependent packages count: 0.0%
  • Average: 100%

ubuntu-23.10: golang-gonum-v1-gonum

• Homepage: https://github.com/gonum/gonum
• Licenses: bsd-3-clause
• Latest release: 0.13.0-2 (published 6 months ago)
• Last Synced: 2026-03-13T17:20:52.127Z (5 months ago)
• Versions: 1
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent repos count: 0.0%
  • Dependent packages count: 0.0%
  • Average: 100%

debian-13: golang-gonum-v1-gonum

• Homepage: https://github.com/gonum/gonum
• Documentation: https://packages.debian.org/trixie/golang-gonum-v1-gonum
• Licenses: bsd-3-clause
• Latest release: 0.15.1-1 (published 6 months ago)
• Last Synced: 2026-03-13T21:21:57.625Z (5 months ago)
• Versions: 1
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent repos count: 0.0%
  • Dependent packages count: 0.0%
  • Average: 100%

ubuntu-22.04: golang-gonum-v1-gonum

• Homepage: https://github.com/gonum/gonum
• Licenses: bsd-3-clause
• Latest release: 0.9.0-1 (published 6 months ago)
• Last Synced: 2026-03-07T04:43:17.473Z (5 months ago)
• Versions: 1
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent repos count: 0.0%
  • Dependent packages count: 0.0%
  • Average: 100%

ubuntu-24.04: golang-gonum-v1-gonum

• Homepage: https://github.com/gonum/gonum
• Licenses: bsd-3-clause
• Latest release: 0.14.0-1 (published 6 months ago)
• Last Synced: 2026-07-30T17:09:32.438Z (14 days ago)
• Versions: 1
• Dependent Packages: 0
• Dependent Repositories: 0
• Rankings:
  • Dependent repos count: 0.0%
  • Dependent packages count: 0.0%
  • Average: 100%