Return to Question

Mr.Wizard posed this question when discussing another problem.

Mr.Wizard posed this question when discussing another problem.

But I think these cases usually won't occur, so I still want to know: are there any methods avaliable to tell Mathematica, "I know testing result of elements will be the same in each trial, SKIP the repeated testing!"?

###Some Notes

I do NOT need a way to store the result of the pattern test, I'm trying to reduce the testing repetitions.

The latter one will speed up the simple pattern matching process in long lists considerably; the first one won't, as the pattern test completes in a flash, but there're are simply too many flashes, thus the overall speed is low.

Actually, the sample match I used as an example, the four tests complete in a flash, so memoizing will not speed things up. But if we can avoid the testing of the latter three 1, the whole process will be 4 times faster!

This is not simply a matter handing the somewhat unusual case of a stateful test function (e.g. if the test function were (EvenQ[# + i++] &)) as it is baked into immutable patterns as well:

But I think these cases usually won't occur, so I still want to know: are there any methods available to tell Mathematica, "I know testing result of elements will be the same in each trial, SKIP the repeated testing!"?

###Some Notes

• I do NOT need a way to store the result of the pattern test, I'm trying to reduce the testing repetitions.

• The latter one will speed up the simple pattern matching process in long lists considerably; the first one won't, as the pattern test completes in a flash, but there're are simply too many flashes, thus the overall speed is low.

• Actually, the sample match I used as an example, the four tests complete in a flash, so memoizing will not speed things up. But if we can avoid the testing of the latter three 1, the whole process will be 4 times faster!

This is not simply a matter handing the somewhat unusual case of a stateful test function (like the one with flag) as it is baked into expressly stateless patterns as well:

Actually, the sample match I used as an example, the four tests complete in a flash, so memoizing will not speed things up. But if we can aviod the testing of the latter three 1, the whole process will be 4 times faster!

Actually, the sample match I used as an example, the four tests complete in a flash, so memoizing will not speed things up. But if we can avoid the testing of the latter three 1, the whole process will be 4 times faster!

Additional and related examples

Here is an additional example that may help illustrate the inefficiency of reapplying the same test to the same element.

Replace[
  {1.1, 2.2, 3, 4, 5},
  {a___, x__?((Print[##]; IntegerQ[#]) &), y__} :>
    {{a}, {x}, {y}}
]

1.1

1.1

1.1

1.1

2.2

2.2

2.2

3

{{1.1, 2.2}, {3}, {4, 5}}

This causes an algorithmic explosion in the time taken to process this pattern. In most applications it would be better if each element were only tested once. Observe that a test of a list of 200 elements performs almost twenty thousand tests:

i = 0;
MatchQ[N@Range[200], {a___, x__?((i++; IntegerQ[#]) &), y__}]
i

False

19900

This is not simply a matter handing the somewhat unusual case of a stateful test function (e.g. if the test function were (EvenQ[# + i++] &)) as it is baked into immutable patterns as well:

Needs["GeneralUtilities`"]

BenchmarkPlot[
  MatchQ[#, {a___, x__Integer, y__}] &,
  RandomReal[99, #] &
  , "IncludeFits" -> True
]