Does it oscillate periodically? Challenge

Given a list, determine if grouping the list into runs of increasing and decreasing elements will result in a list of equal-sized lists.

In other words, "turning points" of the list are spaced out evenly.

Example

Here's an example: 0, 3, 7, 5, 2, 3, 6

0, 3, 7 increases, 7, 5, 2 decreases, and 2, 3, 6 increases. Therefore this is truthy.

Another example: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8 increases, 8, 5, 3 decreases, and 3, 5, 7, 9 increases. Therefore this is falsy.

Rules and Specifications


No adjacent elements will be equal
All numbers can be assumed to be within your language's reasonable number range
You may assume that all numbers are integers, if it helps you golf your submission
This is code-golf, so the shortest answer wins
Input as a list in any reasonable representation and output as any truthy/falsy value. The two values must be consistent.


Test Cases

Input -&gt; Output
1, 3, 5, 8, 6, 4, 2, 3, 5, 7, 6, 4, 2, 5, 7, 9, 6, 4, 2 -&gt; True
1, 3, 5, 7, 6, 4, 5, 7, 9, 8, 6, 4, 2, 3, 5 -&gt; False
2, 3, 6, 4, 2, 3, 7, 5, 3, 4, 6 -&gt; True
3, 6, 4, 8, 5, 7, 3, 5, 2 -&gt; True
8 -&gt; True
1, 3, 5, 7 -&gt; True
4, 5, 7, 6, 8, 9 -&gt; False
6, 4, 2, 3, 5, 4, 2 -&gt; True
8, 5, 3, 2, 4, 6, 5, 3, 2, 5, 7 -&gt; False


Note: You may not assume that all numbers are single digits (unless that is all your language is capable of handling); the test cases reflect that just because it's easier for me to type the cases this way :P Here are a few test cases with numbers outside of that range:

1, 5, 10, 19, 15, 13, 8, 13, 18, 23, 19, 18, 14 -&gt; True
15, 14, 17, 16, 19, 18 -&gt; True
12, 16, 19, 15, 18, 19 -&gt; False
MATL, 10 9 bytes

dZS&amp;Y'da~


Try it online!

Saved one byte thanks to Luis Mendo! 

Explanation:

Assume the input is: [0, 3, 7, 5, 2, 3, 6]:

            % Implicit input:                                [0, 3, 7, 5, 2, 3, 6]
d           % Difference between adjacent elements:          [3, 4, -2, -3,  1,  3]
 ZS         % Sign of the differences:                       [1, 1, -1, -1, 1, 1]
   &amp;Y'      % Length of runs of consecutive elements:        [2, 2, 2]
     d      % Difference between the lengths:                [0, 0]
      a     % Any non-zero elements:                         False
       ~    % Negate, to get a truthy value if all are zero: True