ALL (67)
# 613xxxxx21 4 (2021-09-13 22:41)
def gen_data(N, W, H):
    N = int(N)
    W = int(W)
    H = int(H)
    x = [0]*N
    y = [0]*N
    dx = [0]*N
    dy = [0]*N
    for i in range(N):
        x[i] = random.random()*W
        y[i] = random.random()*H
        a = random.random()*(2*math.pi)
        dx[i] = math.cos(a)
        dy[i] = math.sin(a)
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    d = float(d)
    W = int(W)
    H = int(H)
    for i in range(len(x)):
        x[i] += d*dx[i]
        y[i] += d*dy[i]
        if x[i] > W :
            x[i] = x[i]- W
        elif x[i] < 0 :
            x[i] = W + x[i]
        elif x[i] == W:
            x[i] = 0.0
        if y[i] > H :
            y[i] = y[i]- H
        elif y[i] < 0 :
            y[i] = H + y[i]
        elif y[i] == H:
            y[i] = 0.0
        
    return
def neighbor_average_direction(x, y, dx, dy, k, R):
    k = int(k)
    R = int(R)
    xr = x[k]
    yr = y[k]
    cdx = 0
    cdy = 0
    n = 0
    for i in range(len(x)):
        a1 = (x[i]-xr)**2
        a2 = (y[i]-yr)**2
        r = math.sqrt((a1+a2))
        if r <= R :
            cdx += dx[i]
            cdy += dy[i]
            n += 1
    avgx = cdx/n
    avgy = cdy/n
    avgmag = math.sqrt(avgx**2+avgy**2)
    mx = avgx/avgmag
    my = avgy/avgmag
    return mx,my
# 623xxxxx21 11 (2021-09-11 22:57)
def gen_data(N, W, H):
    x = [0]*N ; y = [0]*N ; dx = [0]*N ; dy = [0]*N
    for i in range(N): 
        x[i]=random.random()*W
        y[i]=random.random()*H
        angle = random.random()*math.pi*2
        dx[i] = math.cos(angle)
        dy[i] = math.sin(angle) 
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i]+=d*dx[i]
        if x[i] < 0:
            x[i]+=W
        elif x[i] >= W:
            x[i]-=W
    for i in range(len(y)):
        y[i]+=d*dy[i]
        if y[i] < 0:
            y[i]+=H
        elif y[i] >= H:
            y[i]-=H   
def neighbor_average_direction(x, y, dx, dy, k, R):
    mx = 0 ; my = 0 #numerator
    fx = 0 ; fy = 0 #denominator
    for i in range(len(x)):
        if math.sqrt((x[k]-x[i])**2+(y[k]-y[i])**2) <= R:
            fx+=dx[i] ; fy+=dy[i]
            mx+=dx[i]
            my+=dy[i]
    norm = math.sqrt(fx**2+fy**2) #Modulus of vector
    if not norm == 0:
        mx = mx/norm
        my = my/norm
    return mx, my
# 623xxxxx21 17 (2021-09-12 20:53)
def gen_data(N, W, H):
    x=[]
    y=[]
    dx=[]
    dy=[]
    for i in range(N):
        x.append((random.random()*W))
        y.append(random.random()*H)
        d = random.random()*(2*math.pi)
        dx.append(math.cos(d))
        dy.append(math.sin(d))
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    dx1=[]
    for i in dx :
        dx1.append(i*d)
    dy1=[]
    for e in dy :
        dy1.append(e*d)
    for i in range(len(x)):   
        x[i]=x[i]+dx1[i]
        if 0<x[i]<W :
            pass
        else :
            x[i]=x[i]%W
    for i in range(len(y)):
        y[i]+=dy1[i]
        if 0<y[i]<H :
            pass
        else :
            y[i]=y[i]%H
            
def neighbor_average_direction(x, y, dx, dy, k, R):
    mx1=[]                    
    my1=[]
    for i in range(len(x)):
        r=math.sqrt((x[i]-x[k])**2+(y[i]-y[k])**2)
        if r <=R :
            mx1.append(dx[i])
            my1.append(dy[i])
    a = sum(mx1)
    b = sum(my1)
    mx = a/math.sqrt(a**2+b**2)
    my = b/math.sqrt(a**2+b**2)
    return mx,my            
# 633xxxxx21 33 (2021-09-13 23:35)
def gen_data(N, W, H):
    x = []
    y = []
    dx = []
    dy = []
    for i in range(N):
        x1 =  random.uniform(0, W)
        y1 = random.uniform(0, H)
        angle = random.uniform(0, 2*math.pi)
        dx2 = math.sin(angle)
        dy2 = math.cos(angle)
        x.append(x1)
        y.append(y1)
        dx.append(dx2)
        dy.append(dy2)
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(dx)):
        x1 = (dx[i]*d)+x[i]
        y1 = (dy[i]*d)+y[i]
        if x1>=W:
            x[i] = x1 -W
        elif x1<0:
            x[i] = W+x1
        else:
            x[i] = x1
        if y1>=H:
            y[i] =y1 - H
        elif y1<0:
            y[i] =H + y1
        else:
            y[i] = y1
def neighbor_average_direction(x, y, dx, dy, k, R):
    dx1 = 0
    dy1 = 0
    for i in range(len(x)):
        if ((x[i]-x[k])**2 +(y[i]-y[k])**2)**(1/2)<=R:
            dx1 +=dx[i]
            dy1 +=dy[i]
    b = ((dx1)**2+(dy1)**2)**(1/2)
    nx = dx1/b
    ny = dy1/b
    return nx,ny
# 633xxxxx21 34 (2021-09-11 23:01)
def gen_data(N, W, H):
    x = []
    y = []
    dx = []
    dy = []
    for i in range(N):
        x.append(random.random()*W)
        y.append(random.random()*H)
        theta = random.random()*(math.pi*2)
        dx.append(math.cos(theta))
        dy.append(math.sin(theta))
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = (x[i]+(dx[i]*d)) % W
        y[i] = (y[i]+(dy[i]*d)) % H

def neighbor_average_direction(x, y, dx, dy, k, R):
    mx = []
    my = []
    for i in range(len(x)):
        if ((x[i]-x[k])**2)+((y[i]-y[k])**2) <= R**2:
            mx.append(dx[i])
            my.append(dy[i])
    return sum(mx)/((sum(mx)**2+sum(my)**2)**0.5), sum(my)/((sum(mx)**2+sum(my)**2)**0.5)
# 643xxxxx21 37 (2021-09-08 16:44)
def gen_data(N, W, H):
    #return
    x=[0]*N
    y=[0]*N
    dx=[0]*N
    dy=[0]*N
    for i in range(N):
        x[i]=random.random()*W
        y[i]=random.random()*H
        angle=random.random()*(2*pi)
        dx[i]=math.cos(angle)
        dy[i]=math.sin(angle)
    return x,y,dx,dy

def move_all(x, y, dx, dy, d, W, H):
    #return
    l=len(x)
    for i in range(l):
        x[i]= (x[i]+dx[i]*d)%W
        y[i]= (y[i]+dy[i]*d)%H

def neighbor_average_direction(x, y, dx, dy, k, R):
    #return
    xk=x[k]
    yk=y[k]
    dxk=dx[k]
    dyk=dy[k]
    l=len(x)
    vx=0;vy=0
    for i in range(l):
        disx=x[i]-xk
        disy=y[i]-yk
        dis=math.sqrt((disx**2)+(disy**2))
        if dis <=R:
            vx+=dx[i]
            vy+=dy[i]
        else:
            pass
    size=math.sqrt((vx**2)+(vy**2))
    vx1=vx/size
    vy1=vy/size
    return vx1,vy1
main()
# 643xxxxx21 38 (2021-09-13 23:11)
def gen_data(N, W, H):
    x = [0]*int(N)
    y = [0]*int(N)
    dx = [0]*int(N)
    dy = [0]*int(N)
    for i in range(0,N):
        x[i] = (random.random())*int(W)
        y[i] = (random.random())*int(H)
        seta = (random.random())*(2*math.pi)
        dx[i] = math.cos(seta)
        dy[i] = math.sin(seta)
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = x[i]+(dx[i]*float(d))
        y[i] = y[i]+(dy[i]*float(d))
        if x[i]>=int(W) :
            x[i] = x[i]-int(W)
        elif x[i]<0:
            x[i] = x[i]+int(W)
        else:
            x[i] = x[i]+0
        if y[i]>=int(H) :
            y[i] = y[i]-int(H)
        elif y[i]<0:
            y[i] = y[i]+int(H)
        else:
            y[i] = y[i]+0
def neighbor_average_direction(x, y, dx, dy, k, R):
    sumx = 0
    sumy = 0
    for i in range(len(x)):
        if (((x[i]-x[k])**2)+((y[i]-y[k])**2))**0.5<=R:
            sumx = sumx + dx[i]
            sumy = sumy + dy[i]
        else:
            sumx = sumx+0
            sumy = sumy+0
    ab = (sumy**2+sumx**2)**0.5
    return sumx/ab,sumy/ab
# 643xxxxx21 43 (2021-09-08 19:43)
def gen_data(N, W, H):
    l_x = []
    l_y = []
    l_dx = []
    l_dy = []
    for i in range(N):
        l_x.append(random.random()*W)
        l_y.append(random.random() * H)
        ze = random.random()*2*math.pi
        l_dx.append(math.cos(ze))
        l_dy.append(math.sin(ze))
    return l_x,l_y,l_dx,l_dy
def move_all(x, y, dx, dy, d, W, H):
     for i in range(len(x)):
        x[i] = (x[i] + dx[i] * d)%W
        y[i] = (y[i] + dy[i] * d)%H
def neighbor_average_direction(x, y, dx, dy, k, R):
    sum_dx = 0
    sum_dy = 0
    n = 0
    for i in range(len(x)):
        if (x[k] - x[i])**2 + (y[k] - y[i])**2 <= R**2:
            n+= 1
            sum_dx += dx[i]
            sum_dy += dy[i]
    z = (sum_dx**2 +sum_dy**2)**0.5
    return sum_dx/z,sum_dy/z
# 643xxxxx21 44 (2021-09-11 19:58)
def gen_data(N, W, H):
    x = []; y = []; dx = []; dy = []
    for i in range(N):
        x.append(random.random()*W)
        y.append(random.random()*H)
        mum = random.random()*2*math.pi
        dx.append(math.cos(mum))
        dy.append(math.sin(mum))
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] += dx[i]*d
        x[i] = (x[i]+W)%W
        y[i] += dy[i]*d
        y[i] = (y[i]+H)%H
