[从头学数学] 第210节 带着计算机去高考（二）

高考数学题计算机解答
最新推荐文章于 2024-06-06 21:58:55 发布
原创 最新推荐文章于 2024-06-06 21:58:55 发布 · 3.6k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文展示了使用计算机辅助解决2001年江苏省高考数学题目，包括代数计算、几何绘图及复杂公式推导等内容，旨在探讨计算机在解题过程中的应用。
剧情提要：
[机器小伟]在[工程师阿伟]的陪同下进入了[九转金丹]之第八转的修炼。设想一个场景：
如果允许你带一台不连网的计算机去参加高考，你会放弃选择一个手拿计算器和草稿本吗
？阿伟决定和小伟来尝试一下用计算机算高考题会是怎样的感觉。

正剧开始：


星历2016年05月17日 16:48:27, 银河系厄尔斯星球中华帝国江南行省。
[工程师阿伟]正在和[机器小伟]一起做着2001年的江苏省数学高考题]。








<span style="font-size:18px;">#题1
>>> 
1 1
1 3

def tmp1():
    #定特例
    angle = math.pi/4;

    for i in range(1,2):
        for n in range(4):
            angle_1 = angle+math.pi/2*n
            sini = math.sin(i*angle_1);
            cos = math.cos(angle_1);
            if (sini*cos > 0):
                print(i, n+1);</span>


 



<span style="font-size:18px;">#题2
def tmp2():
    '''
    s1 = '(x-1)^[2]+(y+1)^[2]-(x+1)^[2]-(y-1)^[2] = 0';
    s2 = 'y = (2-x)';

    val1 = ['x', '-1'];
    val2 = ['y', '1'];
    val3 = ['x', '1'];
    val4 = ['y', '-1'];
    
    a = strpow_n(val1, 2)+strpow_n(val2, 2)+minus(strpow_n(val3, 2))+minus(strpow_n(val4, 2));
    a = strcombine(a);
    print(a); #['(0)', '(-4)*x', '(0)', '(0)', '(4)*y']

    #-4x+8-4x=0
    '''

    #两条直线的交点
    A = [1, -1];
    B = [-1, 1];

    C = [0, 2];
    D = [1, 1];
    
    cross = geo.crossPointOfTwoLine([A, B], [C, D]);
    #print(cross); #平行 
    
    #AB距离
    d1 = geo.distance2D(A, B); #2.8284271247461903

    #两平行线的距离
    d = geo.lineDistance2D([A, B], [C, D]);
    print(d); #1.414213562373095

    #半经
    R = ((d1/2)**2+d**2)**0.5;
    print('R = ', R);

    #求AB的中垂线方程
    line = geo.perpendicular([A, B]);
    print(line); #[[0.0, 0.0], [10.0, 10.0]]

    #求中垂线与圆心所在直线的交点
    cross = geo.crossPointOfTwoLine([line[0], line[1]], [C, D]);
    print(cross); #[1.0, 1.0]

    #这是一个R=2, 圆心(1, 1)的方程</span>


 



<span style="font-size:18px;">#题3
def tmp3():
    #4*(4-d)*(4+d) = 48</span>





<span style="font-size:18px;">//题5
	if (1) {      
        var r = 20;            
        config.setSector(1,1,1,1);              
        config.graphPaper2D(0, 0, r);            
        config.axis2D(0, 0,180);              
                
        //坐标轴设定        
        var scaleX = 2*r, scaleY = 2*r;          
        var spaceX = 0.5, spaceY = 0.5;           
        var xS = -10, xE = 10;          
        var yS = -10, yE = 10;          
        config.axisSpacing(xS, xE, spaceX, scaleX, 'X');            
        config.axisSpacing(yS, yE, spaceY, scaleY, 'Y');            
                    
        var transform = new Transform();            
        //存放函数图像上的点        
        var a = [], b = [], c = [], d = [];          
                  
        //需要显示的函数说明    
                    //希腊字母表(存此用于Ctrl C/V  
            //ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ  
            //αβγδεζηθικλμνξοπρστυφχψω  
        var f1 = 'ρ = 2sin(θ+pi/4)', f2 = '', f3 = '', f4 = '';        
            
  
        //函数描点    
        //参数方程  
        var x, y;  
        var pointA = [];  
          
        for (var thita = 0; thita < Math.PI*2; thita +=Math.PI/24) {  
            pointA = [2*Math.sin(thita+Math.PI/4), thita];  
            a.push(polar2XY(pointA));  
        }  
          
                  
        //存放临时数组        
        var tmp = [];        
                  
        //显示变换        
        if (a.length > 0) {        
            a = transform.scale(transform.translate(a, 0, 0), scaleX/spaceX, scaleY/spaceY);         
            //函数1        
            tmp = [].concat(a);            
            shape.pointDraw(tmp, 'red');            
            tmp = [].concat(a);            
            shape.multiLineDraw(tmp, 'pink');          
                      
            plot.setFillStyle('red');        
            plot.fillText(f1, 100, -180, 200);          
        }  
  
          
    }</span>



 


<span style="font-size:18px;">#题6
>>> math.acos(0);
1.5707963267948966
>>> math.acos(1);
0.0
>>> math.acos(-1);
3.141592653589793</span>


 





<span style="font-size:18px;">#题8
>>> 
A

def tmp8():
    a = math.pi/8;
    b = math.pi/6;

    cond1 = math.sin(a)+ math.cos(a);
    cond2 = math.sin(b) + math.cos(b);

    a = cond1;
    b = cond2;

    if (a<b):
        print('A');

    if (a > b):
        print('B');

    if (a*b < 1):
        print('C');

    if (a*b > 2):
        print('D');
    </span>





<span style="font-size:18px;">//题9
	if (1) {  
      
        var r = 20;      
        config.setSector(1,1,1,1);        
        config.graphPaper2D(0, 0, r);      
        config.axis2D(0, 0, 180);    
          
        var scale = 3*r;  
      

        var triangle = new Triangle();  
        var transform = new Transform();  
        var array = triangle.solve([3.464, 2.45, 2.45,  '?', '?', '?']);  
          
        shape.angleDraw(transform.translate(array, -200/scale, 0), 'red', scale, ['B', 'D', 'C\'']);    
        //shape.areaDraw(array, 'red', scale);   
  
        //document.write(array+'<br/>');  
  
    }</span>



 




