gonum / exp Goto Github PK

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

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.

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

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.

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