def neighbor_average_direction(x, y, dx, dy, k, R):
    m = 0
    n = 0
    for i in range(len(x)):
        a = (x[i]-x[k])**2
        b = (y[i]-y[k])**2
        c = (a+b)**0.5
        if c <= R:
            m += dx[i]
            n += dy[i]
    o = (n**2+m**2)**0.5
    p = m/o
    q = n/o
    return p, q
main()
# 643xxxxx21 59 (2021-09-11 23:37)
def gen_data(N, W, H):
    x = []
    y = []
    dx = []
    dy = []
    i = 0
    while i < N :
        x += [random.random()*W]
        y += [random.random()*H]
        ang = random.random()*(2*math.pi)
        dx += [math.cos(ang)]
        dy += [math.sin(ang)]
        i += 1
    return x, y ,dx ,dy


def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)) :
        x[i] = float(d)*float(dx[i]) + x[i] 
        y[i] = float(d)*float(dy[i]) + y[i] 
        if x[i] >= W :
            x[i] = x[i] - W
        if x[i] < 0 :
            x[i] = x[i] + W
        if y[i] >= H :
            y[i] = y[i] - H
        if y[i] < 0 :
            y[i] = y[i] + H
    return


def neighbor_average_direction(x, y, dx, dy, k, R):
    sum_dx = 0
    sum_dy = 0
    for i in range(len(x)):
        if (x[k] - x[i])**2 + (y[k] - y[i])**2 <= R**2 :
            sum_dx += dx[i]
            sum_dy += dy[i]
    dxk = sum_dx/(math.sqrt(sum_dx**2 + sum_dy**2))
    dyk = sum_dy/(math.sqrt(sum_dx**2 + sum_dy**2))
    return dxk, dyk
# 643xxxxx21 62 (2021-09-12 20:32)
def gen_data(N, W, H):
    a = 0
    b = 0
    f = 0
    x = []
    y = []
    dx = []
    dy = []
    while a < N:
        c = [float(random.random()*W)]
        x += c
        a += 1
    
    while b < N:
        d = [float(random.random()*H)]
        y += d
        b += 1
  
    while f < N:
        e = float(random.random()*360)
        dx += [math.sin(math.radians(e))]
        dy += [math.cos(math.radians(e))]
        f += 1
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    i = 0
    k = 0
    while i < len(x):
        dx1 = dx[i]*d
        x[i] = (x[i]+dx1)%W
        i+=1
    while k < len(y):
        dy1 = dy[k]*d
        y[k] = (y[k]+dy1)%H
        k+=1

def neighbor_average_direction(x, y, dx, dy, k, R):
    i = 0
    j = 0
    a = 0
    xsum = 0
    ysum = 0
    while i < len(x):
        if math.sqrt((x[k]-x[i])**2+(y[k]-y[i])**2) <= R:
            b = dx[i]
            xsum += b
            c = dy[i]
            ysum += c
            a += 1
        i += 1
    mx = xsum/math.sqrt(xsum**2+ysum**2)
    my = ysum/math.sqrt(xsum**2+ysum**2)
    return mx,my


main()
# 643xxxxx21 64 (2021-09-08 15:01)
def gen_data(N, W, H): #number, width, height
    x,y,dx,dy = [],[],[],[]
    for i in range(0, N) :
        x.append(random.random()*W)
        y.append(random.random()*H)
        r = random.random()*math.pi*2
        dx.append(math.sin(r))
        dy.append(math.cos(r))
        #size = dx[i]**2+dy[i]**2
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(0, len(x)) :
        x[i] = x[i] + (dx[i]*d)
        if x[i] >= W :
            x[i]-=W
        elif x[i] < 0 :
            x[i]+=W
        y[i] = y[i] + (dy[i]*d)
        if y[i] >= H :
            y[i]-=H
        elif y[i] < 0 :
            y[i]+=H
def neighbor_average_direction(x, y, dx, dy, k, R):
    n = len(x)
    mx,my = 0.0,0.0
    cnt = 0
    for i in range(0,n) :
        disx = abs(x[k]-x[i])
        disy = abs(y[k]-y[i])
        dist = (disx**2+disy**2)**0.5
        if(dist<R) :
            cnt+=1
            mx+=dx[i]
            my+=dy[i]
    size = (mx**2+my**2)**0.5
    mx/=size
    my/=size       
    
    return mx, my
main()
# 643xxxxx21 65 (2021-09-13 23:50)
def gen_data(N, W, H):
    x = []
    y = []
    dx = []
    dy = []
    
    for i in range(N):
        x1 =  random.uniform(0, W)
        y1 = random.uniform(0, H)
        radin = random.uniform(0, math.pi*2)
        dx1 = math.cos(radin)
        dy1 = math.sin(radin)
        x.append(x1)
        y.append(y1)
        dx.append(dx1)
        dy.append(dy1)
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(y)):
        mx = x[i] + (dx[i]*d)
        my = y[i] + (dy[i]*d)
        if mx >= W :
             x[i] = mx - W
        elif mx < 0 :
             x[i] = W + mx
        else :
             x[i] = mx
        if my >= H :
             y[i] = my - H
        elif my < 0 :
             y[i] = H + my
        else :
             y[i] = my
def neighbor_average_direction(x, y, dx, dy, k, R):
    dx1 = 0
    dy1 = 0
    
    for i in range(len(y)) :
        d = math.sqrt((x[i]-x[k])**2 + (y[i]-y[k])**2)
        if d <= R :
           dx1 += dx[i]
           dy1 += dy[i]
    mag = math.sqrt((dx1)**2 + (dy1)**2)
    adx = dx1/mag
    ady = dy1/mag
    return adx, ady
# 643xxxxx21 72 (2021-09-12 22:19)
def gen_data(N, W, H):  
    listx = []
    listy = []
    listdx = []
    listdy = []
    for i in range(N):
        x    = random.random()*W
        y = random.random()*H
        rr   =  random.random()*2*math.pi
        dx = math.cos(rr)
        dy = math.sin(rr)
        listx += [x]
        listy += [y]
        listdx += [dx]
        listdy += [dy]
    return listx, listy, listdx, listdy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        y[i] += d*dy[i]
        x[i] += d*dx[i]
        x[i] = x[i]%W
        y[i] = y[i]%H

def neighbor_average_direction(x, y, dx, dy, k, R):
    #n = range(x[k]**2 + y[k]**2 <= R**2)
    xRoumMit = 0
    yYumlei = 0
    for i in range(len(x)):
        if (x[k]-x[i])**2 + (y[k]-y[i])**2 <= R**2:
            xRoumMit += dx[i]
            yYumlei += dy[i]
    xRoumMitPromServe = xRoumMit/math.sqrt(xRoumMit**2 + yYumlei**2)
    yYumleiPromServe = yYumlei/math.sqrt(xRoumMit**2 + yYumlei**2)
    
    return xRoumMitPromServe, yYumleiPromServe
# 643xxxxx21 73 (2021-09-12 21:03)
def gen_data(N, W, H):
    x = [0]*N ; y = [0]*N ; dx = [0]*N ; dy = [0]*N
    for i in range(N):
        x[i] = random.random()*W
        y[i] = random.random()*H
        a = random.random()*(2*math.pi)
        dx[i] = math.cos(a)
        dy[i] = math.sin(a)
    return x, y, dx, dy

def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = x[i] + dx[i]*d
        if x[i] < 0:
            x[i] += W
        elif x[i] >= W:
            x[i] -= W
    for j in range(len(y)):
        y[j] = y[j] + dy[j]*d
        if y[j] < 0:
            y[j] += H
        elif y[j] >= H:
            y[j] -= H

def neighbor_average_direction(x, y, dx, dy, k, R):
    theta = 0 ; xbtheta = 0 ; smx = 0 ; smy = 0 ; r = 0 ; n = 0
    for l in range(len(x)):
        if math.sqrt((x[l]-x[k])**2+(y[l]-y[k])**2) < R:
            smx += dx[l]
            smy += dy[l]
    r = math.sqrt(smx**2+smy**2)
    theta = math.asin(smy/r)
    theta = abs(theta)
    if smx >= 0 and smy >= 0: 
        mx = math.cos(theta)
        my = math.sin(theta)
    elif smx <= 0 and smy >= 0:
        mx = -math.cos(theta)
        my = math.sin(theta)
    elif smx <= 0 and smy <= 0:
        mx = -math.cos(theta)
        my = -math.sin(theta)
    elif smx >= 0 and smy <= 0:
        mx = math.cos(theta)
        my = -math.sin(theta)
    return mx, my
# 643xxxxx21 75 (2021-09-10 08:17)
def gen_data(N, W, H) :
    x, y, dx, dy = [0]*N, [0]*N, [0]*N, [0]*N
    for i in range(N) :
        x[i] = random.random()*W
        y[i] = random.random()*H
        radian = random.random()*2*math.pi
        dx[i] = math.cos(radian)
        dy[i] = math.sin(radian)
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H) :
    for i in range(len(x)) :
        x[i] = x[i] + (dx[i]*d)
        y[i] = y[i] + (dy[i]*d)
        if x[i] >= W or x[i] < 0 :
            x[i] = abs(W - abs(x[i]))
        if y[i] >= H or y[i] < 0 :
            y[i] = abs(H - abs(y[i]))
def neighbor_average_direction(x, y, dx, dy, k, R):
    sx = 0.0 ; sy = 0.0
    for i in range(len(x)) :
        if math.sqrt((x[k]-x[i])**2+(y[k]-y[i])**2) <= R :
            sx += dx[i]
            sy += dy[i]
    r = math.sqrt((sx**2)+(sy**2))
    sx = sx/r
    sy = sy/r
    return sx, sy
# 643xxxxx21 76 (2021-09-12 22:37)
def gen_data(N, W, H):
    p = []
    q = []
    r = []
    s = []
    for i in range(N) :
        x = random.random()*W
        y = random.random()*H
        mum = random.random()*2*math.pi
        dx = math.cos(mum)
        dy = math.sin(mum)
        p += [x]
        q += [y]
        r += [dx]
        s += [dy]
    return p, q, r, s
def move_all(x, y, dx, dy, d, W, H):
    i = 0
    while i < len(x) :
        x[i] += d*dx[i]
        y[i] += d*dy[i]
        x[i] = x[i]%W 
        y[i] = y[i]%H
        i += 1
def neighbor_average_direction(x, y, dx, dy, k, R):
    pp = 0
    qq = 0
    i = 0
    while i < len(x) :
        if (x[k]-x[i])**2 + (y[k]-y[i])**2 <= R**2 :
            pp += dx[i]
            qq += dy[i]
        i += 1
    rr = pp/math.sqrt(pp**2 + qq**2)
    ss = qq/math.sqrt(pp**2 + qq**2)
    return rr, ss
