v1.3

v1.3

v1.3.1

v1.3.1

v1.3.1

v1.3.1

1.3.1

1.3.1

v1.3.2

v1.3.2

v1.3.2

v1.3.3

v1.3.3

v1.3.3

pip upload

Older Versions/yoshi-otter1.3.1/LICENSE

@@ -0,0 +1,278 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.

Older Versions/yoshi-otter1.3.1/Otter/Otter.py

@@ -0,0 +1,517 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import pandas as pd
+import Seals
+
+sl = Seals.process()
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.F = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.F(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.F(x(i),y)+self.F(x(i+1),(y+(dx*self.F(x(i),y)))))
+                
+            return y
+
+        def adams(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+            
+            for i in range(n):
+
+                f0 = self.F(x(i),y)
+                f1 = self.F(x(i+1),y + dx*self.F(x(i)+(dx/2),y+(dx/2)*self.F(x(i),y)))
+                f2 = self.F(x(i+2),y + (dx/2)*(3*f1-f0))
+                
+                y += (dx/12)*(5*f2 + 8*f1 - f0)
+
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data.x[i]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data.y[i]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data.x[i]*self.data.y[i]
+
+        omega = 0
+        #somatorio de x^2self.dself.dself.d
+        for i in range(self.data.shape[0]):
+
+            omega += self.data.x[i]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data.y[i]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data.x[i] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data.y[i] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data.x[:]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    up = up*(x - self.data.x[i])
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    down = down*(self.data.x[k] - self.data.x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(self.data.x.shape[0]):
+
+                y += self.data.y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data.x[(i+1)+j]-self.data.x[j])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data.x[k])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data.x[0] - self.data.x[1]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data.x[k])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

Older Versions/yoshi-otter1.3.1/Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

Older Versions/yoshi-otter1.3.1/README.md

@@ -0,0 +1,75 @@
+# Otter - Numeric Calculus
+
+This python package is made for applied Numeric Calculus of Algebra Functions. It is made with the following objectives in mind:
+
+* Receive one variable function from user input
+  
+* Receive two variable function from user input
+
+* Performe derivatives with one variable functions
+
+* Performe integral with received functions
+
+* Use methods to proccess the matrices.
+
+* Find root of functions throw method of bissection and method of newton
+
+* Solve Diferential Equations throw method of euler and runge
+
+* Performe Minimus Interpolation and Polinomial Interpolation
+
+## Syntax
+
+To initialize a Otter instance linked to functions use the following syntax `otr = Otter.algebra(f)`, where `otr` will be a arbitrary name for the instance and `f` is a function of *one variable*.
+
+To initialize a Otter instance linked to data and interpolation use the following syntax `otr = Otter.interpolation(data)`, where `otr` will be a arbitrary name for the instance and data will be a *numpy* matrix where the first columns has to contain the values for `x` and the second column contains the values for `y`.
+
+### Algebra
+
+Algebra is a Python Class where some of the features described previously are defined as Classes as well, like: `Integral`, `Roots`, `EDO` (diferential equations).
+
+#### Integral
+
+To call the class *Integral* append the sufix with lower case in front of the instance like: `otr.integral`. The Integral class has two other class defined inside, `Simple` and `Double`, to call them append the sufix with lower case in front as `otr.integral.simple` or `otr.integral.double`. Then pick between Riemann's Method or Simpson's Method by appending the sufix `riemann` or `simpson` as well.
+
+After that the syntax will be something like `otr.integral.double.riemann(a,b,c,d,n,m)`, where `a` and `c` will be the first value of the interval of integration respectively in x and y, `b` and `d` will be the last, `n` and `m` will be the number of partitions.
+
+The syntax for one variable integrations will be `otr.integral.simple.riemann(a,b,n)`.
+
+If `n` is not defined the standart value in 10^6 partitions for one variable and 10^4 for double. And if `m` is not defined the standart value will be equal to `n`.
+
+#### Roots
+
+To call the class *Root* append the sufix with lower case in front of the instance like: `otr.roots`. The Roots class has three methods defined inside, `bissec`, `newton` and `bissec_newton`, to call them append the sufix with lower case in front as `otr.roots.bissec` or `otr.roots.newton` or even `otr.roots.bissecnewton`.
+
+The syntax for the bissection method and bissec_newton is equal to `otr.roots.bissec(a,b,e)` and `otr.roots.bissec_newton(a,b,e)`, where `a` is the first element of the interval containing the root and `b` is the last, `e` being the precision.
+
+The syntax for the newton method is equal to `otr.roots.newton(a,e)`, where `a` is the element closest to the root and `e` is the precision.
+
+If `e` is not defined the standart value is 10^(-6).
+
+#### Diferential Equations
+
+To call the class *EDO* (*E*quações *D*iferenciais *O*rdinárias) append the sufix with lower case in front of the instance like: `otr.edo`. The *EDO* class has two methods defined inside: `euler` and `runge`, to call them append the sufix with lower case in front as `otr.edo.euler` or `otr.edo.runge`.
+
+The syntax for the diferential equations method is equal to `otr.edo.euler(a,y,b,n)` or `otr.edo.runge(a,y,b,n)`, where `a` and `y` will be the inintial point  and `b` is the value in *x* which you want to know the corresponding value in *y* and `n` is the number of operations.
+
+If `n` is not defined the standart value is 10^7.
+
+### Interpolation
+
+The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
+
+To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `data` is a data frame containing values for *x* and *y*, `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+
+To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
+
+## Installation
+
+To install the package from source `cd` into the directory and run:
+
+`pip install .`
+
+or run
+
+`pip install yoshi-otter`

Older Versions/yoshi-otter1.3.1/build/lib/Otter/Otter.py

@@ -0,0 +1,517 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import pandas as pd
+import Seals
+
+sl = Seals.process()
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.F = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.F(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.F(x(i),y)+self.F(x(i+1),(y+(dx*self.F(x(i),y)))))
+                
+            return y
+
+        def adams(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+            
+            for i in range(n):
+
+                f0 = self.F(x(i),y)
+                f1 = self.F(x(i+1),y + dx*self.F(x(i)+(dx/2),y+(dx/2)*self.F(x(i),y)))
+                f2 = self.F(x(i+2),y + (dx/2)*(3*f1-f0))
+                
+                y += (dx/12)*(5*f2 + 8*f1 - f0)
+
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data.x[i]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data.y[i]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data.x[i]*self.data.y[i]
+
+        omega = 0
+        #somatorio de x^2self.dself.dself.d
+        for i in range(self.data.shape[0]):
+
+            omega += self.data.x[i]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data.y[i]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data.x[i] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data.y[i] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data.x[:]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    up = up*(x - self.data.x[i])
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    down = down*(self.data.x[k] - self.data.x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(self.data.x.shape[0]):
+
+                y += self.data.y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data.x[(i+1)+j]-self.data.x[j])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data.x[k])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data.x[0] - self.data.x[1]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data.x[k])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

Older Versions/yoshi-otter1.3.1/build/lib/Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

Older Versions/yoshi-otter1.3.1/setup.py

@@ -0,0 +1,28 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="yoshi-otter", # Replace with your own username
+    version="1.3.1",
+    author="Vitor Hideyoshi",
+    author_email="vitor.h.n.batista@gmail.com",
+    description="Numeric Calculus python module in the topic of Algebra Functions",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/HideyoshiNakazone/Otter-NumericCalculus.git",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
+        "Operating System :: OS Independent",
+        "Development Status :: 2 - Pre-Alpha",
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+          'numpy',
+          'pandas',
+          'yoshi-seals'
+      ],
+)

Older Versions/yoshi-otter1.3.1/yoshi_otter.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: yoshi-otter
+Version: 1.3.1
+Summary: Numeric Calculus python module in the topic of Algebra Functions
+Home-page: https://github.com/HideyoshiNakazone/Otter-NumericCalculus.git
+Author: Vitor Hideyoshi
+Author-email: vitor.h.n.batista@gmail.com
+License: UNKNOWN
+Description: # Otter - Numeric Calculus
+        
+        This python package is made for applied Numeric Calculus of Algebra Functions. It is made with the following objectives in mind:
+        
+        * Receive one variable function from user input
+          
+        * Receive two variable function from user input
+        
+        * Performe derivatives with one variable functions
+        
+        * Performe integral with received functions
+        
+        * Use methods to proccess the matrices.
+        
+        * Find root of functions throw method of bissection and method of newton
+        
+        * Solve Diferential Equations throw method of euler and runge
+        
+        * Performe Minimus Interpolation and Polinomial Interpolation
+        
+        ## Syntax
+        
+        To initialize a Otter instance linked to functions use the following syntax `otr = Otter.algebra(f)`, where `otr` will be a arbitrary name for the instance and `f` is a function of *one variable*.
+        
+        To initialize a Otter instance linked to data and interpolation use the following syntax `otr = Otter.interpolation(data)`, where `otr` will be a arbitrary name for the instance and data will be a *numpy* matrix where the first columns has to contain the values for `x` and the second column contains the values for `y`.
+        
+        ### Algebra
+        
+        Algebra is a Python Class where some of the features described previously are defined as Classes as well, like: `Integral`, `Roots`, `EDO` (diferential equations).
+        
+        #### Integral
+        
+        To call the class *Integral* append the sufix with lower case in front of the instance like: `otr.integral`. The Integral class has two other class defined inside, `Simple` and `Double`, to call them append the sufix with lower case in front as `otr.integral.simple` or `otr.integral.double`. Then pick between Riemann's Method or Simpson's Method by appending the sufix `riemann` or `simpson` as well.
+        
+        After that the syntax will be something like `otr.integral.double.riemann(a,b,c,d,n,m)`, where `a` and `c` will be the first value of the interval of integration respectively in x and y, `b` and `d` will be the last, `n` and `m` will be the number of partitions.
+        
+        The syntax for one variable integrations will be `otr.integral.simple.riemann(a,b,n)`.
+        
+        If `n` is not defined the standart value in 10^6 partitions for one variable and 10^4 for double. And if `m` is not defined the standart value will be equal to `n`.
+        
+        #### Roots
+        
+        To call the class *Root* append the sufix with lower case in front of the instance like: `otr.roots`. The Roots class has three methods defined inside, `bissec`, `newton` and `bissec_newton`, to call them append the sufix with lower case in front as `otr.roots.bissec` or `otr.roots.newton` or even `otr.roots.bissecnewton`.
+        
+        The syntax for the bissection method and bissec_newton is equal to `otr.roots.bissec(a,b,e)` and `otr.roots.bissec_newton(a,b,e)`, where `a` is the first element of the interval containing the root and `b` is the last, `e` being the precision.
+        
+        The syntax for the newton method is equal to `otr.roots.newton(a,e)`, where `a` is the element closest to the root and `e` is the precision.
+        
+        If `e` is not defined the standart value is 10^(-6).
+        
+        #### Diferential Equations
+        
+        To call the class *EDO* (*E*quações *D*iferenciais *O*rdinárias) append the sufix with lower case in front of the instance like: `otr.edo`. The *EDO* class has two methods defined inside: `euler` and `runge`, to call them append the sufix with lower case in front as `otr.edo.euler` or `otr.edo.runge`.
+        
+        The syntax for the diferential equations method is equal to `otr.edo.euler(a,y,b,n)` or `otr.edo.runge(a,y,b,n)`, where `a` and `y` will be the inintial point  and `b` is the value in *x* which you want to know the corresponding value in *y* and `n` is the number of operations.
+        
+        If `n` is not defined the standart value is 10^7.
+        
+        ### Interpolation
+        
+        The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
+        
+        To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `data` is a data frame containing values for *x* and *y*, `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+        
+        To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
+        
+        ## Installation
+        
+        To install the package from source `cd` into the directory and run:
+        
+        `pip install .`
+        
+        or run
+        
+        `pip install yoshi-otter`
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 2 - Pre-Alpha
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