<span style="font-size:18px;">#题11
def tmp11():
    S_1 = a*b/math.cos(thita);
    S_2 = a*b/math.cos(thita);
    S_3 = 0.5*b*b/math.cos(thita) + (a+a-b/2)*b/math.cos(thita);
    #相等</span>


 









<span style="font-size:18px;">#题14
def tmp14():
    c = 5;
    #[(9+(9/16)*y^[2])^[0.5], y], [-5, 0], [5, 0]
    #y^[2]+25 = x^[2];
    #x^[2] =9+(9/16)y^[2]

    #a1 - a2 = 6;
    #a1^[2] + a2^[2] = 100;
    t1 = strpow_n(['6', 'a_2'], 2);
    t2 = strmono('a_[1]^[2]');

    t1 = strcombine(t1);
    print(t1);    
	
	
		if (1) {
		var equation = new Equation();  
          
        var a = [2, 12, 36-100] 
        equation.quadratic(a);  
	}
	
>>> 3.4*9.4/10
3.196
</span>


 


<span style="font-size:18px;">#题15
def tmp15():
    #(1-q^[n+1])*2 = (1-q^[n])+(1-q^[n+2] Q[1, -2, 1]
		if (1) {
		var equation = new Equation();  
          
        var a = [1, -2, 1] 
        equation.quadratic(a);  
	}

方程 1x^[2] + -2x + 1 = 0 =>
Δ = b^[2] - 4ac = 0 ;
方程的解为：x1 = x2 = 1 ;
方程根与系数的关系：x1 + x2 = 2, x1 * x2 = 1 ;</span>


有2n个点，每个点作为直角顶点，另一个点可以在半圆里除它以外再找一个。




<span style="font-size:18px;">#题17
def tmp17():
    SA = AB = BC = 1;
    AD = 1/2;

    V_S_ABCD = (AD+BC)*AB/2*SA/3;

    print('V= ', V_S_ABCD);

    #平面ABCD中CD上的高DE
    CD = (AD**2+AB**2)**0.5;
    DE = CD/AB*AD;
    #AE
    AE = AD/CD*DE;

    SD = (SA**2+AD**2)**0.5;
    SE = (SA**2+AE**2)**0.5;

    print('DE = ', DE);
    print('SD = ', SD);
    print('SE = ', SE);
    print('AE = ', AE);

    #F点为AB和CD的延长线交点，G为D作的SF的垂线
    SF = (SA**2+AB**2)**0.5;
    DG = SD*CD/SF;
    AG = SA*AB/SF;

    print('SF = ', SF);
    print('DG = ', DG);
    print('AG = ', AG);</span>

<span style="font-size:18px;">>>> 
V=  0.25
DE =  0.5590169943749475
SD =  1.118033988749895
SE =  1.0307764064044151
AE =  0.25
SF =  1.4142135623730951
DG =  0.8838834764831845
AG =  0.7071067811865475

>>> math.atan(0.707);
0.6154085176292563
>>> 180*_/math.pi
35.2603107365587

        var array = triangle.solve([0.884, 0.707, 0.5, '?', '?', '?']);  
          
        shape.angleDraw(transform.translate(array, -200/scale, 0), 'red', scale, ['A', 'D', 'G']); 
		</span>


 

<span style="font-size:18px;">	if (1) {  
      
        var r = 20;      
        config.setSector(1,1,1,1);        
        config.graphPaper2D(0, 0, r);      
        config.axis2D(0, 0, 180);    
          
        var scale = 8*r;  
      

        var triangle = new Triangle();  
        var transform = new Transform();  
        var array = triangle.solve([0.559, 1.118, 1.030, '?', '?', '?']);  
          
        shape.angleDraw(transform.translate(array, -200/scale, 0), 'red', scale, ['S', 'E', 'D']);    
        //shape.areaDraw(array, 'red', scale);   
  
        //document.write(array+'<br/>');  
  
    }</span>


 






<span style="font-size:18px;">#题18
def tmp18():
    
    z = complex(0, 1)*pow(complex(1, -1), 3);
    print(z);

    real = z.real;
    print(real);
    image = z.imag;

    print(180/math.pi*math.atan(image/real));
	
>>> 
(2-2j)
2.0
-0.7853981633974483

(2-2j)
2.0
-45.0
>>> (2+0.707)*1.414
3.8276979999999994</span>










贴一下用到的工具，一部分是代数式的，一部分是几何的，以防遗漏

<span style="font-size:18px;">###
# @usage   代数式字符串的运算
# @author  mw
# @date    2016年05月17日  星期二  16:48:56 
# @param
# @return
#
###

#计算代数式用, 传入的是单项式，返回coef*expr的形式
def strmono(s):
    #'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'
    stmp = s;
    size = len(stmp);
    alphaIndex = 0;
    signIndex = 0;
    
    for i in range(size):
        if (stmp[i].isalpha()):
            alphaIndex = i;
            break;
        if (i >= size-1):
            alphaIndex = i+1;

    if (stmp[0] == '-'):
        signIndex = 1;
        if (signIndex >= alphaIndex):
            return '(-1)*'+stmp[alphaIndex:];
        else:
            if alphaIndex >= size:
                return '(-'+stmp[signIndex:alphaIndex]+')';
            return '(-'+stmp[signIndex:alphaIndex]+')*'+stmp[alphaIndex:];
    else:
        signIndex = 0;        
        if (signIndex >= alphaIndex):
            return '(1)*'+stmp[alphaIndex:];
        else:
            if alphaIndex >= size:
                return '('+stmp[signIndex:alphaIndex]+')';
            return '('+stmp[signIndex:alphaIndex]+')*'+stmp[alphaIndex:];

#计算两个单项式的乘积
def strmul(mono1, mono2):
    #这个处理是保证每个单项式统一格式(coef)*expr
    '''
    stmp1 = strmono(s1);
    stmp2 = strmono(s2);
    '''

    if (mono1[0] != '(' or mono2[0] != '('):
        #如果没有规格化，那么就做一下
        mono1 = strmono(mono1);
        mono2 = strmono(mono2);
    else:
        stmp1 = mono1;
        stmp2 = mono2;

    #乘号的位置
    signIndex1 = stmp1.find('*');
    signIndex2 = stmp2.find('*');
    if (signIndex1 == -1):
        coef1 = stmp1;
        expr1 = '';
    else:
        coef1 = stmp1[:signIndex1];
        expr1 = stmp1[signIndex1+1:];

    if (signIndex2 == -1):
        coef2 = stmp2;
        expr2 = '';
    else:
        coef2 = stmp2[:signIndex2];
        expr2 = stmp2[signIndex2+1:];
        
    coef = coef1+'*'+coef2;
    
    if (signIndex1 == -1 or signIndex2 == -1):
        expr = expr1+expr2;
    else:
        expr = expr1+'*'+expr2;

    if (expr == ''):
        return '('+str(round(eval(coef), 6))+')';
    return '('+str(round(eval(coef), 6))+')*'+expr;
    