# 643xxxxx21 80 (2021-09-13 12:10)
def gen_data(N, W, H):
    x = []
    y = []
    dx = []
    dy = []
    rad = []
    for i in range(N) :
        x.append(random.random()*W)
        y.append(random.random()*H)
        rad.append(random.random()*math.pi*2)
    for i in range(N) :
        dx.append(math.cos(rad[i]))
        dy.append(math.sin(rad[i]))
        
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] += d*dx[i]
        if x[i] >= W or x[i] <= 0 : 
          if x[i] <= 0 :
            x[i] += W
          if x[i] >= W :
            x[i] -= W

        y[i] += d*dy[i]
        if y[i] >= H or y[i] <= 0 : 
          if y[i] <= 0 :
            y[i] += H
          if y[i] >= H :
            y[i] -= H
def neighbor_average_direction(x, y, dx, dy, k, R): 
    sumdx = 0
    sumdy = 0
    c = 0
    for i in range(len(x)) :
      if math.sqrt((x[k]-x[i])**2+(y[k]-y[i])**2) <= R :
          sumdx += dx[i]
          sumdy += dy[i]
          c += 1
    a = sumdx/c
    b = sumdy/c
    mx = (a)/math.sqrt(a**2+b**2)
    my = (b)/math.sqrt(a**2+b**2)
    
    return mx,my
# 643xxxxx21 83 (2021-09-12 23:39)
def gen_data(N, W, H):
    x=[]
    y=[]
    dx=[]
    dy=[]
    for i in range(N):
        x.append(random.random()*W)
        y.append(random.random()*H)
        v=random.random()*2*math.pi
        dx.append(math.cos(v))
        dy.append(math.sin(v))
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i]+=d*dx[i]
        if x[i]>=W:
            x[i]=x[i]-W
        elif x[i]<0:
            x[i]+=W
        y[i]+=d*dy[i]
        if y[i]>=H:
            y[i]=y[i]-H
        elif y[i]<0:
            y[i]+=H
def neighbor_average_direction(x, y, dx, dy, k, R):
    xx=0
    yy=0
    z=0
    for i in range(len(x)):
        if R>=math.sqrt(((x[k]-x[i])**2)+((y[k]-y[i])**2)):
            xx+=dx[i]
            yy+=dy[i]
            z+=1
    xa=xx/z
    ya=yy/z
    r=math.sqrt(xa**2+ya**2)
    mx=xa/r
    my=ya/r
    return mx,my
# 643xxxxx21 84 (2021-09-13 20:22)
def gen_data(N, W, H):
    x = [0]*N
    y = [0]*N
    dx = [0]*N
    dy = [0]*N
    for i in range(N):
        x[i] = random.random()*W
        y[i] = random.random()*H
        rad = random.random()*2*math.pi
        dx[i] = math.cos(rad)
        dy[i] = math.sin(rad)
    return x,y,dx,dy    
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] += dx[i]*d
        y[i] += dy[i]*d
        x[i] %= W
        y[i] %= H
 #-------------------------------------------
def neighbor_average_direction(x, y, dx, dy, k, R):
    c = 0
    xbar = 0
    ybar = 0    
    for i in range(len(x)):
        if  (((x[k] - x[i])**2) + ((y[k] - y[i])**2))**(1/2) <= R:
            xbar += dx[i]
            ybar += dy[i]
        c = math.sqrt((xbar**2)+(ybar**2))
    mx = xbar/c
    my = ybar/c
    return mx,my
        
# 643xxxxx21 87 (2021-09-11 12:09)
def gen_data(N, W, H):
    x = [0.0]*N
    y = [0.0]*N
    dx = [0.0]*N
    dy = [0.0]*N
    for i in range(N):
        x[i] = random.random()*W
    for i in range(N):
        y[i] = random.random()*H
    for i in range(N):
        s = random.random()*2*math.pi
        dx[i] = math.cos(s)
        dy[i] = math.sin(s)
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    s = len(x)
    for i in range(s):
        x[i] += dx[i]*d
        if 0 <= x[i] < W:
            pass
        elif x[i] >= W:
            x[i] = x[i] - W
        elif x[i] < 0 :
            x[i] = W + x[i]
    for i in range(s):
        y[i] += dy[i]*d
        if 0 <= y[i] < H:
            pass
        elif y[i] >= H:
            y[i] = y[i] - H
        elif y[i] < 0 :
            y[i] = H + y[i]
def neighbor_average_direction(x, y, dx, dy, k, R):
    a = 0
    b = 0
    s = len(x)
    for i in range(s):
        if math.sqrt((x[i]-x[k])**2 + (y[i]-y[k])**2) <= R :
            a += dx[i]
            b += dy[i]
    c = math.sqrt(a**2 + b**2)
    vec1 = a/c
    vec2 = b/c
    return vec1,vec2
# 643xxxxx21 89 (2021-09-12 20:00)
def gen_data(N, W, H):
    dx, dy = [], []
    for i in range(N) :
        j = random.uniform(0,2*math.pi)
        dx.append(math.sin(j))
        dy.append(math.cos(j))
    return [random.uniform(0,W) for i in range(N)], [random.uniform(0,H) for i in range(N)], dx, dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)) :
        x[i] = x[i] + (d*dx[i])
        x[i] %= W
    for i in range(len(y)) :
        y[i] = y[i] + (d*dy[i])
        y[i] %= H
def neighbor_average_direction(x, y, dx, dy, k, R):
    dirX = dirY = 0
    in_range = 0
    for i in range(len(x)) :
        if math.sqrt(((x[i] - x[k])**2) + ((y[i] - y[k])**2)) <= R :
            dirX += dx[i]
            dirY += dy[i]
            in_range += 1
    dirX /= in_range
    dirY /= in_range
    theta = math.atan2(dirY,dirX)
    dirX = math.cos(theta)
    dirY = math.sin(theta)
    return dirX, dirY


# 643xxxxx21 96 (2021-09-13 21:53)
def gen_data(N, W, H):
    x = [] ; y = [] ; dx = [] ; dy = []
    for i in range(N) :
         a = [random.random()*W]
         b = [random.random()*H]
         c = random.random()*2*math.pi
         d = [math.cos(c)]
         e = [math.sin(c)]
         x += a ; y += b ; dx += d ; dy += e
    return x,y,dx,dy
         
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)) :
        x[i] = x[i] + d*dx[i]
    for i in range(len(y)) :    
        y[i] = y[i] + d*dy[i]
    for i in range(len(x)) :
        if x[i] >= W :
            x[i] = x[i] - W
        elif 0 > x[i] :
            x[i] = x[i] + W
    for i in range(len(y)) :   
        if y[i] >= H :
            y[i] = y[i] - H
        elif 0 > y[i] :
            y[i] = y[i] + H
    
def neighbor_average_direction(x, y, dx, dy, k, R):
    sumx = 0
    sumy = 0
    for i in range(len(x)) :
        if ((x[k]-x[i])**2)+((y[k]-y[i])**2) <= R**2 :
            sumx+= dx[i]
            sumy+= dy[i]
        else :
            pass
    vecx = sumx/((sumx**2+sumy**2)**0.5)
    vecy = sumy/((sumx**2+sumy**2)**0.5)
    return vecx,vecy
# 643xxxxx21 101 (2021-09-13 23:41)
def gen_data(N, W, H):    
    
    i = 0
    x,y,dx,dy = [0]*N,[0]*N,[0]*N,[0]*N
    while i<N :
        x[i] = random.random()*W
        y[i] = random.random()*H
        b = random.random()*2*math.pi
        dx[i] = math.cos(b)
        dy[i] = math.sin(b)
        i += 1
        
    return x,y,dx,dy   

def move_all(x, y, dx, dy, d, W, H):
    i = 0    
    while i<len(x) :
        x[i] = x[i]+d*dx[i]
        y[i] = y[i]+d*dy[i]
        if x[i]>=W :
            x[i] -= W
        if x[i]<0 :
            x[i] += W
        if y[i]>=H :
            y[i] -= H
        if y[i]<0 :
            y[i] += H 
        i += 1
                            
def neighbor_average_direction(x, y, dx, dy, k, R):
    i =0
    sx = 0
    sy = 0
    while i<len(x) :
        n = ((x[i]-x[k])**2+(y[i]-y[k])**2)**0.5     
        if n<=R :
            sx += dx[i]
            sy += dy[i]
        i +=1
    d = (sx**2+sy**2)**0.5
    
    return sx/d, sy/d 
main()

# 643xxxxx21 110 (2021-09-11 23:51)
def gen_data(N, W, H):
    x = []
    y = []
    dx = []
    dy = []
    for e in range(0, N):
        x += [float(random.random() * W)]
        y += [float(random.random() * H)]
        r = random.random()
        dx += [float(math.cos(r * 2 * math.pi))]
        dy += [float(math.sin(r * 2 * math.pi))]
    return x, y, dx, dy

def move_all(x, y, dx, dy, d, W, H):
    for e in range(len(x)):
        x[e] = ((x[e] + W) + dx[e] * d) % W
        y[e] = ((y[e] + H) + dy[e] * d) % H

def neighbor_average_direction(x, y, dx, dy, k, R):
    a = 0
    b = 0
    for i in range(len(x)):
        if (x[i] - x[k]) ** 2 + (y[i] - y[k]) ** 2 <= R ** 2:
            a += dx[i]
            b += dy[i]
    c = a / math.sqrt(a ** 2 + b ** 2)
    d = b / math.sqrt(a ** 2 + b ** 2)
    print(k)
    return c, d


# 643xxxxx21 114 (2021-09-12 19:39)
def gen_data(N, W, H):
    x = [0.0]*N
    y = [0.0]*N
    dx = [0.0]*N
    dy = [0.0]*N 
    for i in range(N):
        x[i] =random.random()*W
        y[i] =random.random()*H
        k = random.random()*(2*math.pi)
        dx[i] = math.cos(k)
        dy[i] = math.sin(k)
    return x,y,dx,dy

def move_all(x, y, dx, dy, d, W, H):
    for i in range (len(x)):
        x[i] = x[i]+(dx[i]*d)
        if x[i] >= W:
            x[i] = x[i] - W
        elif x[i] < 0:
            x[i] = W + x[i]
        y[i] = y[i]+(dy[i]*d)
        if y[i] >= H:
            y[i] = y[i] - H
        elif y[i] < 0:
            y[i] = H + y[i]
  
def neighbor_average_direction(x, y, dx, dy, k, R):
    sx = 0
    sy = 0   
    for i in range (len(x)):
         if  (x[i]-x[k])**2 + (y[i]-y[k])**2 <= R**2:
             sx += dx[i]
             sy += dy[i]          
    ro = math.sqrt(sx**2+sy**2)
    mx = sx/ro
    my = sy/ro
    return mx,my

 