Older Versions/yoshi-otter1.3.1/yoshi_otter.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+Otter/Otter.py
+Otter/__init__.py
+yoshi_otter.egg-info/PKG-INFO
+yoshi_otter.egg-info/SOURCES.txt
+yoshi_otter.egg-info/dependency_links.txt
+yoshi_otter.egg-info/requires.txt
+yoshi_otter.egg-info/top_level.txt

Older Versions/yoshi-otter1.3.1/yoshi_otter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Older Versions/yoshi-otter1.3.1/yoshi_otter.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+pandas
+yoshi-seals

Older Versions/yoshi-otter1.3.1/yoshi_otter.egg-info/top_level.txt

@@ -0,0 +1 @@
+Otter

Older Versions/yoshi-otter1.3.2/LICENSE

@@ -0,0 +1,278 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.

Older Versions/yoshi-otter1.3.2/Otter/Otter.py

@@ -0,0 +1,517 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import pandas as pd
+import Seals
+
+sl = Seals.process
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.F = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.F(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.F(x(i),y)+self.F(x(i+1),(y+(dx*self.F(x(i),y)))))
+                
+            return y
+
+        def adams(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+            
+            for i in range(n):
+
+                f0 = self.F(x(i),y)
+                f1 = self.F(x(i+1),y + dx*self.F(x(i)+(dx/2),y+(dx/2)*self.F(x(i),y)))
+                f2 = self.F(x(i+2),y + (dx/2)*(3*f1-f0))
+                
+                y += (dx/12)*(5*f2 + 8*f1 - f0)
+
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data.x[i]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data.y[i]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data.x[i]*self.data.y[i]
+
+        omega = 0
+        #somatorio de x^2self.dself.dself.d
+        for i in range(self.data.shape[0]):
+
+            omega += self.data.x[i]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data.y[i]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data.x[i] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data.y[i] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data.x[:]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    up = up*(x - self.data.x[i])
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    down = down*(self.data.x[k] - self.data.x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(self.data.x.shape[0]):
+
+                y += self.data.y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data.x[(i+1)+j]-self.data.x[j])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data.x[k])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data.x[0] - self.data.x[1]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data.x[k])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

Older Versions/yoshi-otter1.3.2/Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

Older Versions/yoshi-otter1.3.2/README.md

