数学图形可视化工具的脚本语法

数学图形可视化工具的脚本语法
我写了一套数学图形可视化的工具,可以将数学表达式以图形的形式显示出来.

软件下载地址:http://files.cnblogs.com/WhyEngine/WhyMathGraph.zip

源码下载地址: http://pan.baidu.com/s/1jG9QKq6

QQ交流群: 367752815

在这套软件中,我首先制订了一套脚本语言.语法很简单,用于描述数学参数方程,以做为软件的输入数据.

先看下面的脚本程序

Sin曲线
```
vertices = 1200

x = from (-4*PI) to (4*PI)

y = sin(x)
```
Sin面
```
vertices = D1:360 D2:100
u = from 0 to 1 D1
v = from -1 to 1 D2
s = 10
x = s*u
y = s*v*sin(u*2*PI)

u = u*5
v = v*5
```
(1)顶点数目设置

在计算机图形学中曲线是由顶点组成的
```
 'vertices = 1200' 表示顶点数目,意味着整个曲线上有1200个顶点.

该软件不仅支持曲线还支持曲面,如果是数学曲面图形脚本的话,其顶点输入应该是一个二维的数据.
```
二维数据用于生成生成曲面图形,其定义如下:

vertices = dimension1:80 dimension2:160 或

vertices = D1:80 D2:160

这里表示第一个维度的输入为80,第二个维度的输入为160,整体输入的顶点数目为80*160.而生成的曲面三角形数目为79*159*2个.

(2)常数值
```
脚本程序中PI为定义的常数值,就是圆周率,目前软件中有5个常数值
```
PI 3.1415927
E 2.7182818
GOLD 0.6180034
SQRT2 1.4142136
SQRT3 1.7320508
常量名通常为大写字母,如 (PI + E) 或 sin(PI*0.5)

(3)数值解析
对整数的解析支持2,8,10,16四种进制
0X开头为16进制, XABCDEF大小写都可以, 如0xffff
0Y开头为2进制, Y大小写都可以, 如0y10101010000
0开头为8进制, 如07523, 注意出现了"08"之类的会解析失败
默认为10进制

对浮点数的解析支持两种方式
(a)形如”0.12”的格式,不能省略前面的0,后面也不能加f
(b)科学表达格式.形如1.2e2

(4)变量及其赋值

系统中使用a-z的26个英文小写字母表示变量,变量能够存储单个实数,或一个实数数组.如果为实数数据,则其数组大小为之前设置的顶点数目(见1).

设置为单个实数

a = 3.1415 // 将a赋值为3.1415

a = PI // 将a赋值为常量PI

a = 0y10101010000 //2进制
a = 07523 //8进制

一维数组的设置

a = from 0 to 100 // a为一个实数数组,数组大小为vertices的设置,数值为线性插值求得.得到一个等差数组.

二维数据的设置

a = from 0 to (2*PI) dimension1

b = from (-PI*0.5) to (PI*0.5) dimension2

或者

a = from 0 to (2*PI) D1

b = from (-PI*0.5) to (PI*0.5) D2

这里的D1,D2表示这两个数组是第一维度的数据还是第二个维度的数据.

如果之前设置的vertices = D1:80 D2:160,那么这里a,b所生成的数组大小为80*160

对输出变量的使用:

软件中将变量x,y,z组成3D顶点位置坐标

r,g,b将组成顶点颜色.其值范围在0-1.0之间.如果没有设置r,g,b,将使用默认方式生成顶点色.

u,v为顶点的纹理坐标,如果没有设置u,v,将使用x,z生成顶点的纹理坐标.

(5)运算符
运算符这一块比较多,用户最好看下
”. MathGraphProjectMathExpressionoperator.cpp”文件中的代码.
以及文件夹” MathScript函数面”里面的脚本文件.

标准单目运算符
+,-
如:a = -b

标准双目运算符
+,-,*,/,%,^ <,>,=,&,|
如:c = a * b 如果a,b都为单个实数则运算结果c也是单个实数,否则c为实数数组.

a^b 等同于pow(a, b)

&|为逻辑运算符,规定当变量-1<a<1时为false,否则为true

函数单目运算符形如sin(a)
positive,negative,abs,floor,ceil,sign,sqrt,exp,log,log2,log10,sin,cos,tan,asin,acos,atan,rand等

