diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..91ff8c3 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,350 @@ +# What runs Renovate for this organisation is renovate.yml, and until now +# nothing was ever run against a change to it. Its only triggers are `schedule` +# and `workflow_dispatch`, so a Renovate pull request bumping +# renovatebot/github-action -- the action that runs Renovate -- arrived with +# zero checks. Across the fleet, 77 of the 116 repositories holding a runner +# are in that state. +# +# That is worse than an untested library, because the failure is silent: a +# runner that stops produces no pull requests, and a fleet with no updates due +# looks exactly the same. Nothing anywhere watches for it. +# +# So: this runs on pull_request, and every step below states what it proves. +# A step that cannot fail is not a check, it is an alibi -- which is why the +# validator is made to reject a known-bad config on every run (step 4). + +name: ci + +# No `branches:` filter on pull_request, deliberately. A filtered trigger +# reports "no checks" forever for any pull request not aimed at main, which is +# the same blind spot one level down. +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +concurrency: + group: ci-${{ github.ref }} + cancel-in-progress: true + +permissions: + contents: read + +jobs: + validate: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + + - uses: actions/setup-node@v7 + with: + node-version: '24' + + # 1. PROVES: every workflow file is a parseable GitHub Actions workflow + # with well-formed expressions and no unknown keys. + # DOES NOT PROVE: that any action it references exists or works. + - name: Workflows parse + run: | + curl -sSfL -o actionlint.tar.gz \ + https://github.com/rhysd/actionlint/releases/download/v1.7.7/actionlint_1.7.7_linux_amd64.tar.gz + tar xzf actionlint.tar.gz actionlint + ./actionlint .github/workflows/*.yml + + # 2. PROVES: every `uses: owner/repo@ref` in every workflow resolves to a + # ref that exists in that repository today. This is the step with + # teeth on the pull requests that actually arrive here, which bump + # renovatebot/github-action and nothing else. + # DOES NOT PROVE: that the new version behaves. See the note at the + # foot of this file about what the action actually pins. + # Uses `git ls-remote`, so it needs no token and has no API budget. + - name: Every pinned action ref exists + run: | + set -euo pipefail + rc=0 + # No pipe into `while`: that is a subshell, rc=1 set inside it is + # discarded, and the step passes whatever it found. A check that + # cannot fail is the thing this whole file exists to stop. + # Anchored to the start of a line, after optional indent and an + # optional list dash. Unanchored, this matched the example `uses:` + # written inside a comment in this very file and reported it missing. + refs=$(grep -hoE '^[[:space:]]*-?[[:space:]]*uses:[[:space:]]*[A-Za-z0-9._-]+/[A-Za-z0-9._-]+@[A-Za-z0-9._/-]+' \ + .github/workflows/*.yml \ + | sed -E 's/^[[:space:]]*-?[[:space:]]*uses:[[:space:]]*//' | sort -u) + [ -n "$refs" ] || { echo "no pinned action refs found -- grep is wrong"; exit 1; } + while read -r ref; do + repo="${ref%@*}"; rev="${ref##*@}" + if git ls-remote --refs "https://github.com/$repo" \ + "refs/tags/$rev" "refs/heads/$rev" | grep -q .; then + echo "ok $ref" + elif [ "${#rev}" -eq 40 ] && \ + git ls-remote "https://github.com/$repo" | grep -q "^$rev"; then + echo "ok(sha) $ref" + else + echo "MISSING $ref -- no such tag, branch or sha"; rc=1 + fi + done <<< "$refs" + exit $rc + + # 3. PROVES: the Renovate configuration this organisation runs on holds no + # unknown option, is well-formed, and -- for config.js -- evaluates + # STANDALONE. + # + # Standalone matters and is not pedantry. renovatebot/github-action + # mounts the configuration file BY ITSELF (src/renovate.ts, v46.2.5): + # + # --volume ${configurationFile.value}:/github-action/ + # + # so a `require('./sibling')` resolves in the checkout, passes a + # validator run there, and still kills every scheduled run with + # "FATAL: Error parsing config file" -- a message naming no path, + # reading like a syntax error in a file that has none. + # + # DOES NOT PROVE -- both measured against renovate@latest, not + # inferred from the documentation: + # + # - that a TOP-LEVEL `extends:` resolves. Renovate DOES resolve a + # preset nested inside a packageRules[] entry, over the network, + # and a bad one there fails correctly. A top-level one is not + # resolved at all: a config whose top-level extends is + # `github>no-such-org-xyz99/nope` validates and exits 0. Every + # config in this organisation extends at the top level. Step 5 + # exists for that case, and only that case. + # + # - `matchUpdateTypes`. Most types ARE checked: a string for + # `automerge` (boolean), for `prConcurrentLimit` (integer), or an + # object for `packageRules` (array) each fail correctly. But + # `"matchUpdateTypes": "minor"` where an array is required + # validates and exits 0, with or without --strict and --no-global. + # Nothing here catches that one. + - name: Renovate config validates, as the container sees it + run: | + set -euo pipefail + iso="$(mktemp -d)" + global=() repo=() + # `if` blocks, not `[ -f x ] && ...`: under `set -e` a false test is + # a failed statement and aborts the step. + if [ -f config.js ]; then cp config.js "$iso/"; global+=(config.js); fi + for f in default.json renovate.json; do + if [ -f "$f" ]; then cp "$f" "$iso/"; repo+=("$f"); fi + done + cd "$iso" + # config.js is self-hosted (global) config; default.json and + # renovate.json are repo config. Passing a filename makes the + # validator assume GLOBAL unless --no-global is given -- its own + # --help warns about this -- so the two kinds are validated + # separately, each in the mode Renovate will actually read it in. + if [ ${#global[@]} -gt 0 ]; then + npx --yes --package renovate@latest renovate-config-validator --strict "${global[@]}" + fi + if [ ${#repo[@]} -gt 0 ]; then + npx --yes --package renovate@latest renovate-config-validator --strict --no-global "${repo[@]}" + fi + if [ ${#global[@]} -eq 0 ] && [ ${#repo[@]} -eq 0 ]; then + echo "no Renovate config in this repository -- nothing validated"; exit 1 + fi + + # 4. PROVES: step 3 can still fail. A check whose subject silently stops + # being checked is worse than no check, because it turns an absence + # into assurance. If a future validator, or a future --strict, stops + # rejecting an unknown option, this fails here rather than going quiet. + - name: The validator still rejects a bad config + run: | + set -euo pipefail + bad="$(mktemp -d)" + printf '{"thisOptionDoesNotExist": true}\n' > "$bad/renovate.json" + cd "$bad" + if npx --yes --package renovate@latest renovate-config-validator \ + --strict --no-global renovate.json; then + echo "SELF-TEST FAILED: the validator accepted an unknown option." + echo "Step 3 above therefore proves nothing. Fix this before trusting it." + exit 1 + fi + echo "self-test ok: the validator rejects what it should" + + # 4b. PROVES: this preset survives the INHERITED path, which is a + # different validator from step 3 and stricter. + # + # config.js sets inheritConfig, so Renovate reads default.json + # through validateConfig('inherit', ...) -- and that runs WITHOUT + # the migration applied to a preset. A plain string `description` + # is legal in a preset, migrated to a list, and REJECTED when + # inherited: + # + # Configuration option `description` should be a list (Array) + # Configuration option `packageRules[0].description` should be a + # list (Array) + # + # Renovate then opens "Action Required: Fix Renovate Configuration" + # on EVERY repository in the organisation and stops producing + # updates there. On 2026-09-03 that landed on all 117 organisations + # at once, and step 3 above passed the whole time, because it + # validates default.json as REPO config -- the shape Renovate no + # longer reads it in. + # + # The failure is silent twice over: the Renovate workflow run still + # reports success, since a per-repository config error is an issue + # rather than a failed job. + # + # DOES NOT PROVE: that nothing else differs between the two + # validators. This checks the one rule that has actually bitten. + # If another surfaces, add it here rather than to a person's memory. + - name: The preset survives the inherited path + run: | + set -euo pipefail + [ -f default.json ] || { echo "no default.json -- nothing to check"; exit 0; } + python3 - default.json <<'CHECK' + import json, sys + bad = [] + d = json.load(open(sys.argv[1])) + if isinstance(d.get("description"), str): + bad.append("description") + for i, r in enumerate(d.get("packageRules") or []): + if isinstance(r.get("description"), str): + bad.append("packageRules[%d].description" % i) + if bad: + print("REJECTED on the inherited path:") + for b in bad: + print(" %s is a string; it must be a list (Array)" % b) + print("A string is fine in a preset and fatal when inherited.") + sys.exit(1) + print("ok: every description is a list") + CHECK + + # 4c. PROVES: step 4b can still fail, on a config shaped exactly like + # the one that caused the outage. + - name: The inherited-path check still rejects a string description + run: | + set -euo pipefail + bad="$(mktemp -d)" + printf '{"packageRules":[{"description":"a string","matchUpdateTypes":["minor"]}]}\n' \ + > "$bad/default.json" + if python3 - "$bad/default.json" <<'CHECK' + import json, sys + d = json.load(open(sys.argv[1])) + if isinstance(d.get("description"), str): + sys.exit(1) + for r in d.get("packageRules") or []: + if isinstance(r.get("description"), str): + sys.exit(1) + sys.exit(0) + CHECK + then + echo "SELF-TEST FAILED: a string description was accepted." + echo "Step 4b therefore proves nothing. Fix this before trusting it." + exit 1 + fi + echo "self-test ok: a string description is still rejected" + + # 5. PROVES: every preset named in a TOP-LEVEL `extends` exists and is + # parseable JSON -- the one case the validator provably skips + # (measured, step 3). Every repository in the fleet carries + # `"extends": ["github>ORG/.github"]` at the top level, so a renamed + # or emptied preset repository silently drops every repository that + # points at it back to Renovate's defaults, with every run still + # green. + # + # A preset naming THE REPOSITORY THIS IS RUNNING IN is resolved from + # the CHECKOUT, and that is not a convenience. This step used to fetch + # every preset from raw.githubusercontent.com//HEAD, which is + # the PUBLISHED copy -- so when the pull request under test IS the + # preset repository, it asked about a version of the file that the + # pull request has not created yet. On the first landing in a new + # organisation, `github>ORG/.github` therefore reported MISSING while + # `default.json` sat right there in the tree, added by the very commit + # being checked. go-gitsafe/.github#1 is that failure. The published + # copy is simply the wrong source for a repository the checkout + # already holds authoritatively. + # + # Do NOT "simplify" this back to one remote fetch. It is not two code + # paths for the sake of it: for THIS repository the tree is the truth + # and `main` is stale by exactly the change under review, and for every + # OTHER repository the tree knows nothing and the published copy is + # the only truth there is. + # + # The failure stays sharp. Absent from the tree AND absent from the + # remote is still MISSING, which is the renamed-preset case this step + # exists to catch. Only "present in one of them" passes. + # + # One trap the tree path has and the remote path did not. Every + # `/.github` holds BOTH the preset (`default.json`) and the stub + # that consumes it (`renovate.json`, `{"extends": ["github>ORG/.github"]}`). + # Renovate falls back from the first to the second, so a tree that has + # lost `default.json` would resolve the preset to the stub that names + # it -- a file extending itself -- and this step would call that `ok` + # while Renovate chokes on the recursion. So a candidate whose own + # top-level `extends` names THIS repository is skipped rather than + # accepted: it is the consumer, not the preset. + # + # DOES NOT PROVE: that the preset's contents are what anyone intended. + # Presets nested in packageRules are left to the validator, which + # already resolves those and does it better. + - name: Every `extends` preset resolves + run: | + set -euo pipefail + rc=0 + refs=$(grep -hoE '"github>[^"]+"' ./*.json 2>/dev/null | tr -d '"' | sort -u || true) + if [ -z "$refs" ]; then echo "no github> presets to resolve"; exit 0; fi + # Slugs are case-insensitive on GitHub; compare them that way. + self=$(printf '%s' "${GITHUB_REPOSITORY:-}" | tr '[:upper:]' '[:lower:]') + # The order Renovate itself looks for a preset file in. + candidates="default.json renovate.json .renovaterc.json .renovaterc .github/renovate.json" + while read -r p; do + slug="${p#github>}"; slug="${slug%%:*}" + found="" + if [ -n "$self" ] && \ + [ "$(printf '%s' "$slug" | tr '[:upper:]' '[:lower:]')" = "$self" ]; then + for f in $candidates; do + if [ -f "$f" ]; then + # The stub that consumes the preset is not the preset. + circular="import json,sys; d=json.load(open(sys.argv[1])); sys.exit(0 if any(isinstance(x,str) and x.split(':')[0].lower()=='github>'+sys.argv[2] for x in (d.get('extends') or [])) else 1)" + if python3 -c "$circular" "$f" "$self" 2>/dev/null; then + echo "skip ./$f extends $p itself -- it is the consumer, not the preset" + continue + fi + if python3 -c "import json,sys; json.load(open(sys.argv[1]))" "$f"; then + echo "ok(tree) $p -> ./$f -- this repository, as this pull request leaves it" + else + echo "BAD JSON $p -> ./$f -- this repository, as this pull request leaves it" + rc=1 + fi + found=1; break + fi + done + [ -n "$found" ] || \ + echo "note $p names this repository but the checkout has no preset file; asking the published copy" + fi + if [ -z "$found" ]; then + for f in $candidates; do + if curl -sSfL -o /tmp/preset.json \ + "https://raw.githubusercontent.com/$slug/HEAD/$f"; then + if python3 -c "import json;json.load(open('/tmp/preset.json'))"; then + echo "ok $p -> $slug/$f" + else + echo "BAD JSON $p -> $slug/$f"; rc=1 + fi + found=1; break + fi + done + fi + if [ -z "$found" ]; then + echo "MISSING $p -- not in this checkout and no preset file in $slug" + rc=1 + fi + done <<< "$refs" + exit $rc + +# One thing none of this can prove, worth writing down where it will be read. +# +# `renovatebot/github-action` does not pin the Renovate it runs. src/docker.ts +# (v46.2.5) hardcodes: +# +# image = 'ghcr.io/renovatebot/renovate' +# version = '44' +# +# so the container is ghcr.io/renovatebot/renovate:44 -- a FLOATING major tag. +# The engine therefore changes under this organisation on days when nothing in +# this repository changed, and Renovate never opens a pull request for it +# because there is no pin to bump. v46.2.4 and v46.2.5 both say '44': the +# action bump these pull requests carry moves the runner's wrapper, not its +# engine. Pinning that image by digest is a separate decision, not this file's. diff --git a/.github/workflows/renovate.yml b/.github/workflows/renovate.yml new file mode 100644 index 0000000..ca4dc32 --- /dev/null +++ b/.github/workflows/renovate.yml @@ -0,0 +1,30 @@ +name: Renovate + +on: + schedule: + - cron: '7 15 * * *' + workflow_dispatch: + inputs: + logLevel: + description: Renovate log level + default: info + +concurrency: + group: renovate + cancel-in-progress: false + +permissions: + contents: read + +jobs: + renovate: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - name: Run Renovate + uses: renovatebot/github-action@v46.3.7 + with: + configurationFile: config.js + token: ${{ secrets.RENOVATE_TOKEN }} + env: + LOG_LEVEL: ${{ inputs.logLevel || 'info' }} diff --git a/README.md b/README.md index 3ca9e00..f1e2297 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,17 @@ # .github -Organisation profile and shared Renovate preset for go-scikit + +Shared defaults for this organisation. + +`default.json` is the Renovate preset every repository here extends with +`{"extends": ["github>go-scikit/.github"]}`. `config.js` and +`.github/workflows/renovate.yml` run Renovate for this organisation only, with +the `RENOVATE_TOKEN` secret. + +Minor and patch Go dependency updates merge themselves once the tests pass. +**The Go toolchain does not.** `go1.27.0` miscompiles on loong64 +([golang/go#81000](https://github.com/golang/go/issues/81000), bisected on real +hardware to `3fdac6780b`), and a repository without a loong64 lane sees nothing +wrong with the bump. A library that breaks is one library; a toolchain that +breaks is every architecture at once. + +`profile/README.md` is the organisation's public profile. diff --git a/config.js b/config.js new file mode 100644 index 0000000..670d284 --- /dev/null +++ b/config.js @@ -0,0 +1,39 @@ +// Renovate for this organisation, and only this one. +// +// One organisation is a few repositories, so a run never comes near the five +// thousand API requests an hour a token has. A shared runner over hundreds of +// organisations does, and then it walks the list in the same order every time +// and the tail is never reached — silently, while the head keeps producing +// pull requests and the whole thing looks like it works. That is why this is +// here rather than in a fleet-wide runner. +// +// Each repository extends default.json beside this file, which is where the +// policy lives. +module.exports = { + platform: 'github', + // The account blocks pushes that expose a non-noreply email, and Renovate's + // default author is bot@renovateapp.com. Left alone, every branch push is + // rejected and the run still reports success. + gitAuthor: 'tannevaled ', + autodiscover: true, + autodiscoverFilter: ['go-scikit/**'], + onboarding: false, + requireConfig: 'optional', + dependencyDashboard: true, + repositoryCache: 'enabled', + // default.json beside this file is a PRESET, and a preset reaches a + // repository only through an `extends` that names it. Sitting in the + // organisation applies it to nothing: with onboarding:false and + // requireConfig:'optional', a repository carrying no config file runs on + // Renovate's factory defaults and says so only at debug level -- + // "No renovate config file found". Measured 2026-09-03: 77 of the 835 + // repositories across the 117 organisations that run Renovate were in that + // state, so the Go toolchain guard in default.json had never been in force + // on any of them. + inheritConfig: true, + inheritConfigRepoName: '{{parentOrg}}/.github', + inheritConfigFileName: 'default.json', + // Loud when absent. Left at its default of false, Renovate proceeds silently + // when the file is missing -- the same failure, one level up. + inheritConfigStrict: true, +}; diff --git a/default.json b/default.json new file mode 100644 index 0000000..414076f --- /dev/null +++ b/default.json @@ -0,0 +1,40 @@ +{ + "$schema": "https://docs.renovatebot.com/renovate-schema.json", + "extends": [ + "config:recommended", + ":semanticCommits" + ], + "postUpdateOptions": [ + "gomodTidy", + "gomodUpdateImportPaths" + ], + "packageRules": [ + { + "description": [ + "One pull request per repository for everything non-breaking, rather than one per dependency. Merging them singly means every merge rebases the others and restarts their checks: one run over an organisation of 34 repositories updated 109 branches and merged 2. Grouped, a repository needs one round of checks instead of dozens." + ], + "matchUpdateTypes": [ + "minor", + "patch", + "digest" + ], + "groupName": "dependencies", + "groupSlug": "deps", + "automerge": true + }, + { + "description": [ + "Never auto-merge the Go toolchain, and never let it ride in somebody else's group. A rule that says automerge:false for one dependency is defeated by grouping, because Renovate decides automerge per BRANCH: go 1.27.0 rode into seven repositories inside a branch called renovate/github-actions, whose other dependency was actions/setup-go. Ungrouped, it gets a branch of its own and this setting governs it. It matters because go1.27.0 miscompiles on loong64 (golang/go#81000, bisected on real hardware to 3fdac6780b): go-gfx/gfx fails that lane and stayed open only because the lane failed, which is the CI gate holding rather than this rule. A repository without such a lane sees nothing." + ], + "matchManagers": [ + "gomod", + "github-actions" + ], + "matchDepNames": [ + "go" + ], + "automerge": false, + "groupName": null + } + ] +} diff --git a/profile/README.md b/profile/README.md new file mode 100644 index 0000000..5a6a1fa --- /dev/null +++ b/profile/README.md @@ -0,0 +1,100 @@ +