# 643xxxxx21 117 (2021-09-11 11:36)
def gen_data(N, W, H):
    x = [0]*N
    y = [0]*N
    dx = [0]*N
    dy = [0]*N
    for i in range(N):
        x[i] = random.random()*W
        y[i] = random.random()*H
        angle = random.random()*(2*math.pi)
        dx[i] = math.cos(angle)
        dy[i] = math.sin(angle)
    return x,y,dx,dy


def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = x[i]+(dx[i]*d)
        y[i] = y[i]+(dy[i]*d)
        if x[i] >= W:
            x[i] -= W
        elif x[i] < 0:
            x[i] += W
        if y[i] >= H:
            y[i] -= H
        elif y[i] < 0:
            y[i] += H


def neighbor_average_direction(x, y, dx, dy, k, R):
    c = 0
    d = 0
    for i in range(len(x)):
        z = x[i] - x[k]
        a = y[i] - y[k]
        b = math.sqrt((z**2)+(a**2))
        if b <= R:
            c += dx[i]
            d += dy[i]
    e = math.sqrt((c**2)+(d**2))
    c /= e
    d /= e
    return c,d
# 643xxxxx21 127 (2021-09-13 22:12)
def gen_data(N, W, H):
    m = []
    n = []
    o = []
    p = []
    for i in range(N) :
        x = random.random()*W
        y = random.random()*H
        seta = random.random()*2*math.pi
        dx = math.cos(seta)
        dy = math.sin(seta)
        m += [x]
        n += [y]
        o += [dx]
        p += [dy]
    return m, n, o, p
    


def move_all(x, y, dx, dy, d, W, H):
    
    for i in range (len(y)) :
        x[i] += d*dx[i]
        y[i] += d*dy[i]
        x[i] = x[i]%W 
        y[i] = y[i]%H
        
        


def neighbor_average_direction(x, y, dx, dy, k, R):
    mm = 0
    nn = 0
    
    for i in range (len(y)) :
        if (x[k]-x[i])**2 + (y[k]-y[i])**2 <= R**2 :
            mm += dx[i]
            nn += dy[i]
        
    oo = mm/math.sqrt(mm**2 + nn**2)
    pp = nn/math.sqrt(mm**2 + nn**2)
    return oo, pp


# 643xxxxx21 141 (2021-09-11 22:49)
def gen_data(N, W, H):

 x = [0]*N
 y = [0]*N
 dx = [0]*N
 dy = [0]*N
 for i in range(0,N,1):
     x[i] = W*random.random()
     y[i] = H*random.random()
     theta_i = 2*math.pi*random.random()
     dx[i] = math.cos(theta_i)
     dy[i] = math.sin(theta_i)
     
 return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):

    for i in range(0,len(x),1):
        x[i]+=d*dx[i]
        if x[i]>=W:
            x[i]=x[i]%W
        y[i]+=d*dy[i]
        if y[i]>=H:
            y[i]=y[i]%H
    
        if x[i] < 0 :
            x[i]=(W+x[i])
        if y[i] < 0 :
            y[i]=(H+y[i])
       
            
            
            
    
def neighbor_average_direction(x, y, dx, dy, k, R):
    ix=0
    jy=0
    total = 0 #ขนาด
    for i in range(0,len(x),1):
        if (x[k]-x[i])**2 + (y[k]-y[i])**2 <= R**2 :
            ix += dx[i]
            jy += dy[i]
    total += math.sqrt(ix**2 + jy**2)
    mx = ix/total
    my = jy/total
    return mx,my
# 643xxxxx21 145 (2021-09-09 00:50)
def gen_data(N, W, H):
    x=[0]*N
    y=[0]*N
    dx=[0]*N
    dy=[0]*N
    for i in range (N):
        x[i] = random.randrange(0,W)+random.random()
        y[i] = random.randrange(0,H)+random.random()
        p = random.randrange(0,360)
        dx[i] = math.sin(p)
        dy[i] = math.cos(p)
    return x, y, dy, dx
def move_all(x, y, dx, dy, d, W, H):
    for i in range (len(x)):
        l = x[i]+d*dx[i]
        if l<0:
            x[i]=l+W
        else:
            if l>=W:
                x[i]=l-W
            else:
                x[i]=l
    for i in range (len(y)):
        l = y[i]+d*dy[i]
        if l<0:
            y[i]=l+H
        else:
            if l>=H:
                y[i]=l-H
            else:
                y[i]=l
 # ควรเขยีนฟังกช์ ันนี้ใหเ้สร็จเป็นฟังกช์ ันทสี่ อง
 # ถ้ำยังไม่เขียน code ของฟังกช์ ันนี้
 # ใหใ้ส่ค ำสั่ง return ไวท้ บี่ รรทัดแรกของฟังกช์ ันนี้
 
def neighbor_average_direction(x, y, dx, dy, k, R):
    xt=0 ; yt=0
    for i in range(len(x)):
        dis=(((x[k]-x[i])**2)+((y[k]-y[i])**2))**0.5
        if dis <=R:
            xt+=dx[i]
            yt+=dy[i]
    size = (xt**2+yt**2)**0.5
    vecx= xt/size
    vecy = yt/size
    return vecx,vecy
 # ถ้ำยังไม่เขียน code ของฟังกช์ ันนี้
 # ใหใ้ส่ค ำสั่ง return dx[k],dx[k] ไวท้ บี่ รรทัดแรกของฟังกช์ ันนี้
  # ลบบรรทัดนี้ออก ก่อนจะเรมิ่ เขยี นค ำสั่งในฟังกช์ ันนี้
main()
# 643xxxxx21 146 (2021-09-11 18:03)
def gen_data(N, W, H):
    x = [] ; y = [] ; dx = [] ; dy = [] ; pi = math.pi
    for a in range(N) :
        x.append(((random.random())*W))
        y.append(((random.random())*H))
        b = (random.random()*2*pi)
        dx.append(math.cos(b))
        dy.append(math.sin(b))
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
  a = [] ; b = []
  for i in range(len(x)) :
     if x[i] + (dx[i])*d >= W :
        x[i] = (( x[i] + (dx[i])*d ) - W)
     elif x[i] + (dx[i])*d < 0 :
        x[i] = ( W + ( x[i] + (dx[i])*d ))
     else :
        x[i] = (x[i] + (dx[i])*d)
     if y[i] + (dy[i])*d >= H :
        y[i] = (( y[i] + (dy[i])*d ) - H)
     elif y[i] + (dy[i])*d < 0 :
        y[i] = ( H + ( y[i] + (dy[i])*d ))
     else :
        y[i] = (y[i] + (dy[i]*d))
def neighbor_average_direction(x, y, dx, dy, k, R):
    d = [] ; e = [] ; g = 0 ; h = 0 
    for a in range(len(x)) :
        b = (x[a]-x[k])**(2)
        c = (y[a]-y[k])**(2)
        if (b+c)**(1/2) <= R :
            d.append(dx[a])
            e.append(dy[a])
    for f in range(len(d)) :
        g += d[f] ; h += e[f]
    m = g / ((g)**2 + (h)**2)**(1/2)
    n = h / ((g)**2 + (h)**2)**(1/2)
    return m,n
# 643xxxxx21 147 (2021-09-13 21:51)
def gen_data(N, W, H):
    x = [0]*N
    y = [0]*N
    dx = [0]*N
    dy = [0]*N
    for i in range(N):
        x[i] =  random.random()*W
        y[i] =  random.random()*H
        a = random.random()*(2*math.pi)
        dx[i] = math.cos(a)
        dy[i] = math.sin(a)
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] += d*dx[i]
        y[i] += d*dy[i]
    for i in range(len(x)):
        if x[i] < 0:
            x[i] += W
        elif y[i] < 0:
            y[i] += H
    for i in range(len(x)):
        if x[i] >= W:
            x[i] -= W
        elif y[i] >= H:
            y[i] -= H  
    
def neighbor_average_direction(x, y, dx, dy, k, R):
    mx = 0
    my = 0
    for i in range(len(x)):
        if  ((x[k] - x[i])**2 + (y[k] - y[i])**2)**0.5 <= R :
           mx += dx[i]
           my += dy[i]
    sum_vector = (mx**2 + my**2)**0.5
    mx /= sum_vector
    my /= sum_vector

    return mx,my
# 643xxxxx21 150 (2021-09-13 20:39)
def gen_data(N,W,H):
    x = [0.0]*N
    y = [0.0]*N
    dx = [0.0]*N
    dy = [0.0]*N
    for i in range(N):
        x[i] = random.random()*W
        y[i] = random.random()*H
        ang = (random.random()*2*math.pi) 
        dx[i] = math.cos(ang)
        dy[i] = math.sin(ang)
    return x, y, dy, dx
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] += dx[i]*d
        if x[i] < 0:
            while x[i] < 0:
                x[i] = W+x[i]
        elif x[i] >= W:
            while x[i] >= W:
                x[i] = 0+(x[i]-W)
        y[i] += dy[i]*d
        if y[i] < 0:
            while y[i] < 0:
                y[i] = H+y[i]
        elif y[i] >= H:
            while y[i] >= H:
                y[i] = 0+(y[i]-H)
    
            
def neighbor_average_direction(x, y, dx, dy, k, R):
    dxn = [0.0]*len(x)
    dyn = [0.0]*len(x)
    sigx = 0
    sigy = 0
    c = 0
    for i in range(len(x)):
        if (x[i]-float(x[k]))**2+(y[i]-float(y[k]))**2 <= R**2:
            dxn[i],dyn[i] = dx[i],dy[i]
            c += 1

    for i in range(len(x)):
        sigx += float(dxn[i])
        sigy += float(dyn[i])
    mag = ((sigx/c)**2+(sigy/c)**2)**0.5
    mx = sigx/c/mag
    my = sigy/c/mag
    return mx,my
# 643xxxxx21 153 (2021-09-12 16:32)
def gen_data(N, W, H):
    n = int(N)
    w = float(W)
    h = float(H)
    x = [0]*n
    y = [0]*n
    dx = [0]*n
    dy = [0]*n

    for i in range(n):
        x[i] += random.uniform(0, w)
        y[i] += random.uniform(0, h)
        sethax = 360*random.random()
        dx[i] += math.sin(sethax)
        dy[i] += math.cos(sethax)
    return x,y,dx,dy;           
  
  