相关代码如下:
```
    const Operator singleOperators[SINGLE_OPERATORS_COUNT] =
    {
        {"positive",        0, OT_SINGLE, yf_positive,  0, 0, 0, 0, 0},
        {"negative",        0, OT_SINGLE, yf_negative,  0, 0, 0, 0, 0},
        {"abs",             0, OT_SINGLE, yf_abs,       0, 0, 0, 0, 0},
        {"floor",           0, OT_SINGLE, yf_floor,     0, 0, 0, 0, 0},
        {"ceil",            0, OT_SINGLE, yf_ceil,      0, 0, 0, 0, 0},
        {"sign",            0, OT_SINGLE, yf_sign,      0, 0, 0, 0, 0},
        {"rand",            0, OT_SINGLE, yf_rand,      0, 0, 0, 0, 0},
        {"rand_int",        0, OT_SINGLE, yf_rand_int,  0, 0, 0, 0, 0},
        {"round",           0, OT_SINGLE, yf_round,     0, 0, 0, 0, 0},

        {"sqrt",            0, OT_SINGLE, yf_sqrt,      0, 0, 0, 0, 0},
        {"exp",             0, OT_SINGLE, yf_exp,       0, 0, 0, 0, 0},
        {"log",             0, OT_SINGLE, yf_log,       0, 0, 0, 0, 0},
        {"ln",              0, OT_SINGLE, yf_log,       0, 0, 0, 0, 0}, // log == ln
        {"log10",           0, OT_SINGLE, yf_log10,     0, 0, 0, 0, 0},
        {"lg",              0, OT_SINGLE, yf_log10,     0, 0, 0, 0, 0}, // log10 = lg
        {"log2",            0, OT_SINGLE, yf_log2,      0, 0, 0, 0, 0},

        {"sin",             0, OT_SINGLE, yf_sin,       0, 0, 0, 0, 0},
        {"cos",             0, OT_SINGLE, yf_cos,       0, 0, 0, 0, 0},
        {"tan",             0, OT_SINGLE, yf_tan,       0, 0, 0, 0, 0},
        {"cot",             0, OT_SINGLE, yf_cot,       0, 0, 0, 0, 0},
        {"ctg",             0, OT_SINGLE, yf_cot,       0, 0, 0, 0, 0},
        {"asin",            0, OT_SINGLE, yf_asin,      0, 0, 0, 0, 0},
        {"acos",            0, OT_SINGLE, yf_acos,      0, 0, 0, 0, 0},
        {"atan",            0, OT_SINGLE, yf_atan,      0, 0, 0, 0, 0},
        {"acot",            0, OT_SINGLE, yf_acot,      0, 0, 0, 0, 0},
        {"arcsin",          0, OT_SINGLE, yf_asin,      0, 0, 0, 0, 0},
        {"arccos",          0, OT_SINGLE, yf_acos,      0, 0, 0, 0, 0},
        {"arctan",          0, OT_SINGLE, yf_atan,      0, 0, 0, 0, 0},
        {"arccot",          0, OT_SINGLE, yf_acot,      0, 0, 0, 0, 0},

        {"sinh",            0, OT_SINGLE, yf_sinh,      0, 0, 0, 0, 0}, // 双曲正弦函数
        {"cosh",            0, OT_SINGLE, yf_cosh,      0, 0, 0, 0, 0}, // 双曲余弦函数
        {"tanh",            0, OT_SINGLE, yf_tanh,      0, 0, 0, 0, 0}, // 双曲正切函数
        {"coth",            0, OT_SINGLE, yf_coth,      0, 0, 0, 0, 0}, // 双曲余切函数

        {"sh",              0, OT_SINGLE, yf_sh,        0, 0, 0, 0, 0}, // 双曲正弦函数
        {"ch",              0, OT_SINGLE, yf_ch,        0, 0, 0, 0, 0}, // 双曲余弦函数
        {"th",              0, OT_SINGLE, yf_th,        0, 0, 0, 0, 0}, // 双曲正切函数
        {"cth",             0, OT_SINGLE, yf_cth,       0, 0, 0, 0, 0}, // 双曲余切函数

        {"sec",             0, OT_SINGLE, yf_sec,       0, 0, 0, 0, 0}, // 正割函数
        {"csc",             0, OT_SINGLE, yf_csc,       0, 0, 0, 0, 0}, // 余割函数

        {"sech",            0, OT_SINGLE, yf_sech,      0, 0, 0, 0, 0}, // 双曲正割(等同于sch)
        {"sch",             0, OT_SINGLE, yf_sech,      0, 0, 0, 0, 0}, // 双曲正割
        {"csch",            0, OT_SINGLE, yf_csch,      0, 0, 0, 0, 0}, // 双曲余割(等同于xh)       
        {"xh",              0, OT_SINGLE, yf_csch,      0, 0, 0, 0, 0}, // 双曲余割   
    };
```
函数双目运算符形如pow(a, b)
add,sub,multiply,divide,max,min,mod,pow,atan2,rand2,等
```
    const Operator twinOperators[TWIN_OPERATORS_COUNT] =
    {
        {"add",             0, OT_TWIN, 0, yf_add,          0, 0, 0, 0},
        {"sub",             0, OT_TWIN, 0, yf_sub,          0, 0, 0, 0},
        {"multiply",        0, OT_TWIN, 0, yf_multiply,     0, 0, 0, 0},
        {"divide",          0, OT_TWIN, 0, yf_divide,       0, 0, 0, 0},

        {"max",             0, OT_TWIN, 0, yf_max,          0, 0, 0, 0},
        {"min",             0, OT_TWIN, 0, yf_min,          0, 0, 0, 0},
        {"mod",             0, OT_TWIN, 0, yf_mod,          0, 0, 0, 0},
        {"pow",             0, OT_TWIN, 0, yf_pow,          0, 0, 0, 0},
        {"log_ax",          0, OT_TWIN, 0, yf_log_ax,       0, 0, 0, 0},
        {"pow_sign",        0, OT_TWIN, 0, yf_pow_sign,     0, 0, 0, 0},

        {"correction_gamma",0, OT_TWIN, 0, yf_correction_gamma, 0, 0, 0, 0},
        {"correction_pow",  0, OT_TWIN, 0, yf_correction_pow,   0, 0, 0, 0},
        {"correction_sin",  0, OT_TWIN, 0, yf_correction_sin,   0, 0, 0, 0},

        {"atan2",           0, OT_TWIN, 0, yf_atan2,        0, 0, 0, 0},
        {"rand2",           0, OT_TWIN, 0, yf_rand2,        0, 0, 0, 0},
        {"rand_int2",       0, OT_TWIN, 0, yf_rand_int2,    0, 0, 0, 0},

        {"and",             0, OT_TWIN, 0, yf_and,          0, 0, 0, 0},
        {"or",              0, OT_TWIN, 0, yf_or,           0, 0, 0, 0},
        {"xor",             0, OT_TWIN, 0, yf_xor,          0, 0, 0, 0},

        {"greater",         0, OT_TWIN, 0, yf_greater,      0, 0, 0, 0},
        {"greater_equal",   0, OT_TWIN, 0, yf_greater_equal,0, 0, 0, 0},
        {"less",            0, OT_TWIN, 0, yf_less,         0, 0, 0, 0},
        {"less_equal",      0, OT_TWIN, 0, yf_less_equal,   0, 0, 0, 0},
        {"equal",           0, OT_TWIN, 0, yf_equal,        0, 0, 0, 0},
    };
```
函数三目运算符形如lerp(a, b, r)
lerp,clamp,gray,add3,min3,max3,average3
```
    const Operator threeOperators[THREE_OPERATORS_COUNT] =
    {
        {"lerp",            0, OT_THREE, 0, 0, yf_lerp,     0, 0, 0},
        {"clamp",           0, OT_THREE, 0, 0, yf_clamp,    0, 0, 0},
        {"limit",           0, OT_THREE, 0, 0, yf_limit,    0, 0, 0},
        {"in_range",        0, OT_THREE, 0, 0, yf_in_range, 0, 0, 0},
        {"gray",            0, OT_THREE, 0, 0, yf_gray,     0, 0, 0},
        {"add3",            0, OT_THREE, 0, 0, yf_add3,     0, 0, 0},
        {"min3",            0, OT_THREE, 0, 0, yf_min3,     0, 0, 0},
        {"max3",            0, OT_THREE, 0, 0, yf_max3,     0, 0, 0},
        {"average3",        0, OT_THREE, 0, 0, yf_average3, 0, 0, 0},
        {"if",              0, OT_THREE, 0, 0, yf_if,       0, 0, 0},
    };
```
比较特殊的是if函数,可以参考这个例子:
```
vertices = 12000

x = from (-4) to (4)
t = mod(x, 2)
y = if(t, sin(x*PI), tan(x*PI))
```
通过if函数,生成一个sin曲线与tan曲线交错的曲线