go-scikit

+ +# go-scikit + +🌐 **[Website](https://go-scikit.github.io)** + +**The scientific stack for Go, in pure Go (CGO=0): N-dimensional arrays, FFTs, numerical methods, statistics, labelled tables, figures and notebooks.** + +go-scikit is the umbrella over seven organisations. Each is a library, or a +few, with its own site, documentation and release cycle; together they cover +what a Python notebook reaches for in NumPy, SciPy, pandas and matplotlib. No +cgo and no C libraries: one `go build` gives a static binary, and it +cross-compiles like any other Go program. Where a library is slower or less accurate than its +Python reference, its documentation says so. + +## The organisations + +| Organisation | What it is | Site | Docs | +|---|---|---|---| +| [**go-ndarray**](https://github.com/go-ndarray) | N-dimensional arrays in 13 dtypes with NumPy 2 promotion, broadcasting and strided views; `linalg` is `numpy.linalg`, `fft` is `numpy.fft`, `random` is `numpy.random` with NumPy's numbers for the same seed | [site](https://go-ndarray.github.io/) | [docs](https://go-ndarray.github.io/docs/) | +| [**go-fft**](https://github.com/go-fft) | the `numpy.fft` / `scipy.fft` equivalent: complex and real transforms of any length, N-D, DCT and DST, single precision, no FFTW | [site](https://go-fft.github.io/) | [docs](https://go-fft.github.io/docs/) | +| [**go-numerics**](https://github.com/go-numerics) | numerical methods: optimisation and root finding (`optimize`), quadrature and ODE solvers (`integrate`), special functions (`special`) | [site](https://go-numerics.github.io/) | [docs](https://go-numerics.github.io/docs/) | +| [**go-statistics**](https://github.com/go-statistics) | probability distributions with every method of SciPy's frozen distributions, descriptive statistics and statistical tests (`stats`) | [site](https://go-statistics.github.io/) | [docs](https://go-statistics.github.io/docs/) | +| [**go-dataframe**](https://github.com/go-dataframe) | labelled columnar tables: Series, DataFrame and Index, CSV, Arrow and Parquet, group-by, joins, reshaping, time series | [site](https://go-dataframe.github.io/) | [docs](https://go-dataframe.github.io/docs/) | +| [**go-plot**](https://github.com/go-plot) | matplotlib-class figures to SVG and PNG, with matplotlib's object model and defaults and real TeX in the labels | [site](https://go-plot.github.io/) | [docs](https://go-plot.github.io/docs/) | +| [**go-notebook**](https://github.com/go-notebook) | Go notebooks: a Markdown file whose `go` blocks are cells, compiled to a real program, ordered by what each cell uses, re-running only what changed | [site](https://go-notebook.github.io/) | [docs](https://go-notebook.github.io/docs/) | + +## How the pieces fit + +``` +go-notebook a notebook is a Markdown file; every library below is usable in a cell +───────────────────────────────────────────────────────────────────────────────────── +go-numerics go-statistics go-dataframe go-plot +optimize, distributions, labelled tables figures, SVG and PNG +integrate, statistics, +special tests +───────────────────────────────────────────────────────────────────────────────────── +go-ndarray arrays, numpy.linalg, numpy.random go-fft numpy.fft, scipy.fft +``` + +go-ndarray is the bottom: the libraries above take and return its arrays, and +draw random numbers from its generator. go-ndarray's `fft` package runs on +go-fft. go-statistics takes its special functions and optimisers from +go-numerics; go-dataframe's numeric columns are go-ndarray arrays, and its +`dfplot` package draws with go-plot. A go-notebook cell can use any of them, +and shows an array, a frame or a figure through its `Display` method. + +## What is measured + +Each claim below is from the library's own README or documentation, which +says how it was measured. + +- **Accuracy against mpmath.** go-statistics measures every distribution + function in ULPs against [mpmath](https://mpmath.org), with SciPy measured + on the same points: the error is at or below SciPy's in 1473 of 1479 + regions, and the six exceptions are under 4.5 ulp + ([accuracy.md](https://github.com/go-statistics/stats/blob/main/docs/accuracy.md)). + go-numerics' special functions: about 250 000 points in 419 regions over + 62 functions, at or below SciPy's error in 418 regions + ([accuracy.md](https://github.com/go-numerics/special/blob/main/docs/accuracy.md)). +- **NumPy's numbers for the same seed.** go-ndarray's `random` is + `numpy.random`: `SeedSequence`, PCG64, MT19937, Philox, SFC64 and 40 + samplers, bit-exact against NumPy 2.5.3 on x86-64, with the few ULP-level + exceptions listed ([random.md](https://github.com/go-ndarray/ndarray/blob/main/docs/random.md)). + On it, go-statistics' draws of 17 distributions, Dirichlet and multinomial + are bit-identical to SciPy's, and its means, variances, 13 quantile methods + and histograms are NumPy's bit for bit + ([rvs-table.md](https://github.com/go-statistics/stats/blob/main/docs/rvs-table.md)). +- **The reference algorithm's path.** go-numerics ports QUADPACK, MINPACK, + L-BFGS-B and SciPy's ODE solvers statement by statement: 116 of 124 fixture + integrals take SciPy's exact subdivision path and 110 of 120 `solve_ivp` + runs its exact steps ([integrate](https://github.com/go-numerics/integrate)), + and 36 of 38 `Minimize` runs SciPy's exact path + ([optimize](https://github.com/go-numerics/optimize)). +- **The Python reference's answers.** go-ndarray's `linalg` is checked against + NumPy 2.5.3 on 1,040 cases; go-dataframe against pandas 3.0 on 173 recorded + cases; go-plot's tick locations and labels on 408 axes of real figures are + matplotlib's, every location bit for bit + ([design.md](https://github.com/go-plot/plot/blob/main/docs/design.md)). +- **Speed, both ways.** At v0.27.0 go-fft is faster than FFTW on all 24 rows + on Neoverse-N1 and at or above numpy.fft and scipy.fft on all 24 rows on + every host measured ([BENCHMARKS.md](https://github.com/go-fft/fft/blob/main/BENCHMARKS.md)). + go-ndarray against NumPy 2.5.3 and OpenBLAS: faster on reductions and + the `*Into` forms of elementwise operations, slower on `MatMul` against 16-thread OpenBLAS + from 512² ([perf.md](https://github.com/go-ndarray/ndarray/blob/main/docs/perf.md)). + go-statistics against SciPy, rows where SciPy is faster included + ([perf.md](https://github.com/go-statistics/stats/blob/main/docs/perf.md)). + polars is faster than go-dataframe on most of the operations measured + ([perf.md](https://github.com/go-dataframe/dataframe/blob/main/docs/perf.md)). + +## Repositories here + +| Repo | What it is | +|------|------------| +| [**go-scikit.github.io**](https://github.com/go-scikit/go-scikit.github.io) | the portal (Hugo): the stack, one card per organisation, a first notebook | +| [**brand**](https://github.com/go-scikit/brand) | logo, icons and social images; the mark is the stack, written by a Go program | +| [**.github**](https://github.com/go-scikit/.github) | this profile and the shared Renovate preset | + +The libraries themselves live in their organisations above. Everything is +BSD-3-Clause. diff --git a/renovate.json b/renovate.json new file mode 100644 index 0000000..123150f --- /dev/null +++ b/renovate.json @@ -0,0 +1,4 @@ +{ + "$schema": "https://docs.renovatebot.com/renovate-schema.json", + "extends": ["github>go-scikit/.github"] +}