无功功率，无功功率 代数=要求('ganja.js');

功能 代数( 第页, q个, 第页, 函数 );
  //p=正尺寸数。
  //q=可选的负尺寸数。
  //r=可选的零维数。
  //func=可选函数。（速记..它被传递到.inline并执行）

功能 代数( 选项, 函数 );
  //options=包含子集的对象
  //           {
  //p，正维数的整数。
  //q，负维的整数。
  //r，零维的整数。
  //metric，[a，b，..]数组，每个生成维度具有metric。（例如，PGA2D为[0,1,1]）
  //基础，[“1”，“e1”，”e2“]基础，推翻了标准的cannonical基础。
  //Cayley，[[“1”，“e1”]，[“e1”，“-1”]]Cayley表否决标准GA表。
  //baseType、float32Array（默认）、float64Array、。。用于元素的baseType。
  //mix设置为true以启用可互操作的子代数。（默认为false）。
  //           }


  //返回：如果没有提供函数，则返回代数类；如果提供了函数，则为函数结果。

//基本
无功功率，无功功率 超（Hyper）   = 代数(1);       //双曲型数字。
无功功率，无功功率 复杂 = 代数(0,1);     //复数。
无功功率，无功功率 二重的    = 代数(0,0,1);   //双重数字。
无功功率，无功功率 H（H）       = 代数(0,2);     //四元数。

//克利福德
变量 二氧化氯 = 代数(2);           //二维向量空间的Clifford代数。
无功功率，无功功率 氯离子 = 代数(三);           //三维向量空间的Clifford代数。
无功功率，无功功率 timeSpace（时间空间） = 代数(1,三);   //时空向量的Clifford代数。

//子代数
无功功率，无功功率 复杂 = 代数({第页:三,基础:['1',“e123”]});        //作为Cl3子代数的复数
无功功率，无功功率 H（H） = 代数({第页:三,基础:['1',“e12”,“e13”,“e23”]});   //四元数作为Cl3的偶子代数

//几何
无功功率，无功功率 第2d页 = 代数(2,0,1);     //投影欧几里德二维平面。（双重）
无功功率，无功功率 PGA3D系列 = 代数(三,0,1);     //投影欧几里德三维空间。（双重）
无功功率，无功功率 CGA2D公司 = 代数(三,1);       //保形2D空间。
无功功率，无功功率 CGA3D公司 = 代数(4,1);       //保形3D空间。

//高维GA
无功功率，无功功率 DCGA3D公司 = 代数(6,2);      //双共形3D空间。
无功功率，无功功率 tcga3天 = 代数(9,三);      //三重共形3D空间。
无功功率，无功功率 DCGSTA公司 = 代数(4,8);      //双共形几何时空代数。
无功功率，无功功率 QCGA公司   = 代数(9,6);      //二次共形几何代数。

无功功率，无功功率 复杂 = 代数(0,1);     //复数。
无功功率，无功功率 一 = 新的 复杂([三,2]);     //3+2i
无功功率，无功功率 b = 新的 综合体([1,4]);     //1+4i
返回 一.穆尔(b);                //返回[-5，14]

代数(0,1).内联(()=>(三+第2版)*(1+第四版))();  //返回[-5,14]

代数(0,1,()=>(三+第2版)*(1+第四版)); //返回[-5,14]

