added writer thing
This commit is contained in:
@@ -0,0 +1,24 @@
|
||||
import cv2
|
||||
cap = cv2.VideoCapture(0)
|
||||
print(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
|
||||
print(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
|
||||
|
||||
cap.set(3, 3000)
|
||||
cap.set(4, 3000)
|
||||
|
||||
print(cap.get(3))
|
||||
print(cap.get(4))
|
||||
while(cap.isOpened()):
|
||||
ret, frame = cap.read()
|
||||
if ret == True:
|
||||
|
||||
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
|
||||
cv2.imshow('frame', gray)
|
||||
|
||||
if cv2.waitKey(1) & 0xFF == ord('q'):
|
||||
break
|
||||
else:
|
||||
break
|
||||
|
||||
cap.release()
|
||||
cv2.destroyAllWindows()
|
||||
@@ -0,0 +1,29 @@
|
||||
import pygame
|
||||
from pygame.locals import *
|
||||
import cv2
|
||||
import numpy as np
|
||||
import sys
|
||||
|
||||
camera = cv2.VideoCapture(0)
|
||||
pygame.init()
|
||||
pygame.display.set_caption("OpenCV camera stream on Pygame")
|
||||
screen = pygame.display.set_mode([1280,720])
|
||||
|
||||
try:
|
||||
while True:
|
||||
|
||||
ret, frame = camera.read()
|
||||
|
||||
screen.fill([0,0,0])
|
||||
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
|
||||
frame = np.rot90(frame)
|
||||
frame = pygame.surfarray.make_surface(frame)
|
||||
screen.blit(frame, (0,0))
|
||||
pygame.display.update()
|
||||
|
||||
for event in pygame.event.get():
|
||||
if event.type == KEYDOWN:
|
||||
sys.exit(0)
|
||||
except (KeyboardInterrupt,SystemExit):
|
||||
pygame.quit()
|
||||
cv2.destroyAllWindows()
|
||||
Binary file not shown.
@@ -0,0 +1,26 @@
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
sj="saint jalm.jpg"
|
||||
vl="valentin.png"
|
||||
tm="tetedemarc.png"
|
||||
pm="profiledemarc.jpg"
|
||||
|
||||
img = cv2.imread(tm,0)
|
||||
img = cv2.medianBlur(img,5)
|
||||
img = cv2.Canny(img,50,150)
|
||||
cimg = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR)
|
||||
|
||||
circles = cv2.HoughCircles(img,cv2.HOUGH_GRADIENT,1,20,
|
||||
param1=50,param2=30,minRadius=0,maxRadius=200)
|
||||
|
||||
circles = np.uint16(np.around(circles))
|
||||
for i in circles[0,:]:
|
||||
# draw the outer circle
|
||||
cv2.circle(cimg,(i[0],i[1]),i[2],(0,255,0),2)
|
||||
# draw the center of the circle
|
||||
cv2.circle(cimg,(i[0],i[1]),2,(0,0,255),3)
|
||||
|
||||
cv2.imshow('detected circles',cimg)
|
||||
cv2.waitKey(0)
|
||||
cv2.destroyAllWindows()
|
||||
@@ -0,0 +1,18 @@
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
sj="saint jalm.jpg"
|
||||
vl="valentin.png"
|
||||
tm="tetedemarc.png"
|
||||
pm="profiledemarc.jpg"
|
||||
|
||||
img = cv2.imread(tm)
|
||||
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
|
||||
edges = cv2.Canny(gray,50,150,apertureSize = 3)
|
||||
minLineLength = 100
|
||||
maxLineGap = 10
|
||||
lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap)
|
||||
for (x1,y1,x2,y2) in lines[0]:
|
||||
cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)
|
||||
|
||||
cv2.imwrite('houghlines5.jpg',img)
|
||||
@@ -0,0 +1,4 @@
|
||||
level=0
|
||||
|
||||
while not (level in [1,2,3]):
|
||||
level=int(input("Sélectionner votre level:"))
|
||||
@@ -0,0 +1,20 @@
|
||||
|
||||
|
||||
"""
|
||||
x| |o
|
||||
| |x
|
||||
| |x
|
||||
"""
|
||||
|
||||
class Morpion:
|
||||
def __init__(self):
|
||||
self.grille=[[0,0,0],
|
||||
[0,0,0],
|
||||
[0,0,0]]
|
||||
self.symboles=[" ","x","o"]
|
||||
|
||||
def aff(self):
|
||||
for y in range(3):
|
||||
a="|".join(map(lambda x:self.symboles[x],self.grille[y]))
|
||||
print(a)
|
||||
m.aff()
|
||||
@@ -0,0 +1,509 @@
|
||||
"""
|
||||
Features:
|
||||
1:COMPLETED: print #renvoie str
|
||||
2:COMPLETED: addition #renvoie Polynomial
|
||||
3:COMPLETED: multiplication #renvoie Polynomial
|
||||
4:COMPLETED: derive #renvoie un Polynomial
|
||||
5:COMPLETED: division #renvoie couple de Polynomial
|
||||
6:COMPLETED: pgcd #renvoie Polynomial
|
||||
7:COMPLETED: ppcm #renvoie Polynomial
|
||||
8:COMPLETED: taylor #renvoie Polynomial
|
||||
9: factoriser #renvoie str ou liste de liste des coefficients "pareil"
|
||||
10: racines reelles #renvoie liste des racines reelles
|
||||
11: racines complexes #renvoie liste des racines complexes
|
||||
12: Decomposition en éléments simples
|
||||
12: show #Affiche le polynome sur une fenetre pygame, pyglet ou matplotlib
|
||||
"""
|
||||
|
||||
from copy import deepcopy
|
||||
# import matplotlib.pyplot as plt #Old way to show the polynomials on screen. Not very nice though...
|
||||
|
||||
# from mygrapher.grapher import Grapher #Used to show the polynome on screen with the ability to move within it.
|
||||
|
||||
import random # Used only to generate random polynomials.
|
||||
import functools
|
||||
|
||||
# Changing the type of the coefficients
|
||||
#from decimal import Decimal
|
||||
#from numpy import float128
|
||||
|
||||
# p=Polynomial.createFromInterpolation(x,y)
|
||||
|
||||
|
||||
def prod(l): return functools.reduce(lambda a, b: a * b, l)
|
||||
|
||||
|
||||
class Polynomial:
|
||||
def null():
|
||||
"""Return the null polynomial."""
|
||||
return Polynomial([0])
|
||||
|
||||
def sum(ps):
|
||||
"""Sum polynomials between themselves."""
|
||||
v = Polynomial([0]) # Addition neutral
|
||||
for p in ps:
|
||||
v += p
|
||||
return v
|
||||
|
||||
def prod(ps):
|
||||
"""Multiply polynomials between themselves."""
|
||||
v = Polynomial([1]) # Multiplication neutral
|
||||
for p in ps:
|
||||
v *= p
|
||||
return v
|
||||
|
||||
def createFromInterpolation(x, y):
|
||||
"""Create a polynomial using the lagrangian interpolation."""
|
||||
n = max(len(x), len(y))
|
||||
p = Polynomial.sum([Polynomial([y[j]]) * Polynomial.prod([Polynomial([-x[i] / (
|
||||
x[j] - x[i]), 1 / (x[j] - x[i])]) for i in range(n) if x[i] != x[j]]) for j in range(n)])
|
||||
return Polynomial(p.coefficients)
|
||||
|
||||
def __init__(self, coefficients, definition=[-10**20, 10**20]):
|
||||
"""Create a polynomial using its coefficients."""
|
||||
self.coefficients = coefficients
|
||||
self.definition = definition
|
||||
|
||||
def make(self, f):
|
||||
"""Transform all the coefficients into a decimal type."""
|
||||
self.coefficients = [f(c) for c in self.coefficients]
|
||||
self.definition = [f(d) for d in self.definition]
|
||||
|
||||
def __str__(self):
|
||||
"""Return the usual representation of a polynomial."""
|
||||
if self.coefficients == []:
|
||||
return "0"
|
||||
liste = []
|
||||
if self.coefficients[0] != 0:
|
||||
liste.append(str(self.coefficients[0]))
|
||||
for degre, coefficient in enumerate(self.coefficients[1:], 1):
|
||||
if coefficient != 0:
|
||||
liste.append(str(coefficient) + "X^" + str(degre))
|
||||
liste.reverse()
|
||||
text = "+".join(liste)
|
||||
text = text.replace("^1", "").replace("+-", "-").replace("1X", "X")
|
||||
return text
|
||||
|
||||
def adapt(coefficients, size):
|
||||
"""Add zeros to the coefficients using coefficients and size."""
|
||||
return coefficients + [0] * (size - len(coefficients))
|
||||
|
||||
def __eq__(self, other):
|
||||
"""Determine if two polynomials are equals by checking if the coefficients
|
||||
are the same."""
|
||||
return self.coefficients == other.coefficients
|
||||
|
||||
def __add__(self, other):
|
||||
"""Add 2 polynomials together by adding their coefficients."""
|
||||
maxdegree = max(self.degree + 1, other.degree + 1)
|
||||
cA = Polynomial.adapt(self.coefficients, maxdegree)
|
||||
cB = Polynomial.adapt(other.coefficients, maxdegree)
|
||||
coefficients = [a + b for (a, b) in zip(cA, cB)]
|
||||
A = Polynomial(coefficients)
|
||||
A.correct()
|
||||
return A
|
||||
|
||||
def __sub__(self, other):
|
||||
"""Substract 2 polynomials together by multiplying the second polynomial by -1 and adding it to the first using add method."""
|
||||
return self + other * Polynomial([-1])
|
||||
|
||||
def __mul__(self, other):
|
||||
"""Multiply 2 polynomials together using the formula for the coefficients."""
|
||||
degree = len(self.coefficients) + len(other.coefficients)
|
||||
A = self.coefficients + [0] * (degree - len(self.coefficients) + 1)
|
||||
B = other.coefficients + [0] * (degree - len(other.coefficients) + 1)
|
||||
newcoefficients = []
|
||||
for k in range(degree + 1):
|
||||
coeff = 0
|
||||
for i in range(k + 1):
|
||||
coeff += A[i] * B[k - i]
|
||||
newcoefficients.append(coeff)
|
||||
C = Polynomial(newcoefficients)
|
||||
C.correct()
|
||||
return C
|
||||
|
||||
def __pow__(self, n):
|
||||
"""Does an ~exponentiation of the polynomial."""
|
||||
return Polynomial.mul([self for i in range(n)])
|
||||
|
||||
def correct(self):
|
||||
"""Correct the coefficients of the polynomial by deleting useless zeros at the end,"""
|
||||
while len(self.coefficients) > 1:
|
||||
if self.coefficients[-1] == 0:
|
||||
del self.coefficients[-1]
|
||||
else:
|
||||
break
|
||||
if self.coefficients == [0]:
|
||||
self.coefficients = []
|
||||
"""and then replace float coefficients by int coefficients if possible."""
|
||||
for i in range(len(self.coefficients)):
|
||||
if self.coefficients[i] == int(self.coefficients[i]):
|
||||
self.coefficients[i] = int(self.coefficients[i])
|
||||
|
||||
def __len__(self):
|
||||
"""Return the number of coefficients.
|
||||
It is important to notice that it is not the degree due to the fact that
|
||||
the polynomial might have a degree of -inf and the len method must have positive values.
|
||||
In such a case this method will raise an error.
|
||||
It is why it is better to use the degree method in the general case."""
|
||||
A = deepcopy(self)
|
||||
A.correct()
|
||||
return len(A.coefficients) - 1
|
||||
|
||||
def getDegree(self):
|
||||
"""Return the degree of a polynomial.
|
||||
It will return -1 if the degree is -inf to be computer friendly."""
|
||||
A = deepcopy(self)
|
||||
A.correct()
|
||||
return len(A.coefficients) - 1
|
||||
|
||||
def __getitem__(self, index):
|
||||
"""Return a coefficient of the polynomial."""
|
||||
return self.coefficients[index]
|
||||
|
||||
def __setitem__(self, index, value):
|
||||
"""Change a coefficient of the polynomial."""
|
||||
self.coefficients[index] = value
|
||||
|
||||
def __delitem__(self, index):
|
||||
"""Delete a coefficient of the polynomial."""
|
||||
del self.coefficients[index]
|
||||
|
||||
def derivate(self):
|
||||
"""Derivate the polynomial."""
|
||||
self.coefficients = [i * c for (i, c) in enumerate(self.coefficients)]
|
||||
del self.coefficients[0]
|
||||
|
||||
def derivative(self):
|
||||
"""Return the derivative polynomial."""
|
||||
newcoefficients = [i * c for (i, c) in enumerate(self.coefficients)]
|
||||
del newcoefficients[0]
|
||||
return Polynomial(newcoefficients)
|
||||
|
||||
def unit(self):
|
||||
"""Return the polynomial unit form."""
|
||||
k = self.coefficients[-1]
|
||||
newcoefficients = []
|
||||
for i in range(len(self.coefficients)):
|
||||
newcoefficients.append(self.coefficients[i] / k)
|
||||
A = Polynomial(newcoefficients)
|
||||
A.correct()
|
||||
return A
|
||||
|
||||
def unitarize(self):
|
||||
"""Convert the polynomial into its unit form."""
|
||||
self.coefficients = self.unit().coefficients
|
||||
|
||||
def __xor__(self, other):
|
||||
"""Return the HCF (PGCD en francais) of self and other by Euclide algorithm. Make use of "^" operator."""
|
||||
R0 = deepcopy(self)
|
||||
R1 = deepcopy(other)
|
||||
R0.correct()
|
||||
R1.correct()
|
||||
listR = [R0, R1]
|
||||
while listR[-1].degree > 0:
|
||||
R, Q = listR[-2] / listR[-1]
|
||||
listR.append(R)
|
||||
return listR[-2]
|
||||
|
||||
# Resultat d'une enorme galere de 2h...
|
||||
# Algorithme d'Euclide:
|
||||
# a=b*q0+r0
|
||||
# b=r*q1+r1
|
||||
# r=r1*q2+r2
|
||||
# r1=r2*q3+r3
|
||||
# ...
|
||||
# ri=r(i-1)*q(i-1)+1+0
|
||||
|
||||
def __or__(self, other):
|
||||
"""Return the LCM (PPCM en francais) using "i have absolutely no clue how to do this so figure it out!" Make use of "|" operator."""
|
||||
# On sent la (tres) grosse fatigue apres minuit.
|
||||
return "Figure it out!"
|
||||
|
||||
def __truediv__(self, other):
|
||||
"""Return the division of 2 polynomials."""
|
||||
R = deepcopy(self)
|
||||
B = deepcopy(other)
|
||||
R.correct()
|
||||
B.correct()
|
||||
Q = Polynomial([])
|
||||
while R.degree >= B.degree:
|
||||
d = R.degree - B.degree + 1
|
||||
C = Polynomial([0 for i in range(d)])
|
||||
C[-1] = R[-1] / B[-1]
|
||||
R = R - B * C
|
||||
Q = Q + C
|
||||
return [R, Q]
|
||||
|
||||
# Ce que j'ai du faire pour trouver l'implementation...
|
||||
# On a: A=BQ+R
|
||||
# [3,2,4,5,1]/[1,4,1]
|
||||
# [3,2,3,1,0]=[3,2,4,5,1]-[0,0,1]*[1,4,1] #[0,0,1,4,1]
|
||||
# [3,1,-1,0]=[3,2,3,1]-[0,1]*[1,4,1] #[0,1,4,1]
|
||||
# [4,5,0]=[3,1,-1]-[-1]*[1,4,1] #[-1,-4,-1]
|
||||
# [4,5]
|
||||
|
||||
# 5=8*0+5 cas particulier de la division euclidienne
|
||||
|
||||
def isDivisible(self, other):
|
||||
"""Determine if the polynomial is divisible by other."""
|
||||
q, r = self / other
|
||||
return r == Polynomial.zero
|
||||
|
||||
def __call__(self, x):
|
||||
"""Evaluate the polynomial given an x value."""
|
||||
return sum([c * x**n for (n, c) in enumerate(self.coefficients)])
|
||||
|
||||
def getFactoredForm(self):
|
||||
"""Return the list of the factors of the factored form of the polynomial."""
|
||||
return
|
||||
|
||||
def allDerivatives(self):
|
||||
"""Return the list of all derivatives of the polynome until the zero polynome."""
|
||||
B = deepcopy(self)
|
||||
derivatives = [deepcopy(self)]
|
||||
while B.degree > 1:
|
||||
B.derivate()
|
||||
derivatives.append(deepcopy(B))
|
||||
return derivatives
|
||||
|
||||
def getRootsByDichotomy(self, precision=1e-15):
|
||||
"""Return the list of all the roots of the polynomial."""
|
||||
"""Does that by finding where all the derivates cancel, to find new extrema and applying tvi."""
|
||||
roots = []
|
||||
derivatives = self.allDerivatives()
|
||||
derivatives.reverse()
|
||||
old_extrema = []
|
||||
for derivative in derivatives:
|
||||
new_extrema = []
|
||||
neglim = self.definition[0]
|
||||
poslim = self.definition[1]
|
||||
extrema = [neglim] + old_extrema + [poslim]
|
||||
for i in range(len(extrema) - 1):
|
||||
if derivative(extrema[i]) * derivative(extrema[i + 1]) <= 0:
|
||||
new_extrema.append(derivative.dichotomy(
|
||||
extrema[i], extrema[i + 1], precision))
|
||||
old_extrema = new_extrema[:]
|
||||
return new_extrema
|
||||
|
||||
def dichotomy(self, xa, xb, precision=1e-15):
|
||||
"""Return a float value x between a and b for which the polynomial canceled itself.
|
||||
Does that based on theoreme of intermediate value with dichotomy."""
|
||||
if self(xa) * self(xb) > 0:
|
||||
raise Exception(
|
||||
"The polynomial cannot cancel itself within this interval.")
|
||||
a = min(xa, xb)
|
||||
b = max(xa, xb)
|
||||
x = (a + b) / 2
|
||||
while abs(self(x)) > precision:
|
||||
print(x, self(x), abs(self(x)), precision)
|
||||
if self(x) * self(b) > 0:
|
||||
b = x
|
||||
if self(x) * self(a) > 0:
|
||||
a = x
|
||||
x = (a + b) / 2
|
||||
return x
|
||||
|
||||
def getRoots(self, precision=1e-15):
|
||||
"""
|
||||
Return the roots of the polynomial by doing the best possible calculation
|
||||
that combines precision and efficiency.
|
||||
"""
|
||||
degree = self.degree # There are less calculations by selecting the degree
|
||||
if degree == 0:
|
||||
if self.coefficients[0] == 0:
|
||||
raise Exception("Every number is a root of p.")
|
||||
else:
|
||||
return []
|
||||
elif self.degree == 1:
|
||||
b, a = self.coefficients
|
||||
return [-b / a] # a cannot be null
|
||||
elif self.degree == 2:
|
||||
c, b, a = self.coefficients
|
||||
discriminant = b**2 - 4 * a * c
|
||||
x1 = (-b - discriminant**(1 / 2)) / (2 * a) # a cannot be null
|
||||
x2 = (-b + discriminant**(1 / 2)) / (2 * a) # a cannot be null
|
||||
return [x1, x2]
|
||||
else:
|
||||
return self.getRootsByDichotomy(precision)
|
||||
|
||||
def getMultiplicity(self, root):
|
||||
"""Return the multiplicity of a root."""
|
||||
b = self
|
||||
n = 0
|
||||
while b.coefficients != [1]:
|
||||
q, b = b / Polynomial([-root, 1])
|
||||
n += 1
|
||||
return n
|
||||
|
||||
def getRootsWithMultiplicity(self):
|
||||
"""Return a list of couples of roots with their multiplicity associated.
|
||||
Example: [(r1,m1),(r2,m2),...] """
|
||||
return [(r, self.getMultiplicity(r)) for r in list(set(self.roots))]
|
||||
|
||||
def __floordiv__(self, other):
|
||||
"""Return a rational function of numerator the polynomial, and the denominator the other."""
|
||||
return RationalFunction(self, other)
|
||||
|
||||
def show(self):
|
||||
"""Show the polynomial with grapher."""
|
||||
Grapher([self])() # Instance Grapher only takes the list of the functions in parameter and can be called to display them.
|
||||
|
||||
def matplotlibShow(self, zone=[-5, 5], precision=0.1):
|
||||
"""Show the polynomial with matplotlib using optional zone and precision."""
|
||||
z, Z = zone
|
||||
X = list(
|
||||
[precision * x for x in range(int(z / precision), int(Z / precision))])
|
||||
Y = list([self(x) for x in X])
|
||||
plt.plot(X, Y, label="Polynomial")
|
||||
plt.show()
|
||||
|
||||
degree = property(getDegree)
|
||||
roots = property(getRoots)
|
||||
|
||||
|
||||
class FactoredPolynomial(Polynomial):
|
||||
"""For factored of a polynomial."""
|
||||
|
||||
def __init__(self, roots_and_multiplicity):
|
||||
"""Define the factored polynomial with its roots."""
|
||||
self.roots = roots
|
||||
|
||||
def __str__(self):
|
||||
"""Return a string representation of the factored polynomial."""
|
||||
|
||||
def getCoefficients(self):
|
||||
"""Return the coefficients of the polynomial."""
|
||||
|
||||
|
||||
class RationalFunction:
|
||||
"""Wikipedia: In algebra, the partial fraction decomposition or partial
|
||||
fraction expansion of a rational function (that is, a fraction such that the
|
||||
numerator and the denominator are both polynomials) is an operation that
|
||||
consists of expressing the fraction as a sum of a polynomial (possibly zero)
|
||||
and one or several fractions with a simpler denominator"""
|
||||
|
||||
def __init__(self, p, q):
|
||||
"""Define a rational function using two polynomials p: the numerator
|
||||
and q: the denominator."""
|
||||
self.p = p
|
||||
self.q = q
|
||||
|
||||
def __str__(self):
|
||||
"""String representation of a rational function."""
|
||||
return "(" + str(self.p) + ")/(" + str(self.q) + ")"
|
||||
|
||||
def __call__(self, x):
|
||||
"""Evaluate in x the rational function."""
|
||||
return self.p(x) / self.q(x)
|
||||
|
||||
def __add__(self, other):
|
||||
"""Add two rational functions."""
|
||||
p = self.p * other.q + other.p * self.q
|
||||
q = self.q * other.q
|
||||
return RationalFunction(p, q)
|
||||
|
||||
def __sub__(self, other):
|
||||
"""Substract two rational functions."""
|
||||
p = self.p * other.q - other.p * self.q
|
||||
q = self.q * other.q
|
||||
return RationalFunction(p, q)
|
||||
|
||||
def __mul__(self, other):
|
||||
"""Multiply two rational functions."""
|
||||
p = self.p * other.p
|
||||
q = self.q * other.q
|
||||
return RationalFunction(p, q)
|
||||
|
||||
def __invert__(self, other):
|
||||
"""Return the inverse of the rational function. (This operation is optional.)"""
|
||||
return RationalFunction(self.q, self.p)
|
||||
|
||||
def __truediv__(self, other):
|
||||
"""Divide a rational function by another."""
|
||||
p = self.p * other.q
|
||||
q = self.q * other.p
|
||||
return RationalFunction(p, q)
|
||||
|
||||
def getDegree(self):
|
||||
"""Return the degree of the rational function."""
|
||||
return self.p.degree - self.q.degree
|
||||
|
||||
def getPoles(self):
|
||||
"""Return the poles of the rational function."""
|
||||
return self.q.roots
|
||||
|
||||
def getRoots(self):
|
||||
"""Return the roots of the rational function."""
|
||||
return self.p.roots
|
||||
|
||||
def decompose(self): # Not implemented
|
||||
"""Return the partial fraction decomposition."""
|
||||
# Note this method is supposed to work with complexes
|
||||
# So it is not always valid and needs a more general case
|
||||
e, r = self.p / self.q
|
||||
roots = self.q.getRoots()
|
||||
l = [e]
|
||||
for (j, xj) in enumerate(roots):
|
||||
p = Polynomial([self.p(xj) / self.q.derivative(xj)])
|
||||
q = Polynomial([-xj, 1])
|
||||
fp = RationalFunction(p, q)
|
||||
l.append(fp)
|
||||
return l
|
||||
|
||||
def getWholePart(self): # Not finished
|
||||
"""Return the whole part of the fraction."""
|
||||
e, r = self.p / self.q
|
||||
return e
|
||||
|
||||
def getFractionalPart(self): # Not finished
|
||||
"""Return the fractional part of the fraction."""
|
||||
e, r = self.p / self.q
|
||||
return r
|
||||
|
||||
degree = property(getDegree)
|
||||
poles = property(getPoles)
|
||||
|
||||
|
||||
class PartialFraction(RationalFunction): # This is just an idea
|
||||
"""The only difference with the rational function is that the denominator is
|
||||
of the form: [a,b] which corresponds to q=(x-a)**b."""
|
||||
# It might not be a good idea.
|
||||
|
||||
def __init__(self, p, q):
|
||||
"""Define a rational function using two polynomials p: the numerator
|
||||
and q: the denominator."""
|
||||
self.p = p
|
||||
self.q = q
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# suite_random = [random.randint(0,10) for i in range(10)] #Create polynome as big as needed.
|
||||
# X=Polynomial(suite_random)
|
||||
# t=float128
|
||||
suite1 = [3, 2, 4, 5, 1]
|
||||
suite2 = [1, -2, 1]
|
||||
suite3 = [4, 5]
|
||||
A = Polynomial(suite1)
|
||||
B = Polynomial(suite2)
|
||||
C = Polynomial(suite3)
|
||||
FP = RationalFunction(A, B)
|
||||
print("A =", A)
|
||||
print("B =", B)
|
||||
print("C =", C)
|
||||
print("A+B =", A + B)
|
||||
print("A*B =", A * B)
|
||||
print("Derivative of A =", A.derivative())
|
||||
print("A/B :", A / B)
|
||||
print("A//B:", A // B)
|
||||
print("Unit polynomial of C =", C.unit())
|
||||
print("HCF (PGCD en francais) of A and B (written A^B) =", A ^ B)
|
||||
print("LCM (PPCM en francais) of A and B (written A|B) =", A | B)
|
||||
print("Roots of B:", B.roots)
|
||||
print("Multiplicity of the root 2 of B:", B.getMultiplicity(2))
|
||||
print("Roots with multiplicities of B:", B.getRootsWithMultiplicity())
|
||||
#print("Show A on screen:")
|
||||
# C=Polynomial.createFromInterpolation([1,2,-4,-6,4],[1,-3,-2,5,-2])
|
||||
print(C.coefficients)
|
||||
print(FP.decompose())
|
||||
# C.show()
|
||||
@@ -0,0 +1,18 @@
|
||||
#from __future__ import *
|
||||
|
||||
simple_stmt ::= expression_stmt
|
||||
| assert_stmt
|
||||
| assignment_stmt
|
||||
| augmented_assignment_stmt
|
||||
| annotated_assignment_stmt
|
||||
| pass_stmt
|
||||
| del_stmt
|
||||
| return_stmt
|
||||
| yield_stmt
|
||||
| raise_stmt
|
||||
| break_stmt
|
||||
| continue_stmt
|
||||
| import_stmt
|
||||
| future_stmt
|
||||
| global_stmt
|
||||
| nonlocal_stmt
|
||||
@@ -0,0 +1,13 @@
|
||||
a=8*3600
|
||||
b=1*60+12
|
||||
|
||||
print(a/b)
|
||||
|
||||
print(b*15)
|
||||
|
||||
|
||||
c=(1e13/200)**(1/1000)
|
||||
print(c)
|
||||
|
||||
|
||||
print(1080/8/60)
|
||||
@@ -0,0 +1,11 @@
|
||||
class Test:
|
||||
v=1
|
||||
def __init__(self):
|
||||
self.v=1
|
||||
|
||||
@staticmethod
|
||||
def test(cls,self):
|
||||
print(cls.v,self.v)
|
||||
|
||||
t=Test()
|
||||
print(t.test())
|
||||
@@ -0,0 +1,17 @@
|
||||
from collections import deque
|
||||
|
||||
d = deque('hello', maxlen=5)
|
||||
|
||||
d.append('4')
|
||||
d.append(4)
|
||||
d.appendleft(2)
|
||||
d.pop()
|
||||
d.popleft()
|
||||
d.clear()
|
||||
|
||||
d.extend(iter([1,2,3]))
|
||||
print(d)
|
||||
d.extendleft('hey')
|
||||
print(d)
|
||||
d.rotate(2) #useful
|
||||
print(d)
|
||||
@@ -0,0 +1,45 @@
|
||||
def creer_personne(personne, nom, prenom):
|
||||
"""La fonction qui jouera le rôle de constructeur pour notre classe Personne.
|
||||
|
||||
Elle prend en paramètre, outre la personne :
|
||||
nom -- son nom
|
||||
prenom -- son prenom"""
|
||||
|
||||
personne.nom = nom
|
||||
personne.prenom = prenom
|
||||
personne.age = 21
|
||||
personne.lieu_residence = "Lyon"
|
||||
|
||||
def presenter_personne(personne):
|
||||
"""Fonction présentant la personne.
|
||||
|
||||
Elle affiche son prénom et son nom"""
|
||||
|
||||
print("{} {}".format(personne.prenom, personne.nom))
|
||||
|
||||
# Dictionnaire des méthodes
|
||||
methodes = {
|
||||
"__init__": creer_personne,
|
||||
"presenter": presenter_personne,
|
||||
}
|
||||
|
||||
# Création dynamique de la classe
|
||||
Personne = type("Personne", (), methodes)
|
||||
print(Personne)
|
||||
|
||||
|
||||
#---------------------#
|
||||
|
||||
class MaMetaClasse(type):
|
||||
|
||||
"""Exemple d'une métaclasse."""
|
||||
|
||||
def __new__(metacls, nom, bases, dict):
|
||||
"""Création de notre classe."""
|
||||
print("On cree la classe {}".format(nom))
|
||||
return type.__new__(metacls, nom, bases, dict)
|
||||
|
||||
class MaClasse(metaclass=MaMetaClasse):
|
||||
pass
|
||||
|
||||
print()
|
||||
@@ -0,0 +1,80 @@
|
||||
import pygame
|
||||
import cv2
|
||||
|
||||
pygame.init()
|
||||
|
||||
# --- create PyGame image ---
|
||||
|
||||
pg_img = pygame.Surface((400, 200))
|
||||
pygame.draw.circle(pg_img, (255,0,0), (0,0), 200)
|
||||
|
||||
# --- display PyGame image ---
|
||||
|
||||
screen = pygame.display.set_mode((400, 400))
|
||||
|
||||
screen.fill((255,255,255))
|
||||
screen.blit(pg_img, pg_img.get_rect())
|
||||
pygame.display.flip()
|
||||
|
||||
running = True
|
||||
while running:
|
||||
for event in pygame.event.get():
|
||||
if event.type == pygame.QUIT:
|
||||
running = False
|
||||
if event.type == pygame.KEYDOWN:
|
||||
running = False
|
||||
|
||||
pygame.quit()
|
||||
|
||||
# --- move from PyGame to CV2 ---
|
||||
|
||||
color_image = pygame.surfarray.array3d(pg_img)
|
||||
|
||||
color_image = cv2.transpose(color_image)
|
||||
color_image = cv2.cvtColor(color_image, cv2.COLOR_RGB2BGR)
|
||||
|
||||
# --- display CV2 image ---
|
||||
|
||||
cv2.imshow('Color', color_image)
|
||||
cv2.waitKey(0)
|
||||
cv2.destroyAllWindows()
|
||||
|
||||
# --- change CV2 image ---
|
||||
|
||||
color_image = cv2.rotate(color_image, cv2.ROTATE_90_CLOCKWISE)
|
||||
gray_image = cv2.cvtColor(color_image, cv2.COLOR_BGR2GRAY)
|
||||
|
||||
# --- display CV2 image ---
|
||||
|
||||
cv2.imshow('Gray', gray_image)
|
||||
cv2.waitKey(0)
|
||||
cv2.destroyAllWindows()
|
||||
|
||||
# --- save in file in CV2 ---
|
||||
|
||||
cv2.imwrite('test.png', color_image)
|
||||
|
||||
# --- move back from CV2 to PyGame ---
|
||||
|
||||
gray_image = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2RGB)
|
||||
gray_image = cv2.transpose(gray_image)
|
||||
|
||||
pg_img = pygame.surfarray.make_surface(gray_image)
|
||||
|
||||
# --- display PyGame image ---
|
||||
|
||||
screen = pygame.display.set_mode((400, 400))
|
||||
|
||||
screen.fill((255,255,255))
|
||||
screen.blit(pg_img, pg_img.get_rect())
|
||||
pygame.display.flip()
|
||||
|
||||
running = True
|
||||
while running:
|
||||
for event in pygame.event.get():
|
||||
if event.type == pygame.QUIT:
|
||||
running = False
|
||||
if event.type == pygame.KEYDOWN:
|
||||
running = False
|
||||
|
||||
pygame.quit()
|
||||
@@ -0,0 +1,29 @@
|
||||
import numpy as np
|
||||
import cv2
|
||||
|
||||
cap = cv2.VideoCapture(0)
|
||||
|
||||
# Get the Default resolutions
|
||||
frame_width = int(cap.get(3))
|
||||
frame_height = int(cap.get(4))
|
||||
|
||||
# Define the codec and filename.
|
||||
out = cv2.VideoWriter('output.avi',cv2.VideoWriter_fourcc('M','J','P','G'), 10, (frame_width,frame_height))
|
||||
|
||||
while(cap.isOpened()):
|
||||
ret, frame = cap.read()
|
||||
if ret==True:
|
||||
|
||||
# write the frame
|
||||
out.write(frame)
|
||||
|
||||
cv2.imshow('frame',frame)
|
||||
if cv2.waitKey(1) & 0xFF == ord('q'):
|
||||
break
|
||||
else:
|
||||
break
|
||||
|
||||
# Release everything if job is finished
|
||||
cap.release()
|
||||
out.release()
|
||||
cv2.destroyAllWindows()
|
||||
@@ -0,0 +1,27 @@
|
||||
import numpy as np
|
||||
import cv2
|
||||
|
||||
cap = cv2.VideoCapture(0)
|
||||
|
||||
# Define the codec and create VideoWriter object
|
||||
#fourcc = cv2.cv.CV_FOURCC(*'DIVX')
|
||||
#out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480))
|
||||
out = cv2.VideoWriter("output.mp4",
|
||||
cv2.VideoWriter_fourcc(*'MP4V'), 10,(640,480))
|
||||
|
||||
|
||||
while(cap.isOpened()):
|
||||
ret, frame = cap.read()
|
||||
frame = cv2.flip(frame,0)
|
||||
|
||||
# write the flipped frame
|
||||
out.write(frame)
|
||||
|
||||
cv2.imshow('frame',frame)
|
||||
if cv2.waitKey(1) & 0xFF == ord('q'):
|
||||
break
|
||||
|
||||
# Release everything if job is finished
|
||||
cap.release()
|
||||
out.release()
|
||||
cv2.destroyAllWindows()
|
||||
@@ -0,0 +1,13 @@
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
a="MPEG"
|
||||
b='MP4V'
|
||||
|
||||
writer = cv2.VideoWriter("output.mp4",
|
||||
cv2.VideoWriter_fourcc(*a), 100,(640,480))
|
||||
|
||||
for frame in range(1000):
|
||||
writer.write(np.random.randint(0, 255, (480,640,3)).astype('uint8'))
|
||||
|
||||
writer.release()
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,23 @@
|
||||
from math import sin
|
||||
from sympy import Symbol,sin,sqrt
|
||||
from sympy import *
|
||||
|
||||
x=Symbol('x')
|
||||
|
||||
|
||||
#f=sin(x)/x
|
||||
f=sqrt(sin(x)/(2*x))
|
||||
|
||||
a=5
|
||||
|
||||
print(f)
|
||||
|
||||
#x=2
|
||||
|
||||
print(f)
|
||||
|
||||
print("\n".join(map(str,Symbol.__dict__.items())))
|
||||
|
||||
a=(1/x)~(1/x**2)
|
||||
|
||||
print(a)
|
||||
Binary file not shown.
-256
@@ -1,256 +0,0 @@
|
||||
"""mots=[]
|
||||
|
||||
determinants=["le","la","un","une"]
|
||||
|
||||
determinants={"avant":[],
|
||||
"apres":[],
|
||||
"masculin":None,
|
||||
"singulier":None}
|
||||
|
||||
#print(determinants)"""
|
||||
|
||||
words=[]
|
||||
|
||||
articles=["a","an","the"]
|
||||
a=["I","you","he","she","it","we","they"]
|
||||
|
||||
class List(list):
|
||||
def __init__(self,object):
|
||||
super().__init__(object)
|
||||
|
||||
def removeall(self,element):
|
||||
while element in self:
|
||||
self.remove(element)
|
||||
|
||||
def purge(self,elements):
|
||||
for element in elements:
|
||||
self.removeall(element)
|
||||
|
||||
def keep(self,elements):
|
||||
for element in self[:]:
|
||||
if not (element in elements):
|
||||
self.removeall(element)
|
||||
|
||||
def whipe(self):
|
||||
accumulator=[]
|
||||
for e in self:
|
||||
accumulator+=e
|
||||
return accumulator
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class Str(str):
|
||||
def __init__(self,object):
|
||||
super().__init__()
|
||||
self.alphabet="abcdefghijklmnopqrstuvwxyz"
|
||||
self.consonants="bcdfghjklmnpqrstvwxyz"
|
||||
self.vowels="aeiouy"
|
||||
self.numbers="0123456789"
|
||||
|
||||
def remove(self,element):
|
||||
self.replace(element,"")
|
||||
|
||||
|
||||
def removeall(self,element):
|
||||
while element in self:
|
||||
self.replace(element,"")
|
||||
|
||||
|
||||
def purge(self,elements):
|
||||
a=Str("")
|
||||
l=List(self)
|
||||
l.purge(elements)
|
||||
return Str(a.join(l))
|
||||
|
||||
def keep(self,elements):
|
||||
a=Str("")
|
||||
l=List(self)
|
||||
l.keep(elements)
|
||||
return Str(a.join(l))
|
||||
|
||||
|
||||
def reverse(self):
|
||||
self=[l for l in self[-1:]]
|
||||
#for i in range(len(self)//2):
|
||||
# self[i]=self[-i-1]
|
||||
|
||||
def append(self,element):
|
||||
self+=element
|
||||
|
||||
|
||||
def apphead(self,element):
|
||||
self.reverse()
|
||||
self.append(element)
|
||||
self.reverse()
|
||||
|
||||
def __sub__(self,element):
|
||||
return self.replace(element,"")
|
||||
|
||||
def __isub__(self,element):
|
||||
self.replace(element,"")
|
||||
|
||||
def __truediv__(self,elements):
|
||||
for element in elements:
|
||||
self.replace(element,"")
|
||||
|
||||
def __floordiv__(self,element):
|
||||
for element in elements:
|
||||
self.removeall(element,"")
|
||||
|
||||
def decompose(self):
|
||||
accumulator=[]
|
||||
for i in range(1,len(self)):
|
||||
for j in range(len(self)-i):
|
||||
accumulator.append(self[j:j+i])
|
||||
return accumulator
|
||||
|
||||
def union(self,l1,l2):
|
||||
accumulator=[]
|
||||
for e1 in l1:
|
||||
if e1 in l2:
|
||||
accumulator.append(e1)
|
||||
return set(accumulator)
|
||||
|
||||
def __mod__(self,other):
|
||||
other=Str(other)
|
||||
own_dec=self.decompose()
|
||||
other_dec=other.decompose()
|
||||
result=len(self.union(own_dec,other_dec))/len(own_dec+other_dec)*100
|
||||
return result #in [0,1]
|
||||
|
||||
|
||||
|
||||
def reverse(self):
|
||||
data=list(self)
|
||||
data.reverse()
|
||||
return Str("".join(data))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class Sentence(Str):
|
||||
def __init__(self,object):
|
||||
super().__init__(object)
|
||||
self.words=self.wordsplit()
|
||||
|
||||
def wordsplit(self):
|
||||
text=self[:]
|
||||
text=text.lower()
|
||||
text=Str(text.replace("'"," "))
|
||||
text=text.keep(" "+self.alphabet)
|
||||
words=List(text.split(" "))
|
||||
words.removeall('')
|
||||
words=[Word(word) for word in words]
|
||||
return words
|
||||
|
||||
def __mod__(self,other):
|
||||
other=Sentence(other)
|
||||
own_dec=self.wordsplit()
|
||||
other_dec=other.wordsplit()
|
||||
print(own_dec,other_dec)
|
||||
union=self.union(own_dec,other_dec)
|
||||
print(union)
|
||||
result=len(union)/len(own_dec+other_dec)*100
|
||||
return result #in [0,1]
|
||||
|
||||
|
||||
|
||||
|
||||
class Word(Str):
|
||||
def __init__(self,object):
|
||||
super().__init__(object)
|
||||
self.syllables=self.syllablesplit()
|
||||
|
||||
def syllablesplit(self):
|
||||
syllables=[]
|
||||
word=self[:]
|
||||
while word!="":
|
||||
syllable=self.firstsyllable(word)
|
||||
syllables.append(syllable)
|
||||
word=word[len(syllable):]
|
||||
return syllables
|
||||
|
||||
def firstsyllable(self,word):
|
||||
vowelfound=False
|
||||
for i in range(len(word)-1):
|
||||
if word[i] in self.vowels: vowelfound=True
|
||||
if (word[i] in self.consonants) and (word[i+1] in self.vowels):
|
||||
if i>0 and vowelfound: return word[:i]
|
||||
return word
|
||||
|
||||
|
||||
class MutableString(object):
|
||||
def __init__(self, data):
|
||||
self.data = list(data)
|
||||
def __str__(self):
|
||||
return "".join(self.data)
|
||||
def append(self,element):
|
||||
self.data+=list(element)
|
||||
def appstart(self,element):
|
||||
self.data.reverse()
|
||||
element.reverse()
|
||||
self.data.append(element)
|
||||
self.data.reverse()
|
||||
|
||||
def __repr__(self):
|
||||
return "".join(self.data)
|
||||
def __setitem__(self, index, value):
|
||||
self.data[index] = value
|
||||
def __getitem__(self, index):
|
||||
if type(index) == slice:
|
||||
return "".join(self.data[index])
|
||||
return self.data[index]
|
||||
def __delitem__(self, index):
|
||||
del self.data[index]
|
||||
def __add__(self, other):
|
||||
self.data.extend(list(other))
|
||||
def __len__(self):
|
||||
return len(self.data)
|
||||
def __reverse__(self):
|
||||
self.data.reverse()
|
||||
|
||||
|
||||
|
||||
noun={"nature":None,
|
||||
"singular":None,
|
||||
"synonyms":[]}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if __name__=="__main__":
|
||||
|
||||
sentence=Sentence("you're a fucking asshole you dumbass, you are a scrotumbag")
|
||||
#b=Str([1,2])
|
||||
#a=a.remove(".")
|
||||
#print(a)
|
||||
#print(sentence.words)
|
||||
#print([word.syllables for word in sentence.words])
|
||||
#print(sentence-"fucking ")
|
||||
#sentence=MutableString(sentence)
|
||||
#print(sentence)
|
||||
#print(Str(sentence).title())
|
||||
#print(list(a))
|
||||
#print(a.remove("s"))
|
||||
#print(b.remove(1))
|
||||
other=Sentence("you are a fucking asshole and a dumbass")
|
||||
other.words.reverse()
|
||||
other=Sentence(" ".join(other.words))
|
||||
#other=other.reverse()
|
||||
print(other)
|
||||
print(sentence%other)
|
||||
|
||||
|
||||
#def decomposeSentence(Str):
|
||||
|
||||
#return words
|
||||
|
||||
#decomposeSentence(a)
|
||||
@@ -1,176 +0,0 @@
|
||||
import inspect
|
||||
|
||||
|
||||
def test(arg1,arg2):
|
||||
a = arg1 + arg2
|
||||
return a
|
||||
|
||||
#do something with args
|
||||
|
||||
keywords=["assert","break","class","continue","def","del","elif","else","except","finally","for",
|
||||
"from","global","if","import","in","pass","print","raise","return","try","while","yield"]
|
||||
|
||||
conversion1 = {"assert":"ASSERT",
|
||||
"break":"SORTIR DE LA BOUCLE",
|
||||
"class":"CLASSE",
|
||||
"continue":"CONTINER",
|
||||
"def":"DONNEES",
|
||||
"del":"SUPPRIMER",
|
||||
"elif":["SINON SI","FAIRE"],
|
||||
"else":["SINON","FAIRE"],
|
||||
"except":"EXCEPTE",
|
||||
"finally":"FINALLEMENT",
|
||||
"for":["POUR","FAIRE"],
|
||||
"from":"DEPUIS",
|
||||
"global":"GLOBAL",
|
||||
"if":"SI",
|
||||
"import":"IMPORTER",
|
||||
"in":"DANS",
|
||||
"pass":"PASSER",
|
||||
"print":"AFFICHER",
|
||||
"raise":"RELEVER",
|
||||
"return":"AFFICHER",
|
||||
"try":"ESSAYER",
|
||||
"while":["TANT QUE","FAIRE"],
|
||||
"yield":"PASSER AU TOUR SUIVANT",
|
||||
"==":"=",
|
||||
"=":"<-"}
|
||||
|
||||
|
||||
|
||||
def algorithm(name):
|
||||
lines = inspect.getsource(name)
|
||||
output = []
|
||||
lines = lines.split("\n")
|
||||
for line in lines:
|
||||
output.append(Converter(line)())
|
||||
#print("output: ",output)
|
||||
return "\n".join(output)
|
||||
|
||||
|
||||
class Converter:
|
||||
def __init__(self,line):
|
||||
self.line=line
|
||||
self.alphabet="abcdefghijklmnopqrstuvwxyz"
|
||||
self.numbers="0123456789"
|
||||
self.punctuation="():.,"
|
||||
self.conversion= {"assert": [[None,"assert",None], [None,"ASSERT",None]],
|
||||
"break": [[None,"break"], [None,"SORTIR DE LA BOUCLE"]],
|
||||
"class": [["class",None], ["CLASS",None]],
|
||||
"continue": [[None,"continue",None], [None,"CONTINUER",None]],
|
||||
"def": [["def",None,"(",None,"):"], [None,":\nDONNES: ",None," :"]],
|
||||
"del": [[None,"del",None], [None,"SUPPRIMER",None]],
|
||||
"elif": [[None,"elif",None,":"], [None,"SINON SI",None," FAIRE"]],
|
||||
"else": [[None,"else:",None], [None,"SINON",None," FAIRE"]],
|
||||
"except": [[None,"except:",None], [None,"EXCEPTE",None]],
|
||||
"finally": [[None,"finally:",None], [None,"FINALLEMENT",None]],
|
||||
"for": [["for",None," in ",None,":"], ["POUR",None," DANS ",None," FAIRE"]],
|
||||
"from": [["from",None], ["DEPUIS",None]],
|
||||
"global": [["global",None], ["GLOBAL",None]],
|
||||
"if": [[None,"if ",None], [None,"SI",None]],
|
||||
"import": [[None,"import",None], [None,"IMPORTER",None]],
|
||||
" in ": [[None," in ",None], [None, "DANS ",None]],
|
||||
" is ": [[None," is ",None], [None," EST ",None]],
|
||||
"pass": [[None,"pass"], [None,"PASSER",None]],
|
||||
"print": [[None,"print",None,"(",None,")"], [None,"AFFICHER: ",None,None]],
|
||||
"raise": [[None,"raise",None], [None,"RELEVER",None]],
|
||||
"return": [[None,"return",None], [None,"AFFICHER",None]],
|
||||
"try": [[None,"try:",None], [None,"ESSAYER",None]],
|
||||
"while": [["while ",None,":"], ["TANT QUE ",None," FAIRE"]],
|
||||
"yield": [[None,"yield"], [None,"PASSER AU TOUR SUIVANT"]],
|
||||
"==": [[None,"==",None], [None,"=",None]],
|
||||
"!=": [[None,"!=",None], [None,"≠",None]],
|
||||
"=": [[None,"=",None], [None,"<=",None]],
|
||||
"append": [[None,".append(",None,")"], ["AJOUTER A ",None," LA VALEUR ",None]]}
|
||||
|
||||
self.removeIndent()
|
||||
|
||||
|
||||
def removeIndent(self):
|
||||
self.indent=0
|
||||
if self.line!="":
|
||||
while self.line[0]==" ":
|
||||
self.indent+=1
|
||||
self.line=self.line[1:]
|
||||
|
||||
def convert(self):
|
||||
if not ("#" in self.line):
|
||||
for key in self.conversion:
|
||||
if key in self.line:
|
||||
self.apply(key)
|
||||
|
||||
def apply(self,key):
|
||||
#print("key:",key)
|
||||
l=self.missing(self.conversion[key][0])
|
||||
#print("l:",l)
|
||||
filled=self.fill(self.conversion[key][1],l)
|
||||
#print("filled:",filled)
|
||||
self.line="".join(filled)
|
||||
#print(self.line)
|
||||
|
||||
def missing(self,l):
|
||||
"""
|
||||
l= ["def ",None,"(",None,"):"]
|
||||
self.line= "def algorithm(name):"
|
||||
l1=["def","(","):"]
|
||||
"""
|
||||
line=[]
|
||||
if l[0]==None:
|
||||
i=self.next(self.line,l[1])
|
||||
line.append(self.line[:i])
|
||||
for i in range(1,len(l)-1):
|
||||
#print("missing loop:",l[i-1],l[i],l[i+1])
|
||||
if l[i]==None:
|
||||
a=self.between(self.line,l[i-1],l[i+1])
|
||||
line.append(a)
|
||||
#print("a",a)
|
||||
if l[-1]==None:
|
||||
i=self.next(self.line,l[-2])+len(l[-2])
|
||||
line.append(self.line[i:])
|
||||
return line
|
||||
|
||||
def removeNone(self,l):
|
||||
l1=[]
|
||||
for word in l:
|
||||
if word!=None:
|
||||
l1.append(word)
|
||||
return l1
|
||||
|
||||
def between(self,text,word1,word2):
|
||||
i1=self.next(text,word1)+len(word1)
|
||||
i2=i1+self.next(text[i1:],word2)
|
||||
return text[i1:i2]
|
||||
|
||||
def cut(self,text,word):
|
||||
for i in range(len(text)-len(word)+1):
|
||||
if text[i:i+len(word)]==word:
|
||||
break
|
||||
return [text[:i],word,text[i+len(word):]]
|
||||
|
||||
def next(self,text,word):
|
||||
for i in range(len(text)-len(word)+1):
|
||||
if text[i:i+len(word)]==word:
|
||||
break
|
||||
return i
|
||||
|
||||
def fill(self,l1,l2):
|
||||
line=[]
|
||||
for e1 in l1:
|
||||
if e1==None:
|
||||
line.append(l2[0])
|
||||
del l2[0]
|
||||
else:
|
||||
line.append(e1)
|
||||
return line
|
||||
|
||||
def __call__(self):
|
||||
self.convert()
|
||||
return " "*self.indent+self.line
|
||||
|
||||
|
||||
|
||||
print(algorithm(algorithm))
|
||||
|
||||
#c=Converter("def test(arg1,arg2):")
|
||||
|
||||
#print(c.between("def test(arg1,arg2):","(",")"))
|
||||
@@ -1,31 +0,0 @@
|
||||
def foo(arg1,arg2):
|
||||
#do something with args
|
||||
a = arg1 + arg2
|
||||
return a
|
||||
|
||||
|
||||
|
||||
print(lines.split("\n"))
|
||||
|
||||
|
||||
|
||||
def convertir(nom):
|
||||
import inspect
|
||||
lines = inspect.getsource(foo)
|
||||
lines=Str(lines)
|
||||
output=[]
|
||||
for line in lines:
|
||||
output.append(convert(line))
|
||||
return "".join(output)
|
||||
|
||||
def convert(line):
|
||||
if word_split():
|
||||
|
||||
|
||||
|
||||
#import dis
|
||||
#print(dis.dis(foo))
|
||||
|
||||
#from dill.source import getsource
|
||||
|
||||
#print(getsource(list.remove))
|
||||
@@ -0,0 +1,36 @@
|
||||
import numpy as np
|
||||
import pylab
|
||||
|
||||
# elephant parameters
|
||||
p1, p2, p3, p4 = (50 - 30j, 18 + 8j, 12 - 10j, -14 - 60j )
|
||||
p5 = 40 + 20j # eyepiece
|
||||
|
||||
def fourier(t, C):
|
||||
f = np.zeros(t.shape)
|
||||
A, B = C.real, C.imag
|
||||
for k in range(len(C)):
|
||||
f = f + A[k]*np.cos(k*t) + B[k]*np.sin(k*t)
|
||||
return f
|
||||
|
||||
def elephant(t, p1, p2, p3, p4, p5):
|
||||
npar = 6
|
||||
Cx = np.zeros((npar,), dtype='complex')
|
||||
Cy = np.zeros((npar,), dtype='complex')
|
||||
|
||||
Cx[1] = p1.real*1j
|
||||
Cx[2] = p2.real*1j
|
||||
Cx[3] = p3.real
|
||||
Cx[5] = p4.real
|
||||
|
||||
Cy[1] = p4.imag + p1.imag*1j
|
||||
Cy[2] = p2.imag*1j
|
||||
Cy[3] = p3.imag*1j
|
||||
|
||||
x = np.append(fourier(t,Cx), [-p5.imag])
|
||||
y = np.append(fourier(t,Cy), [p5.imag])
|
||||
|
||||
return x,y
|
||||
|
||||
x, y = elephant(np.linspace(0,2*np.pi,1000), p1, p2, p3, p4, p5)
|
||||
pylab.plot(y,-x,'.')
|
||||
pylab.show()
|
||||
@@ -1,2 +0,0 @@
|
||||
def __+__(a,b):
|
||||
return a+b
|
||||
Binary file not shown.
Reference in New Issue
Block a user