def move_all(x, y, dx, dy, d, W, H):
    d = float(d)
    w = float(W)
    h = float(H)
    X = []
    Y = []
    DX = []
    DY = []
    
    for i in range(len(x)):
        X += [x[i]]
        Y += [y[i]]
        DX += [dx[i]]
        DY += [dy[i]]
        if 0 <= x[i]+dx[i]*d < w:
            x[i] = x[i]+dx[i]*d
        elif x[i]+dx[i]*d >= w:
            x[i] = (x[i]+dx[i]*d)-w
        elif 0 > x[i]+dx[i]*d:
            x[i] = w+(x[i]+dx[i]*d)
        if 0 <=y[i]+dy[i]*d  <h:
            y[i] = y[i]+dy[i]*d
        elif y[i]+dy[i]*d >= h:
            y[i] = (y[i]+dy[i]*d)-h
        elif 0 > y[i]+dy[i]*d:
            y[i] = h+y[i]+dy[i]*d
    x = X
    y = Y
    dx = DX
    dy = DY

def neighbor_average_direction(x, y, dx, dy, k, R):
    mx = 0
    my = 0
    for i in range(len(x)):
        r = math.sqrt((x[i]-x[k])**2+(y[i]-y[k])**2)
        if r <= R:
            mx += dx[i]
            my += dy[i]
    return mx/(math.sqrt(mx**2+my**2)),my/(math.sqrt(mx**2+my**2));
# 643xxxxx21 158 (2021-09-12 09:45)
def gen_data(N, W, H):
    x=[]
    y=[]
    dx=[]
    dy=[]
    
    for i in range(N):
        x1= random.random()*W
        x.append(x1)
        y1= random.random()*H
        y.append(y1)
        an=random.random()*math.pi*2
        dx1= math.cos(an)
        dx.append(dx1)
        dy1= math.sin(an)
        dy.append(dy1) 
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
            x[i]=(x[i]+dx[i]*d)
            y[i]=(y[i]+dy[i]*d)
            x[i]=x[i]%W
            y[i]=y[i]%H
    return        
def neighbor_average_direction(x, y, dx, dy, k, R):
    x1=0
    y1=0
    for i in range(len(y)):
        if math.sqrt((x[k]-x[i])**2+(y[k]-y[i])**2)<=R:
            x1+=dx[i]
            y1+=dy[i]
    
    u1=math.sqrt((x1)**2+(y1)**2)
    return (x1/u1),(y1/u1)

# 643xxxxx21 159 (2021-09-12 23:56)
def gen_data(N, W, H):
    x = [] ; y = [] ; dx = [] ; dy = []
    for i in range(N):
        x.append(random.random()*W)
        y.append(random.random()*H)
    for i in range(N):
        rad = random.random()*2*math.pi
        dx.append(math.cos(rad))
        dy.append(math.sin(rad))
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = ((dx[i]*d)+x[i]) % W
        y[i] = ((dy[i]*d)+y[i]) % H
def neighbor_average_direction(x, y, dx, dy, k, R):
    mx = 0 ; my = 0
    for i in range(len(x)):
        if ((x[k]-x[i])**2 + (y[k]-y[i])**2)**0.5 <= R :
            mx += dx[i]
            my += dy[i]
    m = (mx**2 + my**2)**0.5
    mx /= m
    my /= m
    return mx, my
# 643xxxxx21 161 (2021-09-13 16:43)
def gen_data(N, W, H):
    x=[random.random()*W for e in range(N) ]
    y=[random.random()*H for e in range(N) ]
    dx=list()
    dy=list()
    for e in range(N):
        radian = (random.random()*math.pi*2)*180/math.pi
        dx.append(math.cos(radian))
        dy.append(math.sin(radian))
    return x,y,dx,dy

def move_all(x, y, dx, dy, d, W, H):
    N = len(x)
    for e in range(N):
        x[e] = (x[e]+(dx[e]*d)+W)%W
        y[e] = (y[e]+(dy[e]*d)+H)%H

def neighbor_average_direction(x, y, dx, dy, k, R):
    N = len(x)
    lx = list()
    ly = list()
    for e in range(N):
        sx=x[e]-x[k]
        sy=y[e]-y[k]
        if sx**2+sy**2<=R**2:
            lx.append(dx[e])
            ly.append(dy[e])
    ax = sum(lx)/len(lx)
    ay = sum(ly)/len(ly)
    uni = math.sqrt(ax**2+ay**2)
    mx = ax/uni
    my = ay/uni
    return mx,my


main()
# 643xxxxx21 166 (2021-09-13 12:01)
def gen_data(N, W, H):
    x = []
    y = []
    a = []
    for i in range(N) :
        x.append(random.random()*W)
        y.append(random.random()*H)
        a.append(random.random()*math.pi*2)
    dx = []
    dy = []
    for i in range(len(a)) :
        dx.append(math.cos(a[i]))
        dy.append(math.sin(a[i]))
            
    return x,y,dx,dy
         
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)) :
        x[i] += d*dx[i]
        if x[i] >= W or x[i] <= 0 :
            if x[i] <= 0 :
                x[i] += W
            if x[i] >= W :
                x[i] -= W
        y[i] += d*dy[i]
        if y[i] >= H or y[i] <= 0 :
            if y[i] <= 0 :
                y[i] += H
            if y[i] >= H :
                y[i] -= H
 
def neighbor_average_direction(x, y, dx, dy, k, R):
    sumdx = 0
    sumdy = 0
    c = 0
    for i in range(len(x)) :
        if  math.sqrt((x[k]-x[i])**2+(y[k]-y[i])**2) <= R :
            sumdx += dx[i]
            sumdy += dy[i]
            c+= 1
    mx = sumdx/c
    my = sumdy/c
    a = mx/math.sqrt(mx**2+my**2)
    b = my/math.sqrt(mx**2+my**2)
    return a,b
      
# 643xxxxx21 167 (2021-09-13 21:40)
def gen_data(N, W, H):
    x = [] 
    y =[]
    dx = []
    dy = []
    theta = []
    for i in range(N):
        x.append(random.random()*W)
        y.append(random.random()*H)
        
    for i in range(N):
        theta.append(random.random()*(2*math.pi))
    for t in theta:
        dx.append(math.cos(t))
        dy.append(math.sin(t))
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(dx)):
        x[i] += d*dx[i]
        y[i] += d*dy[i]
        if x[i] < 0:
            x[i] += W
        elif x[i] >= W:
            x[i] -= W
        if y[i] < 0:
            y[i] += H
        elif y[i] >= H:
            y[i] -= H
def neighbor_average_direction(x, y, dx, dy, k, R):
    Alldx = 0; Alldy = 0
    c = 0
    for i in range(len(x)):
        if math.sqrt((x[k]-x[i])**2 + (y[k]-y[i])**2) <= R:
            Alldx += ((dx[i]))
            Alldy += ((dy[i]))
            c += 1
    
    dxmean = Alldx / c
    dymean = Alldy / c
    vectors = math.sqrt((dxmean**2)+(dymean**2))
    dxmean1 = dxmean / vectors
    dymean1 = dymean / vectors
    
    return dxmean1, dymean1
    

# 643xxxxx21 168 (2021-09-13 22:25)
def gen_data(N, W, H):
    x=[];y=[];dx=[];dy=[]
    for i in range(N):
        x+=[random.random()*W]
        y+=[random.random()*H]
        r=random.random()
        dx+=[math.cos(r*2*math.pi)]
        dy+=[math.sin(r*2*math.pi)]
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i]=(x[i]+d*dx[i])%W
        y[i]=(y[i]+d*dy[i])%H
def neighbor_average_direction(x, y, dx, dy, k, R):
    mx=0
    my=0
    for e in range(len(x)):
        if (x[e]-x[k])**2+(y[e]-y[k])**2<=R**2:
            mx+=dx[e]
            my+=dy[e]
    m=math.sqrt((mx**2)+(my**2))
    mx/=m
    my/=m
    return mx,my
# 643xxxxx21 172 (2021-09-13 22:27)
def gen_data(N, W, H):
   x = [0]*N
   y = [0]*N
   dx = [0]*N
   dy = [0]*N
   for i in range(N) :
       x[i] = random.random()*W
       y[i] = random.random()*H
       angle = random.random()*2*math.pi
       dx[i] = math.cos(angle)
       dy[i] = math.sin(angle)
   return x, y, dx, dy
   
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)) :
        if 0 <= x[i] + d*dx[i] < W :
            x[i] += d*dx[i]
        elif x[i] + d*dx[i] >= W :
            x[i] = (x[i] + d*dx[i]) - W
        else :
            x[i] = W + (x[i] + d*dx[i])
    for i in range(len(y)) :
        if 0 <= y[i] + d*dy[i] < H :
            y[i] += d*dy[i]
        elif y[i] + d*dy[i] >= H :
            y[i] = (y[i] + d*dy[i]) - H
        else :
            y[i] = H + (y[i] + d*dy[i])
def neighbor_average_direction(x, y, dx, dy, k, R):
    sumdx = 0
    sumdy = 0
    for i in range(len(x)) :
        if ((x[k] - x[i])**2 + (y[k] - y[i])**2)**(1/2) <= R :
            sumdx = sumdx + dx[i]
            sumdy = sumdy + dy[i]
    unitx = sumdx / (sumdx**2 + sumdy**2)**(0.5)
    unity = sumdy / (sumdx**2 + sumdy**2)**(0.5)
    return unitx, unity
main()
# 643xxxxx21 174 (2021-09-09 17:45)
def gen_data(N, W, H):
    x=[0]*N
    for i in range(N):
        x[i]=random.random()*W
    y=[0]*N
    for i in range(N):
        y[i]=random.random()*H
    dx=[0]*N
    dy=[0]*N
    for i in range(N):
        rad= (random.random())*math.pi*2
        dx[i]=math.cos(rad)
        dy[i]=math.sin(rad)
    return x,y,dx,dy

def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i]=(x[i]+dx[i]*d)%W
        y[i]=(y[i]+dy[i]*d)%H

def neighbor_average_direction(x, y, dx, dy, k, R):
    dxav=0
    dyav=0
    for i in range(len(x)):
        if ((x[i]-x[k])**2+(y[i]-y[k])**2)**(0.5)<=R:
            dxav+=dx[i]
            dyav+=dy[i]
            
    siz=(dxav**2+dyav**2)**(0.5)
    dxav=dxav/siz
    dyav=dyav/siz
    
    return dxav, dyav
# 643xxxxx21 179 (2021-09-11 18:56)
def gen_data(N, W, H):
    x,y,dx,dy=[],[],[],[]
    for i in range(N):
      x.append(W*random.random())
      y.append(H*random.random())
      randomed_angle = 2*math.pi*random.random()
      dx.append(math.cos(randomed_angle))
      dy.append(math.sin(randomed_angle))
    return [x,y,dx,dy]

