feat: add complex/float32/base/div

[iampratik13]

Resolves stdlib-js/metr-issue-tracker#1107

Description

What is the purpose of this pull request?

This pull request:

feat: add complex/float32/base/div

Related Issues

Does this pull request have any related issues?

This pull request has the following related issues:

stdlib-js/metr-issue-tracker#1107

Questions

Any questions for reviewers of this pull request?

No.

Other

Any other information relevant to this pull request? This may include screenshots, references, and/or implementation notes.

No.

Checklist

Please ensure the following tasks are completed before submitting this pull request.

• Read, understood, and followed the contributing guidelines.

AI Assistance

When authoring the changes proposed in this PR, did you use any kind of AI assistance?

• Yes
• No

If you answered "yes" above, how did you use AI assistance?

• Code generation (e.g., when writing an implementation or fixing a bug)
• Test/benchmark generation
• Documentation (including examples)
• Research and understanding

Disclosure

If you answered "yes" to using AI assistance, please provide a short disclosure indicating how you used AI assistance. This helps reviewers determine how much scrutiny to apply when reviewing your contribution. Example disclosures: "This PR was written primarily by Claude Code." or "I consulted ChatGPT to understand the codebase, but the proposed changes were fully authored manually by myself.".

Claude Code Generation

---

@stdlib-js/reviewers

[stdlib-bot]

Coverage Report

Package	Statements	Branches	Functions	Lines
complex/float32/base/div	$\\color{green}325/325$ $\\color{green}+0.00\\%$	$\\color{green}15/15$ $\\color{green}+0.00\\%$	$\\color{green}4/4$ $\\color{green}+0.00\\%$	$\\color{green}325/325$ $\\color{green}+0.00\\%$

The above coverage report was generated for the changes in this PR.

[iampratik13]

/stdlib update-copyright-years

[kgryte]

@iampratik13 A few comments:

1. Single-precision arithmetic implementations need to emulate single-precision arithmetic, as performed in C. See other float32 implementations.
2. Given how the tests were written, it looks like you used AI, which you did not disclose in the OP. Furthermore, you did not check that the generated assertions made sense, with some test cases always returning true regardless of the actual test result. This smells of having AI attempt to resolve failing test cases. The most surefire way to do so is to author the tests such that they always pass. This is disappointing. I suggest revisiting the tests in this PR and actually implementing them by hand. And for those tests which appear to diverge from Julia, well, I suggest digging in to figure out why they differ. Perhaps, even read Julia's source code (ref: https://github.com/JuliaLang/julia/blob/966d0af0fdffc727eb240e2e4c908fdd46697e57/base/complex.jl#L357). It is possible that their single-precision implementation differs from their double-precision implementation. You might also consider whether the algorithm from Scilab is appropriate for single-precision by actually reading the paper (ref: https://arxiv.org/pdf/1210.4539). It is possible that it is, but it may also require tweaks. You should understand what those are.

[iampratik13]

Thanks for the detailed feedback, and apologies for the issues you pointed out. You’re right that the single-precision implementation should properly emulate C-style float32 arithmetic, and I’ll revise it to match existing float32 patterns in the codebase.
I also acknowledge the problems with the tests and will rework them manually to ensure the assertions are meaningful. I’ll review Julia’s implementation and the referenced paper to better understand any single-precision–specific differences and update the PR accordingly.

[iampratik13]

/stdlib update-copyright-years

[kgryte]

Suggested change

- Julia. "complex.jl." Julia Programming Language. [<https://github.com/JuliaLang/julia/blob/master/base/complex.jl>][@julia:complex].

[anandkaranubc]

A bit ironic that I’m approving my own changes, but this looks good to me.

Spent a whopping 10 hours on this, haha. Thanks @iampratik13 for the initial template, and your dedicated work on this!

cc: @kgryte

[anandkaranubc]

Hopefully, this will unlock all the remaining packages that depend on it! 😄

[kgryte]

@anandkaranubc You were able to figure out the accuracy issues?!?!

[anandkaranubc]

@anandkaranubc You were able to figure out the accuracy issues?!?!

Yes Sir! Since inputs are float32, widening to float64 makes all intermediate products exact and the denominator cannot overflow or underflow, so no scaling is needed. Just the plain formula in double precision with one final rounding, matching Julia's Complex{Float32} division. Verified bit for bit against Julia on 6500 fixtures and 65 edge cases (subnormals, signed zeros, infinities, NaNs), for both JS and C, and across all optimization levels.

😃

Also tried to reference all of this in the code too, so it doesn't get lost anywhere in the future.....

[kgryte]

LGTM

[kgryte]

And yeah, while not ideal to rely on double-precision, I think it is fine for now given that we don't have much of an alternative.

[anandkaranubc]

WOOWOWOWO, this was quick! Thank you!