nodes/mcDandy-more_math
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
8e0b1c65f5f7aa2eb54cc03185d68d1250feace1
mcDandy-more_math/more_math/Parser/MathExprParser.py
T
mcDandy 8e0b1c65f5 (ai) add custom functions
2026-01-19 17:22:23 +01:00

5050 lines
183 KiB
Python
Raw Blame History

# Generated from MathExpr.g4 by ANTLR 4.13.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
from typing import TextIO
else:
from typing.io import TextIO
def serializedATN():
return [
4,1,91,640,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,
6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,
2,14,7,14,2,15,7,15,2,16,7,16,1,0,5,0,36,8,0,10,0,12,0,39,9,0,1,
0,1,0,1,0,1,1,1,1,1,1,3,1,47,8,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,2,
5,2,57,8,2,10,2,12,2,60,9,2,1,3,1,3,3,3,64,8,3,1,4,1,4,1,4,1,4,1,
4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
4,5,4,87,8,4,10,4,12,4,90,9,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,
5,5,5,101,8,5,10,5,12,5,104,9,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,
1,6,1,6,1,6,1,6,5,6,118,8,6,10,6,12,6,121,9,6,1,7,1,7,1,7,1,7,1,
7,3,7,128,8,7,1,8,1,8,1,8,1,8,1,8,3,8,135,8,8,1,9,1,9,1,9,1,9,1,
9,1,9,1,9,1,9,5,9,145,8,9,10,9,12,9,148,9,9,1,9,1,9,5,9,152,8,9,
10,9,12,9,155,9,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,
10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,5,10,177,8,
10,10,10,12,10,180,9,10,1,10,1,10,1,10,1,10,1,10,3,10,187,8,10,1,
10,3,10,190,8,10,1,11,1,11,1,11,5,11,195,8,11,10,11,12,11,198,9,
11,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,
12,1,12,1,12,1,12,1,12,1,12,3,12,400,8,12,1,13,1,13,1,13,1,13,1,
13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,
13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,
13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,
13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,
13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,
13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,
13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,
13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,3,13,507,8,13,1,
14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,
14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,
14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,
14,1,14,1,14,1,14,1,14,1,14,3,14,554,8,14,1,15,1,15,1,15,1,15,1,
15,1,15,1,15,1,15,1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,5,16,572,
8,16,10,16,12,16,575,9,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,5,16,
584,8,16,10,16,12,16,587,9,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
4,16,596,8,16,11,16,12,16,597,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
4,16,607,8,16,11,16,12,16,608,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
4,16,618,8,16,11,16,12,16,619,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,638,8,16,1,16,
0,4,8,10,12,18,17,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,
0,0,724,0,37,1,0,0,0,2,43,1,0,0,0,4,53,1,0,0,0,6,63,1,0,0,0,8,65,
1,0,0,0,10,91,1,0,0,0,12,105,1,0,0,0,14,127,1,0,0,0,16,134,1,0,0,
0,18,136,1,0,0,0,20,189,1,0,0,0,22,191,1,0,0,0,24,399,1,0,0,0,26,
506,1,0,0,0,28,553,1,0,0,0,30,555,1,0,0,0,32,637,1,0,0,0,34,36,3,
2,1,0,35,34,1,0,0,0,36,39,1,0,0,0,37,35,1,0,0,0,37,38,1,0,0,0,38,
40,1,0,0,0,39,37,1,0,0,0,40,41,3,6,3,0,41,42,5,0,0,1,42,1,1,0,0,
0,43,44,5,90,0,0,44,46,5,81,0,0,45,47,3,4,2,0,46,45,1,0,0,0,46,47,
1,0,0,0,47,48,1,0,0,0,48,49,5,82,0,0,49,50,5,85,0,0,50,51,3,6,3,
0,51,52,5,84,0,0,52,3,1,0,0,0,53,58,5,90,0,0,54,55,5,83,0,0,55,57,
5,90,0,0,56,54,1,0,0,0,57,60,1,0,0,0,58,56,1,0,0,0,58,59,1,0,0,0,
59,5,1,0,0,0,60,58,1,0,0,0,61,64,3,20,10,0,62,64,3,8,4,0,63,61,1,
0,0,0,63,62,1,0,0,0,64,7,1,0,0,0,65,66,6,4,-1,0,66,67,3,10,5,0,67,
88,1,0,0,0,68,69,10,7,0,0,69,70,5,75,0,0,70,87,3,10,5,0,71,72,10,
6,0,0,72,73,5,74,0,0,73,87,3,10,5,0,74,75,10,5,0,0,75,76,5,77,0,
0,76,87,3,10,5,0,77,78,10,4,0,0,78,79,5,76,0,0,79,87,3,10,5,0,80,
81,10,3,0,0,81,82,5,78,0,0,82,87,3,10,5,0,83,84,10,2,0,0,84,85,5,
79,0,0,85,87,3,10,5,0,86,68,1,0,0,0,86,71,1,0,0,0,86,74,1,0,0,0,
86,77,1,0,0,0,86,80,1,0,0,0,86,83,1,0,0,0,87,90,1,0,0,0,88,86,1,
0,0,0,88,89,1,0,0,0,89,9,1,0,0,0,90,88,1,0,0,0,91,92,6,5,-1,0,92,
93,3,12,6,0,93,102,1,0,0,0,94,95,10,3,0,0,95,96,5,68,0,0,96,101,
3,12,6,0,97,98,10,2,0,0,98,99,5,69,0,0,99,101,3,12,6,0,100,94,1,
0,0,0,100,97,1,0,0,0,101,104,1,0,0,0,102,100,1,0,0,0,102,103,1,0,
0,0,103,11,1,0,0,0,104,102,1,0,0,0,105,106,6,6,-1,0,106,107,3,14,
7,0,107,119,1,0,0,0,108,109,10,4,0,0,109,110,5,70,0,0,110,118,3,
14,7,0,111,112,10,3,0,0,112,113,5,71,0,0,113,118,3,14,7,0,114,115,
10,2,0,0,115,116,5,72,0,0,116,118,3,14,7,0,117,108,1,0,0,0,117,111,
1,0,0,0,117,114,1,0,0,0,118,121,1,0,0,0,119,117,1,0,0,0,119,120,
1,0,0,0,120,13,1,0,0,0,121,119,1,0,0,0,122,123,3,16,8,0,123,124,
5,73,0,0,124,125,3,14,7,0,125,128,1,0,0,0,126,128,3,16,8,0,127,122,
1,0,0,0,127,126,1,0,0,0,128,15,1,0,0,0,129,130,5,68,0,0,130,135,
3,16,8,0,131,132,5,69,0,0,132,135,3,16,8,0,133,135,3,18,9,0,134,
129,1,0,0,0,134,131,1,0,0,0,134,133,1,0,0,0,135,17,1,0,0,0,136,137,
6,9,-1,0,137,138,3,20,10,0,138,153,1,0,0,0,139,140,10,2,0,0,140,
141,5,86,0,0,141,146,3,6,3,0,142,143,5,83,0,0,143,145,3,6,3,0,144,
142,1,0,0,0,145,148,1,0,0,0,146,144,1,0,0,0,146,147,1,0,0,0,147,
149,1,0,0,0,148,146,1,0,0,0,149,150,5,87,0,0,150,152,1,0,0,0,151,
139,1,0,0,0,152,155,1,0,0,0,153,151,1,0,0,0,153,154,1,0,0,0,154,
19,1,0,0,0,155,153,1,0,0,0,156,190,3,24,12,0,157,190,3,26,13,0,158,
190,3,28,14,0,159,190,3,30,15,0,160,190,3,32,16,0,161,190,5,90,0,
0,162,190,5,89,0,0,163,190,5,88,0,0,164,165,5,81,0,0,165,166,3,6,
3,0,166,167,5,82,0,0,167,190,1,0,0,0,168,169,5,80,0,0,169,170,3,
6,3,0,170,171,5,80,0,0,171,190,1,0,0,0,172,173,5,86,0,0,173,178,
3,6,3,0,174,175,5,83,0,0,175,177,3,6,3,0,176,174,1,0,0,0,177,180,
1,0,0,0,178,176,1,0,0,0,178,179,1,0,0,0,179,181,1,0,0,0,180,178,
1,0,0,0,181,182,5,87,0,0,182,190,1,0,0,0,183,184,5,90,0,0,184,186,
5,81,0,0,185,187,3,22,11,0,186,185,1,0,0,0,186,187,1,0,0,0,187,188,
1,0,0,0,188,190,5,82,0,0,189,156,1,0,0,0,189,157,1,0,0,0,189,158,
1,0,0,0,189,159,1,0,0,0,189,160,1,0,0,0,189,161,1,0,0,0,189,162,
1,0,0,0,189,163,1,0,0,0,189,164,1,0,0,0,189,168,1,0,0,0,189,172,
1,0,0,0,189,183,1,0,0,0,190,21,1,0,0,0,191,196,3,6,3,0,192,193,5,
83,0,0,193,195,3,6,3,0,194,192,1,0,0,0,195,198,1,0,0,0,196,194,1,
0,0,0,196,197,1,0,0,0,197,23,1,0,0,0,198,196,1,0,0,0,199,200,5,1,
0,0,200,201,5,81,0,0,201,202,3,6,3,0,202,203,5,82,0,0,203,400,1,
0,0,0,204,205,5,2,0,0,205,206,5,81,0,0,206,207,3,6,3,0,207,208,5,
82,0,0,208,400,1,0,0,0,209,210,5,3,0,0,210,211,5,81,0,0,211,212,
3,6,3,0,212,213,5,82,0,0,213,400,1,0,0,0,214,215,5,4,0,0,215,216,
5,81,0,0,216,217,3,6,3,0,217,218,5,82,0,0,218,400,1,0,0,0,219,220,
5,5,0,0,220,221,5,81,0,0,221,222,3,6,3,0,222,223,5,82,0,0,223,400,
1,0,0,0,224,225,5,6,0,0,225,226,5,81,0,0,226,227,3,6,3,0,227,228,
5,82,0,0,228,400,1,0,0,0,229,230,5,8,0,0,230,231,5,81,0,0,231,232,
3,6,3,0,232,233,5,82,0,0,233,400,1,0,0,0,234,235,5,9,0,0,235,236,
5,81,0,0,236,237,3,6,3,0,237,238,5,82,0,0,238,400,1,0,0,0,239,240,
5,10,0,0,240,241,5,81,0,0,241,242,3,6,3,0,242,243,5,82,0,0,243,400,
1,0,0,0,244,245,5,11,0,0,245,246,5,81,0,0,246,247,3,6,3,0,247,248,
5,82,0,0,248,400,1,0,0,0,249,250,5,12,0,0,250,251,5,81,0,0,251,252,
3,6,3,0,252,253,5,82,0,0,253,400,1,0,0,0,254,255,5,13,0,0,255,256,
5,81,0,0,256,257,3,6,3,0,257,258,5,82,0,0,258,400,1,0,0,0,259,260,
5,14,0,0,260,261,5,81,0,0,261,262,3,6,3,0,262,263,5,82,0,0,263,400,
1,0,0,0,264,265,5,15,0,0,265,266,5,81,0,0,266,267,3,6,3,0,267,268,
5,82,0,0,268,400,1,0,0,0,269,270,5,16,0,0,270,271,5,81,0,0,271,272,
3,6,3,0,272,273,5,82,0,0,273,400,1,0,0,0,274,275,5,17,0,0,275,276,
5,81,0,0,276,277,3,6,3,0,277,278,5,82,0,0,278,400,1,0,0,0,279,280,
5,18,0,0,280,281,5,81,0,0,281,282,3,6,3,0,282,283,5,82,0,0,283,400,
1,0,0,0,284,285,5,23,0,0,285,286,5,81,0,0,286,287,3,6,3,0,287,288,
5,82,0,0,288,400,1,0,0,0,289,290,5,24,0,0,290,291,5,81,0,0,291,292,
3,6,3,0,292,293,5,82,0,0,293,400,1,0,0,0,294,295,5,25,0,0,295,296,
5,81,0,0,296,297,3,6,3,0,297,298,5,82,0,0,298,400,1,0,0,0,299,300,
5,26,0,0,300,301,5,81,0,0,301,302,3,6,3,0,302,303,5,82,0,0,303,400,
1,0,0,0,304,305,5,27,0,0,305,306,5,81,0,0,306,307,3,6,3,0,307,308,
5,82,0,0,308,400,1,0,0,0,309,310,5,28,0,0,310,311,5,81,0,0,311,312,
3,6,3,0,312,313,5,82,0,0,313,400,1,0,0,0,314,315,5,30,0,0,315,316,
5,81,0,0,316,317,3,6,3,0,317,318,5,82,0,0,318,400,1,0,0,0,319,320,
5,32,0,0,320,321,5,81,0,0,321,322,3,6,3,0,322,323,5,82,0,0,323,400,
1,0,0,0,324,325,5,33,0,0,325,326,5,81,0,0,326,327,3,6,3,0,327,328,
5,82,0,0,328,400,1,0,0,0,329,330,5,34,0,0,330,331,5,81,0,0,331,332,
3,6,3,0,332,333,5,82,0,0,333,400,1,0,0,0,334,335,5,35,0,0,335,336,
5,81,0,0,336,337,3,6,3,0,337,338,5,82,0,0,338,400,1,0,0,0,339,340,
5,40,0,0,340,341,5,81,0,0,341,342,3,6,3,0,342,343,5,82,0,0,343,400,
1,0,0,0,344,345,5,41,0,0,345,346,5,81,0,0,346,347,3,6,3,0,347,348,
5,82,0,0,348,400,1,0,0,0,349,350,5,42,0,0,350,351,5,81,0,0,351,352,
3,6,3,0,352,353,5,82,0,0,353,400,1,0,0,0,354,355,5,43,0,0,355,356,
5,81,0,0,356,357,3,6,3,0,357,358,5,82,0,0,358,400,1,0,0,0,359,360,
5,44,0,0,360,361,5,81,0,0,361,362,3,6,3,0,362,363,5,82,0,0,363,400,
1,0,0,0,364,365,5,36,0,0,365,366,5,81,0,0,366,367,3,6,3,0,367,368,
5,82,0,0,368,400,1,0,0,0,369,370,5,54,0,0,370,371,5,81,0,0,371,372,
3,6,3,0,372,373,5,82,0,0,373,400,1,0,0,0,374,375,5,55,0,0,375,376,
5,81,0,0,376,377,3,6,3,0,377,378,5,82,0,0,378,400,1,0,0,0,379,380,
5,56,0,0,380,381,5,81,0,0,381,382,3,6,3,0,382,383,5,82,0,0,383,400,
1,0,0,0,384,385,5,57,0,0,385,386,5,81,0,0,386,387,3,6,3,0,387,388,
5,82,0,0,388,400,1,0,0,0,389,390,5,58,0,0,390,391,5,81,0,0,391,392,
3,6,3,0,392,393,5,82,0,0,393,400,1,0,0,0,394,395,5,67,0,0,395,396,
5,81,0,0,396,397,3,6,3,0,397,398,5,82,0,0,398,400,1,0,0,0,399,199,
1,0,0,0,399,204,1,0,0,0,399,209,1,0,0,0,399,214,1,0,0,0,399,219,
1,0,0,0,399,224,1,0,0,0,399,229,1,0,0,0,399,234,1,0,0,0,399,239,
1,0,0,0,399,244,1,0,0,0,399,249,1,0,0,0,399,254,1,0,0,0,399,259,
1,0,0,0,399,264,1,0,0,0,399,269,1,0,0,0,399,274,1,0,0,0,399,279,
1,0,0,0,399,284,1,0,0,0,399,289,1,0,0,0,399,294,1,0,0,0,399,299,
1,0,0,0,399,304,1,0,0,0,399,309,1,0,0,0,399,314,1,0,0,0,399,319,
1,0,0,0,399,324,1,0,0,0,399,329,1,0,0,0,399,334,1,0,0,0,399,339,
1,0,0,0,399,344,1,0,0,0,399,349,1,0,0,0,399,354,1,0,0,0,399,359,
1,0,0,0,399,364,1,0,0,0,399,369,1,0,0,0,399,374,1,0,0,0,399,379,
1,0,0,0,399,384,1,0,0,0,399,389,1,0,0,0,399,394,1,0,0,0,400,25,1,
0,0,0,401,402,5,29,0,0,402,403,5,81,0,0,403,404,3,6,3,0,404,405,
5,83,0,0,405,406,3,6,3,0,406,407,5,82,0,0,407,507,1,0,0,0,408,409,
5,7,0,0,409,410,5,81,0,0,410,411,3,6,3,0,411,412,5,83,0,0,412,413,
3,6,3,0,413,414,5,82,0,0,414,507,1,0,0,0,415,416,5,21,0,0,416,417,
5,81,0,0,417,418,3,6,3,0,418,419,5,83,0,0,419,420,3,6,3,0,420,421,
5,82,0,0,421,507,1,0,0,0,422,423,5,22,0,0,423,424,5,81,0,0,424,425,
3,6,3,0,425,426,5,83,0,0,426,427,3,6,3,0,427,428,5,82,0,0,428,507,
1,0,0,0,429,430,5,38,0,0,430,431,5,81,0,0,431,432,3,6,3,0,432,433,
5,83,0,0,433,434,3,6,3,0,434,435,5,82,0,0,435,507,1,0,0,0,436,437,
5,52,0,0,437,438,5,81,0,0,438,439,3,6,3,0,439,440,5,83,0,0,440,441,
3,6,3,0,441,442,5,82,0,0,442,507,1,0,0,0,443,444,5,53,0,0,444,445,
5,81,0,0,445,446,3,6,3,0,446,447,5,83,0,0,447,448,3,6,3,0,448,449,
5,82,0,0,449,507,1,0,0,0,450,451,5,59,0,0,451,452,5,81,0,0,452,453,
3,6,3,0,453,454,5,83,0,0,454,455,3,6,3,0,455,456,5,82,0,0,456,507,
1,0,0,0,457,458,5,60,0,0,458,459,5,81,0,0,459,460,3,6,3,0,460,461,
5,83,0,0,461,462,3,6,3,0,462,463,5,82,0,0,463,507,1,0,0,0,464,465,
5,61,0,0,465,466,5,81,0,0,466,467,3,6,3,0,467,468,5,83,0,0,468,469,
3,6,3,0,469,470,5,82,0,0,470,507,1,0,0,0,471,472,5,61,0,0,472,473,
5,81,0,0,473,474,3,6,3,0,474,475,5,83,0,0,475,476,3,6,3,0,476,477,
5,82,0,0,477,507,1,0,0,0,478,479,5,62,0,0,479,480,5,81,0,0,480,481,
3,6,3,0,481,482,5,83,0,0,482,483,3,6,3,0,483,484,5,82,0,0,484,507,
1,0,0,0,485,486,5,64,0,0,486,487,5,81,0,0,487,488,3,6,3,0,488,489,
5,83,0,0,489,490,3,6,3,0,490,491,5,82,0,0,491,507,1,0,0,0,492,493,
5,65,0,0,493,494,5,81,0,0,494,495,3,6,3,0,495,496,5,83,0,0,496,497,
3,6,3,0,497,498,5,82,0,0,498,507,1,0,0,0,499,500,5,66,0,0,500,501,
5,81,0,0,501,502,3,6,3,0,502,503,5,83,0,0,503,504,3,6,3,0,504,505,
5,82,0,0,505,507,1,0,0,0,506,401,1,0,0,0,506,408,1,0,0,0,506,415,
1,0,0,0,506,422,1,0,0,0,506,429,1,0,0,0,506,436,1,0,0,0,506,443,
1,0,0,0,506,450,1,0,0,0,506,457,1,0,0,0,506,464,1,0,0,0,506,471,
1,0,0,0,506,478,1,0,0,0,506,485,1,0,0,0,506,492,1,0,0,0,506,499,
1,0,0,0,507,27,1,0,0,0,508,509,5,31,0,0,509,510,5,81,0,0,510,511,
3,6,3,0,511,512,5,83,0,0,512,513,3,6,3,0,513,514,5,83,0,0,514,515,
3,6,3,0,515,516,5,82,0,0,516,554,1,0,0,0,517,518,5,37,0,0,518,519,
5,81,0,0,519,520,3,6,3,0,520,521,5,83,0,0,521,522,3,6,3,0,522,523,
5,83,0,0,523,524,3,6,3,0,524,525,5,82,0,0,525,554,1,0,0,0,526,527,
5,39,0,0,527,528,5,81,0,0,528,529,3,6,3,0,529,530,5,83,0,0,530,531,
3,6,3,0,531,532,5,83,0,0,532,533,3,6,3,0,533,534,5,82,0,0,534,554,
1,0,0,0,535,536,5,51,0,0,536,537,5,81,0,0,537,538,3,6,3,0,538,539,
5,83,0,0,539,540,3,6,3,0,540,541,5,83,0,0,541,542,3,6,3,0,542,543,
5,82,0,0,543,554,1,0,0,0,544,545,5,63,0,0,545,546,5,81,0,0,546,547,
3,6,3,0,547,548,5,83,0,0,548,549,3,6,3,0,549,550,5,83,0,0,550,551,
3,6,3,0,551,552,5,82,0,0,552,554,1,0,0,0,553,508,1,0,0,0,553,517,
1,0,0,0,553,526,1,0,0,0,553,535,1,0,0,0,553,544,1,0,0,0,554,29,1,
0,0,0,555,556,5,48,0,0,556,557,5,81,0,0,557,558,3,6,3,0,558,559,
5,83,0,0,559,560,3,6,3,0,560,561,5,83,0,0,561,562,3,6,3,0,562,563,
5,83,0,0,563,564,3,6,3,0,564,565,5,82,0,0,565,31,1,0,0,0,566,567,
5,19,0,0,567,568,5,81,0,0,568,573,3,6,3,0,569,570,5,83,0,0,570,572,
3,6,3,0,571,569,1,0,0,0,572,575,1,0,0,0,573,571,1,0,0,0,573,574,
1,0,0,0,574,576,1,0,0,0,575,573,1,0,0,0,576,577,5,82,0,0,577,638,
1,0,0,0,578,579,5,20,0,0,579,580,5,81,0,0,580,585,3,6,3,0,581,582,
5,83,0,0,582,584,3,6,3,0,583,581,1,0,0,0,584,587,1,0,0,0,585,583,
1,0,0,0,585,586,1,0,0,0,586,588,1,0,0,0,587,585,1,0,0,0,588,589,
5,82,0,0,589,638,1,0,0,0,590,591,5,45,0,0,591,592,5,81,0,0,592,595,
3,6,3,0,593,594,5,83,0,0,594,596,3,6,3,0,595,593,1,0,0,0,596,597,
1,0,0,0,597,595,1,0,0,0,597,598,1,0,0,0,598,599,1,0,0,0,599,600,
5,82,0,0,600,638,1,0,0,0,601,602,5,46,0,0,602,603,5,81,0,0,603,606,
3,6,3,0,604,605,5,83,0,0,605,607,3,6,3,0,606,604,1,0,0,0,607,608,
1,0,0,0,608,606,1,0,0,0,608,609,1,0,0,0,609,610,1,0,0,0,610,611,
5,82,0,0,611,638,1,0,0,0,612,613,5,47,0,0,613,614,5,81,0,0,614,617,
3,6,3,0,615,616,5,83,0,0,616,618,3,6,3,0,617,615,1,0,0,0,618,619,
1,0,0,0,619,617,1,0,0,0,619,620,1,0,0,0,620,621,1,0,0,0,621,622,
5,82,0,0,622,638,1,0,0,0,623,624,5,49,0,0,624,625,5,81,0,0,625,626,
3,6,3,0,626,627,5,83,0,0,627,628,3,6,3,0,628,629,5,82,0,0,629,638,
1,0,0,0,630,631,5,50,0,0,631,632,5,81,0,0,632,633,3,6,3,0,633,634,
5,83,0,0,634,635,3,6,3,0,635,636,5,82,0,0,636,638,1,0,0,0,637,566,
1,0,0,0,637,578,1,0,0,0,637,590,1,0,0,0,637,601,1,0,0,0,637,612,
1,0,0,0,637,623,1,0,0,0,637,630,1,0,0,0,638,33,1,0,0,0,27,37,46,
58,63,86,88,100,102,117,119,127,134,146,153,178,186,189,196,399,
506,553,573,585,597,608,619,637
]
class MathExprParser ( Parser ):
grammarFileName = "MathExpr.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
sharedContextCache = PredictionContextCache()
literalNames = [ "<INVALID>", "'sin'", "'cos'", "'tan'", "'asin'", "'acos'",
"'atan'", "'atan2'", "'sinh'", "'cosh'", "'tanh'",
"'asinh'", "'acosh'", "'atanh'", "'abs'", "'sqrt'",
"'ln'", "'log'", "'exp'", "'smin'", "'smax'", "'tmin'",
"'tmax'", "'tnorm'", "'snorm'", "'floor'", "'ceil'",
"'round'", "'gamma'", "'pow'", "'sigm'", "'clamp'",
"'fft'", "'ifft'", "'angle'", "'print'", "<INVALID>",
"'lerp'", "'step'", "'smoothstep'", "'fract'", "'relu'",
"'softplus'", "'gelu'", "'sign'", "'map'", "<INVALID>",
"<INVALID>", "'swap'", "<INVALID>", "<INVALID>", "'range'",
"'topk'", "'botk'", "'pinv'", "'sum'", "'mean'", "'std'",
"'var'", "<INVALID>", "<INVALID>", "'quantile'", "'dot'",
"'moment'", "'cossim'", "'flip'", "'cov'", "'sort'",
"'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'>='", "'>'",
"'<='", "'<'", "'=='", "'!='", "'|'", "'('", "')'",
"','", "';'", "'->'", "'['", "']'" ]
symbolicNames = [ "<INVALID>", "SIN", "COS", "TAN", "ASIN", "ACOS",
"ATAN", "ATAN2", "SINH", "COSH", "TANH", "ASINH",
"ACOSH", "ATANH", "ABS", "SQRT", "LN", "LOG", "EXP",
"SMIN", "SMAX", "TMIN", "TMAX", "TNORM", "SNORM",
"FLOOR", "CEIL", "ROUND", "GAMMA", "POWE", "SIGM",
"CLAMP", "SFFT", "SIFFT", "ANGL", "PRNT", "PRINT_SHAPE",
"LERP", "STEP", "SMOOTHSTEP", "FRACT", "RELU", "SOFTPLUS",
"GELU", "SIGN", "MAP", "EZCONV", "CONV", "SWAP", "PERM",
"RESHAPE", "RANGE", "TOPK", "BOTK", "PINV", "SUM",
"MEAN", "STD", "VAR", "QUARTILE", "PERCENTILE", "QUANTILE",
"DOT", "MOMENT", "COSSIM", "FLIP", "COV", "SORT",
"PLUS", "MINUS", "MULT", "DIV", "MOD", "POW", "GE",
"GT", "LE", "LT", "EQ", "NE", "PIPE", "LPAREN", "RPAREN",
"COMMA", "SEMICOLON", "ARROW", "LBRACKET", "RBRACKET",
"CONSTANT", "NUMBER", "VARIABLE", "WS" ]
RULE_start = 0
RULE_funcDef = 1
RULE_paramList = 2
RULE_expr = 3
RULE_compExpr = 4
RULE_addExpr = 5
RULE_mulExpr = 6
RULE_powExpr = 7
RULE_unaryExpr = 8
RULE_indexExpr = 9
RULE_atom = 10
RULE_exprList = 11
RULE_func1 = 12
RULE_func2 = 13
RULE_func3 = 14
RULE_func4 = 15
RULE_funcN = 16
ruleNames = [ "start", "funcDef", "paramList", "expr", "compExpr",
"addExpr", "mulExpr", "powExpr", "unaryExpr", "indexExpr",
"atom", "exprList", "func1", "func2", "func3", "func4",
"funcN" ]
EOF = Token.EOF
SIN=1
COS=2
TAN=3
ASIN=4
ACOS=5
ATAN=6
ATAN2=7
SINH=8
COSH=9
TANH=10
ASINH=11
ACOSH=12
ATANH=13
ABS=14
SQRT=15
LN=16
LOG=17
EXP=18
SMIN=19
SMAX=20
TMIN=21
TMAX=22
TNORM=23
SNORM=24
FLOOR=25
CEIL=26
ROUND=27
GAMMA=28
POWE=29
SIGM=30
CLAMP=31
SFFT=32
SIFFT=33
ANGL=34
PRNT=35
PRINT_SHAPE=36
LERP=37
STEP=38
SMOOTHSTEP=39
FRACT=40
RELU=41
SOFTPLUS=42
GELU=43
SIGN=44
MAP=45
EZCONV=46
CONV=47
SWAP=48
PERM=49
RESHAPE=50
RANGE=51
TOPK=52
BOTK=53
PINV=54
SUM=55
MEAN=56
STD=57
VAR=58
QUARTILE=59
PERCENTILE=60
QUANTILE=61
DOT=62
MOMENT=63
COSSIM=64
FLIP=65
COV=66
SORT=67
PLUS=68
MINUS=69
MULT=70
DIV=71
MOD=72
POW=73
GE=74
GT=75
LE=76
LT=77
EQ=78
NE=79
PIPE=80
LPAREN=81
RPAREN=82
COMMA=83
SEMICOLON=84
ARROW=85
LBRACKET=86
RBRACKET=87
CONSTANT=88
NUMBER=89
VARIABLE=90
WS=91
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
super().__init__(input, output)
self.checkVersion("4.13.2")
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
self._predicates = None
class StartContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def EOF(self):
return self.getToken(MathExprParser.EOF, 0)
def funcDef(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.FuncDefContext)
else:
return self.getTypedRuleContext(MathExprParser.FuncDefContext,i)
def getRuleIndex(self):
return MathExprParser.RULE_start
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStart" ):
return visitor.visitStart(self)
else:
return visitor.visitChildren(self)
def start(self):
localctx = MathExprParser.StartContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_start)
try:
self.enterOuterAlt(localctx, 1)
self.state = 37
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,0,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 34
self.funcDef()
self.state = 39
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,0,self._ctx)
self.state = 40
self.expr()
self.state = 41
self.match(MathExprParser.EOF)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class FuncDefContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_funcDef
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class FunctionDefContext(FuncDefContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.FuncDefContext
super().__init__(parser)
self.copyFrom(ctx)
def VARIABLE(self):
return self.getToken(MathExprParser.VARIABLE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def ARROW(self):
return self.getToken(MathExprParser.ARROW, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def SEMICOLON(self):
return self.getToken(MathExprParser.SEMICOLON, 0)
def paramList(self):
return self.getTypedRuleContext(MathExprParser.ParamListContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionDef" ):
return visitor.visitFunctionDef(self)
else:
return visitor.visitChildren(self)
def funcDef(self):
localctx = MathExprParser.FuncDefContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_funcDef)
self._la = 0 # Token type
try:
localctx = MathExprParser.FunctionDefContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 43
self.match(MathExprParser.VARIABLE)
self.state = 44
self.match(MathExprParser.LPAREN)
self.state = 46
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==90:
self.state = 45
self.paramList()
self.state = 48
self.match(MathExprParser.RPAREN)
self.state = 49
self.match(MathExprParser.ARROW)
self.state = 50
self.expr()
self.state = 51
self.match(MathExprParser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class ParamListContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def VARIABLE(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.VARIABLE)
else:
return self.getToken(MathExprParser.VARIABLE, i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def getRuleIndex(self):
return MathExprParser.RULE_paramList
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParamList" ):
return visitor.visitParamList(self)
else:
return visitor.visitChildren(self)
def paramList(self):
localctx = MathExprParser.ParamListContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_paramList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 53
self.match(MathExprParser.VARIABLE)
self.state = 58
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==83:
self.state = 54
self.match(MathExprParser.COMMA)
self.state = 55
self.match(MathExprParser.VARIABLE)
self.state = 60
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class ExprContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def atom(self):
return self.getTypedRuleContext(MathExprParser.AtomContext,0)
def compExpr(self):
return self.getTypedRuleContext(MathExprParser.CompExprContext,0)
def getRuleIndex(self):
return MathExprParser.RULE_expr
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExpr" ):
return visitor.visitExpr(self)
else:
return visitor.visitChildren(self)
def expr(self):
localctx = MathExprParser.ExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 6, self.RULE_expr)
try:
self.state = 63
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 61
self.atom()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 62
self.compExpr(0)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class CompExprContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_compExpr
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class LtExpContext(CompExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.CompExprContext
super().__init__(parser)
self.copyFrom(ctx)
def compExpr(self):
return self.getTypedRuleContext(MathExprParser.CompExprContext,0)
def LT(self):
return self.getToken(MathExprParser.LT, 0)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLtExp" ):
return visitor.visitLtExp(self)
else:
return visitor.visitChildren(self)
class EqExpContext(CompExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.CompExprContext
super().__init__(parser)
self.copyFrom(ctx)
def compExpr(self):
return self.getTypedRuleContext(MathExprParser.CompExprContext,0)
def EQ(self):
return self.getToken(MathExprParser.EQ, 0)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEqExp" ):
return visitor.visitEqExp(self)
else:
return visitor.visitChildren(self)
class ToAddContext(CompExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.CompExprContext
super().__init__(parser)
self.copyFrom(ctx)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitToAdd" ):
return visitor.visitToAdd(self)
else:
return visitor.visitChildren(self)
class GeExpContext(CompExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.CompExprContext
super().__init__(parser)
self.copyFrom(ctx)
def compExpr(self):
return self.getTypedRuleContext(MathExprParser.CompExprContext,0)
def GE(self):
return self.getToken(MathExprParser.GE, 0)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGeExp" ):
return visitor.visitGeExp(self)
else:
return visitor.visitChildren(self)
class LeExpContext(CompExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.CompExprContext
super().__init__(parser)
self.copyFrom(ctx)
def compExpr(self):
return self.getTypedRuleContext(MathExprParser.CompExprContext,0)
def LE(self):
return self.getToken(MathExprParser.LE, 0)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLeExp" ):
return visitor.visitLeExp(self)
else:
return visitor.visitChildren(self)
class NeExpContext(CompExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.CompExprContext
super().__init__(parser)
self.copyFrom(ctx)
def compExpr(self):
return self.getTypedRuleContext(MathExprParser.CompExprContext,0)
def NE(self):
return self.getToken(MathExprParser.NE, 0)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNeExp" ):
return visitor.visitNeExp(self)
else:
return visitor.visitChildren(self)
class GtExpContext(CompExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.CompExprContext
super().__init__(parser)
self.copyFrom(ctx)
def compExpr(self):
return self.getTypedRuleContext(MathExprParser.CompExprContext,0)
def GT(self):
return self.getToken(MathExprParser.GT, 0)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGtExp" ):
return visitor.visitGtExp(self)
else:
return visitor.visitChildren(self)
def compExpr(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = MathExprParser.CompExprContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 8
self.enterRecursionRule(localctx, 8, self.RULE_compExpr, _p)
try:
self.enterOuterAlt(localctx, 1)
localctx = MathExprParser.ToAddContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 66
self.addExpr(0)
self._ctx.stop = self._input.LT(-1)
self.state = 88
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,5,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 86
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
if la_ == 1:
localctx = MathExprParser.GtExpContext(self, MathExprParser.CompExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_compExpr)
self.state = 68
if not self.precpred(self._ctx, 7):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
self.state = 69
self.match(MathExprParser.GT)
self.state = 70
self.addExpr(0)
pass
elif la_ == 2:
localctx = MathExprParser.GeExpContext(self, MathExprParser.CompExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_compExpr)
self.state = 71
if not self.precpred(self._ctx, 6):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
self.state = 72
self.match(MathExprParser.GE)
self.state = 73
self.addExpr(0)
pass
elif la_ == 3:
localctx = MathExprParser.LtExpContext(self, MathExprParser.CompExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_compExpr)
self.state = 74
if not self.precpred(self._ctx, 5):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
self.state = 75
self.match(MathExprParser.LT)
self.state = 76
self.addExpr(0)
pass
elif la_ == 4:
localctx = MathExprParser.LeExpContext(self, MathExprParser.CompExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_compExpr)
self.state = 77
if not self.precpred(self._ctx, 4):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
self.state = 78
self.match(MathExprParser.LE)
self.state = 79
self.addExpr(0)
pass
elif la_ == 5:
localctx = MathExprParser.EqExpContext(self, MathExprParser.CompExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_compExpr)
self.state = 80
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 81
self.match(MathExprParser.EQ)
self.state = 82
self.addExpr(0)
pass
elif la_ == 6:
localctx = MathExprParser.NeExpContext(self, MathExprParser.CompExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_compExpr)
self.state = 83
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 84
self.match(MathExprParser.NE)
self.state = 85
self.addExpr(0)
pass
self.state = 90
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,5,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class AddExprContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_addExpr
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class AddExpContext(AddExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AddExprContext
super().__init__(parser)
self.copyFrom(ctx)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def PLUS(self):
return self.getToken(MathExprParser.PLUS, 0)
def mulExpr(self):
return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAddExp" ):
return visitor.visitAddExp(self)
else:
return visitor.visitChildren(self)
class ToMulContext(AddExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AddExprContext
super().__init__(parser)
self.copyFrom(ctx)
def mulExpr(self):
return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitToMul" ):
return visitor.visitToMul(self)
else:
return visitor.visitChildren(self)
class SubExpContext(AddExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AddExprContext
super().__init__(parser)
self.copyFrom(ctx)
def addExpr(self):
return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
def MINUS(self):
return self.getToken(MathExprParser.MINUS, 0)
def mulExpr(self):
return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubExp" ):
return visitor.visitSubExp(self)
else:
return visitor.visitChildren(self)
def addExpr(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = MathExprParser.AddExprContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 10
self.enterRecursionRule(localctx, 10, self.RULE_addExpr, _p)
try:
self.enterOuterAlt(localctx, 1)
localctx = MathExprParser.ToMulContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 92
self.mulExpr(0)
self._ctx.stop = self._input.LT(-1)
self.state = 102
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,7,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 100
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
if la_ == 1:
localctx = MathExprParser.AddExpContext(self, MathExprParser.AddExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_addExpr)
self.state = 94
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 95
self.match(MathExprParser.PLUS)
self.state = 96
self.mulExpr(0)
pass
elif la_ == 2:
localctx = MathExprParser.SubExpContext(self, MathExprParser.AddExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_addExpr)
self.state = 97
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 98
self.match(MathExprParser.MINUS)
self.state = 99
self.mulExpr(0)
pass
self.state = 104
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,7,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class MulExprContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_mulExpr
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class MulExpContext(MulExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.MulExprContext
super().__init__(parser)
self.copyFrom(ctx)
def mulExpr(self):
return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
def MULT(self):
return self.getToken(MathExprParser.MULT, 0)
def powExpr(self):
return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMulExp" ):
return visitor.visitMulExp(self)
else:
return visitor.visitChildren(self)
class ModExpContext(MulExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.MulExprContext
super().__init__(parser)
self.copyFrom(ctx)
def mulExpr(self):
return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
def MOD(self):
return self.getToken(MathExprParser.MOD, 0)
def powExpr(self):
return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitModExp" ):
return visitor.visitModExp(self)
else:
return visitor.visitChildren(self)
class DivExpContext(MulExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.MulExprContext
super().__init__(parser)
self.copyFrom(ctx)
def mulExpr(self):
return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
def DIV(self):
return self.getToken(MathExprParser.DIV, 0)
def powExpr(self):
return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDivExp" ):
return visitor.visitDivExp(self)
else:
return visitor.visitChildren(self)
class ToPowContext(MulExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.MulExprContext
super().__init__(parser)
self.copyFrom(ctx)
def powExpr(self):
return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitToPow" ):
return visitor.visitToPow(self)
else:
return visitor.visitChildren(self)
def mulExpr(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = MathExprParser.MulExprContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 12
self.enterRecursionRule(localctx, 12, self.RULE_mulExpr, _p)
try:
self.enterOuterAlt(localctx, 1)
localctx = MathExprParser.ToPowContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 106
self.powExpr()
self._ctx.stop = self._input.LT(-1)
self.state = 119
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,9,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 117
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
if la_ == 1:
localctx = MathExprParser.MulExpContext(self, MathExprParser.MulExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_mulExpr)
self.state = 108
if not self.precpred(self._ctx, 4):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
self.state = 109
self.match(MathExprParser.MULT)
self.state = 110
self.powExpr()
pass
elif la_ == 2:
localctx = MathExprParser.DivExpContext(self, MathExprParser.MulExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_mulExpr)
self.state = 111
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 112
self.match(MathExprParser.DIV)
self.state = 113
self.powExpr()
pass
elif la_ == 3:
localctx = MathExprParser.ModExpContext(self, MathExprParser.MulExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_mulExpr)
self.state = 114
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 115
self.match(MathExprParser.MOD)
self.state = 116
self.powExpr()
pass
self.state = 121
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,9,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class PowExprContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_powExpr
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class PowExpContext(PowExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.PowExprContext
super().__init__(parser)
self.copyFrom(ctx)
def unaryExpr(self):
return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0)
def POW(self):
return self.getToken(MathExprParser.POW, 0)
def powExpr(self):
return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPowExp" ):
return visitor.visitPowExp(self)
else:
return visitor.visitChildren(self)
class ToUnaryContext(PowExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.PowExprContext
super().__init__(parser)
self.copyFrom(ctx)
def unaryExpr(self):
return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitToUnary" ):
return visitor.visitToUnary(self)
else:
return visitor.visitChildren(self)
def powExpr(self):
localctx = MathExprParser.PowExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_powExpr)
try:
self.state = 127
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
if la_ == 1:
localctx = MathExprParser.PowExpContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 122
self.unaryExpr()
self.state = 123
self.match(MathExprParser.POW)
self.state = 124
self.powExpr()
pass
elif la_ == 2:
localctx = MathExprParser.ToUnaryContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 126
self.unaryExpr()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class UnaryExprContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_unaryExpr
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class UnaryPlusContext(UnaryExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.UnaryExprContext
super().__init__(parser)
self.copyFrom(ctx)
def PLUS(self):
return self.getToken(MathExprParser.PLUS, 0)
def unaryExpr(self):
return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnaryPlus" ):
return visitor.visitUnaryPlus(self)
else:
return visitor.visitChildren(self)
class UnaryMinusContext(UnaryExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.UnaryExprContext
super().__init__(parser)
self.copyFrom(ctx)
def MINUS(self):
return self.getToken(MathExprParser.MINUS, 0)
def unaryExpr(self):
return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnaryMinus" ):
return visitor.visitUnaryMinus(self)
else:
return visitor.visitChildren(self)
class ToIndexContext(UnaryExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.UnaryExprContext
super().__init__(parser)
self.copyFrom(ctx)
def indexExpr(self):
return self.getTypedRuleContext(MathExprParser.IndexExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitToIndex" ):
return visitor.visitToIndex(self)
else:
return visitor.visitChildren(self)
def unaryExpr(self):
localctx = MathExprParser.UnaryExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_unaryExpr)
try:
self.state = 134
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [68]:
localctx = MathExprParser.UnaryPlusContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 129
self.match(MathExprParser.PLUS)
self.state = 130
self.unaryExpr()
pass
elif token in [69]:
localctx = MathExprParser.UnaryMinusContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 131
self.match(MathExprParser.MINUS)
self.state = 132
self.unaryExpr()
pass
elif token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 80, 81, 86, 88, 89, 90]:
localctx = MathExprParser.ToIndexContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 133
self.indexExpr(0)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class IndexExprContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_indexExpr
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class IndexExpContext(IndexExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.IndexExprContext
super().__init__(parser)
self.copyFrom(ctx)
def indexExpr(self):
return self.getTypedRuleContext(MathExprParser.IndexExprContext,0)
def LBRACKET(self):
return self.getToken(MathExprParser.LBRACKET, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def RBRACKET(self):
return self.getToken(MathExprParser.RBRACKET, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIndexExp" ):
return visitor.visitIndexExp(self)
else:
return visitor.visitChildren(self)
class ToAtomContext(IndexExprContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.IndexExprContext
super().__init__(parser)
self.copyFrom(ctx)
def atom(self):
return self.getTypedRuleContext(MathExprParser.AtomContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitToAtom" ):
return visitor.visitToAtom(self)
else:
return visitor.visitChildren(self)
def indexExpr(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = MathExprParser.IndexExprContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 18
self.enterRecursionRule(localctx, 18, self.RULE_indexExpr, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
localctx = MathExprParser.ToAtomContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 137
self.atom()
self._ctx.stop = self._input.LT(-1)
self.state = 153
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,13,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = MathExprParser.IndexExpContext(self, MathExprParser.IndexExprContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_indexExpr)
self.state = 139
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 140
self.match(MathExprParser.LBRACKET)
self.state = 141
self.expr()
self.state = 146
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==83:
self.state = 142
self.match(MathExprParser.COMMA)
self.state = 143
self.expr()
self.state = 148
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 149
self.match(MathExprParser.RBRACKET)
self.state = 155
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,13,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class AtomContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_atom
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class Func4ExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def func4(self):
return self.getTypedRuleContext(MathExprParser.Func4Context,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunc4Exp" ):
return visitor.visitFunc4Exp(self)
else:
return visitor.visitChildren(self)
class Func2ExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def func2(self):
return self.getTypedRuleContext(MathExprParser.Func2Context,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunc2Exp" ):
return visitor.visitFunc2Exp(self)
else:
return visitor.visitChildren(self)
class VariableExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def VARIABLE(self):
return self.getToken(MathExprParser.VARIABLE, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVariableExp" ):
return visitor.visitVariableExp(self)
else:
return visitor.visitChildren(self)
class CallExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def VARIABLE(self):
return self.getToken(MathExprParser.VARIABLE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def exprList(self):
return self.getTypedRuleContext(MathExprParser.ExprListContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCallExp" ):
return visitor.visitCallExp(self)
else:
return visitor.visitChildren(self)
class Func3ExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def func3(self):
return self.getTypedRuleContext(MathExprParser.Func3Context,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunc3Exp" ):
return visitor.visitFunc3Exp(self)
else:
return visitor.visitChildren(self)
class ParenExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParenExp" ):
return visitor.visitParenExp(self)
else:
return visitor.visitChildren(self)
class ConstantExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def CONSTANT(self):
return self.getToken(MathExprParser.CONSTANT, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConstantExp" ):
return visitor.visitConstantExp(self)
else:
return visitor.visitChildren(self)
class Func1ExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def func1(self):
return self.getTypedRuleContext(MathExprParser.Func1Context,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunc1Exp" ):
return visitor.visitFunc1Exp(self)
else:
return visitor.visitChildren(self)
class FuncNExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def funcN(self):
return self.getTypedRuleContext(MathExprParser.FuncNContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFuncNExp" ):
return visitor.visitFuncNExp(self)
else:
return visitor.visitChildren(self)
class NumberExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def NUMBER(self):
return self.getToken(MathExprParser.NUMBER, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNumberExp" ):
return visitor.visitNumberExp(self)
else:
return visitor.visitChildren(self)
class AbsExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def PIPE(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.PIPE)
else:
return self.getToken(MathExprParser.PIPE, i)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAbsExp" ):
return visitor.visitAbsExp(self)
else:
return visitor.visitChildren(self)
class ListExpContext(AtomContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.AtomContext
super().__init__(parser)
self.copyFrom(ctx)
def LBRACKET(self):
return self.getToken(MathExprParser.LBRACKET, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def RBRACKET(self):
return self.getToken(MathExprParser.RBRACKET, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitListExp" ):
return visitor.visitListExp(self)
else:
return visitor.visitChildren(self)
def atom(self):
localctx = MathExprParser.AtomContext(self, self._ctx, self.state)
self.enterRule(localctx, 20, self.RULE_atom)
self._la = 0 # Token type
try:
self.state = 189
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
if la_ == 1:
localctx = MathExprParser.Func1ExpContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 156
self.func1()
pass
elif la_ == 2:
localctx = MathExprParser.Func2ExpContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 157
self.func2()
pass
elif la_ == 3:
localctx = MathExprParser.Func3ExpContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 158
self.func3()
pass
elif la_ == 4:
localctx = MathExprParser.Func4ExpContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 159
self.func4()
pass
elif la_ == 5:
localctx = MathExprParser.FuncNExpContext(self, localctx)
self.enterOuterAlt(localctx, 5)
self.state = 160
self.funcN()
pass
elif la_ == 6:
localctx = MathExprParser.VariableExpContext(self, localctx)
self.enterOuterAlt(localctx, 6)
self.state = 161
self.match(MathExprParser.VARIABLE)
pass
elif la_ == 7:
localctx = MathExprParser.NumberExpContext(self, localctx)
self.enterOuterAlt(localctx, 7)
self.state = 162
self.match(MathExprParser.NUMBER)
pass
elif la_ == 8:
localctx = MathExprParser.ConstantExpContext(self, localctx)
self.enterOuterAlt(localctx, 8)
self.state = 163
self.match(MathExprParser.CONSTANT)
pass
elif la_ == 9:
localctx = MathExprParser.ParenExpContext(self, localctx)
self.enterOuterAlt(localctx, 9)
self.state = 164
self.match(MathExprParser.LPAREN)
self.state = 165
self.expr()
self.state = 166
self.match(MathExprParser.RPAREN)
pass
elif la_ == 10:
localctx = MathExprParser.AbsExpContext(self, localctx)
self.enterOuterAlt(localctx, 10)
self.state = 168
self.match(MathExprParser.PIPE)
self.state = 169
self.expr()
self.state = 170
self.match(MathExprParser.PIPE)
pass
elif la_ == 11:
localctx = MathExprParser.ListExpContext(self, localctx)
self.enterOuterAlt(localctx, 11)
self.state = 172
self.match(MathExprParser.LBRACKET)
self.state = 173
self.expr()
self.state = 178
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==83:
self.state = 174
self.match(MathExprParser.COMMA)
self.state = 175
self.expr()
self.state = 180
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 181
self.match(MathExprParser.RBRACKET)
pass
elif la_ == 12:
localctx = MathExprParser.CallExpContext(self, localctx)
self.enterOuterAlt(localctx, 12)
self.state = 183
self.match(MathExprParser.VARIABLE)
self.state = 184
self.match(MathExprParser.LPAREN)
self.state = 186
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 121831487) != 0):
self.state = 185
self.exprList()
self.state = 188
self.match(MathExprParser.RPAREN)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class ExprListContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def getRuleIndex(self):
return MathExprParser.RULE_exprList
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExprList" ):
return visitor.visitExprList(self)
else:
return visitor.visitChildren(self)
def exprList(self):
localctx = MathExprParser.ExprListContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_exprList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 191
self.expr()
self.state = 196
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==83:
self.state = 192
self.match(MathExprParser.COMMA)
self.state = 193
self.expr()
self.state = 198
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func1Context(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_func1
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class SoftplusFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SOFTPLUS(self):
return self.getToken(MathExprParser.SOFTPLUS, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSoftplusFunc" ):
return visitor.visitSoftplusFunc(self)
else:
return visitor.visitChildren(self)
class SortFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SORT(self):
return self.getToken(MathExprParser.SORT, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSortFunc" ):
return visitor.visitSortFunc(self)
else:
return visitor.visitChildren(self)
class TanhFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def TANH(self):
return self.getToken(MathExprParser.TANH, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTanhFunc" ):
return visitor.visitTanhFunc(self)
else:
return visitor.visitChildren(self)
class AcoshFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ACOSH(self):
return self.getToken(MathExprParser.ACOSH, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAcoshFunc" ):
return visitor.visitAcoshFunc(self)
else:
return visitor.visitChildren(self)
class SqrtFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SQRT(self):
return self.getToken(MathExprParser.SQRT, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSqrtFunc" ):
return visitor.visitSqrtFunc(self)
else:
return visitor.visitChildren(self)
class FloorFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def FLOOR(self):
return self.getToken(MathExprParser.FLOOR, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFloorFunc" ):
return visitor.visitFloorFunc(self)
else:
return visitor.visitChildren(self)
class RoundFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ROUND(self):
return self.getToken(MathExprParser.ROUND, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRoundFunc" ):
return visitor.visitRoundFunc(self)
else:
return visitor.visitChildren(self)
class MeanFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def MEAN(self):
return self.getToken(MathExprParser.MEAN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMeanFunc" ):
return visitor.visitMeanFunc(self)
else:
return visitor.visitChildren(self)
class CeilFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def CEIL(self):
return self.getToken(MathExprParser.CEIL, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCeilFunc" ):
return visitor.visitCeilFunc(self)
else:
return visitor.visitChildren(self)
class GeluFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def GELU(self):
return self.getToken(MathExprParser.GELU, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGeluFunc" ):
return visitor.visitGeluFunc(self)
else:
return visitor.visitChildren(self)
class PrintFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def PRNT(self):
return self.getToken(MathExprParser.PRNT, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPrintFunc" ):
return visitor.visitPrintFunc(self)
else:
return visitor.visitChildren(self)
class AbsFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ABS(self):
return self.getToken(MathExprParser.ABS, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAbsFunc" ):
return visitor.visitAbsFunc(self)
else:
return visitor.visitChildren(self)
class AtanFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ATAN(self):
return self.getToken(MathExprParser.ATAN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAtanFunc" ):
return visitor.visitAtanFunc(self)
else:
return visitor.visitChildren(self)
class ReluFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def RELU(self):
return self.getToken(MathExprParser.RELU, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReluFunc" ):
return visitor.visitReluFunc(self)
else:
return visitor.visitChildren(self)
class SinhFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SINH(self):
return self.getToken(MathExprParser.SINH, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSinhFunc" ):
return visitor.visitSinhFunc(self)
else:
return visitor.visitChildren(self)
class SigmoidFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SIGM(self):
return self.getToken(MathExprParser.SIGM, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSigmoidFunc" ):
return visitor.visitSigmoidFunc(self)
else:
return visitor.visitChildren(self)
class LogFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def LOG(self):
return self.getToken(MathExprParser.LOG, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLogFunc" ):
return visitor.visitLogFunc(self)
else:
return visitor.visitChildren(self)
class LnFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def LN(self):
return self.getToken(MathExprParser.LN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLnFunc" ):
return visitor.visitLnFunc(self)
else:
return visitor.visitChildren(self)
class TNormFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def TNORM(self):
return self.getToken(MathExprParser.TNORM, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTNormFunc" ):
return visitor.visitTNormFunc(self)
else:
return visitor.visitChildren(self)
class SNormFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SNORM(self):
return self.getToken(MathExprParser.SNORM, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSNormFunc" ):
return visitor.visitSNormFunc(self)
else:
return visitor.visitChildren(self)
class SinFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SIN(self):
return self.getToken(MathExprParser.SIN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSinFunc" ):
return visitor.visitSinFunc(self)
else:
return visitor.visitChildren(self)
class StdFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def STD(self):
return self.getToken(MathExprParser.STD, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStdFunc" ):
return visitor.visitStdFunc(self)
else:
return visitor.visitChildren(self)
class AcosFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ACOS(self):
return self.getToken(MathExprParser.ACOS, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAcosFunc" ):
return visitor.visitAcosFunc(self)
else:
return visitor.visitChildren(self)
class CoshFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def COSH(self):
return self.getToken(MathExprParser.COSH, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCoshFunc" ):
return visitor.visitCoshFunc(self)
else:
return visitor.visitChildren(self)
class AnglFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ANGL(self):
return self.getToken(MathExprParser.ANGL, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAnglFunc" ):
return visitor.visitAnglFunc(self)
else:
return visitor.visitChildren(self)
class SumFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SUM(self):
return self.getToken(MathExprParser.SUM, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSumFunc" ):
return visitor.visitSumFunc(self)
else:
return visitor.visitChildren(self)
class SignFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SIGN(self):
return self.getToken(MathExprParser.SIGN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSignFunc" ):
return visitor.visitSignFunc(self)
else:
return visitor.visitChildren(self)
class TanFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def TAN(self):
return self.getToken(MathExprParser.TAN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTanFunc" ):
return visitor.visitTanFunc(self)
else:
return visitor.visitChildren(self)
class PinvFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def PINV(self):
return self.getToken(MathExprParser.PINV, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPinvFunc" ):
return visitor.visitPinvFunc(self)
else:
return visitor.visitChildren(self)
class SifftFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SIFFT(self):
return self.getToken(MathExprParser.SIFFT, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSifftFunc" ):
return visitor.visitSifftFunc(self)
else:
return visitor.visitChildren(self)
class FractFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def FRACT(self):
return self.getToken(MathExprParser.FRACT, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFractFunc" ):
return visitor.visitFractFunc(self)
else:
return visitor.visitChildren(self)
class GammaFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def GAMMA(self):
return self.getToken(MathExprParser.GAMMA, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGammaFunc" ):
return visitor.visitGammaFunc(self)
else:
return visitor.visitChildren(self)
class CosFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def COS(self):
return self.getToken(MathExprParser.COS, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCosFunc" ):
return visitor.visitCosFunc(self)
else:
return visitor.visitChildren(self)
class VarFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def VAR(self):
return self.getToken(MathExprParser.VAR, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVarFunc" ):
return visitor.visitVarFunc(self)
else:
return visitor.visitChildren(self)
class AsinFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ASIN(self):
return self.getToken(MathExprParser.ASIN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAsinFunc" ):
return visitor.visitAsinFunc(self)
else:
return visitor.visitChildren(self)
class AsinhFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ASINH(self):
return self.getToken(MathExprParser.ASINH, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAsinhFunc" ):
return visitor.visitAsinhFunc(self)
else:
return visitor.visitChildren(self)
class SfftFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def SFFT(self):
return self.getToken(MathExprParser.SFFT, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSfftFunc" ):
return visitor.visitSfftFunc(self)
else:
return visitor.visitChildren(self)
class AtanhFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def ATANH(self):
return self.getToken(MathExprParser.ATANH, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAtanhFunc" ):
return visitor.visitAtanhFunc(self)
else:
return visitor.visitChildren(self)
class ExpFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def EXP(self):
return self.getToken(MathExprParser.EXP, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExpFunc" ):
return visitor.visitExpFunc(self)
else:
return visitor.visitChildren(self)
class PrintShapeFuncContext(Func1Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context
super().__init__(parser)
self.copyFrom(ctx)
def PRINT_SHAPE(self):
return self.getToken(MathExprParser.PRINT_SHAPE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self):
return self.getTypedRuleContext(MathExprParser.ExprContext,0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPrintShapeFunc" ):
return visitor.visitPrintShapeFunc(self)
else:
return visitor.visitChildren(self)
def func1(self):
localctx = MathExprParser.Func1Context(self, self._ctx, self.state)
self.enterRule(localctx, 24, self.RULE_func1)
try:
self.state = 399
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [1]:
localctx = MathExprParser.SinFuncContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 199
self.match(MathExprParser.SIN)
self.state = 200
self.match(MathExprParser.LPAREN)
self.state = 201
self.expr()
self.state = 202
self.match(MathExprParser.RPAREN)
pass
elif token in [2]:
localctx = MathExprParser.CosFuncContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 204
self.match(MathExprParser.COS)
self.state = 205
self.match(MathExprParser.LPAREN)
self.state = 206
self.expr()
self.state = 207
self.match(MathExprParser.RPAREN)
pass
elif token in [3]:
localctx = MathExprParser.TanFuncContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 209
self.match(MathExprParser.TAN)
self.state = 210
self.match(MathExprParser.LPAREN)
self.state = 211
self.expr()
self.state = 212
self.match(MathExprParser.RPAREN)
pass
elif token in [4]:
localctx = MathExprParser.AsinFuncContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 214
self.match(MathExprParser.ASIN)
self.state = 215
self.match(MathExprParser.LPAREN)
self.state = 216
self.expr()
self.state = 217
self.match(MathExprParser.RPAREN)
pass
elif token in [5]:
localctx = MathExprParser.AcosFuncContext(self, localctx)
self.enterOuterAlt(localctx, 5)
self.state = 219
self.match(MathExprParser.ACOS)
self.state = 220
self.match(MathExprParser.LPAREN)
self.state = 221
self.expr()
self.state = 222
self.match(MathExprParser.RPAREN)
pass
elif token in [6]:
localctx = MathExprParser.AtanFuncContext(self, localctx)
self.enterOuterAlt(localctx, 6)
self.state = 224
self.match(MathExprParser.ATAN)
self.state = 225
self.match(MathExprParser.LPAREN)
self.state = 226
self.expr()
self.state = 227
self.match(MathExprParser.RPAREN)
pass
elif token in [8]:
localctx = MathExprParser.SinhFuncContext(self, localctx)
self.enterOuterAlt(localctx, 7)
self.state = 229
self.match(MathExprParser.SINH)
self.state = 230
self.match(MathExprParser.LPAREN)
self.state = 231
self.expr()
self.state = 232
self.match(MathExprParser.RPAREN)
pass
elif token in [9]:
localctx = MathExprParser.CoshFuncContext(self, localctx)
self.enterOuterAlt(localctx, 8)
self.state = 234
self.match(MathExprParser.COSH)
self.state = 235
self.match(MathExprParser.LPAREN)
self.state = 236
self.expr()
self.state = 237
self.match(MathExprParser.RPAREN)
pass
elif token in [10]:
localctx = MathExprParser.TanhFuncContext(self, localctx)
self.enterOuterAlt(localctx, 9)
self.state = 239
self.match(MathExprParser.TANH)
self.state = 240
self.match(MathExprParser.LPAREN)
self.state = 241
self.expr()
self.state = 242
self.match(MathExprParser.RPAREN)
pass
elif token in [11]:
localctx = MathExprParser.AsinhFuncContext(self, localctx)
self.enterOuterAlt(localctx, 10)
self.state = 244
self.match(MathExprParser.ASINH)
self.state = 245
self.match(MathExprParser.LPAREN)
self.state = 246
self.expr()
self.state = 247
self.match(MathExprParser.RPAREN)
pass
elif token in [12]:
localctx = MathExprParser.AcoshFuncContext(self, localctx)
self.enterOuterAlt(localctx, 11)
self.state = 249
self.match(MathExprParser.ACOSH)
self.state = 250
self.match(MathExprParser.LPAREN)
self.state = 251
self.expr()
self.state = 252
self.match(MathExprParser.RPAREN)
pass
elif token in [13]:
localctx = MathExprParser.AtanhFuncContext(self, localctx)
self.enterOuterAlt(localctx, 12)
self.state = 254
self.match(MathExprParser.ATANH)
self.state = 255
self.match(MathExprParser.LPAREN)
self.state = 256
self.expr()
self.state = 257
self.match(MathExprParser.RPAREN)
pass
elif token in [14]:
localctx = MathExprParser.AbsFuncContext(self, localctx)
self.enterOuterAlt(localctx, 13)
self.state = 259
self.match(MathExprParser.ABS)
self.state = 260
self.match(MathExprParser.LPAREN)
self.state = 261
self.expr()
self.state = 262
self.match(MathExprParser.RPAREN)
pass
elif token in [15]:
localctx = MathExprParser.SqrtFuncContext(self, localctx)
self.enterOuterAlt(localctx, 14)
self.state = 264
self.match(MathExprParser.SQRT)
self.state = 265
self.match(MathExprParser.LPAREN)
self.state = 266
self.expr()
self.state = 267
self.match(MathExprParser.RPAREN)
pass
elif token in [16]:
localctx = MathExprParser.LnFuncContext(self, localctx)
self.enterOuterAlt(localctx, 15)
self.state = 269
self.match(MathExprParser.LN)
self.state = 270
self.match(MathExprParser.LPAREN)
self.state = 271
self.expr()
self.state = 272
self.match(MathExprParser.RPAREN)
pass
elif token in [17]:
localctx = MathExprParser.LogFuncContext(self, localctx)
self.enterOuterAlt(localctx, 16)
self.state = 274
self.match(MathExprParser.LOG)
self.state = 275
self.match(MathExprParser.LPAREN)
self.state = 276
self.expr()
self.state = 277
self.match(MathExprParser.RPAREN)
pass
elif token in [18]:
localctx = MathExprParser.ExpFuncContext(self, localctx)
self.enterOuterAlt(localctx, 17)
self.state = 279
self.match(MathExprParser.EXP)
self.state = 280
self.match(MathExprParser.LPAREN)
self.state = 281
self.expr()
self.state = 282
self.match(MathExprParser.RPAREN)
pass
elif token in [23]:
localctx = MathExprParser.TNormFuncContext(self, localctx)
self.enterOuterAlt(localctx, 18)
self.state = 284
self.match(MathExprParser.TNORM)
self.state = 285
self.match(MathExprParser.LPAREN)
self.state = 286
self.expr()
self.state = 287
self.match(MathExprParser.RPAREN)
pass
elif token in [24]:
localctx = MathExprParser.SNormFuncContext(self, localctx)
self.enterOuterAlt(localctx, 19)
self.state = 289
self.match(MathExprParser.SNORM)
self.state = 290
self.match(MathExprParser.LPAREN)
self.state = 291
self.expr()
self.state = 292
self.match(MathExprParser.RPAREN)
pass
elif token in [25]:
localctx = MathExprParser.FloorFuncContext(self, localctx)
self.enterOuterAlt(localctx, 20)
self.state = 294
self.match(MathExprParser.FLOOR)
self.state = 295
self.match(MathExprParser.LPAREN)
self.state = 296
self.expr()
self.state = 297
self.match(MathExprParser.RPAREN)
pass
elif token in [26]:
localctx = MathExprParser.CeilFuncContext(self, localctx)
self.enterOuterAlt(localctx, 21)
self.state = 299
self.match(MathExprParser.CEIL)
self.state = 300
self.match(MathExprParser.LPAREN)
self.state = 301
self.expr()
self.state = 302
self.match(MathExprParser.RPAREN)
pass
elif token in [27]:
localctx = MathExprParser.RoundFuncContext(self, localctx)
self.enterOuterAlt(localctx, 22)
self.state = 304
self.match(MathExprParser.ROUND)
self.state = 305
self.match(MathExprParser.LPAREN)
self.state = 306
self.expr()
self.state = 307
self.match(MathExprParser.RPAREN)
pass
elif token in [28]:
localctx = MathExprParser.GammaFuncContext(self, localctx)
self.enterOuterAlt(localctx, 23)
self.state = 309
self.match(MathExprParser.GAMMA)
self.state = 310
self.match(MathExprParser.LPAREN)
self.state = 311
self.expr()
self.state = 312
self.match(MathExprParser.RPAREN)
pass
elif token in [30]:
localctx = MathExprParser.SigmoidFuncContext(self, localctx)
self.enterOuterAlt(localctx, 24)
self.state = 314
self.match(MathExprParser.SIGM)
self.state = 315
self.match(MathExprParser.LPAREN)
self.state = 316
self.expr()
self.state = 317
self.match(MathExprParser.RPAREN)
pass
elif token in [32]:
localctx = MathExprParser.SfftFuncContext(self, localctx)
self.enterOuterAlt(localctx, 25)
self.state = 319
self.match(MathExprParser.SFFT)
self.state = 320
self.match(MathExprParser.LPAREN)
self.state = 321
self.expr()
self.state = 322
self.match(MathExprParser.RPAREN)
pass
elif token in [33]:
localctx = MathExprParser.SifftFuncContext(self, localctx)
self.enterOuterAlt(localctx, 26)
self.state = 324
self.match(MathExprParser.SIFFT)
self.state = 325
self.match(MathExprParser.LPAREN)
self.state = 326
self.expr()
self.state = 327
self.match(MathExprParser.RPAREN)
pass
elif token in [34]:
localctx = MathExprParser.AnglFuncContext(self, localctx)
self.enterOuterAlt(localctx, 27)
self.state = 329
self.match(MathExprParser.ANGL)
self.state = 330
self.match(MathExprParser.LPAREN)
self.state = 331
self.expr()
self.state = 332
self.match(MathExprParser.RPAREN)
pass
elif token in [35]:
localctx = MathExprParser.PrintFuncContext(self, localctx)
self.enterOuterAlt(localctx, 28)
self.state = 334
self.match(MathExprParser.PRNT)
self.state = 335
self.match(MathExprParser.LPAREN)
self.state = 336
self.expr()
self.state = 337
self.match(MathExprParser.RPAREN)
pass
elif token in [40]:
localctx = MathExprParser.FractFuncContext(self, localctx)
self.enterOuterAlt(localctx, 29)
self.state = 339
self.match(MathExprParser.FRACT)
self.state = 340
self.match(MathExprParser.LPAREN)
self.state = 341
self.expr()
self.state = 342
self.match(MathExprParser.RPAREN)
pass
elif token in [41]:
localctx = MathExprParser.ReluFuncContext(self, localctx)
self.enterOuterAlt(localctx, 30)
self.state = 344
self.match(MathExprParser.RELU)
self.state = 345
self.match(MathExprParser.LPAREN)
self.state = 346
self.expr()
self.state = 347
self.match(MathExprParser.RPAREN)
pass
elif token in [42]:
localctx = MathExprParser.SoftplusFuncContext(self, localctx)
self.enterOuterAlt(localctx, 31)
self.state = 349
self.match(MathExprParser.SOFTPLUS)
self.state = 350
self.match(MathExprParser.LPAREN)
self.state = 351
self.expr()
self.state = 352
self.match(MathExprParser.RPAREN)
pass
elif token in [43]:
localctx = MathExprParser.GeluFuncContext(self, localctx)
self.enterOuterAlt(localctx, 32)
self.state = 354
self.match(MathExprParser.GELU)
self.state = 355
self.match(MathExprParser.LPAREN)
self.state = 356
self.expr()
self.state = 357
self.match(MathExprParser.RPAREN)
pass
elif token in [44]:
localctx = MathExprParser.SignFuncContext(self, localctx)
self.enterOuterAlt(localctx, 33)
self.state = 359
self.match(MathExprParser.SIGN)
self.state = 360
self.match(MathExprParser.LPAREN)
self.state = 361
self.expr()
self.state = 362
self.match(MathExprParser.RPAREN)
pass
elif token in [36]:
localctx = MathExprParser.PrintShapeFuncContext(self, localctx)
self.enterOuterAlt(localctx, 34)
self.state = 364
self.match(MathExprParser.PRINT_SHAPE)
self.state = 365
self.match(MathExprParser.LPAREN)
self.state = 366
self.expr()
self.state = 367
self.match(MathExprParser.RPAREN)
pass
elif token in [54]:
localctx = MathExprParser.PinvFuncContext(self, localctx)
self.enterOuterAlt(localctx, 35)
self.state = 369
self.match(MathExprParser.PINV)
self.state = 370
self.match(MathExprParser.LPAREN)
self.state = 371
self.expr()
self.state = 372
self.match(MathExprParser.RPAREN)
pass
elif token in [55]:
localctx = MathExprParser.SumFuncContext(self, localctx)
self.enterOuterAlt(localctx, 36)
self.state = 374
self.match(MathExprParser.SUM)
self.state = 375
self.match(MathExprParser.LPAREN)
self.state = 376
self.expr()
self.state = 377
self.match(MathExprParser.RPAREN)
pass
elif token in [56]:
localctx = MathExprParser.MeanFuncContext(self, localctx)
self.enterOuterAlt(localctx, 37)
self.state = 379
self.match(MathExprParser.MEAN)
self.state = 380
self.match(MathExprParser.LPAREN)
self.state = 381
self.expr()
self.state = 382
self.match(MathExprParser.RPAREN)
pass
elif token in [57]:
localctx = MathExprParser.StdFuncContext(self, localctx)
self.enterOuterAlt(localctx, 38)
self.state = 384
self.match(MathExprParser.STD)
self.state = 385
self.match(MathExprParser.LPAREN)
self.state = 386
self.expr()
self.state = 387
self.match(MathExprParser.RPAREN)
pass
elif token in [58]:
localctx = MathExprParser.VarFuncContext(self, localctx)
self.enterOuterAlt(localctx, 39)
self.state = 389
self.match(MathExprParser.VAR)
self.state = 390
self.match(MathExprParser.LPAREN)
self.state = 391
self.expr()
self.state = 392
self.match(MathExprParser.RPAREN)
pass
elif token in [67]:
localctx = MathExprParser.SortFuncContext(self, localctx)
self.enterOuterAlt(localctx, 40)
self.state = 394
self.match(MathExprParser.SORT)
self.state = 395
self.match(MathExprParser.LPAREN)
self.state = 396
self.expr()
self.state = 397
self.match(MathExprParser.RPAREN)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func2Context(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_func2
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class TopkFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def TOPK(self):
return self.getToken(MathExprParser.TOPK, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTopkFunc" ):
return visitor.visitTopkFunc(self)
else:
return visitor.visitChildren(self)
class PercentileFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def PERCENTILE(self):
return self.getToken(MathExprParser.PERCENTILE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPercentileFunc" ):
return visitor.visitPercentileFunc(self)
else:
return visitor.visitChildren(self)
class CovFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def COV(self):
return self.getToken(MathExprParser.COV, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCovFunc" ):
return visitor.visitCovFunc(self)
else:
return visitor.visitChildren(self)
class StepFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def STEP(self):
return self.getToken(MathExprParser.STEP, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStepFunc" ):
return visitor.visitStepFunc(self)
else:
return visitor.visitChildren(self)
class Atan2FuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def ATAN2(self):
return self.getToken(MathExprParser.ATAN2, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAtan2Func" ):
return visitor.visitAtan2Func(self)
else:
return visitor.visitChildren(self)
class QuantileFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def QUANTILE(self):
return self.getToken(MathExprParser.QUANTILE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitQuantileFunc" ):
return visitor.visitQuantileFunc(self)
else:
return visitor.visitChildren(self)
class BotkFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def BOTK(self):
return self.getToken(MathExprParser.BOTK, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBotkFunc" ):
return visitor.visitBotkFunc(self)
else:
return visitor.visitChildren(self)
class TMaxFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def TMAX(self):
return self.getToken(MathExprParser.TMAX, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTMaxFunc" ):
return visitor.visitTMaxFunc(self)
else:
return visitor.visitChildren(self)
class CossimFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def COSSIM(self):
return self.getToken(MathExprParser.COSSIM, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCossimFunc" ):
return visitor.visitCossimFunc(self)
else:
return visitor.visitChildren(self)
class PowFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def POWE(self):
return self.getToken(MathExprParser.POWE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPowFunc" ):
return visitor.visitPowFunc(self)
else:
return visitor.visitChildren(self)
class DotFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def DOT(self):
return self.getToken(MathExprParser.DOT, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDotFunc" ):
return visitor.visitDotFunc(self)
else:
return visitor.visitChildren(self)
class FlipFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def FLIP(self):
return self.getToken(MathExprParser.FLIP, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFlipFunc" ):
return visitor.visitFlipFunc(self)
else:
return visitor.visitChildren(self)
class QuartileFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def QUARTILE(self):
return self.getToken(MathExprParser.QUARTILE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitQuartileFunc" ):
return visitor.visitQuartileFunc(self)
else:
return visitor.visitChildren(self)
class TMinFuncContext(Func2Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func2Context
super().__init__(parser)
self.copyFrom(ctx)
def TMIN(self):
return self.getToken(MathExprParser.TMIN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTMinFunc" ):
return visitor.visitTMinFunc(self)
else:
return visitor.visitChildren(self)
def func2(self):
localctx = MathExprParser.Func2Context(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_func2)
try:
self.state = 506
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
if la_ == 1:
localctx = MathExprParser.PowFuncContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 401
self.match(MathExprParser.POWE)
self.state = 402
self.match(MathExprParser.LPAREN)
self.state = 403
self.expr()
self.state = 404
self.match(MathExprParser.COMMA)
self.state = 405
self.expr()
self.state = 406
self.match(MathExprParser.RPAREN)
pass
elif la_ == 2:
localctx = MathExprParser.Atan2FuncContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 408
self.match(MathExprParser.ATAN2)
self.state = 409
self.match(MathExprParser.LPAREN)
self.state = 410
self.expr()
self.state = 411
self.match(MathExprParser.COMMA)
self.state = 412
self.expr()
self.state = 413
self.match(MathExprParser.RPAREN)
pass
elif la_ == 3:
localctx = MathExprParser.TMinFuncContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 415
self.match(MathExprParser.TMIN)
self.state = 416
self.match(MathExprParser.LPAREN)
self.state = 417
self.expr()
self.state = 418
self.match(MathExprParser.COMMA)
self.state = 419
self.expr()
self.state = 420
self.match(MathExprParser.RPAREN)
pass
elif la_ == 4:
localctx = MathExprParser.TMaxFuncContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 422
self.match(MathExprParser.TMAX)
self.state = 423
self.match(MathExprParser.LPAREN)
self.state = 424
self.expr()
self.state = 425
self.match(MathExprParser.COMMA)
self.state = 426
self.expr()
self.state = 427
self.match(MathExprParser.RPAREN)
pass
elif la_ == 5:
localctx = MathExprParser.StepFuncContext(self, localctx)
self.enterOuterAlt(localctx, 5)
self.state = 429
self.match(MathExprParser.STEP)
self.state = 430
self.match(MathExprParser.LPAREN)
self.state = 431
self.expr()
self.state = 432
self.match(MathExprParser.COMMA)
self.state = 433
self.expr()
self.state = 434
self.match(MathExprParser.RPAREN)
pass
elif la_ == 6:
localctx = MathExprParser.TopkFuncContext(self, localctx)
self.enterOuterAlt(localctx, 6)
self.state = 436
self.match(MathExprParser.TOPK)
self.state = 437
self.match(MathExprParser.LPAREN)
self.state = 438
self.expr()
self.state = 439
self.match(MathExprParser.COMMA)
self.state = 440
self.expr()
self.state = 441
self.match(MathExprParser.RPAREN)
pass
elif la_ == 7:
localctx = MathExprParser.BotkFuncContext(self, localctx)
self.enterOuterAlt(localctx, 7)
self.state = 443
self.match(MathExprParser.BOTK)
self.state = 444
self.match(MathExprParser.LPAREN)
self.state = 445
self.expr()
self.state = 446
self.match(MathExprParser.COMMA)
self.state = 447
self.expr()
self.state = 448
self.match(MathExprParser.RPAREN)
pass
elif la_ == 8:
localctx = MathExprParser.QuartileFuncContext(self, localctx)
self.enterOuterAlt(localctx, 8)
self.state = 450
self.match(MathExprParser.QUARTILE)
self.state = 451
self.match(MathExprParser.LPAREN)
self.state = 452
self.expr()
self.state = 453
self.match(MathExprParser.COMMA)
self.state = 454
self.expr()
self.state = 455
self.match(MathExprParser.RPAREN)
pass
elif la_ == 9:
localctx = MathExprParser.PercentileFuncContext(self, localctx)
self.enterOuterAlt(localctx, 9)
self.state = 457
self.match(MathExprParser.PERCENTILE)
self.state = 458
self.match(MathExprParser.LPAREN)
self.state = 459
self.expr()
self.state = 460
self.match(MathExprParser.COMMA)
self.state = 461
self.expr()
self.state = 462
self.match(MathExprParser.RPAREN)
pass
elif la_ == 10:
localctx = MathExprParser.QuantileFuncContext(self, localctx)
self.enterOuterAlt(localctx, 10)
self.state = 464
self.match(MathExprParser.QUANTILE)
self.state = 465
self.match(MathExprParser.LPAREN)
self.state = 466
self.expr()
self.state = 467
self.match(MathExprParser.COMMA)
self.state = 468
self.expr()
self.state = 469
self.match(MathExprParser.RPAREN)
pass
elif la_ == 11:
localctx = MathExprParser.QuantileFuncContext(self, localctx)
self.enterOuterAlt(localctx, 11)
self.state = 471
self.match(MathExprParser.QUANTILE)
self.state = 472
self.match(MathExprParser.LPAREN)
self.state = 473
self.expr()
self.state = 474
self.match(MathExprParser.COMMA)
self.state = 475
self.expr()
self.state = 476
self.match(MathExprParser.RPAREN)
pass
elif la_ == 12:
localctx = MathExprParser.DotFuncContext(self, localctx)
self.enterOuterAlt(localctx, 12)
self.state = 478
self.match(MathExprParser.DOT)
self.state = 479
self.match(MathExprParser.LPAREN)
self.state = 480
self.expr()
self.state = 481
self.match(MathExprParser.COMMA)
self.state = 482
self.expr()
self.state = 483
self.match(MathExprParser.RPAREN)
pass
elif la_ == 13:
localctx = MathExprParser.CossimFuncContext(self, localctx)
self.enterOuterAlt(localctx, 13)
self.state = 485
self.match(MathExprParser.COSSIM)
self.state = 486
self.match(MathExprParser.LPAREN)
self.state = 487
self.expr()
self.state = 488
self.match(MathExprParser.COMMA)
self.state = 489
self.expr()
self.state = 490
self.match(MathExprParser.RPAREN)
pass
elif la_ == 14:
localctx = MathExprParser.FlipFuncContext(self, localctx)
self.enterOuterAlt(localctx, 14)
self.state = 492
self.match(MathExprParser.FLIP)
self.state = 493
self.match(MathExprParser.LPAREN)
self.state = 494
self.expr()
self.state = 495
self.match(MathExprParser.COMMA)
self.state = 496
self.expr()
self.state = 497
self.match(MathExprParser.RPAREN)
pass
elif la_ == 15:
localctx = MathExprParser.CovFuncContext(self, localctx)
self.enterOuterAlt(localctx, 15)
self.state = 499
self.match(MathExprParser.COV)
self.state = 500
self.match(MathExprParser.LPAREN)
self.state = 501
self.expr()
self.state = 502
self.match(MathExprParser.COMMA)
self.state = 503
self.expr()
self.state = 504
self.match(MathExprParser.RPAREN)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func3Context(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_func3
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class MomentFuncContext(Func3Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func3Context
super().__init__(parser)
self.copyFrom(ctx)
def MOMENT(self):
return self.getToken(MathExprParser.MOMENT, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMomentFunc" ):
return visitor.visitMomentFunc(self)
else:
return visitor.visitChildren(self)
class LerpFuncContext(Func3Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func3Context
super().__init__(parser)
self.copyFrom(ctx)
def LERP(self):
return self.getToken(MathExprParser.LERP, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLerpFunc" ):
return visitor.visitLerpFunc(self)
else:
return visitor.visitChildren(self)
class SmoothstepFuncContext(Func3Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func3Context
super().__init__(parser)
self.copyFrom(ctx)
def SMOOTHSTEP(self):
return self.getToken(MathExprParser.SMOOTHSTEP, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSmoothstepFunc" ):
return visitor.visitSmoothstepFunc(self)
else:
return visitor.visitChildren(self)
class RangeFuncContext(Func3Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func3Context
super().__init__(parser)
self.copyFrom(ctx)
def RANGE(self):
return self.getToken(MathExprParser.RANGE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRangeFunc" ):
return visitor.visitRangeFunc(self)
else:
return visitor.visitChildren(self)
class ClampFuncContext(Func3Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func3Context
super().__init__(parser)
self.copyFrom(ctx)
def CLAMP(self):
return self.getToken(MathExprParser.CLAMP, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClampFunc" ):
return visitor.visitClampFunc(self)
else:
return visitor.visitChildren(self)
def func3(self):
localctx = MathExprParser.Func3Context(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_func3)
try:
self.state = 553
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [31]:
localctx = MathExprParser.ClampFuncContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 508
self.match(MathExprParser.CLAMP)
self.state = 509
self.match(MathExprParser.LPAREN)
self.state = 510
self.expr()
self.state = 511
self.match(MathExprParser.COMMA)
self.state = 512
self.expr()
self.state = 513
self.match(MathExprParser.COMMA)
self.state = 514
self.expr()
self.state = 515
self.match(MathExprParser.RPAREN)
pass
elif token in [37]:
localctx = MathExprParser.LerpFuncContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 517
self.match(MathExprParser.LERP)
self.state = 518
self.match(MathExprParser.LPAREN)
self.state = 519
self.expr()
self.state = 520
self.match(MathExprParser.COMMA)
self.state = 521
self.expr()
self.state = 522
self.match(MathExprParser.COMMA)
self.state = 523
self.expr()
self.state = 524
self.match(MathExprParser.RPAREN)
pass
elif token in [39]:
localctx = MathExprParser.SmoothstepFuncContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 526
self.match(MathExprParser.SMOOTHSTEP)
self.state = 527
self.match(MathExprParser.LPAREN)
self.state = 528
self.expr()
self.state = 529
self.match(MathExprParser.COMMA)
self.state = 530
self.expr()
self.state = 531
self.match(MathExprParser.COMMA)
self.state = 532
self.expr()
self.state = 533
self.match(MathExprParser.RPAREN)
pass
elif token in [51]:
localctx = MathExprParser.RangeFuncContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 535
self.match(MathExprParser.RANGE)
self.state = 536
self.match(MathExprParser.LPAREN)
self.state = 537
self.expr()
self.state = 538
self.match(MathExprParser.COMMA)
self.state = 539
self.expr()
self.state = 540
self.match(MathExprParser.COMMA)
self.state = 541
self.expr()
self.state = 542
self.match(MathExprParser.RPAREN)
pass
elif token in [63]:
localctx = MathExprParser.MomentFuncContext(self, localctx)
self.enterOuterAlt(localctx, 5)
self.state = 544
self.match(MathExprParser.MOMENT)
self.state = 545
self.match(MathExprParser.LPAREN)
self.state = 546
self.expr()
self.state = 547
self.match(MathExprParser.COMMA)
self.state = 548
self.expr()
self.state = 549
self.match(MathExprParser.COMMA)
self.state = 550
self.expr()
self.state = 551
self.match(MathExprParser.RPAREN)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func4Context(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_func4
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class SwapFuncContext(Func4Context):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func4Context
super().__init__(parser)
self.copyFrom(ctx)
def SWAP(self):
return self.getToken(MathExprParser.SWAP, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSwapFunc" ):
return visitor.visitSwapFunc(self)
else:
return visitor.visitChildren(self)
def func4(self):
localctx = MathExprParser.Func4Context(self, self._ctx, self.state)
self.enterRule(localctx, 30, self.RULE_func4)
try:
localctx = MathExprParser.SwapFuncContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 555
self.match(MathExprParser.SWAP)
self.state = 556
self.match(MathExprParser.LPAREN)
self.state = 557
self.expr()
self.state = 558
self.match(MathExprParser.COMMA)
self.state = 559
self.expr()
self.state = 560
self.match(MathExprParser.COMMA)
self.state = 561
self.expr()
self.state = 562
self.match(MathExprParser.COMMA)
self.state = 563
self.expr()
self.state = 564
self.match(MathExprParser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class FuncNContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return MathExprParser.RULE_funcN
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class SMaxFuncContext(FuncNContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.FuncNContext
super().__init__(parser)
self.copyFrom(ctx)
def SMAX(self):
return self.getToken(MathExprParser.SMAX, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSMaxFunc" ):
return visitor.visitSMaxFunc(self)
else:
return visitor.visitChildren(self)
class MapFuncContext(FuncNContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.FuncNContext
super().__init__(parser)
self.copyFrom(ctx)
def MAP(self):
return self.getToken(MathExprParser.MAP, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMapFunc" ):
return visitor.visitMapFunc(self)
else:
return visitor.visitChildren(self)
class EzConvFuncContext(FuncNContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.FuncNContext
super().__init__(parser)
self.copyFrom(ctx)
def EZCONV(self):
return self.getToken(MathExprParser.EZCONV, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEzConvFunc" ):
return visitor.visitEzConvFunc(self)
else:
return visitor.visitChildren(self)
class PermuteFuncContext(FuncNContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.FuncNContext
super().__init__(parser)
self.copyFrom(ctx)
def PERM(self):
return self.getToken(MathExprParser.PERM, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPermuteFunc" ):
return visitor.visitPermuteFunc(self)
else:
return visitor.visitChildren(self)
class ReshapeFuncContext(FuncNContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.FuncNContext
super().__init__(parser)
self.copyFrom(ctx)
def RESHAPE(self):
return self.getToken(MathExprParser.RESHAPE, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def COMMA(self):
return self.getToken(MathExprParser.COMMA, 0)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReshapeFunc" ):
return visitor.visitReshapeFunc(self)
else:
return visitor.visitChildren(self)
class SMinFuncContext(FuncNContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.FuncNContext
super().__init__(parser)
self.copyFrom(ctx)
def SMIN(self):
return self.getToken(MathExprParser.SMIN, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSMinFunc" ):
return visitor.visitSMinFunc(self)
else:
return visitor.visitChildren(self)
class ConvFuncContext(FuncNContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.FuncNContext
super().__init__(parser)
self.copyFrom(ctx)
def CONV(self):
return self.getToken(MathExprParser.CONV, 0)
def LPAREN(self):
return self.getToken(MathExprParser.LPAREN, 0)
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(MathExprParser.ExprContext)
else:
return self.getTypedRuleContext(MathExprParser.ExprContext,i)
def RPAREN(self):
return self.getToken(MathExprParser.RPAREN, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(MathExprParser.COMMA)
else:
return self.getToken(MathExprParser.COMMA, i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConvFunc" ):
return visitor.visitConvFunc(self)
else:
return visitor.visitChildren(self)
def funcN(self):
localctx = MathExprParser.FuncNContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_funcN)
self._la = 0 # Token type
try:
self.state = 637
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [19]:
localctx = MathExprParser.SMinFuncContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 566
self.match(MathExprParser.SMIN)
self.state = 567
self.match(MathExprParser.LPAREN)
self.state = 568
self.expr()
self.state = 573
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==83:
self.state = 569
self.match(MathExprParser.COMMA)
self.state = 570
self.expr()
self.state = 575
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 576
self.match(MathExprParser.RPAREN)
pass
elif token in [20]:
localctx = MathExprParser.SMaxFuncContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 578
self.match(MathExprParser.SMAX)
self.state = 579
self.match(MathExprParser.LPAREN)
self.state = 580
self.expr()
self.state = 585
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==83:
self.state = 581
self.match(MathExprParser.COMMA)
self.state = 582
self.expr()
self.state = 587
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 588
self.match(MathExprParser.RPAREN)
pass
elif token in [45]:
localctx = MathExprParser.MapFuncContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 590
self.match(MathExprParser.MAP)
self.state = 591
self.match(MathExprParser.LPAREN)
self.state = 592
self.expr()
self.state = 595
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 593
self.match(MathExprParser.COMMA)
self.state = 594
self.expr()
self.state = 597
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==83):
break
self.state = 599
self.match(MathExprParser.RPAREN)
pass
elif token in [46]:
localctx = MathExprParser.EzConvFuncContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 601
self.match(MathExprParser.EZCONV)
self.state = 602
self.match(MathExprParser.LPAREN)
self.state = 603
self.expr()
self.state = 606
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 604
self.match(MathExprParser.COMMA)
self.state = 605
self.expr()
self.state = 608
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==83):
break
self.state = 610
self.match(MathExprParser.RPAREN)
pass
elif token in [47]:
localctx = MathExprParser.ConvFuncContext(self, localctx)
self.enterOuterAlt(localctx, 5)
self.state = 612
self.match(MathExprParser.CONV)
self.state = 613
self.match(MathExprParser.LPAREN)
self.state = 614
self.expr()
self.state = 617
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 615
self.match(MathExprParser.COMMA)
self.state = 616
self.expr()
self.state = 619
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==83):
break
self.state = 621
self.match(MathExprParser.RPAREN)
pass
elif token in [49]:
localctx = MathExprParser.PermuteFuncContext(self, localctx)
self.enterOuterAlt(localctx, 6)
self.state = 623
self.match(MathExprParser.PERM)
self.state = 624
self.match(MathExprParser.LPAREN)
self.state = 625
self.expr()
self.state = 626
self.match(MathExprParser.COMMA)
self.state = 627
self.expr()
self.state = 628
self.match(MathExprParser.RPAREN)
pass
elif token in [50]:
localctx = MathExprParser.ReshapeFuncContext(self, localctx)
self.enterOuterAlt(localctx, 7)
self.state = 630
self.match(MathExprParser.RESHAPE)
self.state = 631
self.match(MathExprParser.LPAREN)
self.state = 632
self.expr()
self.state = 633
self.match(MathExprParser.COMMA)
self.state = 634
self.expr()
self.state = 635
self.match(MathExprParser.RPAREN)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
if self._predicates == None:
self._predicates = dict()
self._predicates[4] = self.compExpr_sempred
self._predicates[5] = self.addExpr_sempred
self._predicates[6] = self.mulExpr_sempred
self._predicates[9] = self.indexExpr_sempred
pred = self._predicates.get(ruleIndex, None)
if pred is None:
raise Exception("No predicate with index:" + str(ruleIndex))
else:
return pred(localctx, predIndex)
def compExpr_sempred(self, localctx:CompExprContext, predIndex:int):
if predIndex == 0:
return self.precpred(self._ctx, 7)
if predIndex == 1:
return self.precpred(self._ctx, 6)
if predIndex == 2:
return self.precpred(self._ctx, 5)
if predIndex == 3:
return self.precpred(self._ctx, 4)
if predIndex == 4:
return self.precpred(self._ctx, 3)
if predIndex == 5:
return self.precpred(self._ctx, 2)
def addExpr_sempred(self, localctx:AddExprContext, predIndex:int):
if predIndex == 6:
return self.precpred(self._ctx, 3)
if predIndex == 7:
return self.precpred(self._ctx, 2)
def mulExpr_sempred(self, localctx:MulExprContext, predIndex:int):
if predIndex == 8:
return self.precpred(self._ctx, 4)
if predIndex == 9:
return self.precpred(self._ctx, 3)
if predIndex == 10:
return self.precpred(self._ctx, 2)
def indexExpr_sempred(self, localctx:IndexExprContext, predIndex:int):
if predIndex == 11:
return self.precpred(self._ctx, 2)
Reference in New Issue View Git Blame Copy Permalink