def move_all(x, y, dx, dy, d, W, H):
    #print(x)
    for i in range(len(x)):
      x[i]+=(dx[i]*d)
      if x[i]<0:
          x[i]=W+x[i]
      if x[i]>=W:
          x[i]=x[i]-W
      y[i]+=(dy[i]*d)
      if y[i]<0:
          y[i]=H+y[i]
      if y[i]>=H:
        y[i]=y[i]-H
    return
def neighbor_average_direction(x, y, dx, dy, k, R):
    x_sum,y_sum=0,0
    for i in range(len(x)):
        if ((x[i]-x[k])**2)+((y[i]-y[k])**2)<=(R**2):
            x_sum += dx[i]
            y_sum += dy[i]

    vec_sum = math.sqrt((x_sum**2)+(y_sum**2))
    return [x_sum/vec_sum,y_sum/vec_sum]
# 643xxxxx21 180 (2021-09-10 23:05)
def gen_data(N, W, H):
    x=[]
    for i in range(N):
        a=random.random()*W
        x.append(a)
    y=[]
    for i in range(N):
        b=random.random()*H
        y.append(b)
    dx=[]
    dy=[]
    for i in range(N):
        c=random.random()*2*math.pi
        dx.append(math.cos(c))
        dy.append(math.sin(c))
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        e=d*float(dx[i])
        f=d*float(dy[i])
        if float(x[i])+e>=W:
            x[i]=float(x[i])+e-W
        elif float(x[i])+e<0:
            x[i]=W+float(x[i])+e
        else:
            x[i]=float(x[i])+e
            
        if float(y[i])+f>=H:
            y[i]=float(y[i])+f-H
        elif float(y[i])+f<0:
            y[i]=H+float(y[i])+f
        else:
            y[i]=float(y[i])+f       
def neighbor_average_direction(x, y, dx, dy, k, R):
    g=0
    h=0
    for i in range(len(x)):
        if (float(x[k])-R)<=float(x[i])<=(float(x[k])+R) and (float(y[k])-math.sqrt(R**2-(x[i]-x[k])**2))<=float(y[i])<=(float(y[k])+math.sqrt(R**2-(x[i]-x[k])**2)) :
                                                                                                                     g=g+float(dx[i])
                                                                                                                     h=h+float(dy[i])
                                                                                                                    
                                                                                          
    a=g/math.sqrt(g**2+h**2)
    b=h/math.sqrt(g**2+h**2)                                                                                                                 
    return a,b            

# 643xxxxx21 192 (2021-09-13 17:27)
def gen_data(N, W, H):
    x = [0]*N
    y = [0]*N
    dx = [0]*N
    dy = [0]*N
    i = 0
    while i <= N-1:
        x[i] = W*random.random()
        y[i] = H*random.random()
        u = 2*(math.pi)*random.random()
        dx[i] = math.cos(u)
        dy[i] = math.sin(u)
        i += 1 
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    i = 0
    while i <= len(x)-1:
        x[i] += dx[i]*d
        y[i] += dy[i]*d
        if x[i] < 0 :
            x[i] += W
        elif x[i] >= W :
            x[i] -= W
        if y[i] < 0 :
            y[i] += H
        elif y[i] >= H :
            y[i] -= H
        i += 1
     
def neighbor_average_direction(x, y, dx, dy, k, R):
    ax = 0
    ay = 0
    i = 0
    while i <= len(x)-1:
        if math.sqrt(((x[i] - x[k])**2) + ((y[i] - y[k])**2)) <= R : #ระยะห่างจากนกตัวที่k กับนกตัวที่i ห่างกันไม่เกินR
            ax += dx[i]
            ay += dy[i]
        i += 1
    vt = math.sqrt((ax**2)+(ay**2)) #ขนาดเวกเตอร์
    mx = ax/vt
    my = ay/vt
    return mx,my
# 643xxxxx21 199 (2021-09-13 21:55)
def gen_data(N, W, H):
    x,y,dx,dy = [],[],[],[]
    for i in range(N) :
        x.append(random.random()*W)
        y.append(random.random()*H)
        z = random.random()*2*math.pi
        dx.append(math.cos(z))
        dy.append(math.sin(z))
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = ((x[i]+(d*dx[i]))+W)%W
    for i in range(len(y)):
        y[i] = ((y[i]+(d*dy[i]))+H)%H   
def neighbor_average_direction(x, y, dx, dy, k, R):
    ax = 0
    ay = 0
    n = 0
    for i in range(len(y)):
        if ((x[i]-x[k])**2)+((y[i]-y[k])**2) <=  R**2 :
            ax += dx[i]
            ay += dy[i]
            n +=1
    v = math.sqrt(((ax/n)**2)+((ay/n)**2))
    return ax/(n*v) , ay/(n*v)
# 643xxxxx21 204 (2021-09-13 23:11)
def gen_data(N, W, H):
    x = [0]*N
    y = [0]*N
    dx = [0]*N
    dy = [0]*N
    for i in range(N) :
        mum = random.random()*((math.pi)*2)
        x[i] = random.random()*W
        y[i] = random.random()*H
        dx[i] = math.cos(mum)
        dy[i] = math.sin(mum)
    return x,y,dx,dy
    
def move_all(x, y, dx, dy, d, W, H):

    for i in range(len(x)) : 
        x[i] += dx[i]*d
        if x[i] >= W :
            x[i] = x[i] % W
        elif x[i] < 0 :
            x[i] += W
        
        y[i] += dy[i]*d
        if y[i] >= H :
            y[i] = y[i] % H
        elif y[i] < 0 :
            y[i] += H
def neighbor_average_direction(x, y, dx, dy, k, R):
    z = 0
    X = 0
    Y = 0
    for i in range(len(x)):
        if  math.sqrt((((x[k] - x[i])**2) + ((y[k] - y[i])**2))) <= R :
            X += dx[i]
            Y += dy[i]
    z = ((X**2)+(Y**2))**(1/2)
    
    ansx = X/z
    ansy = Y/z

    return ansx,ansy

# 643xxxxx21 230 (2021-09-13 23:29)
def gen_data(N, W, H):
     x = [0]*N
     y = [0]*N
     dx = [0]*N
     dy = [0]*N
     for i in range(N) :
          x[i] = W*random.random()
          y[i] = H*random.random()
          r = random.random()
          dx[i] = math.cos(r*2*math.pi)
          dy[i] = math.sin(r*2*math.pi)
     return x,y,dx,dy
                 
def move_all(x, y, dx, dy, d, W, H):
     for i in range(len(x)):
        x[i] += dx[i]*d
        y[i] += dy[i]*d
        if x[i] >= W:
            x[i] -= W            
        if x[i] < 0:
            x[i] += W
        if y[i] >= H:
            y[i] -= H
        if y[i] < 0:
            y[i] += H 
def neighbor_average_direction(x, y, dx, dy, k, R): 
         Xs = 0  
         Ys = 0
         for i in range (len(x)) :
           if (x[k]-x[i])**2 + (y[k]-y[i])**2 <= R**2 :
             Xs += dx[i]
             Ys += dy[i]
         mx = Xs / (math.sqrt(Xs**2+Ys**2))
         my = Ys / (math.sqrt(Xs**2+Ys**2))     
         return mx,my
main()
# 643xxxxx21 232 (2021-09-13 21:57)
def gen_data(N, W, H):
    x = [0]*N
    y = [0]*N
    dx = [0]*N
    dy = [0]*N
    c = [0]*N
    for i in range (N) :
        x[i] = random.random()*W
        y[i] = random.random()*H
        c[i] = random.random()*2*math.pi
    for i in range (len(dx)) :
        dx[i] = math.cos(c[i])
    for i in range (len(dy)) :
        dy[i] = math.sin(c[i])
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)) :
        x[i] += dx[i]*d
        if x[i]>=W or x[i]<=0 :
            x[i] %= W
        y[i] += dy[i]*d
        if y[i]>=H or y[i]<=0 :
            y[i] %= H
def neighbor_average_direction(x, y, dx, dy, k, R):
    sdx = 0
    sdy = 0
    c = 0
    for i in range(len(x)):
        if math.sqrt((x[i]-x[k])**2 + (y[i]-y[k])**2) <= R :
            sdx += dx[i]
            sdy += dy[i]
            c += 1
    ex = sdx/c
    ey = sdy/c
    ax = ex/math.sqrt((ex**2)+(ey**2))
    ay = ey/math.sqrt((ex**2)+(ey**2))
    return ax, ay
main()
# 643xxxxx21 242 (2021-09-13 22:39)
def gen_data(N, W, H):
    x = []; y = []; dx = []; dy = []
    for i in range (N):
        posX = random.random() * W;
        posY = random.random() * H;
        x += [posX]; y += [posY];
        theta = float(random.random() * 2 * math.pi)
        dx += [math.cos(theta)]
        dy += [math.sin(theta)]
    return x, y, dx, dy
def move_all(x, y, dx, dy, d, W, H):
    size = len(x)
    for i in range(size):
        _dx = dx[i]; _dy = dy[i];
        if _dx > 0 and _dy > 0: # (0, 90)
            angle = math.atan(_dy/_dx)    
        elif _dx < 0 and _dy > 0: # (90, 180)
            angle = math.pi - math.atan(_dy/-_dx)
        elif _dx < 0 and _dy < 0: # (180, 270)
            angle = math.pi + math.atan(_dy/_dx)    
        elif _dx > 0 and _dy < 0: # (270, 360)
            angle = (2 * math.pi) - math.atan(-_dy/_dx)
        elif _dx == 0 and _dy > 0: # 90
            angle = math.pi/2      
        elif _dx == 0 and _dy < 0: # 270
            angle = (3/2) * math.pi      
        elif _dx < 0 and _dy == 0: # 180
            angle = math.pi     
        else:
            angle = 0
        x[i] = (x[i] + d * math.cos(angle)) % W
        y[i] = (y[i] + d * math.sin(angle)) % H
def neighbor_average_direction(x, y, dx, dy, k, R):
  u = 0; v = 0; n = 0;
  size = len(x);
  for i in range(size):
      if (math.sqrt((x[k] - x[i])**2 + (y[k] - y[i])**2)) <= R:
          u += dx[i]; v += dy[i]
          n += 1
          
  mx = (u/n)/math.sqrt((u/n)**2 + (v/n)**2)
  my = (v/n)/math.sqrt((u/n)**2 + (v/n)**2)
  return mx, my;
main()
# 643xxxxx21 252 (2021-09-13 22:59)
def gen_data(N, W, H):
 x = [0]*N
 y = [0]*N
 dx = [0]*N
 dy = [0]*N
 for i in range(N):
  x[i] = random.random()*W
  y[i] = random.random()*H
  theta = random.random()*(2*math.pi)
  dx[i] = math.cos(theta)
  dy[i] = math.sin(theta)
 return(x,y,dx,dy)