函数四目运算符形如average4(a, b, c, d)
add4,min4,max4,average4
```
    const Operator fourOperators[FOUR_OPERATORS_COUNT] = 
    {
        {"add4",            0, OT_FOUR, 0, 0, 0, yf_add4,     0, 0},
        {"min4",            0, OT_FOUR, 0, 0, 0, yf_min4,     0, 0},
        {"max4",            0, OT_FOUR, 0, 0, 0, yf_max4,     0, 0},
        {"average4",        0, OT_FOUR, 0, 0, 0, yf_average4, 0, 0},
    };
```
函数数组运算符(输入实数数组,输出一个浮点数,如求最大值,最小值,数组加和等)
add_array,min_array,max_array,ave_array
```
    const Operator valueNodeOperators[VALUENODE_TO_FLOAT_OPERATORS_COUNT] = 
    {
        {"array_add",       0, OT_VALUENODE_TO_FLOAT, 0, 0, 0, 0, yf_add_array, 0},
        {"array_min",       0, OT_VALUENODE_TO_FLOAT, 0, 0, 0, 0, yf_min_array, 0},
        {"array_max",       0, OT_VALUENODE_TO_FLOAT, 0, 0, 0, 0, yf_max_array, 0},
        {"array_ave",       0, OT_VALUENODE_TO_FLOAT, 0, 0, 0, 0, yf_average_array, 0},
    };
```
函数数组运算符(输入实数数组,输出也是实数数组,如求数组左移,数组右移,前向累加等)
array_move_right,array_move_left,array_cumulate
```
    const Operator valueNode2Operators[VALUENODE_CONVERT_OPERATORS_COUNT] = 
    {
        {"array_move_right",0, OT_VALUENODE_TO_FLOAT, 0, 0, 0, 0, 0, yf_array_move_right},
        {"array_move_left", 0, OT_VALUENODE_TO_FLOAT, 0, 0, 0, 0, 0, yf_array_move_left},
        {"array_cumulate",  0, OT_VALUENODE_TO_FLOAT, 0, 0, 0, 0, 0, yf_array_cumulate},
    };
```
(6)运算符嵌套
支持{}, [], ()这三类括号标志符,括号必需成对出现.支持最大32级括号的嵌套.如:
(2+(-2+(5.0*(9 + ((1+2)*3))/3) + 2))
-{exp[5*sqrt(1 -abs[sin{rand(100)}]) + 6]}