#计算两个单项式的商
def strdiv(s1, s2):
    #这个处理是保证每个单项式统一格式(coef)*expr
    stmp1 = strmono(s1);
    stmp2 = strmono(s2);

    #乘号的位置
    signIndex1 = stmp1.find('*');
    signIndex2 = stmp2.find('*');
    if (signIndex1 == -1):
        coef1 = stmp1;
        expr1 = '';
    else:
        coef1 = stmp1[:signIndex1];
        expr1 = stmp1[signIndex1+1:];

    if (signIndex2 == -1):
        coef2 = stmp2;
        expr2 = '';
    else:
        coef2 = stmp2[:signIndex2];
        expr2 = stmp2[signIndex2+1:];
        
    coef = coef1+'/'+coef2;
    
    if (signIndex1 == -1 and signIndex2 != -1):
        expr = '('+expr2+')^[-1]';
    elif (signIndex1 == -1 or signIndex2 == -1):
        expr = expr1+expr2;
    else:
        expr = expr1+'/'+expr2;

    if (expr == ''):
        return '('+str(round(eval(coef), 6))+')';
    return '('+str(round(eval(coef), 6))+')*'+expr;


#找一个字符串中所有待查找子串的位置，返回位置阵列
def findall(string, sub):
    size = len(string);
    index = [];

    cur = string.find(sub);
    index.append(cur)
    
    while (index[-1] != -1):        
        cur = string.find(sub, index[-1]+1);
        index.append(cur);   

    return index;

#计算单项式的乘方, s^n
def strpow(s, n):
    stmp = strmono(s);
    signIndex = stmp.find('*');
    if (signIndex == -1):
        coef = stmp+'**'+str(n);
        expr = '';
        return '('+str(round(eval(coef), 6))+')';
    else:
        coef = stmp[:signIndex]+'**'+str(n);
        expr = '('+stmp[signIndex+1:]+')^['+str(n)+']';

    return '('+str(round(eval(coef), 6))+')*'+expr;

#计算代数式用，传入的两个阵列都具有['s1', 's2', ..., 'sn']这样的格式
def strdot(array1, array2):
    size1 = len(array1);
    size2 = len(array2);
    result = [];
    
    for i in range(size1):
        for j in range(size2):
            result.append(strmul(array1[i], array2[j]));

    return result;


#把格式化后的单项式分解成[coef, expr]对组的形式
def explodemono(mono):
    stmp = mono;

    #乘号的位置
    signIndex = stmp.find('*');
    if (signIndex == -1):
        coef = stmp;
        expr = '';
    else:
        coef = stmp[:signIndex];
        expr = stmp[signIndex+1:];

    return [coef, expr];

#合并同类项，传入的阵列具有['s1', 's2', ..., 'sn']这样的格式
def strcombine(array):
    size = len(array);
    explode = [];
    for i in range(size):
        #这里传入的阵列已经是规格化后的了，否则要加一层strmono处理。
        explode.append(explodemono(array[i]));

    result = [];

    for i in range(size):
        size_1 = len(result);

        if size_1 <= 0:
            result.append(explode[i]);
        else:
            for j in range(size_1):
                if result[j][1] == explode[i][1]:
                    result[j][0] = result[j][0] + '+' + explode[i][0];
                    break;

                if j >= size_1-1:
                    result.append(explode[i]);

    result_1 = [];

    size_1 = len(result);
    for j in range(size_1):
        result[j][0] = str(round(eval(result[j][0]), 6));

        if (result[j][0] == '0'):
            result_1.append('(0)');
        else:
            tmps = result[j][1];
            if (tmps == ''):
                result_1.append('('+result[j][0]+')');
            else:            
                result_1.append('('+result[j][0]+')*'+result[j][1]);

    return result_1;

#指数为正整数的乘方
def strpow_n(array, n):
    #进行格式化处理
    s = [];

    for i in range(len(array)):
        s.append(strmono(array[i]));

    array = s;

    #计算
    result = [];

    if (n == 1):
        result = array;
    elif (n == 2):
        result = strdot(array, array);

    elif (n == 3):
        tmp = strdot(array, array);
        result = strdot(tmp, array);

    return result;

#阵列取负
def minus(array):
    for i in range(len(array)):
        if array[i][1] == '-':
            #array[i][0]是'(, 这是规范
            array[i] = array[i][0]+array[i][2:];
        else:
            array[i] = array[i][0]+'-'+array[i][1:];

    return array;
</span>

用例：

<span style="font-size:18px;">>>> 
(-3)
(3)
(1)*x
(-1)*x
(2)*x
(-2)*x
(-2)*x^[2]
(3)*x_[2]^[3]
(-3)*x_[2]^[3]

				
#计算代数式用, 传入的是单项式，返回coef*expr的形式
def strmono(s):
    #'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'
    stmp = s;
    size = len(stmp);
    alphaIndex = 0;
    signIndex = 0;
    
    for i in range(size):
        if (stmp[i].isalpha()):
            alphaIndex = i;
            break;
        if (i >= size-1):
            alphaIndex = i+1;

    if (stmp[0] == '-'):
        signIndex = 1;
        if (signIndex >= alphaIndex):
            return '(-1)*'+stmp[alphaIndex:];
        else:
            if alphaIndex >= size:
                return '(-'+stmp[signIndex:alphaIndex]+')';
            return '(-'+stmp[signIndex:alphaIndex]+')*'+stmp[alphaIndex:];
    else:
        signIndex = 0;        
        if (signIndex >= alphaIndex):
            return '(1)*'+stmp[alphaIndex:];
        else:
            if alphaIndex >= size:
                return '('+stmp[signIndex:alphaIndex]+')';
            return '('+stmp[signIndex:alphaIndex]+')*'+stmp[alphaIndex:];
                