def move_all(x, y, dx, dy, d, W, H):
  for i in range(len(x)):
      x[i] += dx[i]*d
      y[i] += dy[i]*d
      while x[i] >= W:
          x[i] -= W
      while x[i] < 0:
          x[i] += W
      while y[i] >= H:
          y[i] -= H
      while y[i] < 0:
          y[i] += H
def neighbor_average_direction(x, y, dx, dy, k, R):
  N = len(x)
  sx = 0
  sy = 0
  n = 0
  for i in range(N):
    if (x[i] - x[k])**2 + (y[i] - y[k])**2 <= R**2 :
      sx += dx[i]
      sy += dy[i]
      n += 1
  sx /= n
  sy /= n
  s = math.sqrt(sx**2 + sy**2)
  mx = sx / s
  my = sy / s
  return mx, my
# 643xxxxx21 260 (2021-09-13 22:30)
def gen_data(N, W, H):
    x = []
    y = []
    dx = []
    dy = []
    for i in range(N):
        x += [random.random()*W]
        y += [random.random()*H]
        uv = float(random.random()*2*math.pi)
        dx += [math.cos(uv)]
        dy += [math.sin(uv)]
    return x,y,dx,dy

def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        j = x[i] + (dx[i]*d)
        if j >= W:
            j -= W 
        elif j < 0:
            j += W
        k = y[i] + (dy[i]*d)
        if k >= H:
            k -= H
        elif k < 0:
            k += H
        x[i] = j
        y[i] = k


    
def neighbor_average_direction(x, y, dx, dy, k, R):
    dx1 = 0.0
    dy1 = 0.0
   
    for i in range(len(x)):
        if (x[i] - x[k])**2 + (y[i] - y[k])**2 <= R**2:
            dx1 += dx[i]
            dy1 += dy[i]
         
    mx = dx1/(math.sqrt(dx1**2+dy1**2))
    my = dy1/(math.sqrt(dx1**2+dy1**2))
           
    return mx, my

# 643xxxxx21 262 (2021-09-13 23:07)
def gen_data(N, W, H):
    x=[0]*N
    y=[0]*N
    dx=[0]*N
    dy=[0]*N
    for i in range(N) :
        x[i]=random.random()*W
        y[i]=random.random()*H
        ceta = random.random()*(2*math.pi)
        dx[i]=math.cos(ceta)
        dy[i]=math.sin(ceta)
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)) :
        x[i] = x[i]+d*dx[i]
        y[i] = y[i]+d*dy[i]
        if x[i]>=W :
            x[i] = x[i]-W
        elif x[i]<0 :
            x[i] = x[i]+W
        if y[i]>=H :
            y[i] = y[i]-H
        elif y[i]<0 :
            y[i] = y[i]+H
        
        
def neighbor_average_direction(x, y, dx, dy, k, R):
    A = 0
    F = 0
    for i in range(len(x)) :
        if ((x[k]-x[i])**2+(y[k]-y[i])**2)**(0.5) <=R :
         A += dx[i]
         F += dy[i]
    mx = A/((A**2+F**2)**(0.5))
    my = F/((A**2+F**2)**(0.5))
    
    return mx,my
# 643xxxxx21 266 (2021-09-13 23:17)
def gen_data(N, W, H):
   x = [0.0]*N
   y = [0.0]*N
   dx = [0.0]*N
   dy = [0.0]*N 
   for i in range(0,N):
        n = random.random()*2*math.pi
        x[i] = random.random()*W
        y[i] = random.random()*H
        dx[i] = math.cos(n)
        dy[i] = math.sin(n)
   return x,y,dx,dy
        
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(dx)):
        x[i] += dx[i]*d
        y[i] += dy[i]*d
        if x[i]<0 :
            x[i] = W+x[i]
        elif x[i]>=W:
            x[i] = x[i]-W
        if y[i]<0:
            y[i] = H+y[i]
        elif y[i]>=H:
            y[i] = y[i]-H
    return x,y,dx,dy
            
def neighbor_average_direction(x, y, dx, dy, k, R):
    a = 0
    b = 0
    n = 0
    for i in range(len(dx)):
        if math.sqrt((x[k]-x[i])**2+(y[k]-y[i])**2)<=R:
               a += dx[i]
               b += dy[i]
               n += 1
               mx = a/n
               my = b/n
    c = math.sqrt(mx**2+my**2)
    
               
    return mx/c,my/c
            
main()
# 643xxxxx21 274 (2021-09-13 22:39)
def gen_data(N, W, H):
    x = [0.0]*N
    y = [0.0]*N
    dx = [0.0]*N
    dy = [0.0]*N
    for i in range(N):
        x[i] = random.random()*W
        y[i] = random.random()*H
        a = random.random()*(2*math.pi)
        dx[i] = math.cos(a)
        dy[i] = math.sin(a)
    return x,y,dx,dy
    
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = x[i]+(dx[i]*d)
        y[i] = y[i]+(dy[i]*d)
        if x[i] < 0:
            x[i] = W + x[i] 
        elif x[i] >= W:
            x[i] = x[i] - W
        if y[i] < 0:
            y[i] = H + y[i] 
        elif y[i] >= H:
            y[i] = y[i] - H
            
def neighbor_average_direction(x, y, dx, dy, k, R):
    u = 0
    v = 0
    for i in range(len(x)):
        if math.sqrt((x[i]-x[k])**2+(y[i]-y[k])**2) <= R:
            u += dx[i]
            v += dy[i]
    mx = u/(u**2+v**2)**(1/2)
    my = v/(u**2+v**2)**(1/2)
    return mx,my
# 643xxxxx21 279 (2021-09-13 22:12)
def gen_data(N, W, H):
    x = [0.0]*N
    y = [0.0]*N
    dx = [0.0]*N
    dy = [0.0]*N
    for i in range (0,N):
        x[i] = random.random()*W
        y[i] = random.random()*H
        u = (random.random()*(2)*math.pi)
        dx[i] = math.cos(u)
        dy[i] = math.sin(u)
    return x,y,dx,dy
        
        #-------------------------------------------
def move_all(x, y, dx, dy, d, W, H):
    for i in range (0,len(dx)) :
        x[i] = x[i] + dx[i]*d
        y[i] = y[i] + dy[i]*d
        if x[i]>=W  :
            x[i] = x[i]-W 
        elif x[i]<0 :
            x[i] = x[i]+W 
        if y[i]>=H  :
            y[i] = y[i]-H
        elif y[i]<0 :
            y[i] = y[i]+H
    
def neighbor_average_direction(x, y, dx, dy, k, R):
    h = 0
    g = 0
    for i in range (0,len(dy)) :
        if math.sqrt(((x[k]-x[i])**2+(y[k]-y[i])**2)) <= R :
            h += dx[i]
            g += dy[i]
    mx = h/math.sqrt((h**2+g**2))
    my = g/math.sqrt((h**2+g**2))
            
    return mx,my

# 643xxxxx21 290 (2021-09-12 04:19)
def gen_data(N, W, H):
    x = [1]*N
    y = [1]*N
    dx = [1]*N
    dy = [1]*N
    for i in range(N) :
        s = random.random()*2*math.pi
        dx[i] = math.cos(s)
        dy[i] = math.sin(s)
        x[i] = random.random()*W
        y[i] = random.random()*H
    return x , y , dx , dy

def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = x[i]+(d*dx[i])
        y[i] = y[i]+(d*dy[i])
        if x[i] >= W :
            x[i] -= W
        if x[i] < 0 :
            x[i] += W
        if y[i] >= H :
            y[i] -= H
        if y[i] < 0 :
            y[i] += H

def neighbor_average_direction(x, y, dx, dy, k, R):
    n = 0
    nbx = [0]*len(x)
    nby = [0]*len(x)
    for i in range(len(x)):
       a = math.sqrt((y[k]-y[i])**2 + (x[k]-x[i])**2)
       
       if a<=R :
          nbx[i] = dx[i]
          nby[i] = dy[i]
          n += 1
    sdx = 0
    sdy = 0
    b = 1   
    for i in range(len(x)):
          sdx += nbx[i]
          sdy += nby[i]
          b += 1
    V = math.sqrt(sdx**2 + sdy**2)
    mx = sdx/V
    my = sdy/V
    return mx,my

# 643xxxxx21 291 (2021-09-13 01:37)
def gen_data(N, W, H):
    x = [0]*N
    y = [0]*N
    dx = [0]*N
    dy = [0]*N
    for i in range(0,N):
        an = random.random()*(2*math.pi)
        x[i] = random.random()*W
        y[i] = random.random()*H
        dx[i] = math.cos(an)
        dy[i] = math.sin(an)
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = x[i]+(d*dx[i])
        y[i] = y[i]+(d*dy[i])
        if x[i] >= W:
            x[i] -= W
        if x[i] < 0:
            x[i] += W
        if y[i] >= H:
            y[i] -= H
        if y[i] < 0:
            y[i] += H
def neighbor_average_direction(x, y, dx, dy, k, R):
    nbx = [0]*len(x)
    nby = [0]*len(x)
    for i in range(len(x)):
        a = math.sqrt((y[k]-y[i])**2 + (x[k]-x[i])**2)
        if a<=R:
            nbx[i] = dx[i]
            nby[i] = dy[i]
    sdx = 0
    sdy = 0
    for i in range(len(x)):
        sdx += nbx[i]
        sdy += nby[i]
    c = math.sqrt(sdx**2+sdy**2)
    mx = sdx/c
    my = sdy/c
    return mx,my
# 643xxxxx21 293 (2021-09-12 19:22)
def gen_data(N, W, H):
    x=[]
    y=[]
    dx=[]
    dy=[]
    for i in range(N):
        x+=[random.random()*W]
        y+=[random.random()*H]
        a=2*random.random()*math.pi
        dx+=[math.cos(a)]
        dy+=[math.sin(a)]
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for w in range(len(x)):
        x[w]=((x[w]+W)+dx[w]*d)%W
        y[w]=((y[w]+H)+dy[w]*d)%H
        
        


def neighbor_average_direction(x, y, dx, dy, k, R):
    q=0
    v=0
    for i in range(len(x)):
        if (x[k]-x[i])**2+(y[k]-y[i])**2<=R**2:
            q+=dx[i]
            v+=dy[i]
    m=q/(math.sqrt(q**(2)+v**(2)))
    n=v/(math.sqrt(q**(2)+v**(2)))
    return m,n
    
    

main()
# 643xxxxx21 294 (2021-09-12 22:49)
def gen_data(N, W, H):
    x=[]
    y=[]
    dx=[]
    dy=[]
    for i in range(N):        
        x += [random.random()*W]
        y += [random.random()*H]
        o = (math.radians(random.random()*360))
        dx += [math.cos(o)]
        dy += [math.sin(o)]
    return x,y,dx,dy 
