diff --git a/README.md b/README.md index 9e06672..e1352e8 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,9 @@ You can also get the node from comfy manager under the name of More math. - Hyperbolic: `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh` - Aggregates: `smin`, `smax` , `snorm` (scalar), `tmin`, `tmax`, `tnorm` (elementwise) - Other: `floor`, `ceil`, `round`, `gamma`, `clamp`, `sigm` (sigmoid) `fft` (N-D FFT on non-batch/channel dims), `ifft` (Inverse N-D FFT, returns real component), `angle` (in ifft only) +- Shaders: `lerp(a, b, w)`, `step(edge, x)`, `smoothstep(edge0, edge1, x)`, `fract(x)` +- ML: `relu(x)`, `softplus(x)`, `gelu(x)`, `sign(x)` +- Tensor: `swap(tensor, dim, index1, index2)` (swaps two slices of a tensor along a dimension) ## Variables - **common inputs** (matches node input type): @@ -66,3 +69,9 @@ You can also get the node from comfy manager under the name of More math. - no additional variables - Constants: `e`, `pi` + +## Examples + +### Swap Red and Blue Channels +`swap(a, 1, 0, 2)` +*(for ImageMathNode, where dim 1 is Channel)* diff --git a/src/more_math/Parser/FloatEvalVisitor.py b/src/more_math/Parser/FloatEvalVisitor.py index 20fb22a..1a318f3 100644 --- a/src/more_math/Parser/FloatEvalVisitor.py +++ b/src/more_math/Parser/FloatEvalVisitor.py @@ -114,7 +114,24 @@ class FloatEvalVisitor(MathExprVisitor): def visitExpFunc(self, ctx): return math.exp(self.visit(ctx.expr())) def visitNormFunc(self, ctx): return math.sqrt(math.avg(x**2 for x in self.visit(ctx.expr()))) def visitFloorFunc(self, ctx): return math.floor(self.visit(ctx.expr())) + def visitFractFunc(self, ctx): + val = self.visit(ctx.expr()) + return val - math.floor(val) def visitSigmoidFunc(self, ctx): return 1/(1+math.exp(-self.visit(ctx.expr()))) + def visitReluFunc(self, ctx): return max(0.0, self.visit(ctx.expr())) + def visitSoftplusFunc(self, ctx): + # log(1 + exp(x)) + x = self.visit(ctx.expr()) + # stability check? math.log1p(math.exp(x)) is better but might overflow for large x + if x > 20: return x + return math.log(1 + math.exp(x)) + def visitGeluFunc(self, ctx): + # 0.5 * x * (1 + erf(x / sqrt(2))) + x = self.visit(ctx.expr()) + return 0.5 * x * (1 + math.erf(x / 1.4142135623730951)) + def visitSignFunc(self, ctx): + x = self.visit(ctx.expr()) + return math.copysign(1.0, x) if x != 0 else 0.0 def visitCeilFunc(self, ctx): return math.ceil(self.visit(ctx.expr())) def visitRoundFunc(self, ctx): return math.round(self.visit(ctx.expr())) def visitGammaFunc(self, ctx): return math.gamma(self.visit(ctx.expr())).exp() @@ -128,6 +145,10 @@ class FloatEvalVisitor(MathExprVisitor): return math.pow(self.visit(ctx.expr(0)), self.visit(ctx.expr(1))) def visitAtan2Func(self, ctx): return math.atan2(self.visit(ctx.expr(0)), self.visit(ctx.expr(1))) + def visitStepFunc(self, ctx): + edge = self.visit(ctx.expr(0)) + x = self.visit(ctx.expr(1)) + return 1.0 if x >= edge else 0.0 # N-argument functions def visitSMinFunc(self, ctx): @@ -137,10 +158,38 @@ class FloatEvalVisitor(MathExprVisitor): args = [self.visit(e) for e in ctx.expr()] return math.max(args) + def visitClampFunc(self, ctx): + x = self.visit(ctx.expr(0)) + min_val = self.visit(ctx.expr(1)) + max_val = self.visit(ctx.expr(2)) + return max(min(x, max_val), min_val) + + def visitLerpFunc(self, ctx): + # a + (b - a) * w + a = self.visit(ctx.expr(0)) + b = self.visit(ctx.expr(1)) + w = self.visit(ctx.expr(2)) + return a + (b - a) * w + + def visitSmoothstepFunc(self, ctx): + edge0 = self.visit(ctx.expr(0)) + edge1 = self.visit(ctx.expr(1)) + x = self.visit(ctx.expr(2)) + + # Scale, bias and saturate x to 0..1 range + t = (x - edge0) / (edge1 - edge0) + t = max(0.0, min(1.0, t)) + # Evaluate polynomial + return t * t * (3.0 - 2.0 * t) + def visitFunc1Exp(self, ctx): return self.visitChildren(ctx) def visitFunc2Exp(self, ctx): return self.visitChildren(ctx) + def visitFunc3Exp(self, ctx): + return self.visitChildren(ctx) + def visitFunc4Exp(self, ctx): + return self.visitChildren(ctx) def visitFuncNExp(self, ctx): return self.visitChildren(ctx) def visitAtomExp(self, ctx): diff --git a/src/more_math/Parser/MathExpr.g4 b/src/more_math/Parser/MathExpr.g4 index d0cf099..13c13b6 100644 --- a/src/more_math/Parser/MathExpr.g4 +++ b/src/more_math/Parser/MathExpr.g4 @@ -44,6 +44,7 @@ atom : func1 # Func1Exp | func2 # Func2Exp | func3 # Func3Exp + | func4 # Func4Exp | funcN # FuncNExp | VARIABLE # VariableExp | NUMBER # NumberExp @@ -79,8 +80,13 @@ func1 | SIGM '(' expr ')' # sigmoidFunc | SFFT '(' expr ')' # sfftFunc | SIFFT '(' expr ')' # sifftFunc - | ANGL '(' expr ')' # anglFunc - | PRNT '(' expr ')' # printFunc + | ANGL '(' expr ')' # anglFunc + | PRNT '(' expr ')' # printFunc + | FRACT '(' expr ')' # FractFunc + | RELU '(' expr ')' # ReluFunc + | SOFTPLUS '(' expr ')' # SoftplusFunc + | GELU '(' expr ')' # GeluFunc + | SIGN '(' expr ')' # SignFunc ; @@ -90,9 +96,16 @@ func2 | ATAN2 '(' expr ',' expr ')' # Atan2Func | TMIN '(' expr ',' expr ')' # TMinFunc | TMAX '(' expr ',' expr ')' # TMaxFunc + | STEP '(' expr ',' expr ')' # StepFunc ; func3 - : CLAMP '(' expr ',' expr ',' expr ')' # ClampFunc + : CLAMP '(' expr ',' expr ',' expr ')' # ClampFunc + | LERP '(' expr ',' expr ',' expr ')' # LerpFunc + | SMOOTHSTEP '(' expr ',' expr ',' expr ')' # SmoothstepFunc + ; + +func4 + : SWAP '(' expr ',' expr ',' expr ',' expr ')' # SwapFunc ; // N-argument functions (at least 2 arguments) funcN @@ -138,6 +151,15 @@ SFFT : 'fft'; SIFFT : 'ifft'; ANGL : 'angle'; PRNT : 'print'; +LERP : 'lerp'; +STEP : 'step'; +SMOOTHSTEP : 'smoothstep'; +FRACT : 'fract'; +RELU : 'relu'; +SOFTPLUS : 'softplus'; +GELU : 'gelu'; +SIGN : 'sign'; +SWAP : 'swap'; PLUS : '+'; MINUS : '-'; diff --git a/src/more_math/Parser/MathExpr.tokens b/src/more_math/Parser/MathExpr.tokens index 1f55a73..7dbacf6 100644 --- a/src/more_math/Parser/MathExpr.tokens +++ b/src/more_math/Parser/MathExpr.tokens @@ -36,22 +36,31 @@ SFFT=35 SIFFT=36 ANGL=37 PRNT=38 -PLUS=39 -MINUS=40 -MULT=41 -DIV=42 -MOD=43 -POW=44 -GE=45 -GT=46 -LE=47 -LT=48 -EQ=49 -NE=50 -CONSTANT=51 -NUMBER=52 -VARIABLE=53 -WS=54 +LERP=39 +STEP=40 +SMOOTHSTEP=41 +FRACT=42 +RELU=43 +SOFTPLUS=44 +GELU=45 +SIGN=46 +SWAP=47 +PLUS=48 +MINUS=49 +MULT=50 +DIV=51 +MOD=52 +POW=53 +GE=54 +GT=55 +LE=56 +LT=57 +EQ=58 +NE=59 +CONSTANT=60 +NUMBER=61 +VARIABLE=62 +WS=63 '('=1 ')'=2 ','=3 @@ -90,15 +99,24 @@ WS=54 'ifft'=36 'angle'=37 'print'=38 -'+'=39 -'-'=40 -'*'=41 -'/'=42 -'%'=43 -'^'=44 -'>='=45 -'>'=46 -'<='=47 -'<'=48 -'=='=49 -'!='=50 +'lerp'=39 +'step'=40 +'smoothstep'=41 +'fract'=42 +'relu'=43 +'softplus'=44 +'gelu'=45 +'sign'=46 +'swap'=47 +'+'=48 +'-'=49 +'*'=50 +'/'=51 +'%'=52 +'^'=53 +'>='=54 +'>'=55 +'<='=56 +'<'=57 +'=='=58 +'!='=59 diff --git a/src/more_math/Parser/MathExprLexer.py b/src/more_math/Parser/MathExprLexer.py index ba80c82..edb4034 100644 --- a/src/more_math/Parser/MathExprLexer.py +++ b/src/more_math/Parser/MathExprLexer.py @@ -1,4 +1,4 @@ -# Generated from MathExpr.g4 by ANTLR 4.13.2 +# Generated from src/more_math/Parser/MathExpr.g4 by ANTLR 4.13.2 from antlr4 import * from io import StringIO import sys @@ -10,7 +10,7 @@ else: def serializedATN(): return [ - 4,0,54,354,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, + 4,0,63,428,6,-1,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,2,17,7,17,2,18,7,18,2,19,7, 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, @@ -18,122 +18,148 @@ def serializedATN(): 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, - 52,7,52,2,53,7,53,1,0,1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,3,1,3,1,4,1, - 4,1,4,1,4,1,5,1,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1, - 7,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10, - 1,10,1,11,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,12,1,13,1,13, - 1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,14,1,15,1,15,1,15, - 1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,17,1,17,1,17,1,17,1,17,1,18, - 1,18,1,18,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,1,21,1,21,1,21, - 1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,23,1,23,1,23,1,23,1,23,1,24, - 1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,1,26,1,26,1,26, - 1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28, - 1,28,1,29,1,29,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,1,30, - 1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33, - 1,33,1,33,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,36,1,36, - 1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,1,37,1,38,1,38,1,39, - 1,39,1,40,1,40,1,41,1,41,1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,45, - 1,45,1,46,1,46,1,46,1,47,1,47,1,48,1,48,1,48,1,49,1,49,1,49,1,50, - 1,50,1,50,1,50,1,50,3,50,326,8,50,1,51,4,51,329,8,51,11,51,12,51, - 330,1,51,1,51,4,51,335,8,51,11,51,12,51,336,3,51,339,8,51,1,52,1, - 52,5,52,343,8,52,10,52,12,52,346,9,52,1,53,4,53,349,8,53,11,53,12, - 53,350,1,53,1,53,0,0,54,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9, - 19,10,21,11,23,12,25,13,27,14,29,15,31,16,33,17,35,18,37,19,39,20, - 41,21,43,22,45,23,47,24,49,25,51,26,53,27,55,28,57,29,59,30,61,31, - 63,32,65,33,67,34,69,35,71,36,73,37,75,38,77,39,79,40,81,41,83,42, - 85,43,87,44,89,45,91,46,93,47,95,48,97,49,99,50,101,51,103,52,105, - 53,107,54,1,0,5,2,0,69,69,101,101,1,0,48,57,3,0,65,90,95,95,97,122, - 4,0,48,57,65,90,95,95,97,122,3,0,9,10,13,13,32,32,360,0,1,1,0,0, - 0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0, - 13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0, - 23,1,0,0,0,0,25,1,0,0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0, - 33,1,0,0,0,0,35,1,0,0,0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0, - 43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0, - 53,1,0,0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0, - 63,1,0,0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0, - 73,1,0,0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0, - 83,1,0,0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0, - 93,1,0,0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0, - 0,103,1,0,0,0,0,105,1,0,0,0,0,107,1,0,0,0,1,109,1,0,0,0,3,111,1, - 0,0,0,5,113,1,0,0,0,7,115,1,0,0,0,9,119,1,0,0,0,11,123,1,0,0,0,13, - 127,1,0,0,0,15,132,1,0,0,0,17,137,1,0,0,0,19,142,1,0,0,0,21,148, - 1,0,0,0,23,153,1,0,0,0,25,158,1,0,0,0,27,163,1,0,0,0,29,169,1,0, - 0,0,31,175,1,0,0,0,33,181,1,0,0,0,35,185,1,0,0,0,37,190,1,0,0,0, - 39,193,1,0,0,0,41,197,1,0,0,0,43,201,1,0,0,0,45,206,1,0,0,0,47,211, - 1,0,0,0,49,216,1,0,0,0,51,221,1,0,0,0,53,227,1,0,0,0,55,233,1,0, - 0,0,57,239,1,0,0,0,59,244,1,0,0,0,61,250,1,0,0,0,63,256,1,0,0,0, - 65,260,1,0,0,0,67,265,1,0,0,0,69,271,1,0,0,0,71,275,1,0,0,0,73,280, - 1,0,0,0,75,286,1,0,0,0,77,292,1,0,0,0,79,294,1,0,0,0,81,296,1,0, - 0,0,83,298,1,0,0,0,85,300,1,0,0,0,87,302,1,0,0,0,89,304,1,0,0,0, - 91,307,1,0,0,0,93,309,1,0,0,0,95,312,1,0,0,0,97,314,1,0,0,0,99,317, - 1,0,0,0,101,325,1,0,0,0,103,328,1,0,0,0,105,340,1,0,0,0,107,348, - 1,0,0,0,109,110,5,40,0,0,110,2,1,0,0,0,111,112,5,41,0,0,112,4,1, - 0,0,0,113,114,5,44,0,0,114,6,1,0,0,0,115,116,5,115,0,0,116,117,5, - 105,0,0,117,118,5,110,0,0,118,8,1,0,0,0,119,120,5,99,0,0,120,121, - 5,111,0,0,121,122,5,115,0,0,122,10,1,0,0,0,123,124,5,116,0,0,124, - 125,5,97,0,0,125,126,5,110,0,0,126,12,1,0,0,0,127,128,5,97,0,0,128, - 129,5,115,0,0,129,130,5,105,0,0,130,131,5,110,0,0,131,14,1,0,0,0, - 132,133,5,97,0,0,133,134,5,99,0,0,134,135,5,111,0,0,135,136,5,115, - 0,0,136,16,1,0,0,0,137,138,5,97,0,0,138,139,5,116,0,0,139,140,5, - 97,0,0,140,141,5,110,0,0,141,18,1,0,0,0,142,143,5,97,0,0,143,144, - 5,116,0,0,144,145,5,97,0,0,145,146,5,110,0,0,146,147,5,50,0,0,147, - 20,1,0,0,0,148,149,5,115,0,0,149,150,5,105,0,0,150,151,5,110,0,0, - 151,152,5,104,0,0,152,22,1,0,0,0,153,154,5,99,0,0,154,155,5,111, - 0,0,155,156,5,115,0,0,156,157,5,104,0,0,157,24,1,0,0,0,158,159,5, - 116,0,0,159,160,5,97,0,0,160,161,5,110,0,0,161,162,5,104,0,0,162, - 26,1,0,0,0,163,164,5,97,0,0,164,165,5,115,0,0,165,166,5,105,0,0, - 166,167,5,110,0,0,167,168,5,104,0,0,168,28,1,0,0,0,169,170,5,97, - 0,0,170,171,5,99,0,0,171,172,5,111,0,0,172,173,5,115,0,0,173,174, - 5,104,0,0,174,30,1,0,0,0,175,176,5,97,0,0,176,177,5,116,0,0,177, - 178,5,97,0,0,178,179,5,110,0,0,179,180,5,104,0,0,180,32,1,0,0,0, - 181,182,5,97,0,0,182,183,5,98,0,0,183,184,5,115,0,0,184,34,1,0,0, - 0,185,186,5,115,0,0,186,187,5,113,0,0,187,188,5,114,0,0,188,189, - 5,116,0,0,189,36,1,0,0,0,190,191,5,108,0,0,191,192,5,110,0,0,192, - 38,1,0,0,0,193,194,5,108,0,0,194,195,5,111,0,0,195,196,5,103,0,0, - 196,40,1,0,0,0,197,198,5,101,0,0,198,199,5,120,0,0,199,200,5,112, - 0,0,200,42,1,0,0,0,201,202,5,115,0,0,202,203,5,109,0,0,203,204,5, - 105,0,0,204,205,5,110,0,0,205,44,1,0,0,0,206,207,5,115,0,0,207,208, - 5,109,0,0,208,209,5,97,0,0,209,210,5,120,0,0,210,46,1,0,0,0,211, - 212,5,116,0,0,212,213,5,109,0,0,213,214,5,105,0,0,214,215,5,110, - 0,0,215,48,1,0,0,0,216,217,5,116,0,0,217,218,5,109,0,0,218,219,5, - 97,0,0,219,220,5,120,0,0,220,50,1,0,0,0,221,222,5,116,0,0,222,223, - 5,110,0,0,223,224,5,111,0,0,224,225,5,114,0,0,225,226,5,109,0,0, - 226,52,1,0,0,0,227,228,5,115,0,0,228,229,5,110,0,0,229,230,5,111, - 0,0,230,231,5,114,0,0,231,232,5,109,0,0,232,54,1,0,0,0,233,234,5, - 102,0,0,234,235,5,108,0,0,235,236,5,111,0,0,236,237,5,111,0,0,237, - 238,5,114,0,0,238,56,1,0,0,0,239,240,5,99,0,0,240,241,5,101,0,0, - 241,242,5,105,0,0,242,243,5,108,0,0,243,58,1,0,0,0,244,245,5,114, - 0,0,245,246,5,111,0,0,246,247,5,117,0,0,247,248,5,110,0,0,248,249, - 5,100,0,0,249,60,1,0,0,0,250,251,5,103,0,0,251,252,5,97,0,0,252, - 253,5,109,0,0,253,254,5,109,0,0,254,255,5,97,0,0,255,62,1,0,0,0, - 256,257,5,112,0,0,257,258,5,111,0,0,258,259,5,119,0,0,259,64,1,0, - 0,0,260,261,5,115,0,0,261,262,5,105,0,0,262,263,5,103,0,0,263,264, - 5,109,0,0,264,66,1,0,0,0,265,266,5,99,0,0,266,267,5,108,0,0,267, - 268,5,97,0,0,268,269,5,109,0,0,269,270,5,112,0,0,270,68,1,0,0,0, - 271,272,5,102,0,0,272,273,5,102,0,0,273,274,5,116,0,0,274,70,1,0, - 0,0,275,276,5,105,0,0,276,277,5,102,0,0,277,278,5,102,0,0,278,279, - 5,116,0,0,279,72,1,0,0,0,280,281,5,97,0,0,281,282,5,110,0,0,282, - 283,5,103,0,0,283,284,5,108,0,0,284,285,5,101,0,0,285,74,1,0,0,0, - 286,287,5,112,0,0,287,288,5,114,0,0,288,289,5,105,0,0,289,290,5, - 110,0,0,290,291,5,116,0,0,291,76,1,0,0,0,292,293,5,43,0,0,293,78, - 1,0,0,0,294,295,5,45,0,0,295,80,1,0,0,0,296,297,5,42,0,0,297,82, - 1,0,0,0,298,299,5,47,0,0,299,84,1,0,0,0,300,301,5,37,0,0,301,86, - 1,0,0,0,302,303,5,94,0,0,303,88,1,0,0,0,304,305,5,62,0,0,305,306, - 5,61,0,0,306,90,1,0,0,0,307,308,5,62,0,0,308,92,1,0,0,0,309,310, - 5,60,0,0,310,311,5,61,0,0,311,94,1,0,0,0,312,313,5,60,0,0,313,96, - 1,0,0,0,314,315,5,61,0,0,315,316,5,61,0,0,316,98,1,0,0,0,317,318, - 5,33,0,0,318,319,5,61,0,0,319,100,1,0,0,0,320,321,5,112,0,0,321, - 326,5,105,0,0,322,323,5,80,0,0,323,326,5,73,0,0,324,326,7,0,0,0, - 325,320,1,0,0,0,325,322,1,0,0,0,325,324,1,0,0,0,326,102,1,0,0,0, - 327,329,7,1,0,0,328,327,1,0,0,0,329,330,1,0,0,0,330,328,1,0,0,0, - 330,331,1,0,0,0,331,338,1,0,0,0,332,334,5,46,0,0,333,335,7,1,0,0, - 334,333,1,0,0,0,335,336,1,0,0,0,336,334,1,0,0,0,336,337,1,0,0,0, - 337,339,1,0,0,0,338,332,1,0,0,0,338,339,1,0,0,0,339,104,1,0,0,0, - 340,344,7,2,0,0,341,343,7,3,0,0,342,341,1,0,0,0,343,346,1,0,0,0, - 344,342,1,0,0,0,344,345,1,0,0,0,345,106,1,0,0,0,346,344,1,0,0,0, - 347,349,7,4,0,0,348,347,1,0,0,0,349,350,1,0,0,0,350,348,1,0,0,0, - 350,351,1,0,0,0,351,352,1,0,0,0,352,353,6,53,0,0,353,108,1,0,0,0, - 7,0,325,330,336,338,344,350,1,6,0,0 + 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, + 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,1,0,1,0,1,1,1,1,1,2,1, + 2,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,6,1,6,1,6,1, + 6,1,6,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1, + 9,1,9,1,10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,12,1,12, + 1,12,1,12,1,12,1,13,1,13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14, + 1,14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,17, + 1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,20,1,20, + 1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,23, + 1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25, + 1,25,1,25,1,26,1,26,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27, + 1,27,1,28,1,28,1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29,1,30, + 1,30,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32, + 1,32,1,33,1,33,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,35,1,35, + 1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37, + 1,37,1,37,1,38,1,38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,39,1,40, + 1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41, + 1,41,1,41,1,41,1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43, + 1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,45,1,45,1,45,1,45, + 1,45,1,46,1,46,1,46,1,46,1,46,1,47,1,47,1,48,1,48,1,49,1,49,1,50, + 1,50,1,51,1,51,1,52,1,52,1,53,1,53,1,53,1,54,1,54,1,55,1,55,1,55, + 1,56,1,56,1,57,1,57,1,57,1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,59, + 3,59,400,8,59,1,60,4,60,403,8,60,11,60,12,60,404,1,60,1,60,4,60, + 409,8,60,11,60,12,60,410,3,60,413,8,60,1,61,1,61,5,61,417,8,61,10, + 61,12,61,420,9,61,1,62,4,62,423,8,62,11,62,12,62,424,1,62,1,62,0, + 0,63,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25, + 13,27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,23,47, + 24,49,25,51,26,53,27,55,28,57,29,59,30,61,31,63,32,65,33,67,34,69, + 35,71,36,73,37,75,38,77,39,79,40,81,41,83,42,85,43,87,44,89,45,91, + 46,93,47,95,48,97,49,99,50,101,51,103,52,105,53,107,54,109,55,111, + 56,113,57,115,58,117,59,119,60,121,61,123,62,125,63,1,0,5,2,0,69, + 69,101,101,1,0,48,57,3,0,65,90,95,95,97,122,4,0,48,57,65,90,95,95, + 97,122,3,0,9,10,13,13,32,32,434,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0, + 0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0, + 0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0, + 0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0, + 0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0, + 0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0, + 0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0, + 0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1,0,0, + 0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0, + 0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0,0,0,0,95,1,0,0, + 0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1,0,0,0,0,105,1, + 0,0,0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0,113,1,0,0,0,0, + 115,1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0,0,0,0,123,1,0, + 0,0,0,125,1,0,0,0,1,127,1,0,0,0,3,129,1,0,0,0,5,131,1,0,0,0,7,133, + 1,0,0,0,9,137,1,0,0,0,11,141,1,0,0,0,13,145,1,0,0,0,15,150,1,0,0, + 0,17,155,1,0,0,0,19,160,1,0,0,0,21,166,1,0,0,0,23,171,1,0,0,0,25, + 176,1,0,0,0,27,181,1,0,0,0,29,187,1,0,0,0,31,193,1,0,0,0,33,199, + 1,0,0,0,35,203,1,0,0,0,37,208,1,0,0,0,39,211,1,0,0,0,41,215,1,0, + 0,0,43,219,1,0,0,0,45,224,1,0,0,0,47,229,1,0,0,0,49,234,1,0,0,0, + 51,239,1,0,0,0,53,245,1,0,0,0,55,251,1,0,0,0,57,257,1,0,0,0,59,262, + 1,0,0,0,61,268,1,0,0,0,63,274,1,0,0,0,65,278,1,0,0,0,67,283,1,0, + 0,0,69,289,1,0,0,0,71,293,1,0,0,0,73,298,1,0,0,0,75,304,1,0,0,0, + 77,310,1,0,0,0,79,315,1,0,0,0,81,320,1,0,0,0,83,331,1,0,0,0,85,337, + 1,0,0,0,87,342,1,0,0,0,89,351,1,0,0,0,91,356,1,0,0,0,93,361,1,0, + 0,0,95,366,1,0,0,0,97,368,1,0,0,0,99,370,1,0,0,0,101,372,1,0,0,0, + 103,374,1,0,0,0,105,376,1,0,0,0,107,378,1,0,0,0,109,381,1,0,0,0, + 111,383,1,0,0,0,113,386,1,0,0,0,115,388,1,0,0,0,117,391,1,0,0,0, + 119,399,1,0,0,0,121,402,1,0,0,0,123,414,1,0,0,0,125,422,1,0,0,0, + 127,128,5,40,0,0,128,2,1,0,0,0,129,130,5,41,0,0,130,4,1,0,0,0,131, + 132,5,44,0,0,132,6,1,0,0,0,133,134,5,115,0,0,134,135,5,105,0,0,135, + 136,5,110,0,0,136,8,1,0,0,0,137,138,5,99,0,0,138,139,5,111,0,0,139, + 140,5,115,0,0,140,10,1,0,0,0,141,142,5,116,0,0,142,143,5,97,0,0, + 143,144,5,110,0,0,144,12,1,0,0,0,145,146,5,97,0,0,146,147,5,115, + 0,0,147,148,5,105,0,0,148,149,5,110,0,0,149,14,1,0,0,0,150,151,5, + 97,0,0,151,152,5,99,0,0,152,153,5,111,0,0,153,154,5,115,0,0,154, + 16,1,0,0,0,155,156,5,97,0,0,156,157,5,116,0,0,157,158,5,97,0,0,158, + 159,5,110,0,0,159,18,1,0,0,0,160,161,5,97,0,0,161,162,5,116,0,0, + 162,163,5,97,0,0,163,164,5,110,0,0,164,165,5,50,0,0,165,20,1,0,0, + 0,166,167,5,115,0,0,167,168,5,105,0,0,168,169,5,110,0,0,169,170, + 5,104,0,0,170,22,1,0,0,0,171,172,5,99,0,0,172,173,5,111,0,0,173, + 174,5,115,0,0,174,175,5,104,0,0,175,24,1,0,0,0,176,177,5,116,0,0, + 177,178,5,97,0,0,178,179,5,110,0,0,179,180,5,104,0,0,180,26,1,0, + 0,0,181,182,5,97,0,0,182,183,5,115,0,0,183,184,5,105,0,0,184,185, + 5,110,0,0,185,186,5,104,0,0,186,28,1,0,0,0,187,188,5,97,0,0,188, + 189,5,99,0,0,189,190,5,111,0,0,190,191,5,115,0,0,191,192,5,104,0, + 0,192,30,1,0,0,0,193,194,5,97,0,0,194,195,5,116,0,0,195,196,5,97, + 0,0,196,197,5,110,0,0,197,198,5,104,0,0,198,32,1,0,0,0,199,200,5, + 97,0,0,200,201,5,98,0,0,201,202,5,115,0,0,202,34,1,0,0,0,203,204, + 5,115,0,0,204,205,5,113,0,0,205,206,5,114,0,0,206,207,5,116,0,0, + 207,36,1,0,0,0,208,209,5,108,0,0,209,210,5,110,0,0,210,38,1,0,0, + 0,211,212,5,108,0,0,212,213,5,111,0,0,213,214,5,103,0,0,214,40,1, + 0,0,0,215,216,5,101,0,0,216,217,5,120,0,0,217,218,5,112,0,0,218, + 42,1,0,0,0,219,220,5,115,0,0,220,221,5,109,0,0,221,222,5,105,0,0, + 222,223,5,110,0,0,223,44,1,0,0,0,224,225,5,115,0,0,225,226,5,109, + 0,0,226,227,5,97,0,0,227,228,5,120,0,0,228,46,1,0,0,0,229,230,5, + 116,0,0,230,231,5,109,0,0,231,232,5,105,0,0,232,233,5,110,0,0,233, + 48,1,0,0,0,234,235,5,116,0,0,235,236,5,109,0,0,236,237,5,97,0,0, + 237,238,5,120,0,0,238,50,1,0,0,0,239,240,5,116,0,0,240,241,5,110, + 0,0,241,242,5,111,0,0,242,243,5,114,0,0,243,244,5,109,0,0,244,52, + 1,0,0,0,245,246,5,115,0,0,246,247,5,110,0,0,247,248,5,111,0,0,248, + 249,5,114,0,0,249,250,5,109,0,0,250,54,1,0,0,0,251,252,5,102,0,0, + 252,253,5,108,0,0,253,254,5,111,0,0,254,255,5,111,0,0,255,256,5, + 114,0,0,256,56,1,0,0,0,257,258,5,99,0,0,258,259,5,101,0,0,259,260, + 5,105,0,0,260,261,5,108,0,0,261,58,1,0,0,0,262,263,5,114,0,0,263, + 264,5,111,0,0,264,265,5,117,0,0,265,266,5,110,0,0,266,267,5,100, + 0,0,267,60,1,0,0,0,268,269,5,103,0,0,269,270,5,97,0,0,270,271,5, + 109,0,0,271,272,5,109,0,0,272,273,5,97,0,0,273,62,1,0,0,0,274,275, + 5,112,0,0,275,276,5,111,0,0,276,277,5,119,0,0,277,64,1,0,0,0,278, + 279,5,115,0,0,279,280,5,105,0,0,280,281,5,103,0,0,281,282,5,109, + 0,0,282,66,1,0,0,0,283,284,5,99,0,0,284,285,5,108,0,0,285,286,5, + 97,0,0,286,287,5,109,0,0,287,288,5,112,0,0,288,68,1,0,0,0,289,290, + 5,102,0,0,290,291,5,102,0,0,291,292,5,116,0,0,292,70,1,0,0,0,293, + 294,5,105,0,0,294,295,5,102,0,0,295,296,5,102,0,0,296,297,5,116, + 0,0,297,72,1,0,0,0,298,299,5,97,0,0,299,300,5,110,0,0,300,301,5, + 103,0,0,301,302,5,108,0,0,302,303,5,101,0,0,303,74,1,0,0,0,304,305, + 5,112,0,0,305,306,5,114,0,0,306,307,5,105,0,0,307,308,5,110,0,0, + 308,309,5,116,0,0,309,76,1,0,0,0,310,311,5,108,0,0,311,312,5,101, + 0,0,312,313,5,114,0,0,313,314,5,112,0,0,314,78,1,0,0,0,315,316,5, + 115,0,0,316,317,5,116,0,0,317,318,5,101,0,0,318,319,5,112,0,0,319, + 80,1,0,0,0,320,321,5,115,0,0,321,322,5,109,0,0,322,323,5,111,0,0, + 323,324,5,111,0,0,324,325,5,116,0,0,325,326,5,104,0,0,326,327,5, + 115,0,0,327,328,5,116,0,0,328,329,5,101,0,0,329,330,5,112,0,0,330, + 82,1,0,0,0,331,332,5,102,0,0,332,333,5,114,0,0,333,334,5,97,0,0, + 334,335,5,99,0,0,335,336,5,116,0,0,336,84,1,0,0,0,337,338,5,114, + 0,0,338,339,5,101,0,0,339,340,5,108,0,0,340,341,5,117,0,0,341,86, + 1,0,0,0,342,343,5,115,0,0,343,344,5,111,0,0,344,345,5,102,0,0,345, + 346,5,116,0,0,346,347,5,112,0,0,347,348,5,108,0,0,348,349,5,117, + 0,0,349,350,5,115,0,0,350,88,1,0,0,0,351,352,5,103,0,0,352,353,5, + 101,0,0,353,354,5,108,0,0,354,355,5,117,0,0,355,90,1,0,0,0,356,357, + 5,115,0,0,357,358,5,105,0,0,358,359,5,103,0,0,359,360,5,110,0,0, + 360,92,1,0,0,0,361,362,5,115,0,0,362,363,5,119,0,0,363,364,5,97, + 0,0,364,365,5,112,0,0,365,94,1,0,0,0,366,367,5,43,0,0,367,96,1,0, + 0,0,368,369,5,45,0,0,369,98,1,0,0,0,370,371,5,42,0,0,371,100,1,0, + 0,0,372,373,5,47,0,0,373,102,1,0,0,0,374,375,5,37,0,0,375,104,1, + 0,0,0,376,377,5,94,0,0,377,106,1,0,0,0,378,379,5,62,0,0,379,380, + 5,61,0,0,380,108,1,0,0,0,381,382,5,62,0,0,382,110,1,0,0,0,383,384, + 5,60,0,0,384,385,5,61,0,0,385,112,1,0,0,0,386,387,5,60,0,0,387,114, + 1,0,0,0,388,389,5,61,0,0,389,390,5,61,0,0,390,116,1,0,0,0,391,392, + 5,33,0,0,392,393,5,61,0,0,393,118,1,0,0,0,394,395,5,112,0,0,395, + 400,5,105,0,0,396,397,5,80,0,0,397,400,5,73,0,0,398,400,7,0,0,0, + 399,394,1,0,0,0,399,396,1,0,0,0,399,398,1,0,0,0,400,120,1,0,0,0, + 401,403,7,1,0,0,402,401,1,0,0,0,403,404,1,0,0,0,404,402,1,0,0,0, + 404,405,1,0,0,0,405,412,1,0,0,0,406,408,5,46,0,0,407,409,7,1,0,0, + 408,407,1,0,0,0,409,410,1,0,0,0,410,408,1,0,0,0,410,411,1,0,0,0, + 411,413,1,0,0,0,412,406,1,0,0,0,412,413,1,0,0,0,413,122,1,0,0,0, + 414,418,7,2,0,0,415,417,7,3,0,0,416,415,1,0,0,0,417,420,1,0,0,0, + 418,416,1,0,0,0,418,419,1,0,0,0,419,124,1,0,0,0,420,418,1,0,0,0, + 421,423,7,4,0,0,422,421,1,0,0,0,423,424,1,0,0,0,424,422,1,0,0,0, + 424,425,1,0,0,0,425,426,1,0,0,0,426,427,6,62,0,0,427,126,1,0,0,0, + 7,0,399,404,410,412,418,424,1,6,0,0 ] class MathExprLexer(Lexer): @@ -180,22 +206,31 @@ class MathExprLexer(Lexer): SIFFT = 36 ANGL = 37 PRNT = 38 - PLUS = 39 - MINUS = 40 - MULT = 41 - DIV = 42 - MOD = 43 - POW = 44 - GE = 45 - GT = 46 - LE = 47 - LT = 48 - EQ = 49 - NE = 50 - CONSTANT = 51 - NUMBER = 52 - VARIABLE = 53 - WS = 54 + LERP = 39 + STEP = 40 + SMOOTHSTEP = 41 + FRACT = 42 + RELU = 43 + SOFTPLUS = 44 + GELU = 45 + SIGN = 46 + SWAP = 47 + PLUS = 48 + MINUS = 49 + MULT = 50 + DIV = 51 + MOD = 52 + POW = 53 + GE = 54 + GT = 55 + LE = 56 + LT = 57 + EQ = 58 + NE = 59 + CONSTANT = 60 + NUMBER = 61 + VARIABLE = 62 + WS = 63 channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] @@ -207,27 +242,30 @@ class MathExprLexer(Lexer): "'acosh'", "'atanh'", "'abs'", "'sqrt'", "'ln'", "'log'", "'exp'", "'smin'", "'smax'", "'tmin'", "'tmax'", "'tnorm'", "'snorm'", "'floor'", "'ceil'", "'round'", "'gamma'", "'pow'", "'sigm'", - "'clamp'", "'fft'", "'ifft'", "'angle'", "'print'", "'+'", "'-'", - "'*'", "'/'", "'%'", "'^'", "'>='", "'>'", "'<='", "'<'", "'=='", - "'!='" ] + "'clamp'", "'fft'", "'ifft'", "'angle'", "'print'", "'lerp'", + "'step'", "'smoothstep'", "'fract'", "'relu'", "'softplus'", + "'gelu'", "'sign'", "'swap'", "'+'", "'-'", "'*'", "'/'", "'%'", + "'^'", "'>='", "'>'", "'<='", "'<'", "'=='", "'!='" ] symbolicNames = [ "", "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", "PLUS", "MINUS", "MULT", "DIV", - "MOD", "POW", "GE", "GT", "LE", "LT", "EQ", "NE", "CONSTANT", - "NUMBER", "VARIABLE", "WS" ] + "SFFT", "SIFFT", "ANGL", "PRNT", "LERP", "STEP", "SMOOTHSTEP", + "FRACT", "RELU", "SOFTPLUS", "GELU", "SIGN", "SWAP", "PLUS", + "MINUS", "MULT", "DIV", "MOD", "POW", "GE", "GT", "LE", "LT", + "EQ", "NE", "CONSTANT", "NUMBER", "VARIABLE", "WS" ] ruleNames = [ "T__0", "T__1", "T__2", "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", "PLUS", "MINUS", "MULT", "DIV", "MOD", "POW", - "GE", "GT", "LE", "LT", "EQ", "NE", "CONSTANT", "NUMBER", - "VARIABLE", "WS" ] + "PRNT", "LERP", "STEP", "SMOOTHSTEP", "FRACT", "RELU", + "SOFTPLUS", "GELU", "SIGN", "SWAP", "PLUS", "MINUS", "MULT", + "DIV", "MOD", "POW", "GE", "GT", "LE", "LT", "EQ", "NE", + "CONSTANT", "NUMBER", "VARIABLE", "WS" ] grammarFileName = "MathExpr.g4" diff --git a/src/more_math/Parser/MathExprLexer.tokens b/src/more_math/Parser/MathExprLexer.tokens index 1f55a73..7dbacf6 100644 --- a/src/more_math/Parser/MathExprLexer.tokens +++ b/src/more_math/Parser/MathExprLexer.tokens @@ -36,22 +36,31 @@ SFFT=35 SIFFT=36 ANGL=37 PRNT=38 -PLUS=39 -MINUS=40 -MULT=41 -DIV=42 -MOD=43 -POW=44 -GE=45 -GT=46 -LE=47 -LT=48 -EQ=49 -NE=50 -CONSTANT=51 -NUMBER=52 -VARIABLE=53 -WS=54 +LERP=39 +STEP=40 +SMOOTHSTEP=41 +FRACT=42 +RELU=43 +SOFTPLUS=44 +GELU=45 +SIGN=46 +SWAP=47 +PLUS=48 +MINUS=49 +MULT=50 +DIV=51 +MOD=52 +POW=53 +GE=54 +GT=55 +LE=56 +LT=57 +EQ=58 +NE=59 +CONSTANT=60 +NUMBER=61 +VARIABLE=62 +WS=63 '('=1 ')'=2 ','=3 @@ -90,15 +99,24 @@ WS=54 'ifft'=36 'angle'=37 'print'=38 -'+'=39 -'-'=40 -'*'=41 -'/'=42 -'%'=43 -'^'=44 -'>='=45 -'>'=46 -'<='=47 -'<'=48 -'=='=49 -'!='=50 +'lerp'=39 +'step'=40 +'smoothstep'=41 +'fract'=42 +'relu'=43 +'softplus'=44 +'gelu'=45 +'sign'=46 +'swap'=47 +'+'=48 +'-'=49 +'*'=50 +'/'=51 +'%'=52 +'^'=53 +'>='=54 +'>'=55 +'<='=56 +'<'=57 +'=='=58 +'!='=59 diff --git a/src/more_math/Parser/MathExprParser.py b/src/more_math/Parser/MathExprParser.py index 01a6b31..b8445b8 100644 --- a/src/more_math/Parser/MathExprParser.py +++ b/src/more_math/Parser/MathExprParser.py @@ -1,4 +1,4 @@ -# Generated from MathExpr.g4 by ANTLR 4.13.2 +# Generated from src/more_math/Parser/MathExpr.g4 by ANTLR 4.13.2 # encoding: utf-8 from antlr4 import * from io import StringIO @@ -10,116 +10,139 @@ else: def serializedATN(): return [ - 4,1,54,316,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,1,0,1,0,3,0,25,8,0,1,1,1,1,1, + 4,1,63,382,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,1,0,1,0,3,0,27,8,0, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,5,1,48,8,1,10,1,12,1,51,9,1,1,2,1,2,1,2,1,2,1,2,1,2,1, - 2,1,2,1,2,5,2,62,8,2,10,2,12,2,65,9,2,1,3,1,3,1,3,1,3,1,3,1,3,1, - 3,1,3,1,3,1,3,1,3,1,3,5,3,79,8,3,10,3,12,3,82,9,3,1,4,1,4,1,4,1, - 4,1,4,3,4,89,8,4,1,5,1,5,1,5,1,5,1,5,3,5,96,8,5,1,6,1,6,1,6,1,6, - 1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,109,8,6,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7, - 1,7,1,7,1,7,1,7,1,7,1,7,3,7,251,8,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8, - 1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8, - 1,8,1,8,1,8,1,8,1,8,3,8,281,8,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9, - 1,9,1,10,1,10,1,10,1,10,1,10,4,10,297,8,10,11,10,12,10,298,1,10, - 1,10,1,10,1,10,1,10,1,10,1,10,4,10,308,8,10,11,10,12,10,309,1,10, - 1,10,3,10,314,8,10,1,10,0,3,2,4,6,11,0,2,4,6,8,10,12,14,16,18,20, - 0,0,359,0,24,1,0,0,0,2,26,1,0,0,0,4,52,1,0,0,0,6,66,1,0,0,0,8,88, - 1,0,0,0,10,95,1,0,0,0,12,108,1,0,0,0,14,250,1,0,0,0,16,280,1,0,0, - 0,18,282,1,0,0,0,20,313,1,0,0,0,22,25,3,12,6,0,23,25,3,2,1,0,24, - 22,1,0,0,0,24,23,1,0,0,0,25,1,1,0,0,0,26,27,6,1,-1,0,27,28,3,4,2, - 0,28,49,1,0,0,0,29,30,10,7,0,0,30,31,5,46,0,0,31,48,3,4,2,0,32,33, - 10,6,0,0,33,34,5,45,0,0,34,48,3,4,2,0,35,36,10,5,0,0,36,37,5,48, - 0,0,37,48,3,4,2,0,38,39,10,4,0,0,39,40,5,47,0,0,40,48,3,4,2,0,41, - 42,10,3,0,0,42,43,5,49,0,0,43,48,3,4,2,0,44,45,10,2,0,0,45,46,5, - 50,0,0,46,48,3,4,2,0,47,29,1,0,0,0,47,32,1,0,0,0,47,35,1,0,0,0,47, - 38,1,0,0,0,47,41,1,0,0,0,47,44,1,0,0,0,48,51,1,0,0,0,49,47,1,0,0, - 0,49,50,1,0,0,0,50,3,1,0,0,0,51,49,1,0,0,0,52,53,6,2,-1,0,53,54, - 3,6,3,0,54,63,1,0,0,0,55,56,10,3,0,0,56,57,5,39,0,0,57,62,3,6,3, - 0,58,59,10,2,0,0,59,60,5,40,0,0,60,62,3,6,3,0,61,55,1,0,0,0,61,58, - 1,0,0,0,62,65,1,0,0,0,63,61,1,0,0,0,63,64,1,0,0,0,64,5,1,0,0,0,65, - 63,1,0,0,0,66,67,6,3,-1,0,67,68,3,8,4,0,68,80,1,0,0,0,69,70,10,4, - 0,0,70,71,5,41,0,0,71,79,3,8,4,0,72,73,10,3,0,0,73,74,5,42,0,0,74, - 79,3,8,4,0,75,76,10,2,0,0,76,77,5,43,0,0,77,79,3,8,4,0,78,69,1,0, - 0,0,78,72,1,0,0,0,78,75,1,0,0,0,79,82,1,0,0,0,80,78,1,0,0,0,80,81, - 1,0,0,0,81,7,1,0,0,0,82,80,1,0,0,0,83,84,3,10,5,0,84,85,5,44,0,0, - 85,86,3,8,4,0,86,89,1,0,0,0,87,89,3,10,5,0,88,83,1,0,0,0,88,87,1, - 0,0,0,89,9,1,0,0,0,90,91,5,39,0,0,91,96,3,10,5,0,92,93,5,40,0,0, - 93,96,3,10,5,0,94,96,3,12,6,0,95,90,1,0,0,0,95,92,1,0,0,0,95,94, - 1,0,0,0,96,11,1,0,0,0,97,109,3,14,7,0,98,109,3,16,8,0,99,109,3,18, - 9,0,100,109,3,20,10,0,101,109,5,53,0,0,102,109,5,52,0,0,103,109, - 5,51,0,0,104,105,5,1,0,0,105,106,3,0,0,0,106,107,5,2,0,0,107,109, - 1,0,0,0,108,97,1,0,0,0,108,98,1,0,0,0,108,99,1,0,0,0,108,100,1,0, - 0,0,108,101,1,0,0,0,108,102,1,0,0,0,108,103,1,0,0,0,108,104,1,0, - 0,0,109,13,1,0,0,0,110,111,5,4,0,0,111,112,5,1,0,0,112,113,3,0,0, - 0,113,114,5,2,0,0,114,251,1,0,0,0,115,116,5,5,0,0,116,117,5,1,0, - 0,117,118,3,0,0,0,118,119,5,2,0,0,119,251,1,0,0,0,120,121,5,6,0, - 0,121,122,5,1,0,0,122,123,3,0,0,0,123,124,5,2,0,0,124,251,1,0,0, - 0,125,126,5,7,0,0,126,127,5,1,0,0,127,128,3,0,0,0,128,129,5,2,0, - 0,129,251,1,0,0,0,130,131,5,8,0,0,131,132,5,1,0,0,132,133,3,0,0, - 0,133,134,5,2,0,0,134,251,1,0,0,0,135,136,5,9,0,0,136,137,5,1,0, - 0,137,138,3,0,0,0,138,139,5,2,0,0,139,251,1,0,0,0,140,141,5,11,0, - 0,141,142,5,1,0,0,142,143,3,0,0,0,143,144,5,2,0,0,144,251,1,0,0, - 0,145,146,5,12,0,0,146,147,5,1,0,0,147,148,3,0,0,0,148,149,5,2,0, - 0,149,251,1,0,0,0,150,151,5,13,0,0,151,152,5,1,0,0,152,153,3,0,0, - 0,153,154,5,2,0,0,154,251,1,0,0,0,155,156,5,14,0,0,156,157,5,1,0, - 0,157,158,3,0,0,0,158,159,5,2,0,0,159,251,1,0,0,0,160,161,5,15,0, - 0,161,162,5,1,0,0,162,163,3,0,0,0,163,164,5,2,0,0,164,251,1,0,0, - 0,165,166,5,16,0,0,166,167,5,1,0,0,167,168,3,0,0,0,168,169,5,2,0, - 0,169,251,1,0,0,0,170,171,5,17,0,0,171,172,5,1,0,0,172,173,3,0,0, - 0,173,174,5,2,0,0,174,251,1,0,0,0,175,176,5,18,0,0,176,177,5,1,0, - 0,177,178,3,0,0,0,178,179,5,2,0,0,179,251,1,0,0,0,180,181,5,19,0, - 0,181,182,5,1,0,0,182,183,3,0,0,0,183,184,5,2,0,0,184,251,1,0,0, - 0,185,186,5,20,0,0,186,187,5,1,0,0,187,188,3,0,0,0,188,189,5,2,0, - 0,189,251,1,0,0,0,190,191,5,21,0,0,191,192,5,1,0,0,192,193,3,0,0, - 0,193,194,5,2,0,0,194,251,1,0,0,0,195,196,5,26,0,0,196,197,5,1,0, - 0,197,198,3,0,0,0,198,199,5,2,0,0,199,251,1,0,0,0,200,201,5,27,0, - 0,201,202,5,1,0,0,202,203,3,0,0,0,203,204,5,2,0,0,204,251,1,0,0, - 0,205,206,5,28,0,0,206,207,5,1,0,0,207,208,3,0,0,0,208,209,5,2,0, - 0,209,251,1,0,0,0,210,211,5,29,0,0,211,212,5,1,0,0,212,213,3,0,0, - 0,213,214,5,2,0,0,214,251,1,0,0,0,215,216,5,30,0,0,216,217,5,1,0, - 0,217,218,3,0,0,0,218,219,5,2,0,0,219,251,1,0,0,0,220,221,5,31,0, - 0,221,222,5,1,0,0,222,223,3,0,0,0,223,224,5,2,0,0,224,251,1,0,0, - 0,225,226,5,33,0,0,226,227,5,1,0,0,227,228,3,0,0,0,228,229,5,2,0, - 0,229,251,1,0,0,0,230,231,5,35,0,0,231,232,5,1,0,0,232,233,3,0,0, - 0,233,234,5,2,0,0,234,251,1,0,0,0,235,236,5,36,0,0,236,237,5,1,0, - 0,237,238,3,0,0,0,238,239,5,2,0,0,239,251,1,0,0,0,240,241,5,37,0, - 0,241,242,5,1,0,0,242,243,3,0,0,0,243,244,5,2,0,0,244,251,1,0,0, - 0,245,246,5,38,0,0,246,247,5,1,0,0,247,248,3,0,0,0,248,249,5,2,0, - 0,249,251,1,0,0,0,250,110,1,0,0,0,250,115,1,0,0,0,250,120,1,0,0, - 0,250,125,1,0,0,0,250,130,1,0,0,0,250,135,1,0,0,0,250,140,1,0,0, - 0,250,145,1,0,0,0,250,150,1,0,0,0,250,155,1,0,0,0,250,160,1,0,0, - 0,250,165,1,0,0,0,250,170,1,0,0,0,250,175,1,0,0,0,250,180,1,0,0, - 0,250,185,1,0,0,0,250,190,1,0,0,0,250,195,1,0,0,0,250,200,1,0,0, - 0,250,205,1,0,0,0,250,210,1,0,0,0,250,215,1,0,0,0,250,220,1,0,0, - 0,250,225,1,0,0,0,250,230,1,0,0,0,250,235,1,0,0,0,250,240,1,0,0, - 0,250,245,1,0,0,0,251,15,1,0,0,0,252,253,5,32,0,0,253,254,5,1,0, - 0,254,255,3,0,0,0,255,256,5,3,0,0,256,257,3,0,0,0,257,258,5,2,0, - 0,258,281,1,0,0,0,259,260,5,10,0,0,260,261,5,1,0,0,261,262,3,0,0, - 0,262,263,5,3,0,0,263,264,3,0,0,0,264,265,5,2,0,0,265,281,1,0,0, - 0,266,267,5,24,0,0,267,268,5,1,0,0,268,269,3,0,0,0,269,270,5,3,0, - 0,270,271,3,0,0,0,271,272,5,2,0,0,272,281,1,0,0,0,273,274,5,25,0, - 0,274,275,5,1,0,0,275,276,3,0,0,0,276,277,5,3,0,0,277,278,3,0,0, - 0,278,279,5,2,0,0,279,281,1,0,0,0,280,252,1,0,0,0,280,259,1,0,0, - 0,280,266,1,0,0,0,280,273,1,0,0,0,281,17,1,0,0,0,282,283,5,34,0, - 0,283,284,5,1,0,0,284,285,3,0,0,0,285,286,5,3,0,0,286,287,3,0,0, - 0,287,288,5,3,0,0,288,289,3,0,0,0,289,290,5,2,0,0,290,19,1,0,0,0, - 291,292,5,22,0,0,292,293,5,1,0,0,293,296,3,0,0,0,294,295,5,3,0,0, - 295,297,3,0,0,0,296,294,1,0,0,0,297,298,1,0,0,0,298,296,1,0,0,0, - 298,299,1,0,0,0,299,300,1,0,0,0,300,301,5,2,0,0,301,314,1,0,0,0, - 302,303,5,23,0,0,303,304,5,1,0,0,304,307,3,0,0,0,305,306,5,3,0,0, - 306,308,3,0,0,0,307,305,1,0,0,0,308,309,1,0,0,0,309,307,1,0,0,0, - 309,310,1,0,0,0,310,311,1,0,0,0,311,312,5,2,0,0,312,314,1,0,0,0, - 313,291,1,0,0,0,313,302,1,0,0,0,314,21,1,0,0,0,15,24,47,49,61,63, - 78,80,88,95,108,250,280,298,309,313 + 1,1,1,1,1,1,1,1,1,1,5,1,50,8,1,10,1,12,1,53,9,1,1,2,1,2,1,2,1,2, + 1,2,1,2,1,2,1,2,1,2,5,2,64,8,2,10,2,12,2,67,9,2,1,3,1,3,1,3,1,3, + 1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,5,3,81,8,3,10,3,12,3,84,9,3,1,4, + 1,4,1,4,1,4,1,4,3,4,91,8,4,1,5,1,5,1,5,1,5,1,5,3,5,98,8,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,3,6,112,8,6,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,3,7,279,8,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1, + 8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1, + 8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,3,8,316,8,8,1,9,1,9,1,9,1,9,1, + 9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1, + 9,1,9,1,9,1,9,1,9,1,9,1,9,3,9,345,8,9,1,10,1,10,1,10,1,10,1,10,1, + 10,1,10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,4,11,363,8, + 11,11,11,12,11,364,1,11,1,11,1,11,1,11,1,11,1,11,1,11,4,11,374,8, + 11,11,11,12,11,375,1,11,1,11,3,11,380,8,11,1,11,0,3,2,4,6,12,0,2, + 4,6,8,10,12,14,16,18,20,22,0,0,433,0,26,1,0,0,0,2,28,1,0,0,0,4,54, + 1,0,0,0,6,68,1,0,0,0,8,90,1,0,0,0,10,97,1,0,0,0,12,111,1,0,0,0,14, + 278,1,0,0,0,16,315,1,0,0,0,18,344,1,0,0,0,20,346,1,0,0,0,22,379, + 1,0,0,0,24,27,3,12,6,0,25,27,3,2,1,0,26,24,1,0,0,0,26,25,1,0,0,0, + 27,1,1,0,0,0,28,29,6,1,-1,0,29,30,3,4,2,0,30,51,1,0,0,0,31,32,10, + 7,0,0,32,33,5,55,0,0,33,50,3,4,2,0,34,35,10,6,0,0,35,36,5,54,0,0, + 36,50,3,4,2,0,37,38,10,5,0,0,38,39,5,57,0,0,39,50,3,4,2,0,40,41, + 10,4,0,0,41,42,5,56,0,0,42,50,3,4,2,0,43,44,10,3,0,0,44,45,5,58, + 0,0,45,50,3,4,2,0,46,47,10,2,0,0,47,48,5,59,0,0,48,50,3,4,2,0,49, + 31,1,0,0,0,49,34,1,0,0,0,49,37,1,0,0,0,49,40,1,0,0,0,49,43,1,0,0, + 0,49,46,1,0,0,0,50,53,1,0,0,0,51,49,1,0,0,0,51,52,1,0,0,0,52,3,1, + 0,0,0,53,51,1,0,0,0,54,55,6,2,-1,0,55,56,3,6,3,0,56,65,1,0,0,0,57, + 58,10,3,0,0,58,59,5,48,0,0,59,64,3,6,3,0,60,61,10,2,0,0,61,62,5, + 49,0,0,62,64,3,6,3,0,63,57,1,0,0,0,63,60,1,0,0,0,64,67,1,0,0,0,65, + 63,1,0,0,0,65,66,1,0,0,0,66,5,1,0,0,0,67,65,1,0,0,0,68,69,6,3,-1, + 0,69,70,3,8,4,0,70,82,1,0,0,0,71,72,10,4,0,0,72,73,5,50,0,0,73,81, + 3,8,4,0,74,75,10,3,0,0,75,76,5,51,0,0,76,81,3,8,4,0,77,78,10,2,0, + 0,78,79,5,52,0,0,79,81,3,8,4,0,80,71,1,0,0,0,80,74,1,0,0,0,80,77, + 1,0,0,0,81,84,1,0,0,0,82,80,1,0,0,0,82,83,1,0,0,0,83,7,1,0,0,0,84, + 82,1,0,0,0,85,86,3,10,5,0,86,87,5,53,0,0,87,88,3,8,4,0,88,91,1,0, + 0,0,89,91,3,10,5,0,90,85,1,0,0,0,90,89,1,0,0,0,91,9,1,0,0,0,92,93, + 5,48,0,0,93,98,3,10,5,0,94,95,5,49,0,0,95,98,3,10,5,0,96,98,3,12, + 6,0,97,92,1,0,0,0,97,94,1,0,0,0,97,96,1,0,0,0,98,11,1,0,0,0,99,112, + 3,14,7,0,100,112,3,16,8,0,101,112,3,18,9,0,102,112,3,20,10,0,103, + 112,3,22,11,0,104,112,5,62,0,0,105,112,5,61,0,0,106,112,5,60,0,0, + 107,108,5,1,0,0,108,109,3,0,0,0,109,110,5,2,0,0,110,112,1,0,0,0, + 111,99,1,0,0,0,111,100,1,0,0,0,111,101,1,0,0,0,111,102,1,0,0,0,111, + 103,1,0,0,0,111,104,1,0,0,0,111,105,1,0,0,0,111,106,1,0,0,0,111, + 107,1,0,0,0,112,13,1,0,0,0,113,114,5,4,0,0,114,115,5,1,0,0,115,116, + 3,0,0,0,116,117,5,2,0,0,117,279,1,0,0,0,118,119,5,5,0,0,119,120, + 5,1,0,0,120,121,3,0,0,0,121,122,5,2,0,0,122,279,1,0,0,0,123,124, + 5,6,0,0,124,125,5,1,0,0,125,126,3,0,0,0,126,127,5,2,0,0,127,279, + 1,0,0,0,128,129,5,7,0,0,129,130,5,1,0,0,130,131,3,0,0,0,131,132, + 5,2,0,0,132,279,1,0,0,0,133,134,5,8,0,0,134,135,5,1,0,0,135,136, + 3,0,0,0,136,137,5,2,0,0,137,279,1,0,0,0,138,139,5,9,0,0,139,140, + 5,1,0,0,140,141,3,0,0,0,141,142,5,2,0,0,142,279,1,0,0,0,143,144, + 5,11,0,0,144,145,5,1,0,0,145,146,3,0,0,0,146,147,5,2,0,0,147,279, + 1,0,0,0,148,149,5,12,0,0,149,150,5,1,0,0,150,151,3,0,0,0,151,152, + 5,2,0,0,152,279,1,0,0,0,153,154,5,13,0,0,154,155,5,1,0,0,155,156, + 3,0,0,0,156,157,5,2,0,0,157,279,1,0,0,0,158,159,5,14,0,0,159,160, + 5,1,0,0,160,161,3,0,0,0,161,162,5,2,0,0,162,279,1,0,0,0,163,164, + 5,15,0,0,164,165,5,1,0,0,165,166,3,0,0,0,166,167,5,2,0,0,167,279, + 1,0,0,0,168,169,5,16,0,0,169,170,5,1,0,0,170,171,3,0,0,0,171,172, + 5,2,0,0,172,279,1,0,0,0,173,174,5,17,0,0,174,175,5,1,0,0,175,176, + 3,0,0,0,176,177,5,2,0,0,177,279,1,0,0,0,178,179,5,18,0,0,179,180, + 5,1,0,0,180,181,3,0,0,0,181,182,5,2,0,0,182,279,1,0,0,0,183,184, + 5,19,0,0,184,185,5,1,0,0,185,186,3,0,0,0,186,187,5,2,0,0,187,279, + 1,0,0,0,188,189,5,20,0,0,189,190,5,1,0,0,190,191,3,0,0,0,191,192, + 5,2,0,0,192,279,1,0,0,0,193,194,5,21,0,0,194,195,5,1,0,0,195,196, + 3,0,0,0,196,197,5,2,0,0,197,279,1,0,0,0,198,199,5,26,0,0,199,200, + 5,1,0,0,200,201,3,0,0,0,201,202,5,2,0,0,202,279,1,0,0,0,203,204, + 5,27,0,0,204,205,5,1,0,0,205,206,3,0,0,0,206,207,5,2,0,0,207,279, + 1,0,0,0,208,209,5,28,0,0,209,210,5,1,0,0,210,211,3,0,0,0,211,212, + 5,2,0,0,212,279,1,0,0,0,213,214,5,29,0,0,214,215,5,1,0,0,215,216, + 3,0,0,0,216,217,5,2,0,0,217,279,1,0,0,0,218,219,5,30,0,0,219,220, + 5,1,0,0,220,221,3,0,0,0,221,222,5,2,0,0,222,279,1,0,0,0,223,224, + 5,31,0,0,224,225,5,1,0,0,225,226,3,0,0,0,226,227,5,2,0,0,227,279, + 1,0,0,0,228,229,5,33,0,0,229,230,5,1,0,0,230,231,3,0,0,0,231,232, + 5,2,0,0,232,279,1,0,0,0,233,234,5,35,0,0,234,235,5,1,0,0,235,236, + 3,0,0,0,236,237,5,2,0,0,237,279,1,0,0,0,238,239,5,36,0,0,239,240, + 5,1,0,0,240,241,3,0,0,0,241,242,5,2,0,0,242,279,1,0,0,0,243,244, + 5,37,0,0,244,245,5,1,0,0,245,246,3,0,0,0,246,247,5,2,0,0,247,279, + 1,0,0,0,248,249,5,38,0,0,249,250,5,1,0,0,250,251,3,0,0,0,251,252, + 5,2,0,0,252,279,1,0,0,0,253,254,5,42,0,0,254,255,5,1,0,0,255,256, + 3,0,0,0,256,257,5,2,0,0,257,279,1,0,0,0,258,259,5,43,0,0,259,260, + 5,1,0,0,260,261,3,0,0,0,261,262,5,2,0,0,262,279,1,0,0,0,263,264, + 5,44,0,0,264,265,5,1,0,0,265,266,3,0,0,0,266,267,5,2,0,0,267,279, + 1,0,0,0,268,269,5,45,0,0,269,270,5,1,0,0,270,271,3,0,0,0,271,272, + 5,2,0,0,272,279,1,0,0,0,273,274,5,46,0,0,274,275,5,1,0,0,275,276, + 3,0,0,0,276,277,5,2,0,0,277,279,1,0,0,0,278,113,1,0,0,0,278,118, + 1,0,0,0,278,123,1,0,0,0,278,128,1,0,0,0,278,133,1,0,0,0,278,138, + 1,0,0,0,278,143,1,0,0,0,278,148,1,0,0,0,278,153,1,0,0,0,278,158, + 1,0,0,0,278,163,1,0,0,0,278,168,1,0,0,0,278,173,1,0,0,0,278,178, + 1,0,0,0,278,183,1,0,0,0,278,188,1,0,0,0,278,193,1,0,0,0,278,198, + 1,0,0,0,278,203,1,0,0,0,278,208,1,0,0,0,278,213,1,0,0,0,278,218, + 1,0,0,0,278,223,1,0,0,0,278,228,1,0,0,0,278,233,1,0,0,0,278,238, + 1,0,0,0,278,243,1,0,0,0,278,248,1,0,0,0,278,253,1,0,0,0,278,258, + 1,0,0,0,278,263,1,0,0,0,278,268,1,0,0,0,278,273,1,0,0,0,279,15,1, + 0,0,0,280,281,5,32,0,0,281,282,5,1,0,0,282,283,3,0,0,0,283,284,5, + 3,0,0,284,285,3,0,0,0,285,286,5,2,0,0,286,316,1,0,0,0,287,288,5, + 10,0,0,288,289,5,1,0,0,289,290,3,0,0,0,290,291,5,3,0,0,291,292,3, + 0,0,0,292,293,5,2,0,0,293,316,1,0,0,0,294,295,5,24,0,0,295,296,5, + 1,0,0,296,297,3,0,0,0,297,298,5,3,0,0,298,299,3,0,0,0,299,300,5, + 2,0,0,300,316,1,0,0,0,301,302,5,25,0,0,302,303,5,1,0,0,303,304,3, + 0,0,0,304,305,5,3,0,0,305,306,3,0,0,0,306,307,5,2,0,0,307,316,1, + 0,0,0,308,309,5,40,0,0,309,310,5,1,0,0,310,311,3,0,0,0,311,312,5, + 3,0,0,312,313,3,0,0,0,313,314,5,2,0,0,314,316,1,0,0,0,315,280,1, + 0,0,0,315,287,1,0,0,0,315,294,1,0,0,0,315,301,1,0,0,0,315,308,1, + 0,0,0,316,17,1,0,0,0,317,318,5,34,0,0,318,319,5,1,0,0,319,320,3, + 0,0,0,320,321,5,3,0,0,321,322,3,0,0,0,322,323,5,3,0,0,323,324,3, + 0,0,0,324,325,5,2,0,0,325,345,1,0,0,0,326,327,5,39,0,0,327,328,5, + 1,0,0,328,329,3,0,0,0,329,330,5,3,0,0,330,331,3,0,0,0,331,332,5, + 3,0,0,332,333,3,0,0,0,333,334,5,2,0,0,334,345,1,0,0,0,335,336,5, + 41,0,0,336,337,5,1,0,0,337,338,3,0,0,0,338,339,5,3,0,0,339,340,3, + 0,0,0,340,341,5,3,0,0,341,342,3,0,0,0,342,343,5,2,0,0,343,345,1, + 0,0,0,344,317,1,0,0,0,344,326,1,0,0,0,344,335,1,0,0,0,345,19,1,0, + 0,0,346,347,5,47,0,0,347,348,5,1,0,0,348,349,3,0,0,0,349,350,5,3, + 0,0,350,351,3,0,0,0,351,352,5,3,0,0,352,353,3,0,0,0,353,354,5,3, + 0,0,354,355,3,0,0,0,355,356,5,2,0,0,356,21,1,0,0,0,357,358,5,22, + 0,0,358,359,5,1,0,0,359,362,3,0,0,0,360,361,5,3,0,0,361,363,3,0, + 0,0,362,360,1,0,0,0,363,364,1,0,0,0,364,362,1,0,0,0,364,365,1,0, + 0,0,365,366,1,0,0,0,366,367,5,2,0,0,367,380,1,0,0,0,368,369,5,23, + 0,0,369,370,5,1,0,0,370,373,3,0,0,0,371,372,5,3,0,0,372,374,3,0, + 0,0,373,371,1,0,0,0,374,375,1,0,0,0,375,373,1,0,0,0,375,376,1,0, + 0,0,376,377,1,0,0,0,377,378,5,2,0,0,378,380,1,0,0,0,379,357,1,0, + 0,0,379,368,1,0,0,0,380,23,1,0,0,0,16,26,49,51,63,65,80,82,90,97, + 111,278,315,344,364,375,379 ] class MathExprParser ( Parser ): @@ -139,8 +162,10 @@ class MathExprParser ( Parser ): "'smax'", "'tmin'", "'tmax'", "'tnorm'", "'snorm'", "'floor'", "'ceil'", "'round'", "'gamma'", "'pow'", "'sigm'", "'clamp'", "'fft'", "'ifft'", "'angle'", - "'print'", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", - "'>='", "'>'", "'<='", "'<'", "'=='", "'!='" ] + "'print'", "'lerp'", "'step'", "'smoothstep'", "'fract'", + "'relu'", "'softplus'", "'gelu'", "'sign'", "'swap'", + "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'>='", "'>'", + "'<='", "'<'", "'=='", "'!='" ] symbolicNames = [ "", "", "", "", "SIN", "COS", "TAN", "ASIN", "ACOS", "ATAN", "ATAN2", @@ -148,9 +173,11 @@ class MathExprParser ( Parser ): "ABS", "SQRT", "LN", "LOG", "EXP", "SMIN", "SMAX", "TMIN", "TMAX", "TNORM", "SNORM", "FLOOR", "CEIL", "ROUND", "GAMMA", "POWE", "SIGM", "CLAMP", "SFFT", - "SIFFT", "ANGL", "PRNT", "PLUS", "MINUS", "MULT", - "DIV", "MOD", "POW", "GE", "GT", "LE", "LT", "EQ", - "NE", "CONSTANT", "NUMBER", "VARIABLE", "WS" ] + "SIFFT", "ANGL", "PRNT", "LERP", "STEP", "SMOOTHSTEP", + "FRACT", "RELU", "SOFTPLUS", "GELU", "SIGN", "SWAP", + "PLUS", "MINUS", "MULT", "DIV", "MOD", "POW", "GE", + "GT", "LE", "LT", "EQ", "NE", "CONSTANT", "NUMBER", + "VARIABLE", "WS" ] RULE_expr = 0 RULE_compExpr = 1 @@ -162,10 +189,12 @@ class MathExprParser ( Parser ): RULE_func1 = 7 RULE_func2 = 8 RULE_func3 = 9 - RULE_funcN = 10 + RULE_func4 = 10 + RULE_funcN = 11 ruleNames = [ "expr", "compExpr", "addExpr", "mulExpr", "powExpr", - "unaryExpr", "atom", "func1", "func2", "func3", "funcN" ] + "unaryExpr", "atom", "func1", "func2", "func3", "func4", + "funcN" ] EOF = Token.EOF T__0=1 @@ -206,22 +235,31 @@ class MathExprParser ( Parser ): SIFFT=36 ANGL=37 PRNT=38 - PLUS=39 - MINUS=40 - MULT=41 - DIV=42 - MOD=43 - POW=44 - GE=45 - GT=46 - LE=47 - LT=48 - EQ=49 - NE=50 - CONSTANT=51 - NUMBER=52 - VARIABLE=53 - WS=54 + LERP=39 + STEP=40 + SMOOTHSTEP=41 + FRACT=42 + RELU=43 + SOFTPLUS=44 + GELU=45 + SIGN=46 + SWAP=47 + PLUS=48 + MINUS=49 + MULT=50 + DIV=51 + MOD=52 + POW=53 + GE=54 + GT=55 + LE=56 + LT=57 + EQ=58 + NE=59 + CONSTANT=60 + NUMBER=61 + VARIABLE=62 + WS=63 def __init__(self, input:TokenStream, output:TextIO = sys.stdout): super().__init__(input, output) @@ -250,14 +288,6 @@ class MathExprParser ( Parser ): def getRuleIndex(self): return MathExprParser.RULE_expr - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterExpr" ): - listener.enterExpr(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitExpr" ): - listener.exitExpr(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpr" ): return visitor.visitExpr(self) @@ -272,18 +302,18 @@ class MathExprParser ( Parser ): localctx = MathExprParser.ExprContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_expr) try: - self.state = 24 + self.state = 26 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,0,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 22 + self.state = 24 self.atom() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 23 + self.state = 25 self.compExpr(0) pass @@ -328,14 +358,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.AddExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLtExp" ): - listener.enterLtExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLtExp" ): - listener.exitLtExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitLtExp" ): return visitor.visitLtExp(self) @@ -358,14 +380,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.AddExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEqExp" ): - listener.enterEqExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEqExp" ): - listener.exitEqExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitEqExp" ): return visitor.visitEqExp(self) @@ -383,14 +397,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.AddExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterToAdd" ): - listener.enterToAdd(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitToAdd" ): - listener.exitToAdd(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitToAdd" ): return visitor.visitToAdd(self) @@ -413,14 +419,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.AddExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterGeExp" ): - listener.enterGeExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitGeExp" ): - listener.exitGeExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitGeExp" ): return visitor.visitGeExp(self) @@ -443,14 +441,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.AddExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLeExp" ): - listener.enterLeExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLeExp" ): - listener.exitLeExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitLeExp" ): return visitor.visitLeExp(self) @@ -473,14 +463,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.AddExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNeExp" ): - listener.enterNeExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNeExp" ): - listener.exitNeExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitNeExp" ): return visitor.visitNeExp(self) @@ -503,14 +485,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.AddExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterGtExp" ): - listener.enterGtExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitGtExp" ): - listener.exitGtExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitGtExp" ): return visitor.visitGtExp(self) @@ -532,10 +506,10 @@ class MathExprParser ( Parser ): self._ctx = localctx _prevctx = localctx - self.state = 27 + self.state = 29 self.addExpr(0) self._ctx.stop = self._input.LT(-1) - self.state = 49 + self.state = 51 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,2,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: @@ -543,89 +517,89 @@ class MathExprParser ( Parser ): if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx - self.state = 47 + self.state = 49 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,1,self._ctx) if la_ == 1: localctx = MathExprParser.GtExpContext(self, MathExprParser.CompExprContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_compExpr) - self.state = 29 + self.state = 31 if not self.precpred(self._ctx, 7): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") - self.state = 30 + self.state = 32 self.match(MathExprParser.GT) - self.state = 31 + self.state = 33 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 = 32 + self.state = 34 if not self.precpred(self._ctx, 6): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") - self.state = 33 + self.state = 35 self.match(MathExprParser.GE) - self.state = 34 + self.state = 36 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 = 35 + self.state = 37 if not self.precpred(self._ctx, 5): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") - self.state = 36 + self.state = 38 self.match(MathExprParser.LT) - self.state = 37 + self.state = 39 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 = 38 + self.state = 40 if not self.precpred(self._ctx, 4): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") - self.state = 39 + self.state = 41 self.match(MathExprParser.LE) - self.state = 40 + self.state = 42 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 = 41 + self.state = 43 if not self.precpred(self._ctx, 3): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") - self.state = 42 + self.state = 44 self.match(MathExprParser.EQ) - self.state = 43 + self.state = 45 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 = 44 + self.state = 46 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") - self.state = 45 + self.state = 47 self.match(MathExprParser.NE) - self.state = 46 + self.state = 48 self.addExpr(0) pass - self.state = 51 + self.state = 53 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,2,self._ctx) @@ -669,14 +643,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.MulExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAddExp" ): - listener.enterAddExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAddExp" ): - listener.exitAddExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAddExp" ): return visitor.visitAddExp(self) @@ -694,14 +660,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.MulExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterToMul" ): - listener.enterToMul(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitToMul" ): - listener.exitToMul(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitToMul" ): return visitor.visitToMul(self) @@ -724,14 +682,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.MulExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSubExp" ): - listener.enterSubExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSubExp" ): - listener.exitSubExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSubExp" ): return visitor.visitSubExp(self) @@ -753,10 +703,10 @@ class MathExprParser ( Parser ): self._ctx = localctx _prevctx = localctx - self.state = 53 + self.state = 55 self.mulExpr(0) self._ctx.stop = self._input.LT(-1) - self.state = 63 + self.state = 65 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,4,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: @@ -764,37 +714,37 @@ class MathExprParser ( Parser ): if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx - self.state = 61 + self.state = 63 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,3,self._ctx) if la_ == 1: localctx = MathExprParser.AddExpContext(self, MathExprParser.AddExprContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_addExpr) - self.state = 55 + self.state = 57 if not self.precpred(self._ctx, 3): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") - self.state = 56 + self.state = 58 self.match(MathExprParser.PLUS) - self.state = 57 + self.state = 59 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 = 58 + self.state = 60 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") - self.state = 59 + self.state = 61 self.match(MathExprParser.MINUS) - self.state = 60 + self.state = 62 self.mulExpr(0) pass - self.state = 65 + self.state = 67 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,4,self._ctx) @@ -838,14 +788,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.PowExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMulExp" ): - listener.enterMulExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMulExp" ): - listener.exitMulExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitMulExp" ): return visitor.visitMulExp(self) @@ -868,14 +810,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.PowExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterModExp" ): - listener.enterModExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitModExp" ): - listener.exitModExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitModExp" ): return visitor.visitModExp(self) @@ -898,14 +832,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.PowExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDivExp" ): - listener.enterDivExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDivExp" ): - listener.exitDivExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitDivExp" ): return visitor.visitDivExp(self) @@ -923,14 +849,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.PowExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterToPow" ): - listener.enterToPow(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitToPow" ): - listener.exitToPow(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitToPow" ): return visitor.visitToPow(self) @@ -952,10 +870,10 @@ class MathExprParser ( Parser ): self._ctx = localctx _prevctx = localctx - self.state = 67 + self.state = 69 self.powExpr() self._ctx.stop = self._input.LT(-1) - self.state = 80 + self.state = 82 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,6,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: @@ -963,50 +881,50 @@ class MathExprParser ( Parser ): if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx - self.state = 78 + self.state = 80 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,5,self._ctx) if la_ == 1: localctx = MathExprParser.MulExpContext(self, MathExprParser.MulExprContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_mulExpr) - self.state = 69 + self.state = 71 if not self.precpred(self._ctx, 4): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") - self.state = 70 + self.state = 72 self.match(MathExprParser.MULT) - self.state = 71 + self.state = 73 self.powExpr() pass elif la_ == 2: localctx = MathExprParser.DivExpContext(self, MathExprParser.MulExprContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_mulExpr) - self.state = 72 + self.state = 74 if not self.precpred(self._ctx, 3): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") - self.state = 73 + self.state = 75 self.match(MathExprParser.DIV) - self.state = 74 + self.state = 76 self.powExpr() pass elif la_ == 3: localctx = MathExprParser.ModExpContext(self, MathExprParser.MulExprContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_mulExpr) - self.state = 75 + self.state = 77 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") - self.state = 76 + self.state = 78 self.match(MathExprParser.MOD) - self.state = 77 + self.state = 79 self.powExpr() pass - self.state = 82 + self.state = 84 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,6,self._ctx) @@ -1051,14 +969,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.PowExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPowExp" ): - listener.enterPowExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPowExp" ): - listener.exitPowExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPowExp" ): return visitor.visitPowExp(self) @@ -1076,14 +986,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterToUnary" ): - listener.enterToUnary(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitToUnary" ): - listener.exitToUnary(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitToUnary" ): return visitor.visitToUnary(self) @@ -1097,24 +999,24 @@ class MathExprParser ( Parser ): localctx = MathExprParser.PowExprContext(self, self._ctx, self.state) self.enterRule(localctx, 8, self.RULE_powExpr) try: - self.state = 88 + self.state = 90 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,7,self._ctx) if la_ == 1: localctx = MathExprParser.PowExpContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 83 - self.unaryExpr() - self.state = 84 - self.match(MathExprParser.POW) self.state = 85 + self.unaryExpr() + self.state = 86 + self.match(MathExprParser.POW) + self.state = 87 self.powExpr() pass elif la_ == 2: localctx = MathExprParser.ToUnaryContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 87 + self.state = 89 self.unaryExpr() pass @@ -1157,14 +1059,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryPlus" ): - listener.enterUnaryPlus(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryPlus" ): - listener.exitUnaryPlus(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitUnaryPlus" ): return visitor.visitUnaryPlus(self) @@ -1184,14 +1078,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryMinus" ): - listener.enterUnaryMinus(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryMinus" ): - listener.exitUnaryMinus(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitUnaryMinus" ): return visitor.visitUnaryMinus(self) @@ -1209,14 +1095,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.AtomContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterToAtom" ): - listener.enterToAtom(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitToAtom" ): - listener.exitToAtom(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitToAtom" ): return visitor.visitToAtom(self) @@ -1230,29 +1108,29 @@ class MathExprParser ( Parser ): localctx = MathExprParser.UnaryExprContext(self, self._ctx, self.state) self.enterRule(localctx, 10, self.RULE_unaryExpr) try: - self.state = 95 + self.state = 97 self._errHandler.sync(self) token = self._input.LA(1) - if token in [39]: + if token in [48]: localctx = MathExprParser.UnaryPlusContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 90 - self.match(MathExprParser.PLUS) - self.state = 91 - self.unaryExpr() - pass - elif token in [40]: - localctx = MathExprParser.UnaryMinusContext(self, localctx) - self.enterOuterAlt(localctx, 2) self.state = 92 - self.match(MathExprParser.MINUS) + self.match(MathExprParser.PLUS) self.state = 93 self.unaryExpr() pass - elif token in [1, 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, 51, 52, 53]: + elif token in [49]: + localctx = MathExprParser.UnaryMinusContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 94 + self.match(MathExprParser.MINUS) + self.state = 95 + self.unaryExpr() + pass + elif token in [1, 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, 60, 61, 62]: localctx = MathExprParser.ToAtomContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 94 + self.state = 96 self.atom() pass else: @@ -1284,6 +1162,23 @@ class MathExprParser ( Parser ): + 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 @@ -1294,14 +1189,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.Func2Context,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunc2Exp" ): - listener.enterFunc2Exp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunc2Exp" ): - listener.exitFunc2Exp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFunc2Exp" ): return visitor.visitFunc2Exp(self) @@ -1318,14 +1205,6 @@ class MathExprParser ( Parser ): def VARIABLE(self): return self.getToken(MathExprParser.VARIABLE, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVariableExp" ): - listener.enterVariableExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVariableExp" ): - listener.exitVariableExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitVariableExp" ): return visitor.visitVariableExp(self) @@ -1343,14 +1222,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.Func3Context,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunc3Exp" ): - listener.enterFunc3Exp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunc3Exp" ): - listener.exitFunc3Exp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFunc3Exp" ): return visitor.visitFunc3Exp(self) @@ -1368,14 +1239,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParenExp" ): - listener.enterParenExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParenExp" ): - listener.exitParenExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitParenExp" ): return visitor.visitParenExp(self) @@ -1392,14 +1255,6 @@ class MathExprParser ( Parser ): def CONSTANT(self): return self.getToken(MathExprParser.CONSTANT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterConstantExp" ): - listener.enterConstantExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitConstantExp" ): - listener.exitConstantExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitConstantExp" ): return visitor.visitConstantExp(self) @@ -1417,14 +1272,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.Func1Context,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunc1Exp" ): - listener.enterFunc1Exp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunc1Exp" ): - listener.exitFunc1Exp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFunc1Exp" ): return visitor.visitFunc1Exp(self) @@ -1442,14 +1289,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.FuncNContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFuncNExp" ): - listener.enterFuncNExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFuncNExp" ): - listener.exitFuncNExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFuncNExp" ): return visitor.visitFuncNExp(self) @@ -1466,14 +1305,6 @@ class MathExprParser ( Parser ): def NUMBER(self): return self.getToken(MathExprParser.NUMBER, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNumberExp" ): - listener.enterNumberExp(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNumberExp" ): - listener.exitNumberExp(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitNumberExp" ): return visitor.visitNumberExp(self) @@ -1487,59 +1318,65 @@ class MathExprParser ( Parser ): localctx = MathExprParser.AtomContext(self, self._ctx, self.state) self.enterRule(localctx, 12, self.RULE_atom) try: - self.state = 108 + self.state = 111 self._errHandler.sync(self) token = self._input.LA(1) - if token in [4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 26, 27, 28, 29, 30, 31, 33, 35, 36, 37, 38]: + if token in [4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 26, 27, 28, 29, 30, 31, 33, 35, 36, 37, 38, 42, 43, 44, 45, 46]: localctx = MathExprParser.Func1ExpContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 97 + self.state = 99 self.func1() pass - elif token in [10, 24, 25, 32]: + elif token in [10, 24, 25, 32, 40]: localctx = MathExprParser.Func2ExpContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 98 + self.state = 100 self.func2() pass - elif token in [34]: + elif token in [34, 39, 41]: localctx = MathExprParser.Func3ExpContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 99 + self.state = 101 self.func3() pass + elif token in [47]: + localctx = MathExprParser.Func4ExpContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 102 + self.func4() + pass elif token in [22, 23]: localctx = MathExprParser.FuncNExpContext(self, localctx) - self.enterOuterAlt(localctx, 4) - self.state = 100 + self.enterOuterAlt(localctx, 5) + self.state = 103 self.funcN() pass - elif token in [53]: + elif token in [62]: localctx = MathExprParser.VariableExpContext(self, localctx) - self.enterOuterAlt(localctx, 5) - self.state = 101 + self.enterOuterAlt(localctx, 6) + self.state = 104 self.match(MathExprParser.VARIABLE) pass - elif token in [52]: + elif token in [61]: localctx = MathExprParser.NumberExpContext(self, localctx) - self.enterOuterAlt(localctx, 6) - self.state = 102 + self.enterOuterAlt(localctx, 7) + self.state = 105 self.match(MathExprParser.NUMBER) pass - elif token in [51]: + elif token in [60]: localctx = MathExprParser.ConstantExpContext(self, localctx) - self.enterOuterAlt(localctx, 7) - self.state = 103 + self.enterOuterAlt(localctx, 8) + self.state = 106 self.match(MathExprParser.CONSTANT) pass elif token in [1]: localctx = MathExprParser.ParenExpContext(self, localctx) - self.enterOuterAlt(localctx, 8) - self.state = 104 + self.enterOuterAlt(localctx, 9) + self.state = 107 self.match(MathExprParser.T__0) - self.state = 105 + self.state = 108 self.expr() - self.state = 106 + self.state = 109 self.match(MathExprParser.T__1) pass else: @@ -1571,6 +1408,25 @@ class MathExprParser ( Parser ): + 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 expr(self): + return self.getTypedRuleContext(MathExprParser.ExprContext,0) + + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSoftplusFunc" ): + return visitor.visitSoftplusFunc(self) + else: + return visitor.visitChildren(self) + + class TanhFuncContext(Func1Context): def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func1Context @@ -1583,14 +1439,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTanhFunc" ): - listener.enterTanhFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTanhFunc" ): - listener.exitTanhFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitTanhFunc" ): return visitor.visitTanhFunc(self) @@ -1610,14 +1458,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAcoshFunc" ): - listener.enterAcoshFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAcoshFunc" ): - listener.exitAcoshFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAcoshFunc" ): return visitor.visitAcoshFunc(self) @@ -1637,14 +1477,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSqrtFunc" ): - listener.enterSqrtFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSqrtFunc" ): - listener.exitSqrtFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSqrtFunc" ): return visitor.visitSqrtFunc(self) @@ -1664,14 +1496,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFloorFunc" ): - listener.enterFloorFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFloorFunc" ): - listener.exitFloorFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFloorFunc" ): return visitor.visitFloorFunc(self) @@ -1691,14 +1515,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRoundFunc" ): - listener.enterRoundFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRoundFunc" ): - listener.exitRoundFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitRoundFunc" ): return visitor.visitRoundFunc(self) @@ -1718,14 +1534,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCeilFunc" ): - listener.enterCeilFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCeilFunc" ): - listener.exitCeilFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitCeilFunc" ): return visitor.visitCeilFunc(self) @@ -1733,6 +1541,25 @@ class MathExprParser ( Parser ): 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 expr(self): + return self.getTypedRuleContext(MathExprParser.ExprContext,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 @@ -1745,14 +1572,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPrintFunc" ): - listener.enterPrintFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPrintFunc" ): - listener.exitPrintFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPrintFunc" ): return visitor.visitPrintFunc(self) @@ -1772,14 +1591,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAbsFunc" ): - listener.enterAbsFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAbsFunc" ): - listener.exitAbsFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAbsFunc" ): return visitor.visitAbsFunc(self) @@ -1799,14 +1610,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAtanFunc" ): - listener.enterAtanFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAtanFunc" ): - listener.exitAtanFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAtanFunc" ): return visitor.visitAtanFunc(self) @@ -1814,6 +1617,25 @@ class MathExprParser ( Parser ): 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 expr(self): + return self.getTypedRuleContext(MathExprParser.ExprContext,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 @@ -1826,14 +1648,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSinhFunc" ): - listener.enterSinhFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSinhFunc" ): - listener.exitSinhFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSinhFunc" ): return visitor.visitSinhFunc(self) @@ -1853,14 +1667,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSigmoidFunc" ): - listener.enterSigmoidFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSigmoidFunc" ): - listener.exitSigmoidFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSigmoidFunc" ): return visitor.visitSigmoidFunc(self) @@ -1880,14 +1686,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLogFunc" ): - listener.enterLogFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLogFunc" ): - listener.exitLogFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitLogFunc" ): return visitor.visitLogFunc(self) @@ -1907,14 +1705,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLnFunc" ): - listener.enterLnFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLnFunc" ): - listener.exitLnFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitLnFunc" ): return visitor.visitLnFunc(self) @@ -1934,14 +1724,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTNormFunc" ): - listener.enterTNormFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTNormFunc" ): - listener.exitTNormFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitTNormFunc" ): return visitor.visitTNormFunc(self) @@ -1961,14 +1743,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSNormFunc" ): - listener.enterSNormFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSNormFunc" ): - listener.exitSNormFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSNormFunc" ): return visitor.visitSNormFunc(self) @@ -1988,14 +1762,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSinFunc" ): - listener.enterSinFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSinFunc" ): - listener.exitSinFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSinFunc" ): return visitor.visitSinFunc(self) @@ -2015,14 +1781,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAcosFunc" ): - listener.enterAcosFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAcosFunc" ): - listener.exitAcosFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAcosFunc" ): return visitor.visitAcosFunc(self) @@ -2042,14 +1800,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCoshFunc" ): - listener.enterCoshFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCoshFunc" ): - listener.exitCoshFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitCoshFunc" ): return visitor.visitCoshFunc(self) @@ -2069,14 +1819,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAnglFunc" ): - listener.enterAnglFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAnglFunc" ): - listener.exitAnglFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAnglFunc" ): return visitor.visitAnglFunc(self) @@ -2084,6 +1826,25 @@ class MathExprParser ( Parser ): 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 expr(self): + return self.getTypedRuleContext(MathExprParser.ExprContext,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 @@ -2096,14 +1857,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTanFunc" ): - listener.enterTanFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTanFunc" ): - listener.exitTanFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitTanFunc" ): return visitor.visitTanFunc(self) @@ -2123,14 +1876,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSifftFunc" ): - listener.enterSifftFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSifftFunc" ): - listener.exitSifftFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSifftFunc" ): return visitor.visitSifftFunc(self) @@ -2138,6 +1883,25 @@ class MathExprParser ( Parser ): 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 expr(self): + return self.getTypedRuleContext(MathExprParser.ExprContext,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 @@ -2150,14 +1914,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterGammaFunc" ): - listener.enterGammaFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitGammaFunc" ): - listener.exitGammaFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitGammaFunc" ): return visitor.visitGammaFunc(self) @@ -2177,14 +1933,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCosFunc" ): - listener.enterCosFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCosFunc" ): - listener.exitCosFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitCosFunc" ): return visitor.visitCosFunc(self) @@ -2204,14 +1952,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAsinFunc" ): - listener.enterAsinFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAsinFunc" ): - listener.exitAsinFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAsinFunc" ): return visitor.visitAsinFunc(self) @@ -2231,14 +1971,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAsinhFunc" ): - listener.enterAsinhFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAsinhFunc" ): - listener.exitAsinhFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAsinhFunc" ): return visitor.visitAsinhFunc(self) @@ -2258,14 +1990,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSfftFunc" ): - listener.enterSfftFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSfftFunc" ): - listener.exitSfftFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSfftFunc" ): return visitor.visitSfftFunc(self) @@ -2285,14 +2009,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAtanhFunc" ): - listener.enterAtanhFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAtanhFunc" ): - listener.exitAtanhFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAtanhFunc" ): return visitor.visitAtanhFunc(self) @@ -2312,14 +2028,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterExpFunc" ): - listener.enterExpFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitExpFunc" ): - listener.exitExpFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpFunc" ): return visitor.visitExpFunc(self) @@ -2333,343 +2041,403 @@ class MathExprParser ( Parser ): localctx = MathExprParser.Func1Context(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_func1) try: - self.state = 250 + self.state = 278 self._errHandler.sync(self) token = self._input.LA(1) if token in [4]: localctx = MathExprParser.SinFuncContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 110 - self.match(MathExprParser.SIN) - self.state = 111 - self.match(MathExprParser.T__0) - self.state = 112 - self.expr() self.state = 113 + self.match(MathExprParser.SIN) + self.state = 114 + self.match(MathExprParser.T__0) + self.state = 115 + self.expr() + self.state = 116 self.match(MathExprParser.T__1) pass elif token in [5]: localctx = MathExprParser.CosFuncContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 115 - self.match(MathExprParser.COS) - self.state = 116 - self.match(MathExprParser.T__0) - self.state = 117 - self.expr() self.state = 118 + self.match(MathExprParser.COS) + self.state = 119 + self.match(MathExprParser.T__0) + self.state = 120 + self.expr() + self.state = 121 self.match(MathExprParser.T__1) pass elif token in [6]: localctx = MathExprParser.TanFuncContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 120 - self.match(MathExprParser.TAN) - self.state = 121 - self.match(MathExprParser.T__0) - self.state = 122 - self.expr() self.state = 123 + self.match(MathExprParser.TAN) + self.state = 124 + self.match(MathExprParser.T__0) + self.state = 125 + self.expr() + self.state = 126 self.match(MathExprParser.T__1) pass elif token in [7]: localctx = MathExprParser.AsinFuncContext(self, localctx) self.enterOuterAlt(localctx, 4) - self.state = 125 - self.match(MathExprParser.ASIN) - self.state = 126 - self.match(MathExprParser.T__0) - self.state = 127 - self.expr() self.state = 128 + self.match(MathExprParser.ASIN) + self.state = 129 + self.match(MathExprParser.T__0) + self.state = 130 + self.expr() + self.state = 131 self.match(MathExprParser.T__1) pass elif token in [8]: localctx = MathExprParser.AcosFuncContext(self, localctx) self.enterOuterAlt(localctx, 5) - self.state = 130 - self.match(MathExprParser.ACOS) - self.state = 131 - self.match(MathExprParser.T__0) - self.state = 132 - self.expr() self.state = 133 + self.match(MathExprParser.ACOS) + self.state = 134 + self.match(MathExprParser.T__0) + self.state = 135 + self.expr() + self.state = 136 self.match(MathExprParser.T__1) pass elif token in [9]: localctx = MathExprParser.AtanFuncContext(self, localctx) self.enterOuterAlt(localctx, 6) - self.state = 135 - self.match(MathExprParser.ATAN) - self.state = 136 - self.match(MathExprParser.T__0) - self.state = 137 - self.expr() self.state = 138 + self.match(MathExprParser.ATAN) + self.state = 139 + self.match(MathExprParser.T__0) + self.state = 140 + self.expr() + self.state = 141 self.match(MathExprParser.T__1) pass elif token in [11]: localctx = MathExprParser.SinhFuncContext(self, localctx) self.enterOuterAlt(localctx, 7) - self.state = 140 - self.match(MathExprParser.SINH) - self.state = 141 - self.match(MathExprParser.T__0) - self.state = 142 - self.expr() self.state = 143 + self.match(MathExprParser.SINH) + self.state = 144 + self.match(MathExprParser.T__0) + self.state = 145 + self.expr() + self.state = 146 self.match(MathExprParser.T__1) pass elif token in [12]: localctx = MathExprParser.CoshFuncContext(self, localctx) self.enterOuterAlt(localctx, 8) - self.state = 145 - self.match(MathExprParser.COSH) - self.state = 146 - self.match(MathExprParser.T__0) - self.state = 147 - self.expr() self.state = 148 + self.match(MathExprParser.COSH) + self.state = 149 + self.match(MathExprParser.T__0) + self.state = 150 + self.expr() + self.state = 151 self.match(MathExprParser.T__1) pass elif token in [13]: localctx = MathExprParser.TanhFuncContext(self, localctx) self.enterOuterAlt(localctx, 9) - self.state = 150 - self.match(MathExprParser.TANH) - self.state = 151 - self.match(MathExprParser.T__0) - self.state = 152 - self.expr() self.state = 153 + self.match(MathExprParser.TANH) + self.state = 154 + self.match(MathExprParser.T__0) + self.state = 155 + self.expr() + self.state = 156 self.match(MathExprParser.T__1) pass elif token in [14]: localctx = MathExprParser.AsinhFuncContext(self, localctx) self.enterOuterAlt(localctx, 10) - self.state = 155 - self.match(MathExprParser.ASINH) - self.state = 156 - self.match(MathExprParser.T__0) - self.state = 157 - self.expr() self.state = 158 + self.match(MathExprParser.ASINH) + self.state = 159 + self.match(MathExprParser.T__0) + self.state = 160 + self.expr() + self.state = 161 self.match(MathExprParser.T__1) pass elif token in [15]: localctx = MathExprParser.AcoshFuncContext(self, localctx) self.enterOuterAlt(localctx, 11) - self.state = 160 - self.match(MathExprParser.ACOSH) - self.state = 161 - self.match(MathExprParser.T__0) - self.state = 162 - self.expr() self.state = 163 + self.match(MathExprParser.ACOSH) + self.state = 164 + self.match(MathExprParser.T__0) + self.state = 165 + self.expr() + self.state = 166 self.match(MathExprParser.T__1) pass elif token in [16]: localctx = MathExprParser.AtanhFuncContext(self, localctx) self.enterOuterAlt(localctx, 12) - self.state = 165 - self.match(MathExprParser.ATANH) - self.state = 166 - self.match(MathExprParser.T__0) - self.state = 167 - self.expr() self.state = 168 + self.match(MathExprParser.ATANH) + self.state = 169 + self.match(MathExprParser.T__0) + self.state = 170 + self.expr() + self.state = 171 self.match(MathExprParser.T__1) pass elif token in [17]: localctx = MathExprParser.AbsFuncContext(self, localctx) self.enterOuterAlt(localctx, 13) - self.state = 170 - self.match(MathExprParser.ABS) - self.state = 171 - self.match(MathExprParser.T__0) - self.state = 172 - self.expr() self.state = 173 + self.match(MathExprParser.ABS) + self.state = 174 + self.match(MathExprParser.T__0) + self.state = 175 + self.expr() + self.state = 176 self.match(MathExprParser.T__1) pass elif token in [18]: localctx = MathExprParser.SqrtFuncContext(self, localctx) self.enterOuterAlt(localctx, 14) - self.state = 175 - self.match(MathExprParser.SQRT) - self.state = 176 - self.match(MathExprParser.T__0) - self.state = 177 - self.expr() self.state = 178 + self.match(MathExprParser.SQRT) + self.state = 179 + self.match(MathExprParser.T__0) + self.state = 180 + self.expr() + self.state = 181 self.match(MathExprParser.T__1) pass elif token in [19]: localctx = MathExprParser.LnFuncContext(self, localctx) self.enterOuterAlt(localctx, 15) - self.state = 180 - self.match(MathExprParser.LN) - self.state = 181 - self.match(MathExprParser.T__0) - self.state = 182 - self.expr() self.state = 183 + self.match(MathExprParser.LN) + self.state = 184 + self.match(MathExprParser.T__0) + self.state = 185 + self.expr() + self.state = 186 self.match(MathExprParser.T__1) pass elif token in [20]: localctx = MathExprParser.LogFuncContext(self, localctx) self.enterOuterAlt(localctx, 16) - self.state = 185 - self.match(MathExprParser.LOG) - self.state = 186 - self.match(MathExprParser.T__0) - self.state = 187 - self.expr() self.state = 188 + self.match(MathExprParser.LOG) + self.state = 189 + self.match(MathExprParser.T__0) + self.state = 190 + self.expr() + self.state = 191 self.match(MathExprParser.T__1) pass elif token in [21]: localctx = MathExprParser.ExpFuncContext(self, localctx) self.enterOuterAlt(localctx, 17) - self.state = 190 - self.match(MathExprParser.EXP) - self.state = 191 - self.match(MathExprParser.T__0) - self.state = 192 - self.expr() self.state = 193 + self.match(MathExprParser.EXP) + self.state = 194 + self.match(MathExprParser.T__0) + self.state = 195 + self.expr() + self.state = 196 self.match(MathExprParser.T__1) pass elif token in [26]: localctx = MathExprParser.TNormFuncContext(self, localctx) self.enterOuterAlt(localctx, 18) - self.state = 195 - self.match(MathExprParser.TNORM) - self.state = 196 - self.match(MathExprParser.T__0) - self.state = 197 - self.expr() self.state = 198 + self.match(MathExprParser.TNORM) + self.state = 199 + self.match(MathExprParser.T__0) + self.state = 200 + self.expr() + self.state = 201 self.match(MathExprParser.T__1) pass elif token in [27]: localctx = MathExprParser.SNormFuncContext(self, localctx) self.enterOuterAlt(localctx, 19) - self.state = 200 - self.match(MathExprParser.SNORM) - self.state = 201 - self.match(MathExprParser.T__0) - self.state = 202 - self.expr() self.state = 203 + self.match(MathExprParser.SNORM) + self.state = 204 + self.match(MathExprParser.T__0) + self.state = 205 + self.expr() + self.state = 206 self.match(MathExprParser.T__1) pass elif token in [28]: localctx = MathExprParser.FloorFuncContext(self, localctx) self.enterOuterAlt(localctx, 20) - self.state = 205 - self.match(MathExprParser.FLOOR) - self.state = 206 - self.match(MathExprParser.T__0) - self.state = 207 - self.expr() self.state = 208 + self.match(MathExprParser.FLOOR) + self.state = 209 + self.match(MathExprParser.T__0) + self.state = 210 + self.expr() + self.state = 211 self.match(MathExprParser.T__1) pass elif token in [29]: localctx = MathExprParser.CeilFuncContext(self, localctx) self.enterOuterAlt(localctx, 21) - self.state = 210 - self.match(MathExprParser.CEIL) - self.state = 211 - self.match(MathExprParser.T__0) - self.state = 212 - self.expr() self.state = 213 + self.match(MathExprParser.CEIL) + self.state = 214 + self.match(MathExprParser.T__0) + self.state = 215 + self.expr() + self.state = 216 self.match(MathExprParser.T__1) pass elif token in [30]: localctx = MathExprParser.RoundFuncContext(self, localctx) self.enterOuterAlt(localctx, 22) - self.state = 215 - self.match(MathExprParser.ROUND) - self.state = 216 - self.match(MathExprParser.T__0) - self.state = 217 - self.expr() self.state = 218 + self.match(MathExprParser.ROUND) + self.state = 219 + self.match(MathExprParser.T__0) + self.state = 220 + self.expr() + self.state = 221 self.match(MathExprParser.T__1) pass elif token in [31]: localctx = MathExprParser.GammaFuncContext(self, localctx) self.enterOuterAlt(localctx, 23) - self.state = 220 - self.match(MathExprParser.GAMMA) - self.state = 221 - self.match(MathExprParser.T__0) - self.state = 222 - self.expr() self.state = 223 + self.match(MathExprParser.GAMMA) + self.state = 224 + self.match(MathExprParser.T__0) + self.state = 225 + self.expr() + self.state = 226 self.match(MathExprParser.T__1) pass elif token in [33]: localctx = MathExprParser.SigmoidFuncContext(self, localctx) self.enterOuterAlt(localctx, 24) - self.state = 225 - self.match(MathExprParser.SIGM) - self.state = 226 - self.match(MathExprParser.T__0) - self.state = 227 - self.expr() self.state = 228 + self.match(MathExprParser.SIGM) + self.state = 229 + self.match(MathExprParser.T__0) + self.state = 230 + self.expr() + self.state = 231 self.match(MathExprParser.T__1) pass elif token in [35]: localctx = MathExprParser.SfftFuncContext(self, localctx) self.enterOuterAlt(localctx, 25) - self.state = 230 - self.match(MathExprParser.SFFT) - self.state = 231 - self.match(MathExprParser.T__0) - self.state = 232 - self.expr() self.state = 233 + self.match(MathExprParser.SFFT) + self.state = 234 + self.match(MathExprParser.T__0) + self.state = 235 + self.expr() + self.state = 236 self.match(MathExprParser.T__1) pass elif token in [36]: localctx = MathExprParser.SifftFuncContext(self, localctx) self.enterOuterAlt(localctx, 26) - self.state = 235 - self.match(MathExprParser.SIFFT) - self.state = 236 - self.match(MathExprParser.T__0) - self.state = 237 - self.expr() self.state = 238 + self.match(MathExprParser.SIFFT) + self.state = 239 + self.match(MathExprParser.T__0) + self.state = 240 + self.expr() + self.state = 241 self.match(MathExprParser.T__1) pass elif token in [37]: localctx = MathExprParser.AnglFuncContext(self, localctx) self.enterOuterAlt(localctx, 27) - self.state = 240 - self.match(MathExprParser.ANGL) - self.state = 241 - self.match(MathExprParser.T__0) - self.state = 242 - self.expr() self.state = 243 + self.match(MathExprParser.ANGL) + self.state = 244 + self.match(MathExprParser.T__0) + self.state = 245 + self.expr() + self.state = 246 self.match(MathExprParser.T__1) pass elif token in [38]: localctx = MathExprParser.PrintFuncContext(self, localctx) self.enterOuterAlt(localctx, 28) - self.state = 245 - self.match(MathExprParser.PRNT) - self.state = 246 - self.match(MathExprParser.T__0) - self.state = 247 - self.expr() self.state = 248 + self.match(MathExprParser.PRNT) + self.state = 249 + self.match(MathExprParser.T__0) + self.state = 250 + self.expr() + self.state = 251 + self.match(MathExprParser.T__1) + pass + elif token in [42]: + localctx = MathExprParser.FractFuncContext(self, localctx) + self.enterOuterAlt(localctx, 29) + self.state = 253 + self.match(MathExprParser.FRACT) + self.state = 254 + self.match(MathExprParser.T__0) + self.state = 255 + self.expr() + self.state = 256 + self.match(MathExprParser.T__1) + pass + elif token in [43]: + localctx = MathExprParser.ReluFuncContext(self, localctx) + self.enterOuterAlt(localctx, 30) + self.state = 258 + self.match(MathExprParser.RELU) + self.state = 259 + self.match(MathExprParser.T__0) + self.state = 260 + self.expr() + self.state = 261 + self.match(MathExprParser.T__1) + pass + elif token in [44]: + localctx = MathExprParser.SoftplusFuncContext(self, localctx) + self.enterOuterAlt(localctx, 31) + self.state = 263 + self.match(MathExprParser.SOFTPLUS) + self.state = 264 + self.match(MathExprParser.T__0) + self.state = 265 + self.expr() + self.state = 266 + self.match(MathExprParser.T__1) + pass + elif token in [45]: + localctx = MathExprParser.GeluFuncContext(self, localctx) + self.enterOuterAlt(localctx, 32) + self.state = 268 + self.match(MathExprParser.GELU) + self.state = 269 + self.match(MathExprParser.T__0) + self.state = 270 + self.expr() + self.state = 271 + self.match(MathExprParser.T__1) + pass + elif token in [46]: + localctx = MathExprParser.SignFuncContext(self, localctx) + self.enterOuterAlt(localctx, 33) + self.state = 273 + self.match(MathExprParser.SIGN) + self.state = 274 + self.match(MathExprParser.T__0) + self.state = 275 + self.expr() + self.state = 276 self.match(MathExprParser.T__1) pass else: @@ -2716,14 +2484,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTMaxFunc" ): - listener.enterTMaxFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTMaxFunc" ): - listener.exitTMaxFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitTMaxFunc" ): return visitor.visitTMaxFunc(self) @@ -2746,14 +2506,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPowFunc" ): - listener.enterPowFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPowFunc" ): - listener.exitPowFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPowFunc" ): return visitor.visitPowFunc(self) @@ -2761,6 +2513,28 @@ class MathExprParser ( Parser ): 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 expr(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(MathExprParser.ExprContext) + else: + return self.getTypedRuleContext(MathExprParser.ExprContext,i) + + + 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 @@ -2776,14 +2550,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAtan2Func" ): - listener.enterAtan2Func(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAtan2Func" ): - listener.exitAtan2Func(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAtan2Func" ): return visitor.visitAtan2Func(self) @@ -2806,14 +2572,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTMinFunc" ): - listener.enterTMinFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTMinFunc" ): - listener.exitTMinFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitTMinFunc" ): return visitor.visitTMinFunc(self) @@ -2827,71 +2585,87 @@ class MathExprParser ( Parser ): localctx = MathExprParser.Func2Context(self, self._ctx, self.state) self.enterRule(localctx, 16, self.RULE_func2) try: - self.state = 280 + self.state = 315 self._errHandler.sync(self) token = self._input.LA(1) if token in [32]: localctx = MathExprParser.PowFuncContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 252 + self.state = 280 self.match(MathExprParser.POWE) - self.state = 253 + self.state = 281 self.match(MathExprParser.T__0) - self.state = 254 + self.state = 282 self.expr() - self.state = 255 + self.state = 283 self.match(MathExprParser.T__2) - self.state = 256 + self.state = 284 self.expr() - self.state = 257 + self.state = 285 self.match(MathExprParser.T__1) pass elif token in [10]: localctx = MathExprParser.Atan2FuncContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 259 + self.state = 287 self.match(MathExprParser.ATAN2) - self.state = 260 + self.state = 288 self.match(MathExprParser.T__0) - self.state = 261 + self.state = 289 self.expr() - self.state = 262 + self.state = 290 self.match(MathExprParser.T__2) - self.state = 263 + self.state = 291 self.expr() - self.state = 264 + self.state = 292 self.match(MathExprParser.T__1) pass elif token in [24]: localctx = MathExprParser.TMinFuncContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 266 + self.state = 294 self.match(MathExprParser.TMIN) - self.state = 267 + self.state = 295 self.match(MathExprParser.T__0) - self.state = 268 + self.state = 296 self.expr() - self.state = 269 + self.state = 297 self.match(MathExprParser.T__2) - self.state = 270 + self.state = 298 self.expr() - self.state = 271 + self.state = 299 self.match(MathExprParser.T__1) pass elif token in [25]: localctx = MathExprParser.TMaxFuncContext(self, localctx) self.enterOuterAlt(localctx, 4) - self.state = 273 + self.state = 301 self.match(MathExprParser.TMAX) - self.state = 274 + self.state = 302 self.match(MathExprParser.T__0) - self.state = 275 + self.state = 303 self.expr() - self.state = 276 + self.state = 304 self.match(MathExprParser.T__2) - self.state = 277 + self.state = 305 self.expr() - self.state = 278 + self.state = 306 + self.match(MathExprParser.T__1) + pass + elif token in [40]: + localctx = MathExprParser.StepFuncContext(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 308 + self.match(MathExprParser.STEP) + self.state = 309 + self.match(MathExprParser.T__0) + self.state = 310 + self.expr() + self.state = 311 + self.match(MathExprParser.T__2) + self.state = 312 + self.expr() + self.state = 313 self.match(MathExprParser.T__1) pass else: @@ -2923,6 +2697,50 @@ class MathExprParser ( Parser ): + 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 expr(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(MathExprParser.ExprContext) + else: + return self.getTypedRuleContext(MathExprParser.ExprContext,i) + + + 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 expr(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(MathExprParser.ExprContext) + else: + return self.getTypedRuleContext(MathExprParser.ExprContext,i) + + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSmoothstepFunc" ): + return visitor.visitSmoothstepFunc(self) + else: + return visitor.visitChildren(self) + + class ClampFuncContext(Func3Context): def __init__(self, parser, ctx:ParserRuleContext): # actually a MathExprParser.Func3Context @@ -2938,14 +2756,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterClampFunc" ): - listener.enterClampFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitClampFunc" ): - listener.exitClampFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitClampFunc" ): return visitor.visitClampFunc(self) @@ -2959,23 +2769,147 @@ class MathExprParser ( Parser ): localctx = MathExprParser.Func3Context(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_func3) try: - localctx = MathExprParser.ClampFuncContext(self, localctx) + self.state = 344 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [34]: + localctx = MathExprParser.ClampFuncContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 317 + self.match(MathExprParser.CLAMP) + self.state = 318 + self.match(MathExprParser.T__0) + self.state = 319 + self.expr() + self.state = 320 + self.match(MathExprParser.T__2) + self.state = 321 + self.expr() + self.state = 322 + self.match(MathExprParser.T__2) + self.state = 323 + self.expr() + self.state = 324 + self.match(MathExprParser.T__1) + pass + elif token in [39]: + localctx = MathExprParser.LerpFuncContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 326 + self.match(MathExprParser.LERP) + self.state = 327 + self.match(MathExprParser.T__0) + self.state = 328 + self.expr() + self.state = 329 + self.match(MathExprParser.T__2) + self.state = 330 + self.expr() + self.state = 331 + self.match(MathExprParser.T__2) + self.state = 332 + self.expr() + self.state = 333 + self.match(MathExprParser.T__1) + pass + elif token in [41]: + localctx = MathExprParser.SmoothstepFuncContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 335 + self.match(MathExprParser.SMOOTHSTEP) + self.state = 336 + self.match(MathExprParser.T__0) + self.state = 337 + self.expr() + self.state = 338 + self.match(MathExprParser.T__2) + self.state = 339 + self.expr() + self.state = 340 + self.match(MathExprParser.T__2) + self.state = 341 + self.expr() + self.state = 342 + self.match(MathExprParser.T__1) + 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 expr(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(MathExprParser.ExprContext) + else: + return self.getTypedRuleContext(MathExprParser.ExprContext,i) + + + 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, 20, self.RULE_func4) + try: + localctx = MathExprParser.SwapFuncContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 282 - self.match(MathExprParser.CLAMP) - self.state = 283 + self.state = 346 + self.match(MathExprParser.SWAP) + self.state = 347 self.match(MathExprParser.T__0) - self.state = 284 + self.state = 348 self.expr() - self.state = 285 + self.state = 349 self.match(MathExprParser.T__2) - self.state = 286 + self.state = 350 self.expr() - self.state = 287 + self.state = 351 self.match(MathExprParser.T__2) - self.state = 288 + self.state = 352 self.expr() - self.state = 289 + self.state = 353 + self.match(MathExprParser.T__2) + self.state = 354 + self.expr() + self.state = 355 self.match(MathExprParser.T__1) except RecognitionException as re: localctx.exception = re @@ -3018,14 +2952,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSMaxFunc" ): - listener.enterSMaxFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSMaxFunc" ): - listener.exitSMaxFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSMaxFunc" ): return visitor.visitSMaxFunc(self) @@ -3048,14 +2974,6 @@ class MathExprParser ( Parser ): return self.getTypedRuleContext(MathExprParser.ExprContext,i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSMinFunc" ): - listener.enterSMinFunc(self) - - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSMinFunc" ): - listener.exitSMinFunc(self) - def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSMinFunc" ): return visitor.visitSMinFunc(self) @@ -3067,62 +2985,62 @@ class MathExprParser ( Parser ): def funcN(self): localctx = MathExprParser.FuncNContext(self, self._ctx, self.state) - self.enterRule(localctx, 20, self.RULE_funcN) + self.enterRule(localctx, 22, self.RULE_funcN) self._la = 0 # Token type try: - self.state = 313 + self.state = 379 self._errHandler.sync(self) token = self._input.LA(1) if token in [22]: localctx = MathExprParser.SMinFuncContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 291 + self.state = 357 self.match(MathExprParser.SMIN) - self.state = 292 + self.state = 358 self.match(MathExprParser.T__0) - self.state = 293 + self.state = 359 self.expr() - self.state = 296 + self.state = 362 self._errHandler.sync(self) _la = self._input.LA(1) while True: - self.state = 294 + self.state = 360 self.match(MathExprParser.T__2) - self.state = 295 + self.state = 361 self.expr() - self.state = 298 + self.state = 364 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==3): break - self.state = 300 + self.state = 366 self.match(MathExprParser.T__1) pass elif token in [23]: localctx = MathExprParser.SMaxFuncContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 302 + self.state = 368 self.match(MathExprParser.SMAX) - self.state = 303 + self.state = 369 self.match(MathExprParser.T__0) - self.state = 304 + self.state = 370 self.expr() - self.state = 307 + self.state = 373 self._errHandler.sync(self) _la = self._input.LA(1) while True: - self.state = 305 + self.state = 371 self.match(MathExprParser.T__2) - self.state = 306 + self.state = 372 self.expr() - self.state = 309 + self.state = 375 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==3): break - self.state = 311 + self.state = 377 self.match(MathExprParser.T__1) pass else: diff --git a/src/more_math/Parser/MathExprVisitor.py b/src/more_math/Parser/MathExprVisitor.py index ba8a393..c50de3b 100644 --- a/src/more_math/Parser/MathExprVisitor.py +++ b/src/more_math/Parser/MathExprVisitor.py @@ -1,4 +1,4 @@ -# Generated from MathExpr.g4 by ANTLR 4.13.2 +# Generated from src/more_math/Parser/MathExpr.g4 by ANTLR 4.13.2 from antlr4 import * if "." in __name__: from .MathExprParser import MathExprParser @@ -124,6 +124,11 @@ class MathExprVisitor(ParseTreeVisitor): return self.visitChildren(ctx) + # Visit a parse tree produced by MathExprParser#Func4Exp. + def visitFunc4Exp(self, ctx:MathExprParser.Func4ExpContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by MathExprParser#FuncNExp. def visitFuncNExp(self, ctx:MathExprParser.FuncNExpContext): return self.visitChildren(ctx) @@ -289,6 +294,31 @@ class MathExprVisitor(ParseTreeVisitor): return self.visitChildren(ctx) + # Visit a parse tree produced by MathExprParser#FractFunc. + def visitFractFunc(self, ctx:MathExprParser.FractFuncContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by MathExprParser#ReluFunc. + def visitReluFunc(self, ctx:MathExprParser.ReluFuncContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by MathExprParser#SoftplusFunc. + def visitSoftplusFunc(self, ctx:MathExprParser.SoftplusFuncContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by MathExprParser#GeluFunc. + def visitGeluFunc(self, ctx:MathExprParser.GeluFuncContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by MathExprParser#SignFunc. + def visitSignFunc(self, ctx:MathExprParser.SignFuncContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by MathExprParser#PowFunc. def visitPowFunc(self, ctx:MathExprParser.PowFuncContext): return self.visitChildren(ctx) @@ -309,11 +339,31 @@ class MathExprVisitor(ParseTreeVisitor): return self.visitChildren(ctx) + # Visit a parse tree produced by MathExprParser#StepFunc. + def visitStepFunc(self, ctx:MathExprParser.StepFuncContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by MathExprParser#ClampFunc. def visitClampFunc(self, ctx:MathExprParser.ClampFuncContext): return self.visitChildren(ctx) + # Visit a parse tree produced by MathExprParser#LerpFunc. + def visitLerpFunc(self, ctx:MathExprParser.LerpFuncContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by MathExprParser#SmoothstepFunc. + def visitSmoothstepFunc(self, ctx:MathExprParser.SmoothstepFuncContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by MathExprParser#SwapFunc. + def visitSwapFunc(self, ctx:MathExprParser.SwapFuncContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by MathExprParser#SMinFunc. def visitSMinFunc(self, ctx:MathExprParser.SMinFuncContext): return self.visitChildren(ctx) diff --git a/src/more_math/Parser/TensorEvalVisitor.py b/src/more_math/Parser/TensorEvalVisitor.py index dba5ae1..8e8a4a3 100644 --- a/src/more_math/Parser/TensorEvalVisitor.py +++ b/src/more_math/Parser/TensorEvalVisitor.py @@ -124,6 +124,14 @@ class TensorEvalVisitor(MathExprVisitor): def visitRoundFunc(self, ctx): return torch.round(self.visit(ctx.expr())) def visitGammaFunc(self, ctx): return torch.special.gamma(self.visit(ctx.expr())).exp() def visitSigmoidFunc(self, ctx): return torch.sigmoid(self.visit(ctx.expr())) + def visitReluFunc(self, ctx): return torch.relu(self.visit(ctx.expr())) + def visitSoftplusFunc(self, ctx): return torch.nn.functional.softplus(self.visit(ctx.expr())) + def visitGeluFunc(self, ctx): return torch.nn.functional.gelu(self.visit(ctx.expr())) + def visitSignFunc(self, ctx): return torch.sign(self.visit(ctx.expr())) + def visitFractFunc(self, ctx): + val = self.visit(ctx.expr()) + return val - torch.floor(val) + def visitAnglFunc(self, ctx): return torch.angle(self.visit(ctx.expr())) def visitPrintFunc(self, ctx): val = self.visit(ctx.expr()) @@ -138,7 +146,37 @@ class TensorEvalVisitor(MathExprVisitor): return time_to_freq(val) finally: self.variables = old_vars + + def visitSwapFunc(self, ctx): + tsr = self.visit(ctx.expr(0)) + # Evaluate arguments for dim, idx1, idx2. They return full tensors, so we take scalar value. + # We use .data.flatten()[0] to get the scalar safely from any shape + dim_t = self.visit(ctx.expr(1)) + idx1_t = self.visit(ctx.expr(2)) + idx2_t = self.visit(ctx.expr(3)) + + dim = int(dim_t.flatten()[0].item()) + i = int(idx1_t.flatten()[0].item()) + j = int(idx2_t.flatten()[0].item()) + + # Handle negative dim + if dim < 0: dim += tsr.ndim + + # Create permuted index + indices = torch.arange(tsr.shape[dim], device=tsr.device) + # Swap + # Check bounds? Torch index_select will check bounds or crash. + # Support python style negative indexing for indices + if i < 0: i += tsr.shape[dim] + if j < 0: j += tsr.shape[dim] + + val_i = indices[i].clone() + indices[i] = indices[j] + indices[j] = val_i + + return torch.index_select(tsr, dim, indices) + def visitSifftFunc(self, ctx): old_vars = self.variables # Switch to freq variables @@ -208,6 +246,27 @@ class TensorEvalVisitor(MathExprVisitor): return torch.atan2(self.visit(ctx.expr(0)), self.visit(ctx.expr(1))) def visitClampFunc(self, ctx): return torch.clamp(self.visit(ctx.expr(0)), self.visit(ctx.expr(1)), self.visit(ctx.expr(2))) + def visitLerpFunc(self, ctx): + a = self.visit(ctx.expr(0)) + b = self.visit(ctx.expr(1)) + w = self.visit(ctx.expr(2)) + return torch.lerp(a, b, w) + + def visitSmoothstepFunc(self, ctx): + edge0 = self.visit(ctx.expr(0)) + edge1 = self.visit(ctx.expr(1)) + x = self.visit(ctx.expr(2)) + + # Scale, bias and saturate x to 0..1 range + t = torch.clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0) + # Evaluate polynomial + return t * t * (3.0 - 2.0 * t) + + def visitStepFunc(self, ctx): + edge = self.visit(ctx.expr(0)) + x = self.visit(ctx.expr(1)) + # step(edge, x) = 1 if x >= edge else 0 + return torch.where(x >= edge, 1.0, 0.0) # N-argument functions def visitSMinFunc(self, ctx): args = [self.visit(e) for e in ctx.expr()] @@ -227,6 +286,10 @@ class TensorEvalVisitor(MathExprVisitor): return self.visitChildren(ctx) def visitFuncNExp(self, ctx): return self.visitChildren(ctx) + def visitFunc3Exp(self, ctx): + return self.visitChildren(ctx) + def visitFunc4Exp(self, ctx): + return self.visitChildren(ctx) def visitAtomExp(self, ctx): return self.visitChildren(ctx) diff --git a/tests/test_more_math.py b/tests/test_more_math.py index 879fed9..c25df60 100644 --- a/tests/test_more_math.py +++ b/tests/test_more_math.py @@ -2,6 +2,83 @@ """Tests for `more_math` package.""" +import unittest +import torch +from more_math.ConditioningMathNode import ConditioningMathNode +from more_math.LatentMathNode import LatentMathNode +from more_math.LatentMathNode import LatentMathNode +from more_math.ImageMathNode import ImageMathNode +from more_math.FloatMathNode import FloatMathNode +import tokenize +from io import StringIO + +def tokenize_expression(expr): + if not expr.endswith('\n'): + expr = expr + '\n' + f = StringIO(expr) + tokens = tokenize.generate_tokens(f.readline) + filtered_tokens = [] + for toktype, tokval, _, _, _ in tokens: + token_name = tokenize.tok_name[toktype] + # Opravíme ERRORTOKEN na OP pro !, &, |, ^ + if token_name == 'ERRORTOKEN' and tokval in {'!', '&', '|', '^'}: + token_name = 'OP' + if token_name in {'COMMENT', 'NL', 'NEWLINE', 'INDENT', 'DEDENT'}: + continue + filtered_tokens.append((token_name, tokval.strip())) + return filtered_tokens + + +class TestMoreMath(unittest.TestCase): + def test_conditioning_math_node_initialization(self): + node = ConditioningMathNode() + self.assertIsInstance(node, ConditioningMathNode) + + def test_conditioning_math_node_metadata(self): + self.assertEqual(ConditioningMathNode.RETURN_TYPES, ["CONDITIONING"]) + self.assertEqual(ConditioningMathNode.FUNCTION, "EXECUTE_NORMALIZED") + self.assertEqual(ConditioningMathNode.CATEGORY, "More math") + + def test_latent_math_node_initialization(self): + node = LatentMathNode() + self.assertIsInstance(node, LatentMathNode) + + def test_latent_math_node_metadata(self): + self.assertEqual(LatentMathNode.RETURN_TYPES, ["LATENT"]) + self.assertEqual(LatentMathNode.FUNCTION, "EXECUTE_NORMALIZED") + self.assertEqual(LatentMathNode.CATEGORY, "More math") + + def test_image_math_node_initialization(self): + node = ImageMathNode() + self.assertIsInstance(node, ImageMathNode) + + def test_image_math_node_metadata(self): + self.assertEqual(ImageMathNode.RETURN_TYPES, ["IMAGE"]) + self.assertEqual(ImageMathNode.FUNCTION, "EXECUTE_NORMALIZED") + self.assertEqual(ImageMathNode.CATEGORY, "More math") + + def test_fft_invertibility(self): + # 1. Create random input latent (Batch, Channel, Height, Width) + input_tensor = torch.randn(1, 4, 32, 32, dtype=torch.float32) + input_dict = {"samples": input_tensor} + + # 2. Execute ifft(fft(a)) + # Note: execute is a classmethod + result = LatentMathNode.execute( + Latent="ifft(fft(a))", + a=input_dict + ) + + # 3. Get output tensor + output_tensor = result[0]["samples"] + + # 4. Check correctness (approximate equality) + self.assertTrue(torch.allclose(input_tensor, output_tensor, atol=1e-5), \ + f"Max difference: {(input_tensor - output_tensor).abs().max()}") +#!/usr/bin/env python + +"""Tests for `more_math` package.""" + import unittest import torch from more_math.ConditioningMathNode import ConditioningMathNode @@ -89,4 +166,65 @@ class TestMoreMath(unittest.TestCase): self.assertTrue(torch.allclose(input_tensor, output_tensor, atol=1e-5), \ f"Image FFT round trip failed. Max diff: {(input_tensor - output_tensor).abs().max()}") + def test_new_math_functions(self): + node = LatentMathNode() + # Test Lerp + # lerp(a, b, 0.5) where a=0, b=10 -> 5 + l_a = {"samples": torch.zeros(1, 4, 32, 32)} + l_b = {"samples": torch.full((1, 4, 32, 32), 10.0)} + res_lerp = node.execute("lerp(a, b, 0.5)", a=l_a, b=l_b)[0]["samples"] + self.assertTrue(torch.allclose(res_lerp, torch.full_like(res_lerp, 5.0))) + + # Test Step + # step(0.5, a) where a=0.8 -> 1 + res_step = node.execute("step(0.5, a)", a={"samples": torch.full((1,1,1,1), 0.8)})[0]["samples"] + self.assertTrue(torch.allclose(res_step, torch.ones_like(res_step))) + # step(0.5, a) where a=0.2 -> 0 + res_step2 = node.execute("step(0.5, a)", a={"samples": torch.full((1,1,1,1), 0.2)})[0]["samples"] + self.assertTrue(torch.allclose(res_step2, torch.zeros_like(res_step2))) + + # Test Swap + # tensor 1x3: [0, 1, 2]. Swap(dim=1, 0, 2) -> [2, 1, 0] + t = torch.tensor([[[0.0, 1.0, 2.0]]]) # 1x1x3 + l_t = {"samples": t} + # dim 2 (channel dim in 1x1x3? No, dims are B,C,H,W usually but here shape is 1x1x3) + # LatentMathNode uses "samples" directly. + # eval_single_tensor exposes 'a'. + # Let's use simple Latent 1x4x1x1 (B,C,H,W) + t_lat = torch.tensor([0.0, 10.0, 20.0, 30.0]).view(1,4,1,1) + # Swap channels 0 and 3 -> 30, 10, 20, 0 + l_swap = {"samples": t_lat} + # swap(a, 1, 0, 3) . Dim 1 is channel (B=0, C=1) + res_swap = node.execute("swap(a, 1, 0, 3)", a=l_swap)[0]["samples"] + expected = torch.tensor([30.0, 10.0, 20.0, 0.0]).view(1,4,1,1) + self.assertTrue(torch.allclose(res_swap, expected)) + + # Test Relu, Sign, Fract + res_relu = node.execute("relu(-5.0)", a=l_a)[0]["samples"] + self.assertTrue(torch.allclose(res_relu, torch.zeros_like(res_relu))) + + res_sign = node.execute("sign(-5.0)", a=l_a)[0]["samples"] + self.assertTrue(torch.allclose(res_sign, torch.full_like(res_sign, -1.0))) + + res_fract = node.execute("fract(1.5)", a=l_a)[0]["samples"] + self.assertTrue(torch.allclose(res_fract, torch.full_like(res_fract, 0.5))) + + def test_float_math_functions(self): + node = FloatMathNode() + # Test Lerp: lerp(0, 10, 0.5) -> 5.0 + res = node.execute("lerp(a, b, 0.5)", a=0.0, b=10.0)[0] + self.assertAlmostEqual(res, 5.0) + + # Test Step: step(0.5, 0.8) -> 1.0 + res = node.execute("step(0.5, a)", a=0.8)[0] + self.assertAlmostEqual(res, 1.0) + + # Test Relu: relu(-5) -> 0.0 + res = node.execute("relu(a)", a=-5.0)[0] + self.assertAlmostEqual(res, 0.0) + + # Test Smoothstep: smoothstep(0, 1, 0.5) -> 0.5 + # 0.5*0.5*(3 - 2*0.5) = 0.25 * 2 = 0.5 + res = node.execute("smoothstep(0, 1, a)", a=0.5)[0] + self.assertAlmostEqual(res, 0.5)