代数(2,0,1,()=>{

  //使用电子符号直接规范基础叶片。
  无功功率，无功功率 xy_支路 = 第1页,
      伪标量 = 2012年1月;

  //运算符重载..*=几何积，^=楔形，&=V形，<<=点，>>=三明治。。。
  无功功率，无功功率 来自产品的xy支路 = 第1页 * 1个2;

  //直接指定点。
  无功功率，无功功率 某个点 = 第1页 + 0.4电子01 + 0.5电子02;  

  //返回点的函数。
  无功功率，无功功率 函数_ hat_returns_point = ()=>某个点 + 0.5电子01;

  //点与函数的连接。。请注意，没有调用方括号。。
  无功功率，无功功率 点与函数之间的连接 = 某个点 & 函数_目标_返回点;

  //同上。。但作为功能。。（如果点更改，也会更新）
  无功功率，无功功率 函数_that_returns_join = ()=>某个点 & 函数_目标_返回点;

  //数组上的二进制操作也按预期工作。
  无功功率，无功功率 即使 = [1,2,三,4,5]*2;

  //即使它们包含多向量或其他数组：
  无功功率，无功功率 时髦的 = [1, 第1页01+0.5电子02, [三,4]] * 三 + [1,2,三];

  //所有元素和函数都可以直接呈现。（同样，没有调用方括号）。
  无功功率，无功功率 帆布 = 这.图表([ 某个点, 函数_目标_返回点, 函数_that_returns_join ]);

});

//漂亮的数学表达式（！=对偶，^=楔形）

一 = ()=>!(!一^!b)*(c（c）*1电子23)

//转换为。。

b = ()=>这.穆尔(这.二重的((这.楔子(这.二重的(一),这.二重的(b)))),(这.穆尔(c（c）,这.科夫(6,1))))

帆布 = 代数(0).图表(x个=>数学.罪(x个*5));                   //在R中绘制1D函数

帆布 = 代数(0).图表((x个,年)=>x个+年);                         //绘制R中的2D函数

高级副总裁 = 代数(2,0,1,()=>这.图表([第1页,第1页,1个2]));           //在2D PGA中绘制原点以及x和y轴

高级副总裁 = 代数(三,0,1,()=>这.图表([第123页,1电子23,1电子13,第1页],{照相机:1+.5e01型-.5e02版})); //和3D PGA

