Please take a look.

So far I have only added the backing code. I want to add CFFT[IFB] and then I will dismantle some of the array.go support (remove 1-based indexing and the linear support types). It makes sense to add the API in this PR, so suggestions welcome here.

(putting it there, feel free to redirect to the best place)

we should clearly put on all the old gonum/xyz repositories' README.md that these repos are deprecated and that issues, PRs should be redirected at gonum/gonum.

I don't think we clearly communicated this.

The previous implementation of Global was a minefield for incorrectly implementing global optimization methods. It was very difficult to correctly implement methods (both of the provided methods were incorrect), and the resulting code is very ugly. This commit switches to use channels to communicate, allowing a more clear ordering of concurrent code. This also enables better shutdown of methods.

In addition to the main fix of Global, this refactors the two Global methods to use the updated interface, and makes some small improvements that were previously not possible. In addition, there are some small cleanups of Local to better match between the two calls.

If anyone has been curious about what is meant by 'Don't communicate by sharing memory, share memory by communicating' this is it, and why.

@btracey @vladimir-ch @Armadilloa16 @ReubenBuck Please take a look.

This is commit one of ~~two~~ three. The ~~second~~ final commit will add element-wise weights, after the API is otherwise settled.

Possible considerations are adding a reset method to allow data/locality reuse.

What

floats/floats.go has a function

// Same returns true if the input slices have the same length and all elements
// have the same value with NaN treated as the same.
func Same(s, t []float64) bool {
...}

I would like to add there a function SameScalars which does the same for scalar inputs:

// SameScalars returns true if the inputs have the same value with NaN treated as the same.
func SameScalars(a, b float64) bool {
	return a == b || (math.IsNaN(a) && math.IsNaN(b))
}

Rationale

Such a function will be useful for unit testing functions which are expected to return NaNs for some inputs.

Updated proposal

Rename Same to AllSame (breaks code) and call the new function Same.

I seem to be getting an occasional test failure in TestFormat (and travis-ci does as well):

--- FAIL: TestFormat (0.00 seconds) unit_test.go:44: Format "%#v": got: "&unit.Unit{dimensions:unit.Dimensions{6:-1, 4:2}, formatted:"", value:6.62606957e-34}" expected: "&unit.Unit{dimensions:unit.Dimensions{4:2, 6:-1}, formatted:"", value:6.62606957e-34}" FAIL

go test -race doesn't find anything wrong.

I came up with what I think is an improvement to the ROC function, in which the cutoffs are defined explicitly instead of the number of cutoffs n. This allows for unequally-spaced cutoffs, allows for all cutoffs to be used more naturally, and simplifies the code itself.

Is this a good idea -- should I put a PR in for it, @sbinet @kortschak ?

Also, I was thinking maybe ROC should output an error as well, instead of all the panic statements? Or is it appropriate that it panic?

What I did is here, in case you wanted to look at the specifics of what I am suggesting: https://github.com/Armadilloa16/stat/tree/roc

While discussing a PR (https://github.com/gonum/floats/pull/61) on the floats package before the merger, it was suggested that an AreUnique function would be useful.

Disclaimer: Only tested with square matrices since that's all I seem to be able to generate with constructQK helper.

ARE issue: https://github.com/gonum/gonum/issues/1651

interp: This change modifies Gonum by adding a new interp/ package with interpolation algorithms.

I implemented three basic 1D interpolators so far:

• constant
• piecewise linear
• piecewise constant

Submitting a PR now to start the review process and adjust the code design & style to the project requirements, before I go down some rabbit hole ;-)

Cheers, Roman

This is a proposal for an approach to optimising sparse or sparsish matrix accesses raised in https://github.com/gonum/gonum/pull/124#discussion_r126201816

~~Only https://github.com/gonum/gonum/commit/2eb65a280581fdb47fa2714f84b793f652ccbb58 is relevant to this PR and I'll revise the history of the PR when #95 is merged.~~

Depends #95.

Previously the code was not removing nodes on the root of the search path, resulting in searches that could re-enter previously searched nodes. In addition to this, the logic for making edges was incorrectly making both directions for digraphs and only one direction for undirected graphs.

Finally, the range of nodes to include in the spur-node set was off-by-one. This is now clarified by including the comment from the wiki article since the pseudo-code is less clear than the English due to choice of range indexing convention.

Please take a look.

Fixes #1778

What are you trying to do?

When running renovate bot on my project, it fails to resolve the gonum dependency:

Does anyone have any suggestions, why this is the case? I do not have this problem for any other dependency.

What are you trying to do?

I'm trying to get median value when I request even size of dataset to stat.Quantile

What did you do?

func main() {
	xs := []float64{2, 3, 5, 9}
	median := stat.Quantile(0.5, stat.Empirical, xs, nil)

	fmt.Println(median)
}

https://go.dev/play/p/8b6vDMunna8

What did you expect to happen?

I expect return value 4

What actually happened?

its returns 3

What version of Go and Gonum are you using?

1.19

Does this issue reproduce with the current master?

Yes

What are you trying to do?

Create simplex noise in 2D.

What did you try?

Created my own package here: https://github.com/soypat/decaffeinator/blob/main/tagalong/pkg-noise/simplex.go

How does Gonum not allow you to achieve your goal?

I was not able to find noise generation in gonum.

Are you able to help contribute the feature?

Yes, see above link.

What are you trying to do?

The current implementation of the StudentsT distribution doesn't allow you to specify a non-centrality parameter ($\delta$). This would be useful because the noncentral-t distribution is useful for power analyses and in Bayesian inference (my personal usecase)

Are you able to help contribute the feature?

See #1819: I'm currently using translations I've made of R's nmath C library, and these translations could be used as the basis for this.