if __name__ == '__main__':
    #tmp1();
    s = ['-3', '3', 'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'];

    for i in range(len(s)):
        print(strmono(s[i]));
		
>>> 
(-9)
(3)*x
(-1)*x*x
(-2)*x*x
(-4)*x*x
(4)*x*x^[2]
(-6)*x^[2]*x_[2]^[3]
(-9)*x_[2]^[3]*x_[2]^[3]

#计算两个单项式的乘积
def strmul(s1, s2):
    #这个处理是保证每个单项式统一格式(coef)*expr
    stmp1 = strmono(s1);
    stmp2 = strmono(s2);

    #乘号的位置
    signIndex1 = stmp1.find('*');
    signIndex2 = stmp2.find('*');
    if (signIndex1 == -1):
        coef1 = stmp1;
        expr1 = '';
    else:
        coef1 = stmp1[:signIndex1];
        expr1 = stmp1[signIndex1+1:];

    if (signIndex2 == -1):
        coef2 = stmp2;
        expr2 = '';
    else:
        coef2 = stmp2[:signIndex2];
        expr2 = stmp2[signIndex2+1:];
        
    coef = coef1+'*'+coef2;
    
    if (signIndex1 == -1 or signIndex2 == -1):
        expr = expr1+expr2;
    else:
        expr = expr1+'*'+expr2;

    if (expr == ''):
        return '('+str(round(eval(coef), 6))+')';
    return '('+str(round(eval(coef), 6))+')*'+expr;
                

if __name__ == '__main__':
    #tmp1();
    s = ['-3', '3', 'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'];

    for i in range(len(s)-1):
        print(strmul(s[i], s[i+1]));
		
		

>>> 
(-1.0)
(3.0)*(x)^[-1]
(-1.0)*x/x
(-0.5)*x/x
(-1.0)*x/x
(1.0)*x/x^[2]
(-0.666667)*x^[2]/x_[2]^[3]
(-1.0)*x_[2]^[3]/x_[2]^[3]
(-1.0)*x_[2]^[3]/x_[2]^[3]
(-1.5)*x_[2]^[3]/x^[2]
(1.0)*x^[2]/x
(-1.0)*x/x
(-2.0)*x/x
(-1.0)*x/x
(0.333333)*x
(-1.0)

#计算两个单项式的商
def strdiv(s1, s2):
    #这个处理是保证每个单项式统一格式(coef)*expr
    stmp1 = strmono(s1);
    stmp2 = strmono(s2);

    #乘号的位置
    signIndex1 = stmp1.find('*');
    signIndex2 = stmp2.find('*');
    if (signIndex1 == -1):
        coef1 = stmp1;
        expr1 = '';
    else:
        coef1 = stmp1[:signIndex1];
        expr1 = stmp1[signIndex1+1:];

    if (signIndex2 == -1):
        coef2 = stmp2;
        expr2 = '';
    else:
        coef2 = stmp2[:signIndex2];
        expr2 = stmp2[signIndex2+1:];
        
    coef = coef1+'/'+coef2;
    
    if (signIndex1 == -1 and signIndex2 != -1):
        expr = '('+expr2+')^[-1]';
    elif (signIndex1 == -1 or signIndex2 == -1):
        expr = expr1+expr2;
    else:
        expr = expr1+'/'+expr2;

    if (expr == ''):
        return '('+str(round(eval(coef), 6))+')';
    return '('+str(round(eval(coef), 6))+')*'+expr;
                

if __name__ == '__main__':
    #tmp1();
    s = ['-3', '3', 'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'];

    for i in range(len(s)-1):
        print(strdiv(s[i], s[i+1]));

    for i in range(len(s)-1, 0, -1):
        print(strdiv(s[i], s[i-1]));
		

#找一个字符串中所有待查找子串的位置，返回位置阵列
def findall(string, sub):
    size = len(string);
    index = [];

    cur = string.find(sub);
    index.append(cur)
    
    while (index[-1] != -1):        
        cur = string.find(sub, index[-1]+1);
        index.append(cur);   

    return index;

if __name__ == '__main__':
    #tmp1();
    s = 'abcdefgabcdefgabcdefg';

    print(findall(s, 'c'));
    
#计算单项式的乘方, s^n
def strpow(s, n):
    stmp = strmono(s);
    signIndex = stmp.find('*');
    coef = stmp[:signIndex]+'**'+str(n);
    expr = '('+stmp[signIndex+1:]+')^['+str(n)+']';

    return '('+str(round(eval(coef), 6))+')*'+expr;


    

if __name__ == '__main__':
    #tmp1();
    s = ['-3', '3', 'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'];

    for i in range(len(s)):
        print(strpow(s[i], 3));

#计算代数式用，传入的两个阵列都具有['s1', 's2', ..., 'sn']这样的格式
def strdot(array1, array2):
    size1 = len(array1);
    size2 = len(array2);
    result = [];
    
    for i in range(size1):
        for j in range(size2):
            result.append(strmul(array1[i], array2[j]));

    return result;

    

if __name__ == '__main__':
    #tmp1();
    s = ['-3', '3', 'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'];
    s1 = ['3x'];

    answer = strdot(s, s1);
    print(answer);
	
>>> 
['(-3)', '']
['(3)', '']
['(1)', 'x']
['(-1)', 'x']
['(2)', 'x']
['(-2)', 'x']
['(-2)', 'x^[2]']
['(3)', 'x_[2]^[3]']
['(-3)', 'x_[2]^[3]']

#把格式化后的单项式分解成[coef, expr]对组的形式
def explodemono(mono):
    stmp = mono;

    #乘号的位置
    signIndex = stmp.find('*');
    if (signIndex == -1):
        coef = stmp;
        expr = '';
    else:
        coef = stmp[:signIndex];
        expr = stmp[signIndex+1:];

    return [coef, expr];

if __name__ == '__main__':
    #tmp1();
    s = ['-3', '3', 'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'];

    for i in range(len(s)):
        print(explodemono(strmono(s[i])));
		

>>> 
[['(-3)+(3)', ''], ['(1)+(-1)+(2)+(-2)', 'x'], ['(-2)', 'x^[2]'], ['(3)+(-3)', 'x_[2]^[3]']]	
		
