Add fuzzy equals comparisons #3895

lindsayad · 2024-07-01T20:01:33Z

Split off from #3883

Add unit tests

moosebuild · 2024-07-01T23:39:30Z

Job Coverage on 6af1064 wanted to post the following:

Coverage

	b76c44	#3895 6af106
	Total	Total	+/-	New
Rate	62.84%	62.85%	+0.02%	89.36%
Hits	69469	69511	+42	42
Misses	41082	41080	-2	5

Diff coverage report

Full coverage report

Warnings

New new line coverage rate 89.36% is less than the suggested 90.0%

This comment will be updated on new commits.

jwpeterson · 2024-07-02T13:33:38Z

include/numerics/numeric_vector.h

+   * A given element will be deemed fuzzy equal if either a relative or absolute tolerance fuzzy
+   * equal comparison returns true
+   */
+  bool fuzzy_equal(const NumericVector<T> & v,


We have TypeVector<T>::relative_fuzzy_equals and TypeVector<T>::absolute_fuzzy_equals, so there is some precedent already for the "plural" form of "equal". So I would prefer to just maintain that unless you intend to replace the those existing "equals" functions as well?

I'd prefer to maintain that. "If you don't know whether you want absolute or relative tolerance, you don't know what you're doing" is a tautology on one level and a critically important statement on another. My "eh, it's all fuzzy equality" attitude in the libMesh shape-function-caching code long ago turned into a disaster when it eventually interacted with the MOOSE displaced-mesh code.

I took @jwpeterson's comment to be more aimed at the plural naming vs. the separation of relative and absolute. I've addressed the former. For the latter, I added distinct tolerances for relative and absolute to the APIs in this PR. I think this is better than having separate APIs. i don't care to loop over the vector or matrix twice when I can do it once. We don't run SNES twice to see whether we meet the relative convergence criteria or absolute convergence criteria

Ah, looks like I misinterpreted; thanks for clarifying.

I read "plural" as "there's two of them", and the comment on the main page cuts off the function arguments below it. This looks good to me.

Also introduce a `scale` API for `SparseMatrix`

moosebuild · 2024-07-02T17:16:29Z

Job Distributed make check sweep (even) on 52a5ebe : invalidated by @lindsayad

moosebuild · 2024-07-02T17:16:37Z

Job Test MOOSE min clang on 52a5ebe : invalidated by @lindsayad

roystgnr · 2024-07-10T16:34:30Z

include/utils/fuzzy_equals.h

+          typename std::enable_if<ScalarTraits<T>::value && ScalarTraits<T2>::value &&
+                                      ScalarTraits<T3>::value,
+                                  int>::type = 0>
+bool absolute_fuzzy_equals(const T & var1, const T2 & var2, const T3 & tol = TOLERANCE * TOLERANCE);


tol should always conceptually be a positive real, right? What's the use case for const T3 & vs just Real?

roystgnr · 2024-07-10T16:35:14Z

include/utils/fuzzy_equals.h

+ * within an absolute tolerance
+ * @param var1 The first complex variable to be checked
+ * @param var2 The second complex variable to be checked
+ * @param tol The real tolerance to be used for comparing both real and imgainary parts


Suggested change

* @param tol The real tolerance to be used for comparing both real and imgainary parts

* @param tol The real tolerance to be used for comparing both real and imaginary parts

I feel like I just successfully found the "No Brown M&Ms" clause.

I need a confused emoji

the poor spelling is fixed though 😄

roystgnr · 2024-07-10T16:39:42Z

include/utils/fuzzy_equals.h

+      for (const auto i : make_range(libmesh_dim))
+        if (!relative_fuzzy_equals(var1(i), var2(i), tol))
+          return false;
+


Won't this conclude that the vectors [1e9, 1] and [1e9, 1+1e-5] aren't relatively equal? That doesn't seem like the behavior we want.

The simplest comparable thing to do here is to get the l∞ norm in one pass, then use that as the scale for each difference comparison on a second pass. We could avoid a 2-pass solution by keeping track of l∞ of both the values and the differences in a single pass and then comparing at the end. That doesn't let us take advantage of early-return cases, but I don't think I see a way around that.

Does the norm we use really matter? I think I'm going to do a bit of consolidation. It looks like we're using the L1 norm in TypeVector

lindsayad · 2024-07-11T18:31:27Z

I'm thinking that I might drop the fuzzy_equals routines for the global data structures

roystgnr · 2024-07-11T20:34:03Z

Those are the trickiest, I admit. That's exactly the reason we want library routines for them IMHO, but if you want to get the obviously-acceptable parts merged right away then I'm fine with postponing anything that will take longer.

Developers should overload `libMesh::l1_norm` and `libMesh::l1_norm_diff` for their numeric types and then they automatically get correct application of `libMesh::*fuzzy_equals`

lindsayad · 2024-07-16T02:41:18Z

Ok I've attempted a fairly generic, yet I believe simple, implementation that supports the more complicated global data structures. Let's see what you think

moosebuild · 2024-07-17T17:01:20Z

Job Test mac on 6af1064 : invalidated by @lindsayad

lindsayad · 2024-07-18T01:07:41Z

Failures are unrelated. I think this should be ready for review

roystgnr

Where/how do we end up instantiating TypeVector<bool>?

lindsayad · 2024-07-23T01:24:13Z

MOOSE solid mechanics module does it 🤷‍♂️

refs change `std::norm` overload in libMesh/libmesh#3895

lindsayad added 11 commits July 1, 2024 12:43

Add fuzzy_equal

cc4d20d

Write fuzzy_equal for NumericVector/SparseMatrix

b70cb76

Update Makefile.am files.

440f10b

max_dim -> max_mesh_dim

e86c9bb

Fix fuzzy equal names

8be04be

Add fuzzy_equal complex overloads

b748907

Add tol parameter to global structure fuzzy_equal's

35cddda

Run bootstrap

733cfa2

max_mesh_dim -> libmesh_dim

949dc40

Clearly delineate between rel and abs tol in vec/mat comparisons

3e5bba4

Don't use petscarraycmp because of really old PETSc

5005750

jwpeterson reviewed Jul 2, 2024

View reviewed changes

lindsayad added 2 commits July 2, 2024 09:33

fuzzy_equal -> fuzzy_equals

89362cc

Unit test

52a5ebe

Also introduce a `scale` API for `SparseMatrix`

lindsayad marked this pull request as ready for review July 2, 2024 16:37

roystgnr requested changes Jul 10, 2024

View reviewed changes

lindsayad added 4 commits July 15, 2024 11:02

Just use Real for tolerancing

73667ce

Refactor TypeVector::*fuzzy_equals

65d7c4b

Simplify logic in fuzzy_equals.h

97f633c

Developers should overload `libMesh::l1_norm` and `libMesh::l1_norm_diff` for their numeric types and then they automatically get correct application of `libMesh::*fuzzy_equals`

Change for global data structures

5cf023e

lindsayad force-pushed the fuzzy-equal branch from 388f289 to 5cf023e Compare July 16, 2024 02:28

lindsayad added 2 commits July 15, 2024 19:37

Remove uninformative trailing return types

02b0e97

Remove whitespace diffs

8835d12

lindsayad force-pushed the fuzzy-equal branch from c07cd6c to 8835d12 Compare July 16, 2024 02:39

lindsayad added 2 commits July 15, 2024 20:25

Specialize for TypeVector<bool>::l1_norm

7267198

Remove no longer necessary std::abs TypeVector overloads

c825455

lindsayad requested a review from roystgnr July 16, 2024 13:23

Remove unnecessary l1_norm overload for std::complex

6af1064

lindsayad mentioned this pull request Jul 19, 2024

Bounding box testing for $Entities in GmshIO #3903

Merged

roystgnr mentioned this pull request Jul 22, 2024

Libmesh submodule update idaholab/moose#28014

Merged

roystgnr approved these changes Jul 22, 2024

View reviewed changes

lindsayad merged commit 3503133 into libMesh:devel Jul 23, 2024
18 of 20 checks passed

lindsayad deleted the fuzzy-equal branch July 23, 2024 01:24

lindsayad added a commit to arfc/moltres that referenced this pull request Sep 18, 2024

Don't use std::norm for Euclidean norm

f424a00

refs change `std::norm` overload in libMesh/libmesh#3895

lindsayad mentioned this pull request Sep 18, 2024

Don't use std::norm for Euclidean norm arfc/moltres#284

Merged

	* @param tol The real tolerance to be used for comparing both real and imgainary parts
	* @param tol The real tolerance to be used for comparing both real and imaginary parts

Add fuzzy equals comparisons #3895

Add fuzzy equals comparisons #3895

Uh oh!

Conversation

lindsayad commented Jul 1, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

moosebuild commented Jul 1, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Coverage

Warnings

Uh oh!

jwpeterson Jul 2, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

lindsayad Jul 10, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

moosebuild commented Jul 2, 2024

Uh oh!

moosebuild commented Jul 2, 2024

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

lindsayad commented Jul 11, 2024

Uh oh!

roystgnr commented Jul 11, 2024

Uh oh!

lindsayad commented Jul 16, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

moosebuild commented Jul 17, 2024

Uh oh!

lindsayad commented Jul 18, 2024

Uh oh!

roystgnr left a comment

Choose a reason for hiding this comment

Uh oh!

lindsayad commented Jul 23, 2024

Uh oh!

Uh oh!

Uh oh!

lindsayad commented Jul 1, 2024 •

edited

Loading

moosebuild commented Jul 1, 2024 •

edited

Loading

jwpeterson Jul 2, 2024 •

edited

Loading

lindsayad Jul 10, 2024 •

edited

Loading

lindsayad commented Jul 16, 2024 •

edited

Loading