gonum / exp

Experimental packages

Gonum

Installation

The core packages of the Gonum suite are written in pure Go with some assembly. Installation is done using go get.

go get -u gonum.org/v1/gonum/...

Supported Go versions

Gonum supports and tests using the gc compiler on the two most recent Go releases on Linux (386, amd64 and arm64), macOS and Windows (both on amd64).

Note that floating point behavior may differ between compiler versions and between architectures due to differences in floating point operation implementations.

Release schedule

The Gonum modules are released on a six-month release schedule, aligned with the Go releases. i.e.: when Go-1.x is released, Gonum-v0.n.0 is released around the same time. Six months after, Go-1.x+1 is released, and Gonum-v0.n+1.0 as well.

The release schedule, based on the current Go release schedule is thus:

• Gonum-v0.n.0: February
• Gonum-v0.n+1.0: August

Build tags

The Gonum packages use a variety of build tags to set non-standard build conditions. Building Gonum applications will work without knowing how to use these tags, but they can be used during testing and to control the use of assembly and CGO code.

The current list of non-internal tags is as follows:

• safe — do not use assembly or unsafe
• bounds — use bounds checks even in internal calls
• noasm — do not use assembly implementations
• tomita — use Tomita, Tanaka, Takahashi pivot choice for maximimal clique calculation, otherwise use random pivot (only in topo package)

Issues

If you find any bugs, feel free to file an issue on the github issue tracker. Discussions on API changes, added features, code review, or similar requests are preferred on the gonum-dev Google Group.

https://groups.google.com/forum/#!forum/gonum-dev

License

Original code is licensed under the Gonum License found in the LICENSE file. Portions of the code are subject to the additional licenses found in THIRD_PARTY_LICENSES. All third party code is licensed either under a BSD or MIT license.

Code in graph/formats/dot is dual licensed Public Domain Dedication and Gonum License, and users are free to choose the license which suits their needs for this code.

The W3C test suites in graph/formats/rdf are distributed under both the W3C Test Suite License and the W3C 3-clause BSD License.

exp's Issues

linsolve: for sparse matrix

Hello,

Now, design in linsolve/iterative.go is:

func Iterative(a MulVecToer, b *mat.VecDense, ...

Matrix a have matrix interface:

type MulVecToer interface {
	// MulVecTo computes A*x or Aᵀ*x and stores the result into dst.
	MulVecTo(dst *mat.VecDense, trans bool, x mat.Vector)
}

For my sparse matrix in my rep cannot implement that interface MulVecToer.

Could you replace type of variable a into type func(trans bool, x mat.Vector).
So, example linsolve/iterative_example_test.go look like:

...


ATx := func(trans bool, x mat.Vector){
       a.MulVecTo(mat.NewVecDense(dim, nil), trans, x)
}
result, err := linsolve.Iterative(ATx, sys.B, &linsolve.CG{}, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

...

So, design in linsolve/iterative.go in my point of view:

func Iterative(a func(trans bool, x mat.Vector), b *mat.VecDense, ...

Feel free for ignore.

linsolve: test fails with undefined: mat.NewDiagonal

running go test in travis fails (locally too) with:

$> go test ./...
# gonum.org/v1/exp/linsolve [gonum.org/v1/exp/linsolve.test]
linsolve/linsolve_test.go:154:7: undefined: mat.NewDiagonal

rings: add replacement for Lens type

The design intention for the Lens type in the rings package was to allow users to selectively magnify regions of the plot. This has benefits in genomics plotting and also in highly differentially dense graph plots. The approach was to provide a shim arc that adjusted the circumferential coordinates of arcs places on top of it. This was not properly wired through all the types that would need to know about it.

I still think this is a useful addition to the package, but I think a better approach would be to add an interface type:

// Lens modifies an Arc to allow it to adjust the magnification of regions of itself.
type Lens interface {
    // Focus returns a change in position for a given angle.
    // The returned delta must not result in an angle outside
    // the receiver's arc.
    Focus(theta Angle) (delta Angle)
}

With this change arcs that are being plotted onto will be queried for satisfaction of Lens and have the angular coordinates adjusted by the returned delta.

exp: no check for vanity import

it seems gonum.org/v1/exp/... packages are lacking vanity import decoration.
e.g.:

• https://github.com/gonum/exp/blob/master/plotter/rings/rings.go#L10
• https://github.com/gonum/exp/blob/master/dframe/dframe.go#L13
• https://github.com/gonum/exp/blob/master/linsolve/doc.go#L18

Proposal for ODE package: multistep methods

Proposal: multistep methods

Dear maintainers,
I am a Matlab user, and I am familiar with the ode solvers in Matlab.
In order to make gonum's ode package more complete (and more useful for people who need to solve a wide variety of ODEs), I would like to implement some multistep methods. To start, I aim to implement these three families of methods:

• Adams-Bashfort,
• Adams-Moulton,
• Backward Difference Formula methods.

Of course, I'm going to keep the same structure of DormandPrince5 (i.e., implementing the Integrator interface).

Methods to implement

These are the coefficients for the methods that I wish to implement:

1. Adams-Bashfort (explicit) methods
   

2. Adams-Moulton (implicit) methods
   

3. Backward Difference Formula methods
   

Thanks for your time,
Matteo Nicoli