帆布 = 代数(4,1,()=>这.图表([.5电子4-.5电子5],{保角的:真的,全球:真的}); //3D CGA的起源

代数(0,1).描述();

//作为R2偶子代数的复数
C类 = 代数({第页:2,基础:['1',“e12”]});

//作为R3偶子代数的四元数
无功功率，无功功率 H（H） = 代数({第页:三,基础:['1',“e12”,“e13”,“e23”]});  

无功功率，无功功率 R3_32段 = 代数(三);

无功功率，无功功率 64兰特 = 代数({第页:三,基本类型:Float64数组});

无功功率，无功功率 基础=['1',“e1”,“e2”,“e3”];
无功功率，无功功率 凯利=[['1', “e1”,“e2”,“e3”],
            [“e1”,“e2”,“e3”, '0'],
            [“e2”,“e3”, '0', '0'],
            [“e3”, '0', '0', '0']];

代数({基础,凯利},()=>{
  无功功率，无功功率 （f） = (x个)=>0.25*x个*x个*x个*x个-0.5; 
  对于 (无功功率，无功功率 我=-5; 我<5; 我++) 慰问.日志( 我, （f）(我+第1页) );
});

//创建R2-克利福德2D向量代数-表示您想要混合模式。
无功功率，无功功率 R2级 = 代数({第页:2,q个:0,第页:0,混合:真的}); 

//创建复数作为R2的偶子代数。
无功功率，无功功率 C类  = 代数({第页:2,q个:0,第页:0,基础:['1',“e12”],混合:真的});

//R2的元素有四个成分。
//创建复数1+4i
无功功率，无功功率 一=新的 R2级([1,0,0,4])

//C元素有两个组件。
//创建复数3+2i
无功功率，无功功率 b=新的 C类([三,2]); 

//他们互相操作。。
一.穆尔(b);   //返回R2元素：[-5,0,0,14]
b.Mul公司(一);   //返回C:[-5,14]的元素

//用2个正生成器和1个零生成器创建一个Clifford代数。
代数(2,0,1,()=>{
    
    //将代数信息输出到控制台。
    这.描述();
    
    //默认基础为s、e0、e1、e2、e01、e02、e12、e012
    //向量的度量为0、1、1-向量将表示直线。
    //双向量的度量是0，0，-1-双向量将表示点。
    //伪标量是退化的，所以请使用内置的对偶运算符。
    
    //双矢量由两个电机元件和一个旋转元件组成-
    //准确地表示平面中的平移和旋转所需的内容。
    
    //在对偶投影空间中，原点由e12双向量表示。
    无功功率，无功功率 起源 = 第1页, 前任=-第1页02, 安永=第1页01;
    
    //可以直接指定点和线。（注：-e02=e20）
    无功功率，无功功率 指向 = (x个,年)=>起源+x个*前任+年*安永;
    无功功率，无功功率 线  = (一,b,c（c）)=>一*第1页+b*1个2+c（c）*第1页;
    
    //或者通过join and meet操作。（双楔接，V接。）
    无功功率，无功功率 参加 = (第1页,第2页)=>第1页&第2页;
    无功功率，无功功率 满足 = (l1级,第二语言)=>l1级^第二语言;
    
    //距离和角度
    无功功率，无功功率 dist_points（分布点）     = (第1页,第2页)=>(第1页.标准化（Normalized）&第2页.标准化（Normalized）).长度;
    无功功率，无功功率 dist_point_line（分布点线） = (P（P）,我)=>((P（P）.标准化（Normalized）)^(我.标准化（Normalized）)).2012年第1季度;
    无功功率，无功功率 角度（_L）     = (l1级,第二语言)=>(l1级.标准化（Normalized）<<第二语言.标准化（Normalized）).秒;
  
    //可以投影和拒绝点和线。
    无功功率，无功功率 项目         = (P（P）,我)=>P（P）<<我*我;
    无功功率，无功功率 平行        = (P（P）,我)=>P（P）<<我*P（P）;
    无功功率，无功功率 正交的           = (P（P）,我)=>P（P）<<我;
  
    //平移和旋转。
    无功功率，无功功率 转子           = (一,P（P）)=>数学.余弦(一*0.5)+数学.罪(一*0.5)*P（P）;
    无功功率，无功功率 翻译      = (x个,年)=>1+0.5*(x个*第1页02-年*第1页01); 
    
    //为了演示图形，我们创建了一些点和线。
    //用户可以拖动图形中的点，lambda表达式可以
    //用于创建动态更新项。
    无功功率，无功功率 A类 = 指向(-1,-1), B类 = 指向(1,-1), C类 = 指向(-1,1), 我 = 线(-1,1,0.5);
    
    //Ganja.js可以直接绘制2D PGA元素。传入一个数组
    //要渲染的项。（数字是颜色，字符串是标签，PGA点
    //和行被自动渲染，数组可以用于行
    //线段和多边形）。graph函数返回HTML SVG元素。
    文件.身体.appendChild（附加子项）(这.图表([
      //使用数字设置当前颜色。
        0x444444号,
      //字符串标记它们所跟随的项，第一个字符串是标题。
        “标题”,
      //渲染点（用户可以拖动这些点）
        A类, B类, C类, “点的标签”,
      //渲染线
        我,“线条标签”,
      //线段
        ()=>[A类,B类], “段的标签”,
      //多边形
        0x咖啡,
        ()=>[A类,B类,C类], 0xff7777个, “多边形标签”
    ],{栅格:真的, 使有生气:假}));
    
    //使用动画模式时，所有lambda的值都将在每帧进行求值。
    //使用Date.now（）或类似工具。（咖啡馆里有很多例子。）
});

//用3个正生成器和1个零生成器创建一个Clifford代数。
代数(三,0,1,()=>{
    
    //将代数信息输出到控制台。
    这.描述();
    
    //默认基础为1，e0，e1，e2，e3，e01，e02，e03，e12，e13，e23，e012，e013，e023，e123，e0123
    //向量的度量是0，1，1，1-向量表示平面。
    //双向量的度量为0、0、0，-1、-1，双向量表示直线。
    //三向量的度量为0、0、0和-1-三向量将表示点。
    //伪标量是退化的，所以请使用内置的对偶运算符。
    
    //双矢量由三个电机元件和三个旋转元件组成-
    //在欧几里德空间中表示平移和旋转所需要的确切内容。
    
    //在对偶投影空间中，原点由e12双向量表示。
    无功功率，无功功率 起源=第123页, 前任=-第1页023, 安永=2013年1月, EZ公司=-2012年1月;
    
    //可以直接指定点和平面。
    无功功率，无功功率 指向 = (x个,年,z（z）)=>起源+x个*前任+年*安永+z（z）*EZ公司,
        飞机 = (一,b,c（c）,d日)=>一*第1页+b*1个2+c（c）*1电子3+d日*1个0;
    
    //表摘自“计算机图形的几何代数”第15页
    无功功率，无功功率 线自点            = (P（P）,问)=>P（P）&问,
        平面线            = (一,b)=>一^b,
        从平面指向           = (一,b,c（c）)=>一^b^c（c）,
        平面起点           = (P（P）,问,对)=>P（P）&问&对,
        距离点到平面          = (一,P（P）)=>一&P（P）,
        DistPoints（距离点）                = (P（P）,问)=>(P（P）&问).长度,
        角度平面               = (一,b)=>数学.acos公司((一<<b).长度),
        每个平面的线通过点 = (P（P）,一)=>P（P）<<一,
        Orth项目指向平面      = (P（P）,一)=>P（P）<<一*一,
        平面通过点ParPlane = (P（P）,一)=>P（P）<<一*P（P）,
        相交线平面        = (圆周率,一)=>圆周率^一,
        每条线的平面通过点 = (圆周率,P（P）)=>P（P）<<圆周率,
        Orth项目指向线条       = (圆周率,P（P）)=>P（P）<<圆周率*圆周率,
        线路通过点ParLine   = (圆周率,P（P）)=>P（P）<<圆周率*P（P）,
        每行通过点  = (圆周率,P（P）)=>(P（P）<<圆周率*P（P）)&P（P）,
        DistLines（距离线）                 = (圆周率,欧洲药典)=>圆周率&欧洲药典,
        角度线                = (圆周率,欧洲药典)=>数学.acos公司((圆周率<<欧洲药典).长度),
        平面内反射         = (一,X（X）)=>一*X（X）*一,
        转子                     = (圆周率,阿尔法)=>数学.余弦(阿尔法/2) + 数学.罪(阿尔法/2)*圆周率,
        绕直线旋转        = (X（X）,圆周率,阿尔法)=>转子(圆周率,阿尔法)*X（X）*~转子(圆周率,阿尔法),
        翻译家                = (x个,年,z（z）)=>1+0.5*(x个*前任+年*安永+z（z）*EZ公司);
    
    //为了演示图形，我们创建了一些点和线。
    //用户可以拖动图形中的点，lambda表达式可以
    //用于创建动态更新项。
    无功功率，无功功率 A类 = 指向(-1,-1, 0), B类 = 指向(1,-1, 0), C类 = 指向(-1,1,0);
    
    //Ganja.js可以直接绘制3D PGA元素。传入一个数组
    //要渲染的项。（数字是颜色，字符串是标签，PGA点
    //和行被自动渲染，数组可以用于行
    //线段和多边形）。graph函数返回HTML SVG元素。
    文件.身体.appendChild（附加子项）(这.图表([
      //使用数字设置当前颜色。
        0x444444号,
      //字符串标记它们所跟随的项，第一个字符串是标题。
        “标题”,
      //渲染点（用户可以拖动这些点）
        A类, B类, C类, “点的标签”,
      //渲染线
        ()=>(B类&C类&A类)<<(B类&C类)<<-A类,“线条标签”,
      //线段
        ()=>[A类,B类], “段的标签”,
      //多边形
        0x咖啡,
        ()=>[A类,B类,C类], 0xff7777个, “多边形标签”
    ],{栅格:假, 使有生气:假}));
    
    //使用动画模式时，所有lambda的值都将在每帧进行求值。
    //使用Date.now（）或类似工具。（咖啡馆里有很多例子。）
});