@@ -0,0 +1,75 @@
+# Otter - Numeric Calculus
+
+This python package is made for applied Numeric Calculus of Algebra Functions. It is made with the following objectives in mind:
+
+* Receive one variable function from user input
+  
+* Receive two variable function from user input
+
+* Performe derivatives with one variable functions
+
+* Performe integral with received functions
+
+* Use methods to proccess the matrices.
+
+* Find root of functions throw method of bissection and method of newton
+
+* Solve Diferential Equations throw method of euler and runge
+
+* Performe Minimus Interpolation and Polinomial Interpolation
+
+## Syntax
+
+To initialize a Otter instance linked to functions use the following syntax `otr = Otter.algebra(f)`, where `otr` will be a arbitrary name for the instance and `f` is a function of *one variable*.
+
+To initialize a Otter instance linked to data and interpolation use the following syntax `otr = Otter.interpolation(data)`, where `otr` will be a arbitrary name for the instance and data will be a *numpy* matrix where the first columns has to contain the values for `x` and the second column contains the values for `y`.
+
+### Algebra
+
+Algebra is a Python Class where some of the features described previously are defined as Classes as well, like: `Integral`, `Roots`, `EDO` (diferential equations).
+
+#### Integral
+
+To call the class *Integral* append the sufix with lower case in front of the instance like: `otr.integral`. The Integral class has two other class defined inside, `Simple` and `Double`, to call them append the sufix with lower case in front as `otr.integral.simple` or `otr.integral.double`. Then pick between Riemann's Method or Simpson's Method by appending the sufix `riemann` or `simpson` as well.
+
+After that the syntax will be something like `otr.integral.double.riemann(a,b,c,d,n,m)`, where `a` and `c` will be the first value of the interval of integration respectively in x and y, `b` and `d` will be the last, `n` and `m` will be the number of partitions.
+
+The syntax for one variable integrations will be `otr.integral.simple.riemann(a,b,n)`.
+
+If `n` is not defined the standart value in 10^6 partitions for one variable and 10^4 for double. And if `m` is not defined the standart value will be equal to `n`.
+
+#### Roots
+
+To call the class *Root* append the sufix with lower case in front of the instance like: `otr.roots`. The Roots class has three methods defined inside, `bissec`, `newton` and `bissec_newton`, to call them append the sufix with lower case in front as `otr.roots.bissec` or `otr.roots.newton` or even `otr.roots.bissecnewton`.
+
+The syntax for the bissection method and bissec_newton is equal to `otr.roots.bissec(a,b,e)` and `otr.roots.bissec_newton(a,b,e)`, where `a` is the first element of the interval containing the root and `b` is the last, `e` being the precision.
+
+The syntax for the newton method is equal to `otr.roots.newton(a,e)`, where `a` is the element closest to the root and `e` is the precision.
+
+If `e` is not defined the standart value is 10^(-6).
+
+#### Diferential Equations
+
+To call the class *EDO* (*E*quações *D*iferenciais *O*rdinárias) append the sufix with lower case in front of the instance like: `otr.edo`. The *EDO* class has two methods defined inside: `euler` and `runge`, to call them append the sufix with lower case in front as `otr.edo.euler` or `otr.edo.runge`.
+
+The syntax for the diferential equations method is equal to `otr.edo.euler(a,y,b,n)` or `otr.edo.runge(a,y,b,n)`, where `a` and `y` will be the inintial point  and `b` is the value in *x* which you want to know the corresponding value in *y* and `n` is the number of operations.
+
+If `n` is not defined the standart value is 10^7.
+
+### Interpolation
+
+The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
+
+To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `data` is a data frame containing values for *x* and *y*, `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+
+To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
+
+## Installation
+
+To install the package from source `cd` into the directory and run:
+
+`pip install .`
+
+or run
+
+`pip install yoshi-otter`

Older Versions/yoshi-otter1.3.2/build/lib/Otter/Otter.py

@@ -0,0 +1,517 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import pandas as pd
+import Seals
+
+sl = Seals.process
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.F = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.F(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.F(x(i),y)+self.F(x(i+1),(y+(dx*self.F(x(i),y)))))
+                
+            return y
+
+        def adams(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+            
+            for i in range(n):
+
+                f0 = self.F(x(i),y)
+                f1 = self.F(x(i+1),y + dx*self.F(x(i)+(dx/2),y+(dx/2)*self.F(x(i),y)))
+                f2 = self.F(x(i+2),y + (dx/2)*(3*f1-f0))
+                
+                y += (dx/12)*(5*f2 + 8*f1 - f0)
+
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data.x[i]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data.y[i]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data.x[i]*self.data.y[i]
+
+        omega = 0
+        #somatorio de x^2self.dself.dself.d
+        for i in range(self.data.shape[0]):
+
+            omega += self.data.x[i]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data.y[i]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data.x[i] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data.y[i] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data.x[:]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    up = up*(x - self.data.x[i])
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    down = down*(self.data.x[k] - self.data.x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(self.data.x.shape[0]):
+
+                y += self.data.y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data.x[(i+1)+j]-self.data.x[j])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data.x[k])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data.x[0] - self.data.x[1]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data.x[k])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

Older Versions/yoshi-otter1.3.2/build/lib/Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

Older Versions/yoshi-otter1.3.2/setup.py

@@ -0,0 +1,28 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="yoshi-otter", # Replace with your own username
+    version="1.3.2",
+    author="Vitor Hideyoshi",
+    author_email="vitor.h.n.batista@gmail.com",
+    description="Numeric Calculus python module in the topic of Algebra Functions",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/HideyoshiNakazone/Otter-NumericCalculus.git",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
+        "Operating System :: OS Independent",
+        "Development Status :: 2 - Pre-Alpha",
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+          'numpy',
+          'pandas',
+          'yoshi-seals'
+      ],
+)

Older Versions/yoshi-otter1.3.2/yoshi_otter.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: yoshi-otter
+Version: 1.3.2
+Summary: Numeric Calculus python module in the topic of Algebra Functions
+Home-page: https://github.com/HideyoshiNakazone/Otter-NumericCalculus.git
+Author: Vitor Hideyoshi
+Author-email: vitor.h.n.batista@gmail.com
+License: UNKNOWN
+Description: # Otter - Numeric Calculus
+        
+        This python package is made for applied Numeric Calculus of Algebra Functions. It is made with the following objectives in mind:
+        
+        * Receive one variable function from user input
+          
+        * Receive two variable function from user input
+        
+        * Performe derivatives with one variable functions
+        
+        * Performe integral with received functions
+        
+        * Use methods to proccess the matrices.
+        
+        * Find root of functions throw method of bissection and method of newton
+        
+        * Solve Diferential Equations throw method of euler and runge
+        
+        * Performe Minimus Interpolation and Polinomial Interpolation
+        
+        ## Syntax
+        
+        To initialize a Otter instance linked to functions use the following syntax `otr = Otter.algebra(f)`, where `otr` will be a arbitrary name for the instance and `f` is a function of *one variable*.
+        
+        To initialize a Otter instance linked to data and interpolation use the following syntax `otr = Otter.interpolation(data)`, where `otr` will be a arbitrary name for the instance and data will be a *numpy* matrix where the first columns has to contain the values for `x` and the second column contains the values for `y`.
+        
+        ### Algebra
+        
+        Algebra is a Python Class where some of the features described previously are defined as Classes as well, like: `Integral`, `Roots`, `EDO` (diferential equations).
+        
+        #### Integral
+        
+        To call the class *Integral* append the sufix with lower case in front of the instance like: `otr.integral`. The Integral class has two other class defined inside, `Simple` and `Double`, to call them append the sufix with lower case in front as `otr.integral.simple` or `otr.integral.double`. Then pick between Riemann's Method or Simpson's Method by appending the sufix `riemann` or `simpson` as well.
+        
+        After that the syntax will be something like `otr.integral.double.riemann(a,b,c,d,n,m)`, where `a` and `c` will be the first value of the interval of integration respectively in x and y, `b` and `d` will be the last, `n` and `m` will be the number of partitions.
+        
+        The syntax for one variable integrations will be `otr.integral.simple.riemann(a,b,n)`.
+        
+        If `n` is not defined the standart value in 10^6 partitions for one variable and 10^4 for double. And if `m` is not defined the standart value will be equal to `n`.
+        
+        #### Roots
+        
+        To call the class *Root* append the sufix with lower case in front of the instance like: `otr.roots`. The Roots class has three methods defined inside, `bissec`, `newton` and `bissec_newton`, to call them append the sufix with lower case in front as `otr.roots.bissec` or `otr.roots.newton` or even `otr.roots.bissecnewton`.
+        
+        The syntax for the bissection method and bissec_newton is equal to `otr.roots.bissec(a,b,e)` and `otr.roots.bissec_newton(a,b,e)`, where `a` is the first element of the interval containing the root and `b` is the last, `e` being the precision.
+        
+        The syntax for the newton method is equal to `otr.roots.newton(a,e)`, where `a` is the element closest to the root and `e` is the precision.
+        
+        If `e` is not defined the standart value is 10^(-6).
+        
+        #### Diferential Equations
+        
+        To call the class *EDO* (*E*quações *D*iferenciais *O*rdinárias) append the sufix with lower case in front of the instance like: `otr.edo`. The *EDO* class has two methods defined inside: `euler` and `runge`, to call them append the sufix with lower case in front as `otr.edo.euler` or `otr.edo.runge`.
+        
+        The syntax for the diferential equations method is equal to `otr.edo.euler(a,y,b,n)` or `otr.edo.runge(a,y,b,n)`, where `a` and `y` will be the inintial point  and `b` is the value in *x* which you want to know the corresponding value in *y* and `n` is the number of operations.
+        
+        If `n` is not defined the standart value is 10^7.
+        
+        ### Interpolation
+        
+        The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
+        
+        To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `data` is a data frame containing values for *x* and *y*, `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+        
+        To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
+        
+        ## Installation
+        
+        To install the package from source `cd` into the directory and run:
+        
+        `pip install .`
+        
+        or run
+        
+        `pip install yoshi-otter`
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 2 - Pre-Alpha
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