========================================================

（1）单目运算函数，形如a = log(b)

"positive", // 取正，基本上没什么用，相当于(+a)
"negative", // 取负
"abs", // 求绝对值
"floor", // 整数位
"ceil", // 整数位+1
"sign", // 返回-1.0或1.0
"sgn", // 返回-1.0或0.0或1.0
"is_zero", // 返回0.0或1.0
"rand", // 返回一个随机的浮点数
"rand_int", // 返回一个随机整数
"round", // 四舍五入
"reciprocal", // 倒数

"sqrt", // 开根号
"exp", //
"log", // 求对数
"ln", // log == ln
"log10",
"lg", // log10 = lg
"log2",

"sin", // 正弦函数
"cos", // 余弦函数
"asin", // 反正弦函数
"acos", // 反余弦函数
"arcsin", // 反正弦函数
"arccos", // 反余弦函数

"tan", // 正切函数
"cot", // 余切函数
"ctg", // 余切函数
"atan", // 反正切函数
"acot", // 反余切函数
"actg", // 反余切函数
"arctan", // 反正切函数
"arccot", // 反余切函数
"arcctg", // 反余切函数

"sec", // 正割函数
"csc", // 余割函数
"asec", // 反正割函数
"acsc", // 反余割函数
"arcsec", // 反正割函数
"arccsc", // 反余割函数

