From 0962cf4f73b6bee09cbf4bb5410201bc86612f89 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Mon, 12 Oct 2026 13:10:28 +0200 Subject: [PATCH] Organisation profile and per-organisation Renovate runner profile/README.md presents the umbrella: the seven member organisations with their sites and documentation, how the stack fits together, and the measured claims with links to the documents that measure them. config.js, default.json, renovate.json and the two workflows are go-statistics/.github's, with the organisation's name changed: Renovate runs here for this organisation only, and ci.yml validates the config as the container reads it. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 350 +++++++++++++++++++++++++++++++++ .github/workflows/renovate.yml | 30 +++ README.md | 17 +- config.js | 39 ++++ default.json | 40 ++++ profile/README.md | 100 ++++++++++ renovate.json | 4 + 7 files changed, 579 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/ci.yml create mode 100644 .github/workflows/renovate.yml create mode 100644 config.js create mode 100644 default.json create mode 100644 profile/README.md create mode 100644 renovate.json 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"] +}