#合并同类项，传入的阵列具有['s1', 's2', ..., 'sn']这样的格式
def strcombine(array):
    size = len(array);
    explode = [];
    for i in range(size):
        #这里传入的阵列已经是规格化后的了，否则要加一层strmono处理。
        explode.append(explodemono(array[i]));

    result = [];

    for i in range(size):
        size_1 = len(result);

        if size_1 <= 0:
            result.append(explode[i]);
        else:
            for j in range(size_1):
                if result[j][1] == explode[i][1]:
                    result[j][0] = result[j][0] + '+' + explode[i][0];
                    break;

                if j >= size_1-1:
                    result.append(explode[i]);

    return result;

    

if __name__ == '__main__':
    #tmp1();
    s = ['-3', '3', 'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'];

    result = [];
    
    for i in range(len(s)):
        result.append(strmono(s[i]));

    answer = strcombine(result);
    print(answer);
	
>>> 
[['0', ''], ['0', 'x'], ['-2', 'x^[2]'], ['0', 'x_[2]^[3]']]

    size_1 = len(result);
    for j in range(size_1):
        result[j][0] = str(round(eval(result[j][0]), 6));
		
>>> 
['(0)', '(0)*x', '(-2)*x^[2]', '(0)*x_[2]^[3]']

>>> 
['(0)', '(0)', '(-2)*x^[2]', '(0)']

#合并同类项，传入的阵列具有['s1', 's2', ..., 'sn']这样的格式
def strcombine(array):
    size = len(array);
    explode = [];
    for i in range(size):
        #这里传入的阵列已经是规格化后的了，否则要加一层strmono处理。
        explode.append(explodemono(array[i]));

    result = [];

    for i in range(size):
        size_1 = len(result);

        if size_1 <= 0:
            result.append(explode[i]);
        else:
            for j in range(size_1):
                if result[j][1] == explode[i][1]:
                    result[j][0] = result[j][0] + '+' + explode[i][0];
                    break;

                if j >= size_1-1:
                    result.append(explode[i]);

    result_1 = [];

    size_1 = len(result);
    for j in range(size_1):
        result[j][0] = str(round(eval(result[j][0]), 6));

        if (result[j][0] == '0'):
            result_1.append('(0)');
        else:
            tmps = result[j][1];
            if (tmps == ''):
                result_1.append('('+result[j][0]+')');
            else:            
                result_1.append('('+result[j][0]+')*'+result[j][1]);

    return result_1;
	

>>> 
['(1)*x', '(-1)*y']
['(1)*x*x', '(-1)*x*y', '(-1)*y*x', '(1)*y*y']
['(1)*x*x*x', '(-1)*x*x*y', '(-1)*x*y*x', '(1)*x*y*y', '(-1)*y*x*x', '(1)*y*x*y', '(1)*y*y*x', '(-1)*y*y*y']
[]

#指数为正整数的乘方
def strpow_n(array, n):
    result = [];

    if (n == 1):
        result = array;
    elif (n == 2):
        result = strdot(array, array);

    elif (n == 3):
        tmp = strdot(array, array);
        result = strdot(tmp, array);

    return result;

if __name__ == '__main__':
    #tmp1();
    s = ['x', '-y'];

    array = [];

    for i in range(len(s)):
        array.append(strmono(s[i]));

    s = array;

    print(s);

    result = [];
    
    print(strpow_n(s, 2));
    print(strpow_n(s, 3));
    print(strpow_n(s, 4));
	
#指数为正整数的乘方
def strpow_n(array, n):
    #进行格式化处理
    s = [];

    for i in range(len(array)):
        s.append(strmono(array[i]));

    array = s;

    #计算
    result = [];

    if (n == 1):
        result = array;
    elif (n == 2):
        result = strdot(array, array);

    elif (n == 3):
        tmp = strdot(array, array);
        result = strdot(tmp, array);

    return result;
	
>>> 
['(3)', '(-3)', '(-1)*x', '(1)*x', '(-2)*x', '(2)*x', '(2)*x^[2]', '(-3)*x_[2]^[3]', '(3)*x_[2]^[3]']

#阵列取负
def minus(array):
    for i in range(len(array)):
        if array[i][1] == '-':
            #array[i][0]是'(, 这是规范
            array[i] = array[i][0]+array[i][2:];
        else:
            array[i] = array[i][0]+'-'+array[i][1:];

    return array;

if __name__ == '__main__':
    #tmp2();

    s = ['-3', '3', 'x', '-x', '2x', '-2x', '-2x^[2]', '3x_[2]^[3]', '-3x_[2]^[3]'];

    for i in range(len(s)):
        s[i] = strmono(s[i]);
        
    result = minus(s);

    print(result);
	</span>

几何运算：

<span style="font-size:18px;">#两点之间
#平面两点的距离[x1, y1] -- [x2, y2]
def distance2D(Point_1, Point_2):
    x1, y1, x2, y2 = Point_1[0], Point_1[1], Point_2[0], Point_2[1];

    return ((x2-x1)**2+(y2-y1)**2)**0.5;

#平面直线的斜率[x1, y1] -- [x2, y2]
def slope(Point_1, Point_2):
    x1, y1, x2, y2 = Point_1[0], Point_1[1], Point_2[0], Point_2[1];

    if (x1 == x2):
        return 'inf';
    else:
        return (y2-y1)/(x2-x1);

#平面直线与X轴的夹角[x1, y1] -- [x2, y2]
def angleFromX(Point_1, Point_2):
    x1, y1, x2, y2 = Point_1[0], Point_1[1], Point_2[0], Point_2[1];

    delta = ((x2-x1)**2+(y2-y1)**2)**0.5;
    dx = x2 - x1;
    dy = y2 - y1;
    
    sin = math.asin(dy / delta)/math.pi*180;
    cos = math.acos(dx / delta)/math.pi*180;

    if (dy >= 0 and dx >= 0):
        return math.asin(dy / delta)/math.pi*180;
    elif (dy >= 0 and dx < 0):
        return 180- math.asin(dy / delta)/math.pi*180;
    elif (dy < 0 and dx <= 0):
        return 180 - math.asin(dy / delta)/math.pi*180;
    else:
        return 360 + math.asin(dy / delta)/math.pi*180;

#平面直线的截距[x1, y1] -- [x2, y2]
def interceptOfLine(Point_1, Point_2):
    k = slope(Point_1, Point_2);

    if k == 'inf':
        return [k, Point_1[0], 1e8];
    elif k == 0:
        return [k, 1e8, Point_1[1]];
    else:
        return [k, Point_1[0]-Point_1[1]/k, Point_1[1]-Point_1[0]*k];
    
