Which is better for testing for non finite floats IsNaN or IsInf?

I need to test for non finite floats and eliminate them. I was planing to use math.IsInf() to test the floats but I have seen some ppl using math.IsNaN() for this purpose. Is one of these better for this purpose than the other ? and if so why?

edit: This has been put on hold because it is unclear so here is more information that will hopefully clarify the question. I was doing exercise 3.1 from "The Go Programming Language" which references this program. The exercise it asks
> If the function f returns a non-finite float64 value, the SVG file will > contain invalid <polygon> elements (although many SVG renderers handle > this gracefully). Modify the program to skip invalid polygons.

I was planing to solve it by adding the following to the corner func

if math.IsInf(z, 0) {
    return math.NaN(), math.NaN()
}    

and changing the contents of the second for loop in main to

ax, ay := corner(i+1, j)
if math.IsNaN(ax) {
    continue
}
bx, by := corner(i, j)
if math.IsNaN(bx) {
    continue
}
cx, cy := corner(i, j+1)
if math.IsNaN(cx) {
    continue
}
dx, dy := corner(i+1, j+1)
if math.IsNaN(dx) {
    continue
}
fmt.Printf("<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\n",
           ax, ay, bx, by, cx, cy, dx, dy)

I wanted to check my work so I decided to look up any answers other ppl had posted online to this problem. No one else that I found had used math.IsInf() in there solutions but most had used math.IsNaN() . This made me wonder if I was missing some something and if math.IsNaN() was better for this purpose for some reason. So I looked through the Go Docs for both functions. I looked up NaN on wikipedia and the IEEE 754. I did general web searches for why everyone else was using math.IsNaN() even though it seemed less intuitive to me. Then I did searches on here and on stackoverflow for answers after all of that I didn't really have an answer so I decided to post a question.

If you only need to account for either infinities, then math.IsInf() should suffice. However, if you need to guard against both infinities and values that are not numbers, you should use both in conjunction.

For more reading on floats: https://en.wikipedia.org/wiki/IEEE_754

An example of math.IsNaN() not working for infinite values: https://play.golang.org/p/blHjr8i7p9

Mathematically speaking, it's weird that NaN is a thing in programming because invalid expressions should not compile (unfortunately they do however).

Use math.IsNaN() if your number won't fit on the real line (like sqrt(-1), for example) or if it's mathematically undefined (like 0/0).

Use math.IsInf() if your number might be really large (in either the positive or negative direction) such that you don't have enough bits to represent it, or if it actually should be infinity.