Older Versions/yoshi-otter1.3.2/yoshi_otter.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+Otter/Otter.py
+Otter/__init__.py
+yoshi_otter.egg-info/PKG-INFO
+yoshi_otter.egg-info/SOURCES.txt
+yoshi_otter.egg-info/dependency_links.txt
+yoshi_otter.egg-info/requires.txt
+yoshi_otter.egg-info/top_level.txt

Older Versions/yoshi-otter1.3.2/yoshi_otter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Older Versions/yoshi-otter1.3.2/yoshi_otter.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+pandas
+yoshi-seals

Older Versions/yoshi-otter1.3.2/yoshi_otter.egg-info/top_level.txt

@@ -0,0 +1 @@
+Otter

Older Versions/yoshi-otter1.3/LICENSE

@@ -0,0 +1,278 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.

Older Versions/yoshi-otter1.3/Otter/Otter.py

@@ -0,0 +1,499 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import Seals
+
+sl = Seals.process()
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.f = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**7
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.f(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**7
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.f(x(i),y)+self.f(x(i+1),(y+(dx*self.f(x(i),y)))))
+                
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data[i][0]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data[i][1]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data[i][0]*self.data[i][1]
+
+        omega = 0
+        #somatorio de x^2
+        for i in range(self.data.shape[0]):
+
+            omega += self.data[i][0]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data[i][1]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data[i][0] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data[i][1] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data[:,0]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            data_x = self.data[:,0]
+            data_y = self.data[:,1]
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(data_x.shape[0]) if x != k]:
+                    up = up*(x - data_x[i])
+
+                for i in [x for x in range(data_x.shape[0]) if x != k]:
+                    down = down*(data_x[k] - data_x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(data_x.shape[0]):
+
+                y += data_y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data[:,1]
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data[(i+1)+j][0]-self.data[j][0])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data[k][0])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data[0][0] - self.data[1][0]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data[:,1]
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data[k][0])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

Older Versions/yoshi-otter1.3/Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

Older Versions/yoshi-otter1.3/README.md

@@ -0,0 +1,75 @@
+# Otter - Numeric Calculus
+
+This python package is made for applied Numeric Calculus of Algebra Functions. It is made with the following objectives in mind:
+
+* Receive one variable function from user input
+  
+* Receive two variable function from user input
+
+* Performe derivatives with one variable functions
+
+* Performe integral with received functions
+
+* Use methods to proccess the matrices.
+
+* Find root of functions throw method of bissection and method of newton
+
+* Solve Diferential Equations throw method of euler and runge
+
+* Performe Minimus Interpolation and Polinomial Interpolation
+
+## Syntax
+
+To initialize a Otter instance linked to functions use the following syntax `otr = Otter.algebra(f)`, where `otr` will be a arbitrary name for the instance and `f` is a function of *one variable*.
+
+To initialize a Otter instance linked to data and interpolation use the following syntax `otr = Otter.interpolation(data)`, where `otr` will be a arbitrary name for the instance and data will be a *numpy* matrix where the first columns has to contain the values for `x` and the second column contains the values for `y`.
+
+### Algebra
+
+Algebra is a Python Class where some of the features described previously are defined as Classes as well, like: `Integral`, `Roots`, `EDO` (diferential equations).
+
+#### Integral
+
+To call the class *Integral* append the sufix with lower case in front of the instance like: `otr.integral`. The Integral class has two other class defined inside, `Simple` and `Double`, to call them append the sufix with lower case in front as `otr.integral.simple` or `otr.integral.double`. Then pick between Riemann's Method or Simpson's Method by appending the sufix `riemann` or `simpson` as well.
+
+After that the syntax will be something like `otr.integral.double.riemann(a,b,c,d,n,m)`, where `a` and `c` will be the first value of the interval of integration respectively in x and y, `b` and `d` will be the last, `n` and `m` will be the number of partitions.
+
+The syntax for one variable integrations will be `otr.integral.simple.riemann(a,b,n)`.
+
+If `n` is not defined the standart value in 10^6 partitions for one variable and 10^4 for double. And if `m` is not defined the standart value will be equal to `n`.
+
+#### Roots
+
+To call the class *Root* append the sufix with lower case in front of the instance like: `otr.roots`. The Roots class has three methods defined inside, `bissec`, `newton` and `bissec_newton`, to call them append the sufix with lower case in front as `otr.roots.bissec` or `otr.roots.newton` or even `otr.roots.bissecnewton`.
+
+The syntax for the bissection method and bissec_newton is equal to `otr.roots.bissec(a,b,e)` and `otr.roots.bissec_newton(a,b,e)`, where `a` is the first element of the interval containing the root and `b` is the last, `e` being the precision.
+
+The syntax for the newton method is equal to `otr.roots.newton(a,e)`, where `a` is the element closest to the root and `e` is the precision.
+
+If `e` is not defined the standart value is 10^(-6).
+
+#### Diferential Equations
+
+To call the class *EDO* (*E*quações *D*iferenciais *O*rdinárias) append the sufix with lower case in front of the instance like: `otr.edo`. The *EDO* class has two methods defined inside: `euler` and `runge`, to call them append the sufix with lower case in front as `otr.edo.euler` or `otr.edo.runge`.
+
+The syntax for the diferential equations method is equal to `otr.edo.euler(a,y,b,n)` or `otr.edo.runge(a,y,b,n)`, where `a` and `y` will be the inintial point  and `b` is the value in *x* which you want to know the corresponding value in *y* and `n` is the number of operations.
+
+If `n` is not defined the standart value is 10^7.
+
+### Interpolation
+
+The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
+
+To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+
+To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
+
+## Installation
+
+To install the package from source `cd` into the directory and run:
+
+`pip install .`
+
+or run
+
+`pip install yoshi-otter`

Older Versions/yoshi-otter1.3/build/lib/Otter/Otter.py