#求直线的中垂线
def perpendicular(Line):
    Point_1, Point_2= Line[0], Line[1];
    
    #求斜率
    k = slope(Line[0], Line[1]);
    if k == 'inf':
        k1 = 0;
    else:
        k1 = -1/k;

    midPoint = [0.5*(Point_1[0]+Point_2[0]), 0.5*(Point_1[1]+Point_2[1])];

    return [midPoint, [midPoint[0]+ 10, midPoint[0]+10*k1]];

#两直线之间
#两直线是否平行 Line_1:[Point_1, Point_2], Line_2:[Point_1, Point_2]
def parallelCheck(Line_1, Line_2):
    L1_Point_1, L1_Point_2, L2_Point_1, L2_Point_2 = Line_1[0], Line_1[1], Line_2[0], Line_2[1];
    k1, k2 = slope(L1_Point_1, L1_Point_2), slope(L2_Point_1, L2_Point_2);
    if  k1 == k2 == 'inf':
        return True;
    elif k1 != 'inf' and k2 != 'inf' and abs(k1 - k2) < 1e-6:
        return True;

    return False;

#两直线距离 Line_1:[Point_1, Point_2], Line_2:[Point_1, Point_2]
def lineDistance2D(Line_1, Line_2):
    if parallelCheck(Line_1, Line_2):
        L1_Point_1, L1_Point_2, L2_Point_1, L2_Point_2 = Line_1[0], Line_1[1], Line_2[0], Line_2[1];
        k1, k2 = slope(L1_Point_1, L1_Point_2), slope(L2_Point_1, L2_Point_2);

        if k1 == 'inf':
            return abs(L1_Point_1[0] - L2_Point_1[0]);
        else:
            dx = L1_Point_1[0] - L2_Point_1[0];
            dy = k1*dx;
            return abs((L2_Point_1[1]+dy-L1_Point_1[1])/(1+k1**2)**0.5);

    else:
        return 0;

#两直线夹角 Line_1:[Point_1, Point_2], Line_2:[Point_1, Point_2]
def angleBetweenTwoLine(Line_1, Line_2):
    L1_Point_1, L1_Point_2, L2_Point_1, L2_Point_2 = Line_1[0], Line_1[1], Line_2[0], Line_2[1];

    return angleFromX(L2_Point_1, L2_Point_2) - angleFromX(L1_Point_1, L1_Point_2);


#两直线交点 Line_1:[Point_1, Point_2], Line_2:[Point_1, Point_2]
def crossPointOfTwoLine(Line_1, Line_2):
    if not parallelCheck(Line_1, Line_2):
        L1_Point_1, L1_Point_2, L2_Point_1, L2_Point_2 = Line_1[0], Line_1[1], Line_2[0], Line_2[1];
        '''
        k1, k2 = slope(L1_Point_1, L1_Point_2), slope(L2_Point_1, L2_Point_2);

        if (k1 == 'inf'):
            return [L1_Point_1[0], L2_Point_1[1]-k2*(L2_Point_1[0]-L1_Point1[0])];
        elif (K2 == 'inf'):
            return [L2_Point_1[0], L1_Point_1[1]-k1*(L1_Point_1[0]-L2_Point1[0])];
        '''

        x0, y0, x1, y1, x2, y2, x3, y3 = L1_Point_1[0], L1_Point_1[1], L1_Point_2[0], L1_Point_2[1],\
                                         L2_Point_1[0], L2_Point_1[1], L2_Point_2[0], L2_Point_2[1];
        
        crossY = ( (y0-y1)*(y3-y2)*x0 + (y3-y2)*(x1-x0)*y0 + (y1-y0)*(y3-y2)*x2 + (x2-x3)*(y1-y0)*y2 ) / \
                 ( (x1-x0)*(y3-y2) + (y0-y1)*(x3-x2) );
        crossX =  x2 + (x3-x2)*(crossY-y2) / (y3-y2);

        
        return [crossX, crossY];




#判定三点共线
def pointInLine(Point_1, Point_2, Point_3):
    x0, y0, x1, y1, x2, y2 = Point_1[0], Point_1[1], Point_2[0], Point_2[1], Point_3[0], Point_3[1];

    return (x0*y1-y0*x1)+(x1*y2-y1*x2)+(x2*y0-y2*x0) == 0;

#点到直线的距离
def plDistance2D(Point, Line):
    LPoint_1, LPoint_2 = Line[0], Line[1];

    if (pointInLine(Point, LPoint_1, LPoint_2)):
        return 0;
    else:
        k = slope(LPoint_1, LPoint_2);

        if k == 'inf':
            return abs(Point[0]-LPoint_1[0]);
        else:
            Point2 = [Point[0] + 10, Point[1] + 10 * k];
            return lineDistance2D([Point, Point2], Line);
            

#圆 三点成圆  
#以确定的三点表示圆的方程，得到圆心和半径 [x1, y1] -- [x2, y2] -- [x3, y3]
def circle(Point_1, Point_2, Point_3):
    if not pointInLine(Point_1, Point_2, Point_3):
        x1, y1, x2, y2, x3, y3 = Point_1[0], Point_1[1], Point_2[0], Point_2[1], Point_3[0], Point_3[1];

        A1 = 2*(x2-x1);
        B1 = 2*(y2-y1);
        C1 = x2*x2+y2*y2-x1*x1-y1*y1;   
        A2 = 2*(x3-x2);
        B2 = 2*(y3-y2);
        C2 = x3*x3+y3*y3-x2*x2-y2*y2;

        #圆心
        px = ((C1*B2)-(C2*B1))/((A1*B2)-(A2*B1));  
        py = ((A1*C2)-(A2*C1))/((A1*B2)-(A2*B1));

        a = round(distance2D(Point_1, Point_2), 3);
        b = round(distance2D(Point_2, Point_3), 3); 
        c = round(distance2D(Point_3, Point_1), 3);

        #半径
        R = a*b*c/(4*b*b*c*c-(b*b+c*c-a*a)**2)**0.5;

        return [[px, py], R];
    else:
        return [[0, 0], 0];