"sinh", // 双曲正弦函数
"cosh", // 双曲余弦函数
"tanh", // 双曲正切函数
"coth", // 双曲余切函数

"sh", // 双曲正弦函数
"ch", // 双曲余弦函数
"th", // 双曲正切函数
"cth", // 双曲余切函数

"sech", // 双曲正割(等同于sch)
"sch", // 双曲正割
"csch", // 双曲余割(等同于xh)
"xh", // 双曲余割

"factorial", // 阶乘
"erf", // 误差函数
"float_to_color", // 将浮点数转化为0-255的颜色数

（2）双目运算函数，形如a = add(b, c)

"add", 相加
"sub", 相减
"multiply", 相乘
"divide", 相除

"max", // 返回两数较大的一个
"min", // 返回两数较小的一个
"mod", // 求余
"pow", // 求幂
"log_ax", // 对数
"pow_sign", // 用于对负数的求幂,相当于pow(abs(a), b)

"correction_gamma",// gamma校正函数
"correction_pow", // pow校正函数
"correction_sin", // sin校正函数

"atan2", // 正切
"rand2", // 返回两数之间的一个随机浮点数
"rand_int2", // 返回两数之间的一个随机整数

"and_bool" // 与,返回0或1.0
"or_bool", // 或,返回0或1.0
"xor_bool" // 异或,返回0或1.0
"and_byte" // 与,返回0到255.0的一个数
"or_byte", // 或,返回0到255.0的一个数
"xor_byte" // 异或,返回0到255.0的一个数
"and_word" // 与,返回0到65535.0的一个数
"or_word", // 或,返回0到65535.0的一个数
"xor_word" // 异或,返回0到65535.0的一个数

"greater", // 返回0或1.0
"greater_equal", // 返回0或1.0
"less", // 返回0或1.0
"less_equal", // 返回0或1.0
"equal", // 返回0或1.0

(3)三目运算符函数形如lerp(a, b, r)

"lerp", // 线性插值
"clamp", // 限定数值的范围
"limit", // 限定数值的范围,与clamp一样
"in_range", // 数值是否范围内,返回0或1.0
"gray", // 颜色的灰度化
"add3", // 相加
"min3", // 三个之中取最小
"max3", // 三个之中取最大
"average3", // 三数平均值
"if", // 如果第一个数不为0则取第二个数,否则取第三个数
"if_else", // 与if等价

(4)函数四目运算符形如average4(a, b, c, d)

"add4", // 相加
"min4", // 四个之中取最小
"max4", // 四个之中取最大
"average4", // 四数平均值

(5)函数数组运算符(输入实数数组,输出一个浮点数,如求最大值,最小值,数组加和等)

"array_add", // 相加
"array_min", // 数组之中取最小
"array_max", // 数组之中取最大
"array_ave", // 数组平均值

(6)函数数组运算符(输入实数数组,输出也是实数数组,如求数组左移,数组右移,前向累加等)

"array_move_right",// 数组右移
"array_move_left", // 数组左移
"array_cumulate", // 数组累加
"array_difference",// 数组差,b[n] = a[n + params] - a[n]

(7)函数数组运算符(输入两个浮点数,输出实数数组)
"array_lerp", // 将数组中的数值变为等差数列
"array_rand", // 将数组中的数值变为随机浮点数
"array_rand_int", // 将数组中的数值变为随机整数
"array_set_all_values",// 将数组设置为统一值

(8)函数数组运算符(输入实数数组和一个浮点数,输出一个浮点数)
"array_get_value" // 获取数组的某一个值
```
 
```
相关阅读:
js optional chaining operator
Linux Bash Script conditions
Linux Bash Script loop
js Nullish Coalescing Operator
js sort tricks All In One
React Portal All In One
最小生成树&&次小生成树
 链式前向星实现以及它的遍历
 [2015.11.8|9图论]解题代码集合
 最短路算法及其延伸
原文地址：https://www.cnblogs.com/WhyEngine/p/3860338.html

数学图形可视化工具的脚本语法

Sin曲线

Sin面

(4)变量及其赋值