@@ -0,0 +1,499 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import Seals
+
+sl = Seals.process()
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.f = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**7
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.f(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**7
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.f(x(i),y)+self.f(x(i+1),(y+(dx*self.f(x(i),y)))))
+                
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data[i][0]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data[i][1]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data[i][0]*self.data[i][1]
+
+        omega = 0
+        #somatorio de x^2
+        for i in range(self.data.shape[0]):
+
+            omega += self.data[i][0]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data[i][1]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data[i][0] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data[i][1] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data[:,0]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            data_x = self.data[:,0]
+            data_y = self.data[:,1]
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(data_x.shape[0]) if x != k]:
+                    up = up*(x - data_x[i])
+
+                for i in [x for x in range(data_x.shape[0]) if x != k]:
+                    down = down*(data_x[k] - data_x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(data_x.shape[0]):
+
+                y += data_y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data[:,1]
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data[(i+1)+j][0]-self.data[j][0])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data[k][0])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data[0][0] - self.data[1][0]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data[:,1]
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data[k][0])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

Older Versions/yoshi-otter1.3/build/lib/Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

Older Versions/yoshi-otter1.3/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="yoshi-otter", # Replace with your own username
-    version="1.2",
+    version="1.3",
     author="Vitor Hideyoshi",
     author_email="vitor.h.n.batista@gmail.com",
     description="Numeric Calculus python module in the topic of Algebra Functions",

Older Versions/yoshi-otter1.3/yoshi_otter.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: yoshi-otter
+Version: 1.3
+Summary: Numeric Calculus python module in the topic of Algebra Functions
+Home-page: https://github.com/HideyoshiNakazone/Otter-NumericCalculus.git
+Author: Vitor Hideyoshi
+Author-email: vitor.h.n.batista@gmail.com
+License: UNKNOWN
+Description: # Otter - Numeric Calculus
+        
+        This python package is made for applied Numeric Calculus of Algebra Functions. It is made with the following objectives in mind:
+        
+        * Receive one variable function from user input
+          
+        * Receive two variable function from user input
+        
+        * Performe derivatives with one variable functions
+        
+        * Performe integral with received functions
+        
+        * Use methods to proccess the matrices.
+        
+        * Find root of functions throw method of bissection and method of newton
+        
+        * Solve Diferential Equations throw method of euler and runge
+        
+        * Performe Minimus Interpolation and Polinomial Interpolation
+        
+        ## Syntax
+        
+        To initialize a Otter instance linked to functions use the following syntax `otr = Otter.algebra(f)`, where `otr` will be a arbitrary name for the instance and `f` is a function of *one variable*.
+        
+        To initialize a Otter instance linked to data and interpolation use the following syntax `otr = Otter.interpolation(data)`, where `otr` will be a arbitrary name for the instance and data will be a *numpy* matrix where the first columns has to contain the values for `x` and the second column contains the values for `y`.
+        
+        ### Algebra
+        
+        Algebra is a Python Class where some of the features described previously are defined as Classes as well, like: `Integral`, `Roots`, `EDO` (diferential equations).
+        
+        #### Integral
+        
+        To call the class *Integral* append the sufix with lower case in front of the instance like: `otr.integral`. The Integral class has two other class defined inside, `Simple` and `Double`, to call them append the sufix with lower case in front as `otr.integral.simple` or `otr.integral.double`. Then pick between Riemann's Method or Simpson's Method by appending the sufix `riemann` or `simpson` as well.
+        
+        After that the syntax will be something like `otr.integral.double.riemann(a,b,c,d,n,m)`, where `a` and `c` will be the first value of the interval of integration respectively in x and y, `b` and `d` will be the last, `n` and `m` will be the number of partitions.
+        
+        The syntax for one variable integrations will be `otr.integral.simple.riemann(a,b,n)`.
+        
+        If `n` is not defined the standart value in 10^6 partitions for one variable and 10^4 for double. And if `m` is not defined the standart value will be equal to `n`.
+        
+        #### Roots
+        
+        To call the class *Root* append the sufix with lower case in front of the instance like: `otr.roots`. The Roots class has three methods defined inside, `bissec`, `newton` and `bissec_newton`, to call them append the sufix with lower case in front as `otr.roots.bissec` or `otr.roots.newton` or even `otr.roots.bissecnewton`.
+        
+        The syntax for the bissection method and bissec_newton is equal to `otr.roots.bissec(a,b,e)` and `otr.roots.bissec_newton(a,b,e)`, where `a` is the first element of the interval containing the root and `b` is the last, `e` being the precision.
+        
+        The syntax for the newton method is equal to `otr.roots.newton(a,e)`, where `a` is the element closest to the root and `e` is the precision.
+        
+        If `e` is not defined the standart value is 10^(-6).
+        
+        #### Diferential Equations
+        
+        To call the class *EDO* (*E*quações *D*iferenciais *O*rdinárias) append the sufix with lower case in front of the instance like: `otr.edo`. The *EDO* class has two methods defined inside: `euler` and `runge`, to call them append the sufix with lower case in front as `otr.edo.euler` or `otr.edo.runge`.
+        
+        The syntax for the diferential equations method is equal to `otr.edo.euler(a,y,b,n)` or `otr.edo.runge(a,y,b,n)`, where `a` and `y` will be the inintial point  and `b` is the value in *x* which you want to know the corresponding value in *y* and `n` is the number of operations.
+        
+        If `n` is not defined the standart value is 10^7.
+        
+        ### Interpolation
+        
+        The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
+        
+        To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+        
+        To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
+        
+        ## Installation
+        
+        To install the package from source `cd` into the directory and run:
+        
+        `pip install .`
+        
+        or run
+        
+        `pip install yoshi-otter`
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 2 - Pre-Alpha
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

Older Versions/yoshi-otter1.3/yoshi_otter.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+Otter/Otter.py
+Otter/__init__.py
+yoshi_otter.egg-info/PKG-INFO
+yoshi_otter.egg-info/SOURCES.txt
+yoshi_otter.egg-info/dependency_links.txt
+yoshi_otter.egg-info/requires.txt
+yoshi_otter.egg-info/top_level.txt

Older Versions/yoshi-otter1.3/yoshi_otter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Older Versions/yoshi-otter1.3/yoshi_otter.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+pandas
+yoshi-seals

Older Versions/yoshi-otter1.3/yoshi_otter.egg-info/top_level.txt

@@ -0,0 +1 @@
+Otter

README.md

@@ -60,7 +60,7 @@ If `n` is not defined the standart value is 10^7.
 
 The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
 