#判断点和圆的距离 Point:[x, y], Circle: [[x1, y1], [x2, y2], [x3, y3]]
def pointFromCircle(Point, Circle):
    cPoint_1, cPoint_2, cPoint_3 = Circle[0], Circle[1], Circle[2];
    circleCenter, R = circle(cPoint_1, cPoint_2, cPoint_3);

    d = distance2D(Point, circleCenter);

    #点与圆的位置关系，分为在内部，在外部和在圆上。
    if (d < R):
        return 'IN';
    elif (d > R):
        return 'OUT';
    else:
        return 'ON';


#过圆外部一点，得到与圆的切点的坐标 Point:[x, y], Circle: [[x1, y1], [x2, y2], [x3, y3]]
def tangencyPoint(Point, Circle):
    if pointFromCircle(Point, Circle) == 'OUT':
        cPoint_1, cPoint_2, cPoint_3 = Circle[0], Circle[1], Circle[2];
        circleCenter, R = circle(cPoint_1, cPoint_2, cPoint_3);

        x1, y1, x2, y2 = circleCenter[0], circleCenter[1], Point[0], Point[1];

        dsquare = (x2-x1)**2+(y2-y1)**2;

        part_1 = (R*R*(y1-y2)**2*(dsquare-R*R))**0.5;
        part_2 = (y1-y2)*dsquare;

        #第一个切点
        x3 = (-part_1+R*R*(x2-x1)+x1*dsquare)/dsquare;
        y3 = ((x1-x2)*part_1-R*R*(y1-y2)**2+y1*part_2)/part_2;
        #第二个切点
        x4 = (part_1+R*R*(x2-x1)+x1*dsquare)/dsquare;
        y4 = (-(x1-x2)*part_1-R*R*(y1-y2)**2+y1*part_2)/part_2;

        return [[x3, y3], [x4,y4]];

    return [[0,0], [0,0]];

#直线到圆的距离
def lcDistance2D(Line, Circle):
    lPoint_1, lPoint_2 = Line[0], Line[1];
    cPoint_1, cPoint_2, cPoint_3 = Circle[0], Circle[1], Circle[2];

    circleCenter, R = circle(cPoint_1, cPoint_2, cPoint_3);

    #圆心到直线的距离
    d = plDistance2D(circleCenter, Line);

    return d-R;


#直经与圆的交点
def lcCrossPoint2D(Line, Circle):
    #直线与圆相交
    if lcDistance2D(Line, Circle) <= 0:
        lPoint_1, lPoint_2 = Line[0], Line[1];
        cPoint_1, cPoint_2, cPoint_3 = Circle[0], Circle[1], Circle[2];
        circleCenter, R = circle(cPoint_1, cPoint_2, cPoint_3);

        k, a, b = interceptOfLine(lPoint_1, lPoint_2);

        if k == 'inf':
            k = 1e8;

        c, d = -circleCenter[0], -circleCenter[1];

        print(k, a, b, c, d, R);

        part_0 = (k*k+1)*R*R-c*c*k*k;
        part_1 = (2*c*d+ 2*b*c)*k- d*d-2*b*d-b*b;
        part_2 = (d+b)*k+c;
        part_3 = d*k*k-b;
        part_4 = (k*k+1);
        
        x1 = -((part_0 + part_1)**0.5+part_2)/part_4;
        y1 = -(k*((part_0+part_1)**0.5 + c)+part_3)/part_4;

        x2 = ((part_0+part_1)**0.5-part_2)/part_4;
        y2 = (k*((part_0+part_1)**0.5 - c)-part_3)/part_4;

        return [[x1, y1], [x2, y2]];

    return [[1e8, 1e8], [1e8, 1e8]];
</span>

