lgAAN

Legion Aarex Array Notation is an eighth part of Aarex's Array Notation.

NOTE: This part doesn't work. I will fix it later.

Changes

This part makes me harder of making definition. Here is the changes:

• # 0{0...0{#}0,n...}_;m = # 0{0...0{#}(# 0{0...0{#}(...),n-1...}_;1{0...0{#}0,n...}_;m-1),n-1...}_;1{0...0{#}0,n...}_;m-1
• Entries on any {}_; adds 1 latter layer each.
• Entries on any () subtracts 1 latter layer each.

There you go, here is the pre-definition.

Separators

Separators is the object between the entries. Let define row of Ax as separators and define the separator:

• , is the 4th-ranking separator.
• {n} is the 3rd-ranking separator.
• {a A1 b A2 c A3 ...} is the 2nd-ranking separator.
• {}_; is the 1st-ranking separator.

We need the separator type, that looks like the similar of the separator, excluding the entries.

There are finite layers of the separators, so we need to define the separator layer too:

• a() array entries are the separator layer 0.
• Separators on the array A in the are the separator layer, 1 more than A.

But we need to define latter layers:

• Entries on any {}_; adds 1 latter layer each.
• Entries on any () subtracts 1 latter layer each.

Now here is the definition.

Definition

The legion array notation look like this:

a(a,b,c A1 d A2 e...)x[y]

The integers a, b, c, etc.; are the entries, and each entry can be any number or semi-colon symbol; the Ax group are the separators where is between the entries, and the outermost "a" (like this can be place outside of the array entries) meaning this expression can be Aarex's Array Notation.

The first entry and second entry of AAN are called base and iterator, but we use numbers not symbols.

The string x[y] is optional and can be removable. x and y means nester and multiplier. Outermost a and x are always be 'a' character and 'x' character.

Note: The comma symbol ',' is shorthand for {0} and {(n)}_; have the same level as {n}.

Rules and process

Every array needs to results in a number. To solve it, we need some rules and processes as follows:

• Rule 1: (base rule - if it have 3 entries and the 3rd entry is 0) a(a,b,0) = a*b
  • Rule 1a: (if it have 2 entries) a(a,b) = a(a,b,0)
  • Rule 1b: (if it have 1 entry) a(a) = a(a,1,0)
• Rule 2: (tailing rule - if the last entry is 0) # 0 = #
• Rule 3: (recursion rule - if the 3rd entry isn't 0, but there is no nester) a(a,b,c #) = a(a,b,c-1 #)x[b]
• Rule 4: (nesting-end rule - if nester and multiplier are exists and multiplier is 1) a(#)x[1] = a(#)
  • English: If the nester are exists and multiplier is 1, remove 'x[1]' in the end.
• Rule 5: (nesting rule - if nester and multiplier are exists and multiplier isn't 1) a(a,b #)x[y] = a(a,a(a,b #)x[y-1] #)

where # is the part of array (a string of separators between the entries or empty string.)

If neither of 5 rules applied, start the process shown below. First, start from the third entry.

• Case A: If the entry is 0, move on to the next entry.
  • English: Else, find the third non-zero entry.
• Case B: If the entry is not 0 and its the number.
  • Case B1: If there is the comma in the left and the entry have 0 latter layers:
  • Decrease the entry by 1.
  • Change the previous entry to the iterator.
  • This process ends.
  • Case B2: If there is the comma in the left and the entry have 1 or more latter layers:
    • Decrease the entry by 1.
    • Define l as the separator layer of S entry.
    • Define S as {#} from the full separator where the current entry is.
    • Define D as S, but the first entry on the separator changed to 0 if there is {}_; outside and have more than 1 entries.
    • Repeat this until l = 0:
      • Subtract n by 1.
      • Define Ll as the separator with separator layer l where S belong to.
      • Define Sl as Ll, but the first entry on the separator changed to 0 if there is {}_; outside else, it will be comma.
    • Find the maximum t such as Lt that lv(D) > lv(St).
    • Define S0 and Sn as '0' and 'Lt', but the first entry on S on Lt will be replaced by '(Sn-1)'.
    • Replace the previous entry with Sb.
    • This process ends.
  • Case B3: If there is the {x #} in the left:
    • Decrease the entry by 1.
    • Define S0 and Sn as '1' and '0{x-1 #}Sn-1'
    • Replace the previous entry with Sb.
    • This process ends.
  • Case B4: If there is the separator in the left and cases B2 & B3 did not applied:
    • Copy the separator to R.
    • Replace the entry before the separator with '0 R 1'.
    • Continue the process within R separator, beside the process with a(x,y,z).
• Case C: If the entry isn't the number and it is (R) entry:
  • Continue the process within R separator, beside the process with a(x,y,z).

Separator Levels

To compare, we need 2 functions as lv(A) and lv(B) and start at case 1. Set the comma into {0}.

• Case 1: Find the separator type on A and B:
  • If B was {}_; and A not, then lv(A) < lv(B) and finish.
  • If A was {}_; and B not, then lv(A) > lv(B) and finish.
  • Else, go to Case 2.
• Case 2: If A or B have () entry, then use this case and call it A' and B' inside of () each; else go to Case 3.
  • If lv({A'}) < lv({B'}), then lv(A) < lv(B) and finish.
  • If lv({A'}) > lv({B'}), then lv(A) > lv(B) and finish.
  • If lv({A'}) = lv({B'}), then lv(A) = lv(B) and finish.
• Case 3: If A and B were all numbers, then use this case; else go to Case 4.
  • If A < B, then lv(A) < lv(B) and finish.
  • If A > B, then lv(A) > lv(B) and finish.
  • If A = B, then lv(A) = lv(B) and finish.
• Case 4: Find the highest separator possible and call it H. Then find the amounts of H and call it A' and B'.
  • If A' < B', then lv(A) < lv(B) and finish.
  • If A' > B', then lv(A) > lv(B) and finish.
  • If A' = B', then go into case 4.
• Case 5: Find the array preceded by the first H separator and call it A' and B'.
  • If lv({A'}) < lv({B'}), then lv(A) < lv(B) and finish.
  • If lv({A'}) > lv({B'}), then lv(A) > lv(B) and finish.
  • If lv({A'}) = lv({B'}), then remove A' and B' and the first H separator that isn't removed, then:
    • If the separator was {}, then lv(A) = lv(B) and finish.
    • Else, repeat case 4.