-To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `data` is a data frame containing values for *x* and *y*, `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
 
 To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
 

Source Code - Otter/Otter.py

@@ -0,0 +1,515 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import pandas as pd
+from Seals import process as sl
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.F = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.F(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.F(x(i),y)+self.F(x(i+1),(y+(dx*self.F(x(i),y)))))
+                
+            return y
+
+        def adams(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+            
+            for i in range(n):
+
+                f0 = self.F(x(i),y)
+                f1 = self.F(x(i+1),y + dx*self.F(x(i)+(dx/2),y+(dx/2)*self.F(x(i),y)))
+                f2 = self.F(x(i+2),y + (dx/2)*(3*f1-f0))
+                
+                y += (dx/12)*(5*f2 + 8*f1 - f0)
+
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data.x[i]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data.y[i]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data.x[i]*self.data.y[i]
+
+        omega = 0
+        #somatorio de x^2self.dself.dself.d
+        for i in range(self.data.shape[0]):
+
+            omega += self.data.x[i]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data.y[i]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data.x[i] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data.y[i] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data.x[:]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    up = up*(x - self.data.x[i])
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    down = down*(self.data.x[k] - self.data.x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(self.data.x.shape[0]):
+
+                y += self.data.y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data.x[(i+1)+j]-self.data.x[j])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data.x[k])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data.x[0] - self.data.x[1]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data.x[k])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

Source Code - Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

yoshi-otter1.3.3/LICENSE

@@ -0,0 +1,278 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.

yoshi-otter1.3.3/Otter/Otter.py

@@ -0,0 +1,515 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import pandas as pd
+from Seals import process as sl
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.F = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.F(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.F(x(i),y)+self.F(x(i+1),(y+(dx*self.F(x(i),y)))))
+                
+            return y
+
+        def adams(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+            
+            for i in range(n):
+
+                f0 = self.F(x(i),y)
+                f1 = self.F(x(i+1),y + dx*self.F(x(i)+(dx/2),y+(dx/2)*self.F(x(i),y)))
+                f2 = self.F(x(i+2),y + (dx/2)*(3*f1-f0))
+                
+                y += (dx/12)*(5*f2 + 8*f1 - f0)
+
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data.x[i]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data.y[i]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data.x[i]*self.data.y[i]
+
+        omega = 0
+        #somatorio de x^2self.dself.dself.d
+        for i in range(self.data.shape[0]):
+
+            omega += self.data.x[i]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data.y[i]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data.x[i] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data.y[i] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data.x[:]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    up = up*(x - self.data.x[i])
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    down = down*(self.data.x[k] - self.data.x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(self.data.x.shape[0]):
+
+                y += self.data.y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data.x[(i+1)+j]-self.data.x[j])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data.x[k])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data.x[0] - self.data.x[1]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data.x[k])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

yoshi-otter1.3.3/Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

yoshi-otter1.3.3/README.md

@@ -0,0 +1,75 @@
+# Otter - Numeric Calculus
+
+This python package is made for applied Numeric Calculus of Algebra Functions. It is made with the following objectives in mind:
+
+* Receive one variable function from user input
+  
+* Receive two variable function from user input
+
+* Performe derivatives with one variable functions
+
+* Performe integral with received functions
+
+* Use methods to proccess the matrices.
+
+* Find root of functions throw method of bissection and method of newton
+
+* Solve Diferential Equations throw method of euler and runge
+
+* Performe Minimus Interpolation and Polinomial Interpolation
+
+## Syntax
+
+To initialize a Otter instance linked to functions use the following syntax `otr = Otter.algebra(f)`, where `otr` will be a arbitrary name for the instance and `f` is a function of *one variable*.
+
+To initialize a Otter instance linked to data and interpolation use the following syntax `otr = Otter.interpolation(data)`, where `otr` will be a arbitrary name for the instance and data will be a *numpy* matrix where the first columns has to contain the values for `x` and the second column contains the values for `y`.
+
+### Algebra
+
+Algebra is a Python Class where some of the features described previously are defined as Classes as well, like: `Integral`, `Roots`, `EDO` (diferential equations).
+
+#### Integral
+
+To call the class *Integral* append the sufix with lower case in front of the instance like: `otr.integral`. The Integral class has two other class defined inside, `Simple` and `Double`, to call them append the sufix with lower case in front as `otr.integral.simple` or `otr.integral.double`. Then pick between Riemann's Method or Simpson's Method by appending the sufix `riemann` or `simpson` as well.
+
+After that the syntax will be something like `otr.integral.double.riemann(a,b,c,d,n,m)`, where `a` and `c` will be the first value of the interval of integration respectively in x and y, `b` and `d` will be the last, `n` and `m` will be the number of partitions.
+
+The syntax for one variable integrations will be `otr.integral.simple.riemann(a,b,n)`.
+
+If `n` is not defined the standart value in 10^6 partitions for one variable and 10^4 for double. And if `m` is not defined the standart value will be equal to `n`.
+
+#### Roots
+
+To call the class *Root* append the sufix with lower case in front of the instance like: `otr.roots`. The Roots class has three methods defined inside, `bissec`, `newton` and `bissec_newton`, to call them append the sufix with lower case in front as `otr.roots.bissec` or `otr.roots.newton` or even `otr.roots.bissecnewton`.
+
+The syntax for the bissection method and bissec_newton is equal to `otr.roots.bissec(a,b,e)` and `otr.roots.bissec_newton(a,b,e)`, where `a` is the first element of the interval containing the root and `b` is the last, `e` being the precision.
+
+The syntax for the newton method is equal to `otr.roots.newton(a,e)`, where `a` is the element closest to the root and `e` is the precision.
+
+If `e` is not defined the standart value is 10^(-6).
+
+#### Diferential Equations
+
+To call the class *EDO* (*E*quações *D*iferenciais *O*rdinárias) append the sufix with lower case in front of the instance like: `otr.edo`. The *EDO* class has two methods defined inside: `euler` and `runge`, to call them append the sufix with lower case in front as `otr.edo.euler` or `otr.edo.runge`.
+
+The syntax for the diferential equations method is equal to `otr.edo.euler(a,y,b,n)` or `otr.edo.runge(a,y,b,n)`, where `a` and `y` will be the inintial point  and `b` is the value in *x* which you want to know the corresponding value in *y* and `n` is the number of operations.
+
+If `n` is not defined the standart value is 10^7.
+
+### Interpolation
+
+The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
+
+To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `data` is a data frame containing values for *x* and *y*, `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+
+To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
+
+## Installation
+
+To install the package from source `cd` into the directory and run:
+
+`pip install .`
+
+or run
+
+`pip install yoshi-otter`

yoshi-otter1.3.3/build/lib/Otter/Otter.py

