@KraZug that should work, maybe I can figure out a more accurate work-around that involves interpolation...I wonder, though, how one might be measuring cw vs ccw when the curve is flattened? It would be sweet if it takes into account the ordering of the points that go into constructing the line/curve. I will find out!

When I see a question that just so obviously shows no thought or effort I have to fight the urge to troll to the point that it's painful sometimes ;_;

Look at the following snippet

fc = Compile[{{m, _Real, 2}},
  Map[Max[1.0, #] &, m, {2}]
]

This compiles down, but the map is not run in parallel. Is there a way to make this Max behave like e.g. m+1 which is threaded automatically?

@halirutan In so far as that is possible, I would have expected the syntax to be

fc2 = Compile[x,
   Max[1.0, x],
   RuntimeAttributes -> {Listable},
   Parallelization -> True
   ];

I don't see any increase in speed from doing this, however.

@C.E. Hmm.. the thing is that something like 3.4*data + 1.2 is more than an order of magnitude faster. For a 512^3 sized array, I get about 3.2 seconds for fc2 and 0.2 seconds for the multiplication and addition.

I'd like to have the performance that Unitize has and for something trivial as Max[1.0, #] there doesn't seem to be a way.

@halirutan Have you tried using Clip? For example, Clip[mat, {1, max}] should be equivalent, and about 3 times faster than your compiled function.

@CarlWoll Embarrassing..

Let's say it played a role that I'm almost 22h awake now and acknowledge that I at least knew it had something to do with Unitize because that's how I found Clip the last time. It just didn't click this time although I saw it in the related section of the docs for Unitize.

Thanks a bunch.

@CarlWoll Huh, didn't know about that one. Glad to delete one more homebrewed function.