需要将Python编写的好友推荐算法转换为Fortran 90/95

Question

我正在尝试自己写一个“朋友的朋友”算法。这种算法处理一组三维数据点，并返回数据集中“光环”的数量。每个光环是指那些距离小于链接长度b的点的集合，而链接长度是这个程序唯一的参数。

算法描述： FOF算法有一个自由参数，叫做链接长度。任何两个粒子，如果它们之间的距离小于或等于链接长度，就被称为“朋友”。FOF组是由一组粒子组成的，这组粒子中的每一个都通过朋友网络与组内的其他粒子相连。

设置FOF组计数器j=1。

对于每个尚未与任何组关联的粒子n：
将n分配到组j，为组j初始化一个新的成员列表mlist，粒子n作为第一个条目，
递归地，对于mlist中的每个新粒子p：
找到距离p小于或等于链接长度的邻居，将那些尚未分配到组j的粒子添加到mlist中，
记录组j的mlist，设置j=j+1。

这是我尝试编写算法的代码。我最熟悉的语言是Python。不过，我需要将这段代码用Fortran写，或者让它运行得更快。我真的希望有人能帮我。

首先，我生成了一组点，应该模拟出3个光环的存在：

import random
from random import *
import math
from math import *
import numpy
from numpy import *
import time

points = 1000

halos=[0,100.,150.]

x=[]
y=[]
z=[]
id=[]
for i in arange(0,points,1):
   x.append(halos[0]+random())
   y.append(halos[0]+random())
   z.append(halos[0]+random())
   id.append(i)

for i in arange(points,points*2,1):
   x.append(halos[1]+random())
   y.append(halos[1]+random())
   z.append(halos[1]+random())
   id.append(i)

for i in arange(points*2,points*3,1):
   x.append(halos[2]+random())
   y.append(halos[2]+random())
   z.append(halos[2]+random())
   id.append(i)

然后我编写了FOF算法：

  x=array(x)
  y=array(y)
  z=array(z)
  id=array(id)

  t0 = time.time()                         

  id_grp=[]
  groups=zeros((len(x),1)).tolist()
  particles=id
  b=1 # linking length
  while len(particles)>0:
  index = particles[0]
  # remove the particle from the particles list
  particles.remove(index)
  groups[index]=[index]
  print "#N ", index
  dx=x-x[index]
  dy=y-y[index]
  dz=z-z[index]
  dr=sqrt(dx**2.+dy**2.+dz**2.)
  id_to_look = where(dr<b)[0].tolist()
  id_to_look.remove(index)
  nlist = id_to_look
  # remove all the neighbors from the particles list
  for i in nlist:
        if (i in particles):
           particles.remove(i)
  print "--> neighbors", nlist
  groups[index]=groups[index]+nlist
  new_nlist = nlist
  while len(new_nlist)>0:
          index_n = new_nlist[0]
          new_nlist.remove(index_n)
          print "----> neigh", index_n
          dx=x-x[index_n]
          dy=y-y[index_n]
          dz=z-z[index_n]
          dr=sqrt(dx**2.+dy**2.+dz**2.)
          id_to_look = where(dr<b)[0].tolist()
          id_to_look = list(set(id_to_look) & set(particles))
          nlist = id_to_look
          if (len(nlist)==0):
             print "No new neighbors found"
          else:
             groups[index]=groups[index]+nlist
             new_nlist=new_nlist+nlist
             print "------> neigh-neigh", new_nlist
             for k in nlist:
               particles.remove(k)

最后，我们会得到一个包含光环的列表，存储在groups中。

这部分代码有点偏题，但我觉得展示给你们看也不错。我基本上是在删除所有没有粒子的组，按照粒子的数量进行排序，并展示一些属性。

  def select(test,list):
  selected = []
  for item in list:
    if test(item) == True:
      selected.append(item)
  return selected

  groups=select(lambda x: sum(x)>0.,groups)
  # sorting groups
  groups.sort(lambda x,y: cmp(len(x),len(y)))
  groups.reverse()

  print time.time() - t0, "seconds"

  mass=x
  for i in arange(0,len(groups),1):
    total_mass=sum([mass[j] for j in groups[i]])
    x_cm = sum([mass[j]*x[j] for j in groups[i]])/total_mass
    y_cm = sum([mass[j]*y[j] for j in groups[i]])/total_mass
    z_cm = sum([mass[j]*z[j] for j in groups[i]])/total_mass
    dummy_x_cm = [x[j]-x_cm for j in groups[i]]
    dummy_y_cm = [y[j]-y_cm for j in groups[i]]
    dummy_z_cm = [z[j]-z_cm for j in groups[i]]
    dummy_x_cm = array(dummy_x_cm)
    dummy_y_cm = array(dummy_y_cm)
    dummy_z_cm = array(dummy_z_cm)
    dr = max(sqrt(dummy_x_cm**2.+dummy_y_cm**2.+dummy_z_cm**2.))
    dummy_x_cm = max(dummy_x_cm)
    dummy_y_cm = max(dummy_y_cm)
    dummy_z_cm = max(dummy_z_cm)
    print i, len(groups[i]), x_cm, y_cm, z_cm,dummy_x_cm,dummy_y_cm,dummy_z_cm

数据处理递归算法 fortran 三维数据好友推荐算法链接长度粒子群体 FOF算法

需要将Python编写的好友推荐算法转换为Fortran 90/95

3 个回答

撰写回答