def move_all(x, y, dx, dy, d, W, H):
    for j in range(len(dx)): 
        if d*dx[j]+x[j] >= W:              
            x[j]=d*dx[j]+x[j]-W
        elif d*dx[j]+x[j] < 0:
            x[j]=W+(d*dx[j]+x[j])
        elif 0<=d*dx[j]+x[j]<W:
            x[j]=d*dx[j]+x[j]
        if d*dy[j]+y[j] >= H:              
            y[j]=d*dy[j]+y[j]-H
        elif d*dy[j]+y[j] < 0:
            y[j]=H+(d*dy[j]+y[j])
        elif 0<=d*dy[j]+y[j]<H:
            y[j]=d*dy[j]+y[j]       
def neighbor_average_direction(x, y, dx, dy, k, R):
    a=0.0
    b=0.0
    for i in range(len(dx)):
        if R**2 >= (x[k]-x[i])**2+(y[k]-y[i])**2:
            a += dx[i]
            b += dy[i]
    a = a/len(dx) ; b = b/len(dy) 
    c = math.sqrt(a**2 + b**2)
    mx = a/c
    my = b/c
    return mx,my               
main()
# 643xxxxx21 295 (2021-09-13 23:24)
def gen_data(N, W, H):
    x=[]
    y=[]
    dx=[]
    dy=[]
    for i in range(N):
        co_x= random.random()*W
        co_y= random.random()*H
        theta=random.random()*(2*math.pi)
        unx=math.cos(theta)
        uny=math.sin(theta)
        x.append(co_x)
        y.append(co_y)
        dx.append(unx)
        dy.append(uny)
    
    return x,y,dx,dy


def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i]+=d*dx[i]
        y[i]+=d*dy[i]
        if W <= x[i] :
            x[i]-=W
        if x[i] < 0 :
            x[i]+=W
        if H <= y[i] :
            y[i]-=H
        if y[i] < 0 :
            y[i]+=H
def neighbor_average_direction(x, y, dx, dy, k, R):
    n=0
    sumdx = 0
    sumdy = 0
    for i in range(len(x)):
        if math.sqrt( (x[i]-x[k])**2 + (y[i]-y[k])**2 ) <= R :
            n+=1
            sumdx += dx[i]
            sumdy += dy[i]
    N = n
    avgdx = (sumdx/N)/math.sqrt(((sumdx/N)**2) + (sumdy/N)**2)
    avgdy = (sumdy/N)/math.sqrt(((sumdy/N)**2) + (sumdx/N)**2)
    
    return avgdx,avgdy
# 643xxxxx21 308 (2021-09-13 20:00)
def gen_data(N, W, H):
    x=[0]*N
    y=[0]*N
    dx=[0]*N
    dy=[0]*N
    i=0
    for i in range(0,int(N)):
        x[i] = W*random.random()
        y[i] = H*random.random()
        k=random.random()
        dx[i]=math.sin((2*math.pi)*k)
        dy[i]=math.cos((2*math.pi)*k)
    return x,y,dx,dy
          
def move_all(x, y, dx, dy, d, W, H):
    i=0
    for i in range(0,len(x)):
        x[i] += dx[i]*d
        y[i] += dy[i]*d
        if x[i] >= W:
            x[i]-=W
        if x[i]< 0 :
            x[i]+=W
        if y[i] >=H:
            y[i]-=H
        if y[i]< 0 :
            y[i]+=H
def neighbor_average_direction(x, y, dx, dy, k, R):
    i=0
    sum_dx=0
    sum_dy=0
    for i in range(0,len(x)) :
        if ((x[i]-x[k])**2)+((y[i]-y[k])**2) <= R**2 :
            sum_dx+=dx[i]
            sum_dy+=dy[i]
    sum_direction= (((sum_dx)**2)+((sum_dy)**2))**(1/2)
    mx=sum_dx/sum_direction
    my=sum_dy/sum_direction
    return mx,my
# 643xxxxx21 323 (2021-09-13 23:19)
def gen_data(N, W, H):
 x = []
 y = []
 dx = []
 dy = []
 for i in range(N):
        x.append(random.random()*W)
        y.append(random.random()*H)
        zeta = random.random()*2*(math.pi)
        dx.append(math.cos(zeta))
        dy.append(math.sin(zeta))
 return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = (x[i] + dx[i] * d)%W
        y[i] = (y[i] + dy[i] * d)%H
def neighbor_average_direction(x, y, dx, dy, k, R):
    sum_dx = 0
    sum_dy = 0
    n = 0
    for i in range(len(x)):
        if (x[k] - x[i])**2 + (y[k] - y[i])**2 <= R**2 :
        
            n+=1
            sum_dx += dx[i]
            sum_dy += dy[i]
    m = (sum_dx**2 + sum_dy**2)**0.5
    return sum_dx/m,sum_dy/m

main()
# 643xxxxx21 324 (2021-09-13 02:10)
def gen_data(N, W, H):
    x=[0.0]*N
    y=[0.0]*N
    dx=[0.0]*N
    dy=[0.0]*N
    for i in range(N):
        s=random.random()*(2*math.pi)
        x[i] = random.random()*W
        y[i] = random.random()*H
        dx[i] = math.cos(s)
        dy[i] = math.sin(s)
    return x,y,dx,dy
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] = x[i]+dx[i]*d
        if x[i] <= 0:
            x[i] = x[i]+W
        else:
            x[i]=x[i]
        if x[i] >= W:
            x[i]=x[i]-W
        else:
            pass
    for i in range(len(y)):
        y[i] = y[i]+dy[i]*d
        if y[i] <= 0:
            y[i]=y[i]+H
        else:
            y[i]=y[i]
        if y[i] >= H:
            y[i]=y[i]-H
        else:
            pass
        
def neighbor_average_direction(x, y, dx, dy, k, R):
    listx = [0.0]*len(x)
    listy = [0.0]*len(y)
    for i in range(len(x)):
        if math.sqrt(((x[k]-x[i])**2)+((y[k]-y[i])**2)) <= R:
            listx[i] = dx[i]
    for i in range(len(y)):
        if math.sqrt(((x[k]-x[i])**2)+((y[k]-y[i])**2)) <= R:
            listy[i] = dy[i]
    equalx = sum(listx)
    equaly = sum(listy)
    total = math.sqrt((equalx**2)+(equaly**2))
    meanx = (equalx/total)
    meany = (equaly/total)
    return meanx,meany

# 643xxxxx21 338 (2021-09-13 18:44)
def gen_data(N, W, H):
 x = []
 y = []
 dx = []
 dy = []
 for i in range(N):
     x.append(random.random()*W)
     y.append(random.random()*H)
     d = random.random()*2*math.pi
     dx.append(math.cos(d))
     dy.append(math.sin(d)) 
 return x,y,dx,dy

def move_all(x, y, dx, dy, d, W, H):
 for i in range(len(x)):
     x[i] = x[i] + dx[i]*d
     x[i] = x[i]%W
     y[i] = y[i] + dy[i]*d
     y[i] = y[i]%H
def neighbor_average_direction(x, y, dx, dy, k, R):
 Sx = 0
 Sy = 0
 n = 0
 for i in range(len(x)):
     if(((x[i]-x[k])**2)+((y[i]-y[k])**2)) <= (R**2):
         n += 1
         Sx += dx[i]
         Sy += dy[i]
 mx = Sx/n
 my = Sy/n
 D = (mx**2+my**2)**(0.5)
 V1 = mx/D
 V2 = my/D
 return V1,V2

# 643xxxxx21 351 (2021-09-13 21:43)
def gen_data(N, W, H):
    x = [0.0]*N
    y = [0.0]*N
    dx = [0.0]*N
    dy = [0.0]*N
    for i in range(N):
        x[i] = random.random()*W
        y[i] = random.random()*H
        k = random.random()*(math.pi*2)
        dx[i] = math.sin(k)
        dy[i] = math.cos(k)
    return x,y,dx,dy
          
def move_all(x, y, dx, dy, d, W, H):
    for i in range(len(x)):
        x[i] += (d*dx[i])
        if x[i] < 0:
            x[i] += W
        elif x[i] > W:
            x[i] -= W
        elif x[i] == W:
            x[i] = 0
    for i in range(len(y)):
        y[i] += (d*dy[i])
        if y[i] < 0:
            y[i] += H
        elif y[i] > H:
            y[i] -= H
        elif y[i] == H:
            y[i] = 0
    
        
def neighbor_average_direction(x, y, dx, dy, k, R):
    u = 0 ; p = 0 ; v = 0; q = 0
    for i in range(len(x)):
        if ((abs(x[k] - x[i]))**2 \
           + (abs(y[k] - y[i]))**2)**0.5 <= R:
            u += dx[i]
            p += 1
            v += dy[i]
            q += 1
    mx = (u/p)/((((u/p)**2)+((v/q))**2)**0.5)
    my = (v/q)/((((u/p)**2)+((v/q))**2)**0.5)
    
    return mx, my
# 643xxxxx21 354 (2021-09-13 20:53)
def gen_data(N, W, H):

    a=[]
    b=[]
    da=[]
    db=[]
    p = math.pi
    for i in range(0,N):
        a.append(random.random()*W)
        b.append(random.random()*H)
        x = random.random()*2*p
        da.append(math.cos(x))
        db.append(math.sin(x))
    return a, b, da, db
def move_all(x, y, dx, dy, d, W, H):

    for i in range(0, len(x)):
       
        if x[i]+d*dx[i] >= W:
            x[i] = (x[i]+d*dx[i]) % W
        elif x[i]+d*dx[i] <= 0:
            x[i] = (x[i]+d*dx[i]) % W
        else :
            x[i] = x[i]+d*dx[i]
        if y[i]+d*dy[i] >= H:
            y[i] = (y[i]+d*dy[i]) % H
        elif y[i]+d*dy[i] <= 0:
            y[i] = (y[i]+d*dy[i]) % H
        else :
            y[i] = y[i]+d*dy[i]
def neighbor_average_direction(x, y, dx, dy, k, R):

    sum_dx = 0
    sum_dy = 0
    for i in range(len(x)):
        dis_x = (x[i]-x[k])**2
        dis_y = (y[i]-y[k])**2
        if (math.sqrt(dis_x + dis_y)) <= R:
            sum_dx += dx[i]
            sum_dy += dy[i]
            

    value_vec = math.sqrt((sum_dx**2 + sum_dy**2))
    av_dx = sum_dx/value_vec
    av_dy = sum_dy/value_vec
    return av_dx, av_dy