@@ -0,0 +1,515 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+#
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import math
+import numpy as np
+import pandas as pd
+from Seals import process as sl
+
+class Algebra:
+
+    def __init__(self, function):
+        self.f = function
+        self.integral = self.Integral(self.f)
+        self.roots = self.Roots(self.f)
+        self.edo = self.Edo(self.f)
+    
+    def d(self, x, e):
+        return (self.f(x + e) - self.f(x - e))/(2*e)
+
+    class Integral:
+
+        def __init__(self,function):
+            self.f = function
+            self.simple = self.Simple(function)
+            self.double = self.Double(function)
+        
+        class Simple:
+            def __init__(self, function):
+                self.f = function
+
+            def riemann(self,a,b,n=None):
+                
+                if n is None:
+                    n = 10**6
+
+                delta = (b-a)/n
+
+                psi = a
+                theta = 0
+
+                while((psi+delta) <= b):
+                    
+                    theta += (self.f(psi) + self.f(psi + delta))/2
+                    psi += delta
+                    
+                integral = delta*theta
+
+                return integral
+
+            def simpson(self,a,b,n=None):
+
+                if n is None:
+                    n = 10**6
+
+                def x(i):
+                    return a + i*h
+
+                h = (b-a)/n
+
+                eta = 0
+                theta = 0
+
+                psi = 1
+                kappa = 1
+
+                while(psi <= (n/2)):
+
+                    eta = eta + self.f(x(2*psi - 1))
+                    psi = psi + 1
+
+                while(kappa <= ((n/2)-1)):
+
+                    theta = theta + self.f(x(2*kappa))
+                    kappa = kappa + 1
+
+                return (h/3)*( self.f(x(0)) + self.f(x(n)) + 4*eta + 2*theta)
+
+
+        class Double:
+            
+            def __init__(self,function):
+                self.f = function
+
+            def riemann(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                kappa = a
+                psi = c
+                theta = 0
+
+                while((psi + dy) < d):
+
+                    while((kappa + dx) < b):
+
+                        theta = theta + self.f(kappa, psi)
+                        kappa = kappa + dx
+
+                    psi = psi + dy
+                    kappa = a
+
+                return theta*(dx)*(dy)
+
+            def simpson(self,a,b,c,d,n=None,m=None):
+                
+                if n is None:
+                    n = 10**4
+
+                if m is None:
+                    m = n
+
+                dx = (b-a)/n
+                dy = (d-c)/m
+                
+                def x(i):
+    
+                    x = a + i*dx
+                    
+                    return x
+
+                def y(i):
+                    
+                    y = c + i*dy
+                    
+                    return y
+
+                def g(i):
+                    
+                    sigma = 0
+                    upsilon  = 0
+                    
+                    zeta = 1
+                    csi = 1
+                    
+                    while(zeta <= (m/2)):
+                        
+                        sigma += self.f(x(i),y(2*zeta - 1))
+                        zeta += 1
+                        
+                    while(csi <= ((m/2)-1)):
+                        
+                        upsilon  += self.f(x(i),y(2*csi))
+                        csi += 1
+                    
+                    return (dy/3)*( self.f(x(i),y(0)) + self.f(x(i),y(m)) + 4*sigma + 2*upsilon )
+
+                eta = 0
+                theta = 0
+                
+                psi = 1
+                kappa = 1
+                
+                while(psi <= (n/2)):
+                    
+                    eta += g(2*psi - 1)
+                    psi += 1
+                    
+                while(kappa <= ((n/2)-1)):
+                    
+                    theta += g(2*kappa)
+                    kappa += 1
+                
+                return (dx/3)*( g(0) + g(n) + 4*eta + 2*theta)
+
+    class Roots:
+
+        def __init__(self, function=None):
+            if function is not None:
+                self.f = function
+
+        def bissec(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+
+            fa = self.f(a)
+            
+            while abs(a-b) > e:
+                
+                c = (a+b)/2
+                fc = self.f(c)
+                
+                if (fa*fc) < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = fc
+                    
+                c = (a+b)/2
+                
+                return c
+
+        def d(self, x, e):
+            return (self.f(x + e) - self.f(x - e))/(2*e)
+
+        def newton(self,a,e=None):
+
+            if e is None:
+                e = 10**(-6)
+            
+            fa = self.f(a)
+            da = self.d(a,e)
+            b = a - fa/da
+            
+            
+            while abs(a-b) > e:
+                
+                b = a
+                a -= (fa/da)
+                fa = self.f(a)
+                da = self.d(a,e)
+                
+            return a
+
+        def bissec_newton(self,a,b,e=None):
+
+            if e is None:
+                e = 10**(-6)
+                
+            fa = self.f(a)
+            
+            c = (a+b)/2                             # 'c' é a raiz calculada
+            
+            while abs(a-b) > 0.1:
+                
+                fc = self.f(c)
+                
+                if fa*fc < 0:
+                    
+                    b = c
+                    
+                else:
+                    
+                    a = c
+                    fa = self.f(a)
+                    
+                c = (a+b)/2
+                
+            fc = self.f(c)
+            dc = self.d(c,e)
+            h = c - fc/dc                          # 'h' é uma variável de controle
+            
+            while abs(c-h) > e:
+                
+                h = c
+                c -= (fc/dc)
+                fc = self.f(c)
+                dc = self.d(c,e)
+                
+            return (c)
+
+
+    class Edo:
+
+        def __init__(self, function):
+            self.F = function
+
+        def euler(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return a + i*dx
+
+            for i in range(n):
+
+                y = y + (self.F(x(i),y))*dx
+                
+            return y
+
+        def runge(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+
+            for i in range(n):
+
+                y = y + (dx/2)*(self.F(x(i),y)+self.F(x(i+1),(y+(dx*self.F(x(i),y)))))
+                
+            return y
+
+        def adams(self,a,y,b,n=None):
+
+            if n is None:
+                n = 10**6
+
+            dx = (b-a)/n
+
+            def x(i):
+                return (a + i*dx)
+            
+            for i in range(n):
+
+                f0 = self.F(x(i),y)
+                f1 = self.F(x(i+1),y + dx*self.F(x(i)+(dx/2),y+(dx/2)*self.F(x(i),y)))
+                f2 = self.F(x(i+2),y + (dx/2)*(3*f1-f0))
+                
+                y += (dx/12)*(5*f2 + 8*f1 - f0)
+
+            return y
+
+class Interpolation:
+    """ Data should be organized in two columns: X and Y"""
+
+    def __init__(self, data):
+
+        self.data = data
+        self.polinomial = self.Polinomial(self.data)
+
+    def minimus(self,x):
+
+        theta = 0
+        # somatorio de x
+        for i in range(self.data.shape[0]):
+
+            theta += self.data.x[i]
+
+        eta = 0
+        #somatorio de y
+        for i in range(self.data.shape[0]):
+
+            eta += self.data.y[i]
+
+        sigma = 0
+        #somatorio de xy
+        for i in range(self.data.shape[0]):
+
+            sigma += self.data.x[i]*self.data.y[i]
+
+        omega = 0
+        #somatorio de x^2self.dself.dself.d
+        for i in range(self.data.shape[0]):
+
+            omega += self.data.x[i]**2
+
+
+        self.a = (self.data.shape[0]*sigma - theta*eta)/(self.data.shape[0]*omega - (theta**2))
+
+        self.b = (theta*sigma - eta*omega)/((theta**2) - self.data.shape[0]*omega)
+        
+        ym = 0
+
+        for i in range(self.data.shape[0]):
+
+            ym += self.data.y[i]/self.data.shape[0]
+
+        sqreq = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqreq += ((self.a*self.data.x[i] + self.b) - ym)**2
+
+        sqtot = 0
+
+        for i in range(self.data.shape[0]):
+
+            sqtot += (self.data.y[i] - ym)**2
+
+        self.r2 = sqreq/sqtot
+
+        return self.a*x + self.b
+
+    class Polinomial:
+
+        def __init__(self, data):
+            self.data = data
+
+        def vandermonde(self, x):
+
+            matrix = np.zeros((self.data.shape[0],self.data.shape[0]))
+            
+            for k in range(0, self.data.shape[0]):
+
+                matrix[:,k] = self.data.x[:]**k 
+
+            self.A = sl.gauss(np.c_[matrix,self.data[:,1]])
+            
+            y = 0
+
+            for i in range(0,self.A.shape[0]):
+
+                y += self.A[i]*(x**i)
+
+            return float(y)
+
+        def lagrange(self, x):
+
+            def L(k,x):
+        
+                up = down = 1
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    up = up*(x - self.data.x[i])
+
+                for i in [x for x in range(self.data.x.shape[0]) if x != k]:
+                    down = down*(self.data.x[k] - self.data.x[i])
+
+                return up/down
+
+            y = 0
+
+            for i in range(self.data.x.shape[0]):
+
+                y += self.data.y[i]*L(i,x)
+
+            return y
+
+        def newton(self,x):
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/(self.data.x[(i+1)+j]-self.data.x[j])
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            def f(x):
+
+                y = d[0][0]
+                i = 0
+                
+                while ((i+1) < self.data.shape[0]):
+
+                    mult = 1
+                    k = 0
+                    while (k <= i):
+                        mult = mult*(x - self.data.x[k])
+                        k += 1
+
+                    y += d[i+1][0]*mult
+                    i += 1
+
+                return y
+
+            self.f = f
+            
+            return f(x)
+
+        def gregory(self,x):
+
+            h = self.data.x[0] - self.data.x[1]
+            
+            d = np.array(np.zeros((self.data.shape[0],self.data.shape[0])))
+
+            d[0] = self.data.y
+
+            i = j = 0
+
+            while (i < self.data.shape[0]):
+
+                while (j < (self.data.shape[0]-(i+1))):
+
+                    d[i+1][j] = (d[i][j+1] - d[i][j])/((i+1)*h)
+                    j += 1
+                
+                i += 1
+                j = 0
+            
+            y = d[0][0]
+            i = 0
+            
+            while ((i+1) < self.data.shape[0]):
+
+                mult = 1
+                k = 0
+                while (k <= i):
+                    mult = mult*(x - self.data.x[k])
+                    k += 1
+
+                y += d[i+1][0]*mult
+                i += 1
+
+            return y   

yoshi-otter1.3.3/build/lib/Otter/__init__.py

@@ -0,0 +1,21 @@
+# Otter - Program made for educational intent, can be freely distributed
+# and can be used for economical intent. I will not take legal actions
+# unless my intelectual propperty, the code, is stolen or change without permission.  
+
+# Copyright (C) 2020  VItor Hideyoshi Nakazone Batista
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from .Otter import Algebra as algebra
+from .Otter import Interpolation as interpolation

yoshi-otter1.3.3/setup.py

@@ -0,0 +1,28 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="yoshi-otter", # Replace with your own username
+    version="1.3.3",
+    author="Vitor Hideyoshi",
+    author_email="vitor.h.n.batista@gmail.com",
+    description="Numeric Calculus python module in the topic of Algebra Functions",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/HideyoshiNakazone/Otter-NumericCalculus.git",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
+        "Operating System :: OS Independent",
+        "Development Status :: 2 - Pre-Alpha",
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+          'numpy',
+          'pandas',
+          'yoshi-seals'
+      ],
+)

yoshi-otter1.3.3/yoshi_otter.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: yoshi-otter
+Version: 1.3.3
+Summary: Numeric Calculus python module in the topic of Algebra Functions
+Home-page: https://github.com/HideyoshiNakazone/Otter-NumericCalculus.git
+Author: Vitor Hideyoshi
+Author-email: vitor.h.n.batista@gmail.com
+License: UNKNOWN
+Description: # Otter - Numeric Calculus
+        
+        This python package is made for applied Numeric Calculus of Algebra Functions. It is made with the following objectives in mind:
+        
+        * Receive one variable function from user input
+          
+        * Receive two variable function from user input
+        
+        * Performe derivatives with one variable functions
+        
+        * Performe integral with received functions
+        
+        * Use methods to proccess the matrices.
+        
+        * Find root of functions throw method of bissection and method of newton
+        
+        * Solve Diferential Equations throw method of euler and runge
+        
+        * Performe Minimus Interpolation and Polinomial Interpolation
+        
+        ## Syntax
+        
+        To initialize a Otter instance linked to functions use the following syntax `otr = Otter.algebra(f)`, where `otr` will be a arbitrary name for the instance and `f` is a function of *one variable*.
+        
+        To initialize a Otter instance linked to data and interpolation use the following syntax `otr = Otter.interpolation(data)`, where `otr` will be a arbitrary name for the instance and data will be a *numpy* matrix where the first columns has to contain the values for `x` and the second column contains the values for `y`.
+        
+        ### Algebra
+        
+        Algebra is a Python Class where some of the features described previously are defined as Classes as well, like: `Integral`, `Roots`, `EDO` (diferential equations).
+        
+        #### Integral
+        
+        To call the class *Integral* append the sufix with lower case in front of the instance like: `otr.integral`. The Integral class has two other class defined inside, `Simple` and `Double`, to call them append the sufix with lower case in front as `otr.integral.simple` or `otr.integral.double`. Then pick between Riemann's Method or Simpson's Method by appending the sufix `riemann` or `simpson` as well.
+        
+        After that the syntax will be something like `otr.integral.double.riemann(a,b,c,d,n,m)`, where `a` and `c` will be the first value of the interval of integration respectively in x and y, `b` and `d` will be the last, `n` and `m` will be the number of partitions.
+        
+        The syntax for one variable integrations will be `otr.integral.simple.riemann(a,b,n)`.
+        
+        If `n` is not defined the standart value in 10^6 partitions for one variable and 10^4 for double. And if `m` is not defined the standart value will be equal to `n`.
+        
+        #### Roots
+        
+        To call the class *Root* append the sufix with lower case in front of the instance like: `otr.roots`. The Roots class has three methods defined inside, `bissec`, `newton` and `bissec_newton`, to call them append the sufix with lower case in front as `otr.roots.bissec` or `otr.roots.newton` or even `otr.roots.bissecnewton`.
+        
+        The syntax for the bissection method and bissec_newton is equal to `otr.roots.bissec(a,b,e)` and `otr.roots.bissec_newton(a,b,e)`, where `a` is the first element of the interval containing the root and `b` is the last, `e` being the precision.
+        
+        The syntax for the newton method is equal to `otr.roots.newton(a,e)`, where `a` is the element closest to the root and `e` is the precision.
+        
+        If `e` is not defined the standart value is 10^(-6).
+        
+        #### Diferential Equations
+        
+        To call the class *EDO* (*E*quações *D*iferenciais *O*rdinárias) append the sufix with lower case in front of the instance like: `otr.edo`. The *EDO* class has two methods defined inside: `euler` and `runge`, to call them append the sufix with lower case in front as `otr.edo.euler` or `otr.edo.runge`.
+        
+        The syntax for the diferential equations method is equal to `otr.edo.euler(a,y,b,n)` or `otr.edo.runge(a,y,b,n)`, where `a` and `y` will be the inintial point  and `b` is the value in *x* which you want to know the corresponding value in *y* and `n` is the number of operations.
+        
+        If `n` is not defined the standart value is 10^7.
+        
+        ### Interpolation
+        
+        The python class *Interpolation* is divided in one method, minimus interpolation, and one class, polinomial interpolation.
+        
+        To call the method *minimus* use a syntax like `otr = Otter.interpolation(data)`, where `data` is a data frame containing values for *x* and *y*, `otr` is an instance and append the method in front of the instance like: `otr.minimus(x)`, where *x* is value of *f(x)* you want to estimate.
+        
+        To call the class *Polinomial* append the sufix with lower case in front of the instance like: `otr.polinomial`. The *Polinomial* class has four methods defined inside: `vandermonde`, `lagrange`, `newton` and `gregory`, to call them append the sufix with lower case in front like `otr.edo.gregory(x)` where *x* is value of *f(x)* you want to estimate.
+        
+        ## Installation
+        
+        To install the package from source `cd` into the directory and run:
+        
+        `pip install .`
+        
+        or run
+        
+        `pip install yoshi-otter`
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 2 - Pre-Alpha
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

yoshi-otter1.3.3/yoshi_otter.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+Otter/Otter.py
+Otter/__init__.py
+yoshi_otter.egg-info/PKG-INFO
+yoshi_otter.egg-info/SOURCES.txt
+yoshi_otter.egg-info/dependency_links.txt
+yoshi_otter.egg-info/requires.txt
+yoshi_otter.egg-info/top_level.txt

yoshi-otter1.3.3/yoshi_otter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yoshi-otter1.3.3/yoshi_otter.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+pandas
+yoshi-seals

yoshi-otter1.3.3/yoshi_otter.egg-info/top_level.txt

@@ -0,0 +1 @@
+Otter