本节到此结束，欲知后事如何，请看下回分解。
我的史诗般的高考逆袭路【第2版】
银行信息系统架构详解
10-24 392
每个人的精神成长都是一部史诗。而人生无处不“高考”。高考，一旦经历过，它带来的影响就是抹不去的。而背后的酸甜苦辣，以及恐惧悲伤焦虑，无论是哪一种心绪，都会持续很久很久。只有兴奋不会太久。高中的那三年我差点进入死了（精神上的）。还好，后来活了过来，浴火重生，荡气回肠。进入名校，拿到奖学金。但，什么是差点死掉？为什么差点死掉？怎么活过来的？浴火重生是什么意思？荡气回肠，是不是太夸张？进入名校又如何？拿到奖学金就一定是好事儿吗？这正是我将要在下面的故事中讲述的内容。
「01」机器学习与深度学习，到底在学些什么？
Machine Learning with Tutors
05-31 4761
根据定义，学习是从有限的例子中，找出问题和答案之间规律的一个过程，而所找出的规律叫做知识，而知识，在我们的意识层面上叫做知识，但在数学层面，它的名字叫做模型。经过千万年的进化，人类已经可以熟练利用大脑神经元所组成的生物记忆网络，将感官收集到的信号，如图像、物体、声音、文字，通过长短期的记忆机制进行保存。通过这些信息，大脑会推演出下一个类似情况、问题发生时，我们该做出的反应。这些反应有先天的，比如面对狮子时，我们的祖先遗留下来的对死亡的基因恐惧，驱使大脑发出逃离的指令。...
Line-Line Intersection (2d)：计算两条2d线的交点，每条线指定2个点-matlab开发
06-01
计算两条 2d 线的交点，每条线指定 2 个点(X1, Y1; X2, Y2; X3, Y3; X4, Y4)，而 1&2 和 3&4 指定一条线。 如果线平行（= 当分母 = 0 时），则返回 NaN 或 Inf/-Inf 见http://en.wikipedia.org/wiki/Line-line_intersection
[从头学数学] 第201节 几何证明选讲
微笑的彩虹的博客
05-01 3460
剧情提要： [机器小伟]在[工程师阿伟]的陪同下进入了[九转金丹]之第七转的修炼。 这次要研究的是[几何证明选讲]。 正剧开始： 星历2016年05月01日 14:07:58, 银河系厄尔斯星球中华帝国江南行省。 [工程师阿伟]正在和[机器小伟]一起研究[几何证明选讲]。 谈到直线，小伟觉得有必要计算一些东西。 比如平面上两
[从头学数学] 第231节 不定积分
微笑的彩虹的博客
06-01 879
剧情提要： [机器小伟]在[工程师阿伟]的陪同下进入了元婴期的修炼。 这次要修炼的是数学分析（或称高等数学、或称微积分）。 正剧开始：
计算机二级MS office高级应用考试笔记攻略(完整-知识点)
热门推荐
方大熊
02-27 7万+
知识点目录 考试内容（考试大纲） 基本要求 考试内容 一、计算机基础知识 二、Ｗｏｒｄ 的功能和使用 三、Ｅｘｃｅｌ 的功能和使用 四、ＰｏｗｅｒＰｏｉｎｔ 的功能和使用 考试方式 上机考试，考试时长 １２０ 分钟，满分 １００ 分。 考试时间 考试成绩 备考建议 选择题基础知识点部分 计算机二级公共基础知识 计算机的发展、类型及其应用领域 计算机软硬件系统的组成及主要技术指标 计算机中...
计算机二级考试加油作文,为中考而加油作文（精选10篇）
weixin_31845243的博客
07-22 492
为中考而加油作文(精选10篇)在平凡的学习、工作、生活中，大家都接触过作文吧，作文是从内部言语向外部言语的过渡，即从经过压缩的简要的、自己能明白的语言，向开展的、具有规范语法结构的、能为他人所理解的外部语言形式的转化。如何写一篇有思想、有文采的作文呢？以下是小编为大家收集的为中考而加油作文(精选10篇)，欢迎阅读与收藏。为中考而加油作文 篇1我现在是一名中学三年级的学生，现在对于我们来说，我们正站...
计算机二级MS office高级应用考试必看攻略(全部 考点)
zhishitu7的博客
11-02 6287
知识点目录 考试内容（考试大纲） 一、计算机基础知识 二、Ｗｏｒｄ 的功能和使用 三、Ｅｘｃｅｌ 的功能和使用 四、ＰｏｗｅｒＰｏｉｎｔ 的功能和使用 考试方式 上机考试，考试时长 １２０ 分钟，满分 １００ 分。 考试时间 考试成绩 备考建议 选择题基础知识点部分 计算机二级公共基础知识 计算机的发展、类型及其应用领域 计算机软硬件系统的组成及主要技术指标 计算机中数据的表示与存储 计算机病毒的特征、分类与防治 计算机网络的概念、组成和分类 计算机与网络信息安全的概念和防控 因特网网络服务的概念、原.
大学计算机系最努力的同学都是如何学习的？
程序员小灰的博客
08-20 702
本文作者小北，后文中的“我”不是小灰，而是小北同学前段时间在知乎看到一个问题：大学计算机系最努力的同学都是如何学习的？看到了非常多努力的同学，感同身受，自己也写了一篇回答用于记录大学这四年...
第二十三章
aohuang8877的博客
09-08 858
第二十三章 曲则全，枉则正，洼则盈，敝则新，少则得，多则惑。是以圣人执一，为天下牧。不自视故彰；不自见故明；不自伐故有功；弗矜故能长。夫唯不争，故莫能与之争。古之所谓「曲则全」者，几语哉！诚全归之。 罗大伦道德经文字版-第二十三章1 暂时的隐忍会换来更多 各位朋友大家好，今天我们接着来聊《道德经》。我们今天聊到了第二十三章了，慢慢改变，这也说明改变已经很巨大了，我们一...
中国互联网第一人的故事＿＿许榕生的不平凡的经历
红孩儿编程大师
06-06 982
许榕生的名字虽然不是状元的名字，但是绝对是成 功者的名字．之后这个名字和中国的互联网联系在了一起
【南卡樱桃|读书笔记《学习高手》】
weixin_44698581的博客
04-21 1万+
∝学霸分享 6大课 通过英语、写作和SMART原则、OKR工作法、LEO解读五步法等文章。同样适用于国内教育环境。 ∝3 学霸分享，直通世界名校的超级学习法 ∞第18课 LEO手把手教你如何学好英语 ◆第1小课 单词 ◆第2小课 语法 ◆第3小课 听力 ◆第4小课 阅读 ◆第5小课 口语 LEO的学习仪式感 我在不同英语学习阶段使用的教材 ∞第19课 三要素写作法，把文章写到读者心里去 ◆第1小课 Ethos，可信 ◆第2小课 Pathos，情感 ◆第3小课 Logos，逻辑 ◆19-本课核心方法回顾 ∞第
而立之年——回顾我的前端转行之路
BOM485480的博客
11-17 976
为什么转行 因为混得不好。 在成为程序员之前，我干过很多工作。由于学历的问题（高中），我的工作基本上都是体力活。包括但不限于：工厂普工、销售（没有干销售的才能）、搬运工、摆地摊等，转行前最后一份工作是修电脑。这么多年，月薪没高过 3300… 后来偶然一个机会我发现了知乎这个网站，在上面了解到程序员的各种优点。于是，我下定决心转行（2016 年，当时 28 了），辞职在家自学编程。并且也得到了媳妇的支持，感谢我的媳妇。 转行准备 转行选择前端也是在知乎上看网友分析的，比后端好入门。 如何选择教程？ 最好在网
洪峰:泛系、自由与“一、百、万”工程（一）
bruce的专栏
09-14 7666
泛系、自由与“一、百、万”工程 由 洪峰 发表于 04月26日 12:33。   徐永久注：洪峰先生是我国自由软件界的先锋人物，今年开始独立发行 Free Software 杂志。本文以回忆录的形式，叙述了他自己从大学毕业以来，走向事业成功所经历的酸甜苦辣。本文是征得他同意后，发表在本网站的。（一） 初识吴学谋教授（二）迷雾中的引路人（三） 蹉跎岁月（四）走出混沌（
二维码(53).zip
09-12
二维码(53).zip
it‘s a simplified library of ZXing that convenient to encode
最新发布
09-12
it‘s a simplified library of ZXing that convenient to encode and decode QR code.简化的Barcode Scanner二维码扫描工程，基于ZXing的开放工程.zip
一个java生成和扫描二维码的程序.zip
09-12
一个java生成和扫描二维码的程序.zip
用于随机Galerkin方法的Matlab_Octave工具箱_A Matlab_Octave toolbox for
09-12
用于随机Galerkin方法的Matlab_Octave工具箱_A Matlab_Octave toolbox for stochastic Galerkin methods.zip
基于Herbank和Gebhardt的SAFE模型，在西门子MRI系统中实现外周神经刺激（PNS）预测的Matlab实现
09-12
基于Herbank和Gebhardt的SAFE模型，在西门子MRI系统中实现外周神经刺激（PNS）预测的Matlab实现。_Matlab implementation of peripheral nerve stimulation (PNS) prediction at Siemens MRI systems based on the SAFE model by Herbank and Gebhardt..zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值