根式进入计算机的方法

1.前人的努力

浮点数是一个广泛使用的数据类型，运算相当快速，可以适应很多场景。

Python提供Fraction类，decimal类。用分数、小数计算，精度高,但其表示不了根式

weixin_39622217提出要发明此类工具，但最终却渐渐跑题。所以我打算发明一种适用根式的计算机存储方法。

2.我的方法

可以采用自底向上的思考方法。先处理好存储，再研究如何生成和输出，接着琢磨加减法，最后实现乘除法。层层包装，由易到难。如图所示。

 

2.1.如何储存

二次根式（本篇不讨论高次根式）可以用以下结构来描述

 

 

可知a1、a2、a3和b1、b2、b3互相对应。

b是不会重复的，一个b一定对应且只对应一个a。

a是可能重复的，即可能存在a1=a2。

所以可以用一个字典代表二次根式，a为键，b为值。

字典是可以随意增删改查的，然而我们并不期望一个数的值改变，同时为了更方便处理其他模块和考虑自己的编程水平限制，我使用了python的实例对象来存储二次根式。它存储一个指针指向存储数据的目标字典。同时集成其他功能。

2.2.四则运算

加减法逻辑不难，创建一个字典，往里面逐个加入元素，系数可以直接相加相减，为了管理方便并进行检查，我从里面分离出了加入单个根式的方法。

乘法也没想象中那么艰难，将两个根式各项逐个进行，根号外的相乘，根号内的相乘。再将结果相加。

除法难度高，但由于前面做了充足准备，也可以克服。

将分母的常数项取反再同分子和分母相乘，这样可以约掉一项。约不干净再来一次。但一旦分母的常数项大于等于四次

将永远无法再约干净，暂时没有替代方案，只得作罢。

2.3输入输出

    我设计以下几种输入方式。一是传入一个字典，做为存储的字典（上文已提及）。

二是传入两个数，第一个作为系数a，第二个作为底数b。三是传入一个数作为系数a，底数为1.支持Fraction和decimal类

创建方法如下。

 

四是调用sqrt函数，传入一个整数，生成根式，建议使用这种方法。

输出目前没有什么好的方法，这是最好的。

 

 

3.后人可改进部分

（1）只有二次式，无论是叫它实数还是代数数，都没有100%覆盖。

（2）除法中除数四项及以上会出现问题，暂时用报错的方式避免死循环。

（3）输出不美观。且不提供转换成其他数据形式的通道。

（4）只支持python语言内部使用。

这还有待后人改进。

4.附录：

没有任何人告诉我那些参数叫什么，只得自己取名了。如果功能存在差异，以程序为准。

项目地址

python实数: 在python中自制一个数据类型

铁板鲈鱼1 / Shishu · GitCode

程序原文

#导入deepcopy

from copy import deepcopy

#方便对格式进行比较

isin=isinstance

from fractions import Fraction



#实数             

class AlgNum:

    

    def __init__(self,number:any=0,base:int=1):      

        if  isin(number,AlgNum):#实数格式

            self.__data=deepcopy(number.__data)

            return

        elif isin(number,dict):#dict格式

            self.__data=number

            return    

        else:

            number=format(number)#其他

            self.__data={}

            self.__data[base]=number

        a=self.simplifications()

        self.__data.clear()       

        for i in a:

            self.__data[i]=a[i]

                

    

    def toadd(self,number,root=1):#添加一个数

        if self.__data.get(root) is None:#已存在，get方法存在则返回切片值，否则返回None

            self.__data[root]=format(number)

        else:                                        #不存在

            self.__data[root]+=format(number)

    

    #四则运算

    

    #加法    

    def __add__(self,number):

        temp=AlgNum(self)

        if isin(number,AlgNum):#实数格式

            for i in number.__data:

                temp.toadd(number.__data[i],i)

                

        else:#分数，小数

            number=format(number)    

            temp.toadd(number)

        return temp

    

    #减法    

    def __sub__(self,number):

        temp=AlgNum(self)#复制一份       

        if isin(number,AlgNum):#实数格式

            for i in number.__data:

                temp.toadd(number.__data[i]*(-1),i)        

        else:#分数，小数

            number=format(number*(-1))    

            temp.toadd(number)

        return temp

    

    def simplifications(self):#化简，暂时不动

        def decompose(a):

            b=1

            c=1

            while c**2<a:

                c+=1                

                if a%(c**2)==0:

                    b=c

            return b

            

        copy0={}

        for temp in self.__data:

            temp2=temp

            temp3=self.__data[temp2]

            temp4=decompose(temp)

            temp2=temp2//(temp4**2)

            temp3=temp3*temp4           

            if  copy0.get(temp2) is None:

                copy0[temp2]=format(temp3)                

            else:

                copy0[temp2]+=format(temp3)

        copy1=dict(copy0)

        for temp in copy0:

            if copy0[temp].numerator==0:####

                del copy1[temp]

        return copy1          

       

    def __mul__(self,number):#乘法

        temp=AlgNum()

        data1=self.__data

        data2=number.__data

        for jia in data1:

            for yi in data2:

                temp.toadd(data1[jia]*data2[yi],root=jia*yi)          

        return AlgNum(temp.simplifications())



    def __truediv__(self,number):#除法

        if len(list(number.__data))>=4:

            raise Exception("理论问题，除数项数不得大于3")

        a=self

        b=number    

        if (b.__data.get(1) is None):

            a=a*b

            b=b*b            

        while not (len(b.__data)==1):                     

            d=b.__data.copy()

            d[1]=d[1]*-1

            c=AlgNum(d)              

            a=a*c

            b=b*c

                

        c=AlgNum(a)        

        for i in a.__data:

            c.__data[i]=a.__data[i]/b.__data[1]    

        return c    

    

    #反运算

    __radd__=lambda self,number:AlgNum(number)+self#加



    __rmul__=lambda self,number:AlgNum(number)*self#乘



    __rsub__=lambda self,number:AlgNum(number)-self#减



    __rtruediv__=lambda self,number:AlgNum(number)/self#除



    __rdiv__=__rfloordiv__=__rtruediv__#n种除法

    

    #文本化    

    __str__=(lambda self : "AlgNum"+str(self.__data).

                     replace("{","[").replace("}","]") )

    __repr__=(lambda self : "AlgNum("+str(self.__data)+")")



    @property

    def data(self):

        return self.__data



#将各种格式转为分数

def format(number):

    return Fraction(number)

    

def sqrt(num):

    """开平方


       可以这么写

        a=1*sqrt(13)+2*sqrt(5)

        方便人工生成

     """
    return AlgNum(number=1,base=num)