精华内容
下载资源
问答
  • 这是一个在 Android 生态系统中针对 Twitarr 实例制作通知的非常快速的示例项目。 有关更多信息,请参阅页面。 为什么不使用而不是轮询? 因为在 Cruise(整个 Twitarr 点)上,我们无法访问互联网。 警告 使用此...
  • 作为 Amethyst 引擎的官方展示项目,逐步设计和开发的微生态系统模拟游戏。 游戏的当前迭代(v0.2 及更高版本)模拟了几不同的物种占据相同的有限空间。 有关当前游戏设计以及迄今为止我们的目标和历史的更多信息...
  • 行业分类-作业装置- 种美观型生态制作工艺和控制系统.zip
  • 模拟生态系统

    2007-12-08 22:36:52
    本软件用vc++6.0制作!用来学习用...
  • 它旨在将各种最佳实践(例如代码可重用性,迭代开发,内容优先方法和模块化,响应式内容编辑)组合到一个一致的生态系统中。 有关更多信息,请访问: : 项目结构 Romanesco当前包含至少5个存储库: Romanesco...
  • python模拟生态系统

    千次阅读 2019-06-28 08:50:23
    基于matplotlib库下animation、pyplot功能进行的一个生态的模拟程序,参考了一些网上可视化的教程和生态模拟的参数。在本程序中由4种东西构成生态系统,草、草食动物、肉食动物、空地,使用了搜索的算法、random函数...

    基于matplotlib库下animation、pyplot功能进行的一个生态的模拟程序,参考了一些网上可视化的教程和生态模拟的参数。在本程序中由4种东西构成生态系统,草、草食动物、肉食动物、空地,使用了搜索的算法、random函数来模拟动物进食关系,以及动物的捕食动向,最后通过times间隔每秒展示出animation动态图的画面。

    import matplotlib
    import matplotlib.pyplot as plt
    import matplotlib.animation as animation
    import numpy as np
    
    
    def addGrass(_num):
        for i in range(_num):
            x = np.random.randint(0, size)
            y = np.random.randint(0, size)
            while grid[x][y] != 0:
                x = np.random.randint(0, size)
                y = np.random.randint(0, size)
    
            grid[x][y] = 1  # 1代表草
    
    
    def addGrassEater(_num):
        for i in range(_num):
            x = np.random.randint(0, size)
            y = np.random.randint(0, size)
            while grid[x][y] != 0:
                x = np.random.randint(0, size)
                y = np.random.randint(0, size)
    
            grid[x][y] = 2  # 2代表食草动物
    
    
    def addMeatEater(_num):
        for i in range(_num):
            x = np.random.randint(0, size)
            y = np.random.randint(0, size)
            while grid[x][y] != 0 or growAround(x, y, 2) == [-1, -1]:
                x = np.random.randint(0, size)
                y = np.random.randint(0, size)
    
            grid[x][y] = 3  # 3代表食肉动物
    
    
    def growAround(_x, _y, _id):
        field = []
        if _x-1 < 0:
            x_begin = 0
        else:
            x_begin = _x-1
        if _y-1 < 0:
            y_begin = 0
        else:
            y_begin = _y-1
        if _x+1 > size-1:
            x_end = size-1
        else:
            x_end = _x+1
        if _y+1 > size-1:
            y_end = size-1
        else:
            y_end = _y+1
    
        for i in range(x_begin, x_end+1):
            for j in range(y_begin, y_end+1):
                if grid[i][j] == _id or grid[i][j] == _id*10:  # 2代表食草动物,1代表草,0代表空地
                    field += [[i, j]]
    
        if len(field) == 0:  # 没有食物或者空地
            return [-1, -1]
        else:
            count = np.random.randint(0, len(field))
            return field[count]
    
    
    def fieldUpdate():
        for i in range(size):
            for j in range(size):
                if grid[i][j] == 30:
                    grid[i][j] = 3
                elif grid[i][j] == 20:
                    grid[i][j] = 2
                elif grid[i][j] == 10:
                    grid[i][j] = 1
    
    
    def data_gen():
        for count in range(times):
            timesText.set_text('times: %d' % (count+1))
            for i in range(size):
                for j in range(size):
                    if grid[i][j] == 3:
                        place = growAround(i, j, 2)
                        if place == [-1, -1]:
                            grid[i][j] = 0  # 食肉动物死亡
                        else:
                            grid[i][j] = 0
                            grid[place[0]][place[1]] = 30  # 食肉动物进食并移动
                            growth = growAround(i, j, 0)
                            if growth != [-1, -1]:
                                grid[growth[0]][growth[1]] = 30  # 食肉动物繁殖
    
                    if grid[i][j] == 2:
                        place = growAround(i, j, 1)
                        if place == [-1, -1]:
                            grid[i][j] = 0  # 食草动物死亡
                        else:
                            grid[i][j] = 0
                            grid[place[0]][place[1]] = 20  # 食草动物进食并移动
                            growth = growAround(i, j, 0)
                            if growth != [-1, -1]:
                                grid[growth[0]][growth[1]] = 20  # 食草动物繁殖
    
                    elif grid[i][j] == 1:
                        growth = growAround(i, j, 0)
                        if growth != [-1, -1]:
                            grid[growth[0]][growth[1]] = 10  # 草生长
    
            fieldUpdate()
           
            yield grid
    
    
    def update(_data):
        ax.imshow(_data, interpolation='nearest', cmap='Set3', norm=norm)
        return ax
    
    times = 100  # 迭代次数
    size = 40
    grid = np.zeros((size, size))  # 0代表空地
    addGrass(1200)
    addGrassEater(150)
    addMeatEater(30)
    
    fig = plt.figure()
    ax = plt.subplot(111)
    norm = matplotlib.colors.Normalize(vmin=0, vmax=3)  # 固定数值对应的颜色映射
    gci = ax.imshow(grid, interpolation='nearest', cmap='Set3', norm=norm)
    ax.set_xticks([])
    ax.set_yticks([])
    cbar = plt.colorbar(gci)
    cbar.set_ticks(np.linspace(0, 3, 4))
    cbar.set_ticklabels(('Space', 'Grass', 'GrassEater', 'MeatEater'))
    timesText = plt.text(-2, -2, 'times: 0') 
    ani = animation.FuncAnimation(fig, update, data_gen, interval=1000, repeat=False)
    
    plt.show()
    

     

    展开全文
  • Ecosystems是一个旨在生成随机交互式3d世界的项目。 这些世界通过使用IMAC工学院3年级AI课程中看到的算法得以实现。 强烈建议使用PC版的Chrome,以获得最佳体验。
  • Processing 模拟池塘生态系统

    千次阅读 2019-04-30 19:24:40
    生态系统 processing

    博文简介

    使用Processing实现了简单的池塘生态系统。
    主要是鱼——水蚤——水草三类生物的行为。
    关键技术是遗传算法和自治智能体

    生物知识

    生态系统

    生态系统指在自然界的一定的空间内,生物与环境构成的统一整体,在这个统一整体中,生物与环境之间相互影响、相互制约,并在一定时期内处于相对稳定的动态平衡状态。

    组成成分:非生物的物质和能量、生产者、消费者、分解者。

    这里模拟了简单的池塘生态系统。忽略掉非生物的物质和能量,还有分解者。只有 生产者–水草、低级消费者–水蚤(以水草为食)、高级消费者–鱼(以水蚤为食)

    核心规则:
    1、·能量传递的过程中逐级递减,传递率为10%~20%
    这点问题不大,简单来说就是 鱼:水蚤:水草 =100:10:1,当然实际上没有这么简单,实现的过程中没有严格按照这点,大概就是注意鱼的数量少于水蚤少于水草,并且鱼的寿命大于水蚤大于水草,生命值也不同。
    2、生物进化
    这里用到了遗传算法,实现这点的方法是寿命,生物活得越久繁殖概率越大,DNA也就会传递下去
    3、动态平衡
    生态系统通常具有自我调节能力,可以实现动态平衡。

    生物进化和动态平衡在实现的过程中都出现了问题,比我一开始想的出入很大,在下文 问题与思考 中详细阐述。

    实现内容

    DNA
    寿命 (有最大最小限制)
    速度 (进化需有一定随机性 、突变性)
    大小

    交叉
    复制
    变异

    水草:
    生命值(被吃会变透明)
    寿命
    大小(与寿命相关)
    速度

    死亡
    无性繁殖
    种子扩散
    有微弱的移动能力

    水蚤(指低级消费者):
    寿命(性成熟)
    性别
    大小
    速度

    躲避行为(躲鱼)
    寻偶
    群集行为(主要是对齐)
    吸收养分(吃植物)
    有性繁殖

    鱼(指高级消费者):
    寿命(性成熟)
    性别
    大小
    速度
    性别
    大小

    捕食(追水蚤)
    寻偶
    群集行为(主要是分离)
    吸收养分(吃虾)
    有性繁殖

    效果展示

    完整视频:https://www.bilibili.com/video/av50958125
    在这里插入图片描述

    操作说明

    可以通过单击鼠标左键、右键、滑轮添加鱼、水蚤、水草,或单击左上角得“-”号减少
    拖拽可以持续生成(后期生物过多,单击生成减少太慢)
    通过交互人为调节生态平衡。

    相关类

    类间关系如图
    在这里插入图片描述

    下面是各类的域和方法,具体实现和全部代码见 https://github.com/sssal/EcoSystem

    主类

    World world;
    
    Boolean isOpenIntroduce;
    void setup() {
      size(800, 600);
      frameRate(60);
    
      world = new World(100, 20, 0);
      textFont(createFont("KaiTi-48.vlw", 48));
      isOpenIntroduce = true;
    }
    
    void draw() {
      background(200);
    
      world.update();
    
      textSize(15);
      fill(50);
      text("Plants:" + (int)world.getPlantNum(), 20, 20);
      text("Fishes:" + (int)world.getFishNum(), 20, 40);
      text("Fleas:" + (int)world.getFleaNum(), 20, 60);
      rect(100, 7, 20, 12);
      rect(100, 27, 20, 12);
      rect(100, 47, 20, 12);
      fill(250);
      rect(105, 12, 10, 3);
      rect(105, 32, 10, 3);
      rect(105, 52, 10, 3);
    
      //说明界面
      if (isOpenIntroduce) {
        fill(0, 200);
        rect(width/4, height/4, width/2, height/2, 20);
        textSize(30);
        fill(250);
        text("说明", width/2-50, height/4+40);
        textSize(20);
        text("按 “ i ” 退出/显示说明界面", width/4+20, height/4+70);
        text("左上角表示示植物、水蚤、鱼数量", width/4+20, height/4+100);
        text("鼠标单击左键生成鱼,右键水蚤,中键植物", width/4+20, height/4+130);
        text("鼠标拖拽持续生成",width/4+20,height/4+160);
        text("鼠标单击左上角“-”减少",width/4+20,height/4+190);
        text("鼠标在左上角“-”处拖拽持续减少",width/4+20,height/4+220);
    }
    }
    
    void mouseDragged() {
      //print(0);
      if (mouseX>100&&mouseX<120&&mouseY>7&&mouseY<19) {
        world.reducePlant();
      } else if (mouseX>100&&mouseX<120&&mouseY>27&&mouseY<39) {
        world.reduceFish();
      } else if (mouseX>100&&mouseX<120&&mouseY>47&&mouseY<59) {
        world.reduceFlea();
      } else {
        if (mouseButton == LEFT) {
          print(1);
          world.addFish(new PVector(mouseX, mouseY));
        } else if (mouseButton == RIGHT) {
          world.addFlea(new PVector(mouseX, mouseY));
        } else if (mouseButton == CENTER) {
          world.addPlant(new PVector(mouseX, mouseY));
        }
      }
    }
    
    void mouseClicked() {
      //print(0);
      if (mouseX>100&&mouseX<120&&mouseY>7&&mouseY<19) {
        world.reducePlant();
      } else if (mouseX>100&&mouseX<120&&mouseY>27&&mouseY<39) {
        world.reduceFish();
      } else if (mouseX>100&&mouseX<120&&mouseY>47&&mouseY<59) {
        world.reduceFlea();
      } else {
        if (mouseButton == LEFT) {
          print(1);
          world.addFish(new PVector(mouseX, mouseY));
        } else if (mouseButton == RIGHT) {
          world.addFlea(new PVector(mouseX, mouseY));
        } else if (mouseButton == CENTER) {
          world.addPlant(new PVector(mouseX, mouseY));
        }
      }
    }
    
    void keyPressed() {
      if (key == 'i') {
        if (isOpenIntroduce) {
          isOpenIntroduce = false;
        } else {
          isOpenIntroduce = true;
        }
      }
    }
    
    class World {
      ArrayList<Flea> fleas;
      ArrayList<Plant> plants;
      ArrayList<Fish> fishes;
    
      World(int plantsNum, int fleasNum, int fishNum) 
      void update() 
      float getFishNum() 
      float getFleaNum()
      float getPlantNum() 
      void addFish(PVector pvector) 
      void addFlea(PVector pvector)
      void addPlant(PVector pvector) 
      void reduceFish() 
      void reducePlant()
      void reduceFlea() 
    }
    
    class Creature {
      //生物类 所有生物的父类
      PVector position;  //位置
      PVector acceleration; //加速度
      PVector velocity;  //速度
    
      float lifetime;     //寿命 
      float maxspeed;     //速度
      float maxforce;    //转向力
      float size;         //大小
      float r;            //画图大小
    
      float maxLifetime; //用来保存生物的最大生命和尺寸
      float maxSize;     
      float health;      //生命值
      float maxHealth;
    
      DNA dna;          
      DNA fatherDNA;
    
      //设置不同行为的权重
      float separateWeight;
      float cohesionWeight;
      float alignWeight;
    
      float breedProbability; //繁殖概率
      float matingProbability; //交配概率
    
      float xoff;
      float yoff;  //控制随机移动速度
    
      float periphery = PI/2; //视野角度
    
      Boolean gender;  //性别
      Boolean isRut;   //是否处于发情期
      Boolean isPregnancy; //怀孕
    
      color col;      //颜色
    
      Creature(PVector pos, DNA initDNA)
      //更新
      void update()
      //移动
      void move() 
      //画图
      void display() 
      //添加力改变加速度
      void applyForce(PVector force)
      //三种群集规则
      //分离  避免碰撞
      //对齐  转向力与邻居一致
      //聚集  朝邻居中心转向 (留在群体内)
      void flock(ArrayList<? extends Creature> Creatures) 
      //寻找
      PVector seek(PVector target) 
      // Cohesion 聚集行为
      PVector cohesion (ArrayList<? extends Creature> creatures) 
      //分离行为
      PVector separate (ArrayList<? extends Creature> creatures) 
      //对齐行为
      PVector align (ArrayList<? extends Creature> creatures)  
      //设置发情期
      void rut()
      //寻偶
      PVector mating(ArrayList<? extends Creature> creatures)
      //觅食
      PVector foraging(ArrayList<? extends Creature> creatures)
      //繁殖
      public Creature  breed() 
      // 避免超出画板范围
      void borders()
      //判断死亡
      boolean dead()
    }
    
    class Plant extends Creature {
      //水草类
      Plant(PVector pos, DNA initDNA)
      @Override
        void display() 
      @Override
        Plant breed()
      //移动
      @Override
        void move()
      //判断死亡
      @Override
        boolean dead()
    
    class Flea extends Creature {
      //水蚤类
      Flea(PVector pos, DNA initDNA)
      //更新
      @Override
        void update() 
      @Override
        void display()
      @Override //加入寻偶行为
        void flock(ArrayList<? extends Creature> Creatures)
      //躲避动作
      void moveElude(ArrayList<Fish> fishes)
      //躲避
      PVector elude(ArrayList<Fish> fishes)
      @Override //有性繁殖
        Flea breed()
      //移动
      @Override
        void move()
      //对齐行为
      @Override  //添加视野角度
        PVector align (ArrayList<? extends Creature> creatures)
      //吃水草
      void eat(ArrayList<Plant> plants)
      //判断死亡
      @Override
        boolean dead()
    
    class Fish extends Creature {
      //鱼类
      Fish(PVector pos, DNA initDNA)
      //更新
      @Override
        void update()
      @Override
        void display()
      @Override   //有性繁殖
        Fish breed()
      @Override //加入寻偶行为
        void flock(ArrayList<? extends Creature> Creatures)
      //捕食运动
      void moveForaging(ArrayList<Flea> fleas)
      //移动
      @Override
        void move() 
      //吃水蚤
      void eat(ArrayList<Flea> fleas)
      //判断死亡
      @Override
        boolean dead()
    
    class DNA {
      private HashMap<String, Float> genes=new HashMap<String,Float>();
      DNA()
      DNA(HashMap newgenes)
      //复制
      public DNA dnaCopy()
      //交叉
      public DNA dnaCross(DNA fatherDNA)
      //变异
      public void mutate(float m)
    

    技术讲解

    向量、力之类的比较基础,这里主要说一下遗传和自治智能体。

    遗传

    这部分的代码比较简单。只需要把遗传相关的属性和方法实现就可以了。
    在DNA类中,使用 HashMap<String, Float> 用作储存基因型,键(String)保存基因型的名字,值(FLoat)保存基因间的差别,在Creature类中实例化DNA类并通过值来实现表现型。

    之后事基因的复制、交叉和变异。
    复制主要用在无性繁殖,直接复制DNA就可以了

      //复制
      public DNA dnaCopy() {
        HashMap<String, Float> childGenes = (HashMap<String,Float>)genes.clone();
        
        return new DNA(childGenes);
      }
    

    交叉则是有性繁殖,父亲把DNA传递给母亲,然后生成孩子的DNA

      //交叉
      public DNA dnaCross(DNA fatherDNA){
        HashMap<String, Float> childGenes = (HashMap<String,Float>)genes.clone();
        HashMap<String, Float> fatherGenes = fatherDNA.genes;
        float lifetime = (fatherGenes.get("lifetime") + genes.get("lifetime"))/2;
        childGenes.put("lifetime",lifetime);
        float speed = (fatherGenes.get("speed") + genes.get("speed"))/2;
        childGenes.put("speed",speed);
        float size = (fatherGenes.get("size") + genes.get("size"))/2;
        childGenes.put("size",size);
        
        return new DNA(childGenes);
      }
    

    变异在有性繁殖和无性繁殖中都会出现

      //变异
      public void mutate(float m) {
        for (String key : genes.keySet()) {
          if (random(1)<m) {
            genes.put(key, random(0, 1));
          }
        }
      }
    

    自治智能体

    这部分是代码的核心,控制生物的行为。
    生物的行为可以分成两类,一类是群集行为,一类是个体行为。
    运动会受到不同权重,生物的视野和角度影响。

    群集行为

    群集行为包括聚集,分离,对齐。
    水蚤的对齐行为权重更大,会与视野内的水蚤速度保持一致。
    统计视野内其他水蚤的速度均值,处理后作为加速度。

      //对齐行为
      @Override  //添加视野角度
        PVector align (ArrayList<? extends Creature> creatures) {
        float neighbordist = size * 2;
        PVector sum = new PVector(0, 0);
        int count = 0;
        for (Creature other : creatures) {
          //从一个生物到另一个生物的向量
          PVector comparison = PVector.sub(other.position, position);
          //距离
          float d = PVector.dist(position, other.position);
          //角度
          float  diff = PVector.angleBetween(comparison, velocity);
          if ((diff < periphery) && (d > 0) && (d < neighbordist)) {
            sum.add(other.velocity);
            count++;
          }
        }
        if (count > 0) {
          sum.div((float)count);
          sum.normalize();
          sum.mult(maxspeed);
          PVector steer = PVector.sub(sum, velocity);
          steer.limit(maxforce);
          return steer;
        } else {
          return new PVector(0, 0);
        }
      }
    

    聚集则是计算视野内其他生物的位置的均值,生成从当前位置指向均值的向量处理后用作加速度

      // Cohesion 聚集行为
      PVector cohesion (ArrayList<? extends Creature> creatures) {
        float neighbordist = r * 5; //视野  ????
        PVector sum = new PVector(0, 0);   // Start with empty vector to accumulate all positions
        int count = 0;
        for (Creature other : creatures) {
          float d = PVector.dist(position, other.position);
          if ((d > 0) && (d < neighbordist)) {
            sum.add(other.position); // 将其他对象位置相加
            count++;
          }
        }
        if (count > 0) {
          sum.div(count);
          return seek(sum);  //寻找邻居的平均坐标
        } else {
          return new PVector(0, 0);
        }
      }
    

    分离统计远离其他生物的向量均值,可以用于避免生物间距离过近重叠。

      //分离行为
      PVector separate (ArrayList<? extends Creature> creatures) {
        float desiredseparation = r*1.5; //分离视野
        PVector steer = new PVector(0, 0, 0);
        int count = 0;
        // For every boid in the system, check if it's too close
        for (Creature other : creatures) {
          float d = PVector.dist(position, other.position);
          // If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
          if ((d > 0) && (d < desiredseparation)) {
            // Calculate vector pointing away from neighbor
            PVector diff = PVector.sub(position, other.position);
            diff.normalize();
            diff.div(d);        // Weight by distance
            steer.add(diff);
            count++;            // Keep track of how many
          }
        }
        // Average -- divide by how many
        if (count > 0) {
          steer.div((float)count);
        }
    
        // As long as the vector is greater than 0
        if (steer.mag() > 0) {
          // Implement Reynolds: Steering = Desired - Velocity
          steer.normalize();
          steer.mult(maxspeed);
          steer.sub(velocity);
          steer.limit(maxforce);
        }
        return steer;
      }
    

    个体行为

    个体的行为是求偶、觅食、躲避

    当个体处于发情期会寻找视野内处于发情期的异性,找到后传递DNA,并结束发情期状态

      //寻偶
      PVector mating(ArrayList<? extends Creature> creatures) {
        float neighbordist = r * 15;
        if (isRut) {
          for (Creature other : creatures) {
            if (other.isRut && gender != other.gender) {
              //都处于发情期且性别不同
              //PVector comparison = PVector.sub(other.position, position);
              //距离
              float d = PVector.dist(position, other.position);
              //角度
              //float  diff = PVector.angleBetween(comparison, velocity);
              if ( (d < neighbordist) && (d>r)) {
                return seek(other.position);
              } else if (d<r) { //当两者足够靠近
                //print(3);
                isRut = false;
                other.isRut = false;
                if (gender) {
                  col = color(255, 0, 0);
                  other.col = color(0, 255, 0);
    
                  isPregnancy = true;
                  fatherDNA = other.dna;
                } else {
                  col = color(0, 255, 0);
                  other.col = color(255, 0, 0);
    
                  other.isPregnancy = true;
                  other.fatherDNA = dna;
                }
              }
            }
          }
        }
        return new PVector(0, 0);
      }
    

    觅食是鱼的行为,主动寻找水蚤

      //觅食
      PVector foraging(ArrayList<? extends Creature> creatures) {
        float neighbordist = r * 10;
        for (Creature c:creatures) {
          //从一个生物到另一个生物的向量
          PVector comparison = PVector.sub(c.position, position);
          //距离
          float d = PVector.dist(position, c.position);
          //角度
          float  diff = PVector.angleBetween(comparison, velocity);
          if ((diff < periphery) && (d < neighbordist)) {
            return seek(c.position);
          }
        }
        return new PVector(0, 0);
      }
    

    躲避与觅食相反,水蚤主动躲避鱼

      //躲避
      PVector elude(ArrayList<Fish> fishes) {
        float neighbordist = r * 10;
        for (Fish f:fishes) {
          //从一个生物到另一个生物的向量
          PVector comparison = PVector.sub(f.position, position);
          //距离
          float d = PVector.dist(position, f.position);
          //角度
          float  diff = PVector.angleBetween(comparison, velocity);
          if ((diff < periphery) && (d < neighbordist)) {
            PVector result = seek(f.position);
            result = new PVector(-result.x, -result.y);
            return result;
          }
        }
        return new PVector(0, 0);
      }
    

    问题与思考

    1、遗传
    遗传算法是计算数学中用于解决最佳化的搜索算法,曾经使用过用来计算函数的最大值,这里考虑把生物的寿命作为适应度,活得越长适应度越大,这样迭代一段时间后就能够得到寿命最长也就是最适应环境的个体,但在尝试的过程中发现这样太理想化了。
    一开始想要把各项参数都放在DNA中,例如不同行为的权重,繁殖率等,但是发现变量太多,效果不好。
    在系统中只有水蚤和水草时,出现过一种情况是水蚤越来越大,但速度却越来越慢,我猜测因为没有给水蚤添加觅食行为,所以走得慢反而更容易生存,越大觅食范围越大,并且水草不会被直接吃掉,生存概率也更高。但是这种情况我后来并没有复现出来。
    这里放了一种能够体现遗传进化的情况:
    初始为水草:100 水蚤:20 无鱼
    在这里插入图片描述
    一段时间后的情况:
    在这里插入图片描述
    发现水蚤在往大的方向进化,速度并没有越来越慢。

    这时候我意识到 适应度 的问题,我希望的适应度是寿命,但实际上想要让水蚤因为各项属性影响寿命是很困难的事,我只把参数修改一点点就可能导致生物灭绝或者过度繁殖,所以寿命的随机性其实挺高的。而真正的适应度其实是交配的概率,吃得多活得长,交配的概率高,但影响交配的概率最大的其实是体积,越大越可能和异性接触并交配。

    2、动态平衡
    正常的生态系统是具有自我调节的能力的,就像狼-兔-草模型中,兔子多了,狼也会多,草减少,这样兔子就会减少,一开始我也是想让鱼-水蚤-水草达到平衡状态,在只有水蚤-水草时还行,加入鱼后我发现这是不可能的,不添加外在条件时不可能的。

    自然界中其实还存在一些规律,实际上当一种生物增多时,首先受影响的是它的下级,生态系统的调节是具有滞后性的,就像兔子多了,首先是草大量减少,然后才是狼多,需要一定的时间跨度,才能恢复平衡。但在我模拟的生态系统中,当存在鱼-水蚤-水草时几乎无法调节平衡,会持续地往极端发展,并最终全部灭绝。

    当然这应该有我对生物的模拟不够真实的原因,并且环境太小,没有足够的时间和空间让模拟生态系统运行下去。

    参考

    参考案例:https://www.openprocessing.org/sketch/687983
    参考书籍:《The nature of code》/《代码本色》

    其他作品推荐

    布料模拟

    布料模拟
    在这里插入图片描述
    这个作品一下子就吸引了我,很简洁又真实,确实有布料运动的感觉,这个技术的实现让我想到曾经制作的愤怒的小鸟的弹弓。
    布料的整体运动取决于部分的运动,每一个局部运动逻辑是相似的,但整体表现出来的效果又很棒。

    融入动画技术的交互应用

    博文地址
    在这里插入图片描述
    一开始实现的跳一跳看起来就很不错,运动、交互的效果看起来很舒服。后边还看到一些有趣的效果,processing实现的融入动画的漫画场景,很好看。最后还分享了一些动画,特别是这个水生物的自然形态模拟,很喜欢,我自己做的生态系统看上去特别丑,早点看到这个例子,或许能让我的作品更具艺术性。在这里插入图片描述

    《Magic Network》:一个小孩都能玩的神经网络交互系统

    Magic Netwo
    在这里插入图片描述
    界面画风很符合主题,在学神经网络、人工智能的时候就经常感觉很抽象,很多东西的中间过程难以理解,这个作品非常好,即便是没有学过相关知识的人也可以操作,帮助理解神经网络。

    展开全文
  • 榆树生态系统 Elm 生态系统中最受欢迎的库是什么? 数字 名称 描述 星星 1 Elm 编译器,种用于可靠 web 应用程序的函数式语言。 4219 2 Elm 的核心库 1553 3 Elm 网站的服务器和客户端代码。 1427 4 用 Elm 编写的...
  • 这是我在2013年制作的基于Java的生态系统模拟器,是CS112类的最终项目。 这是我第一次尝试制作使用各种图形的程序。 我认为这是我永远失去的那些项目中的另一个,因此在这里进行了很好的评估。 已知的问题 将2501只...
  • 关于握手生态系统的令人敬畏的事情的集合。 握手 分散命名和证书颁发机构 握手地点 需要握手解析器才能工作 -有史以来第一个握手站点(由创建) 新Internet的欢迎页面 关于握手的第一个IPFS网站! -Hello World...
  • 基于我国近海海洋综合调查与评价专项课题构建的生态系统健康...根据908专项调查数据,用该软件评价了我国近岸海域、近海海域及重点海域生态系统健康状况,制作了评价专题图,为海洋生态管理及决策支持提供重要的依据。
  • 生态瓶的制作生态系统稳定性的观察 实验目的 1.掌握由水-陆两子系统构成的微型生态瓶的制作原理和方法 2.学会生态瓶内各种生物关系的选择和构建的技术 3.了解影响生态系统稳定性的各种生态
  • 我们希望开发一些有趣的项目,为 Discord 服务器构建一个链上生态系统,并为区块链开发新手提供机会,让他们在实际项目中积累经验。 计划项目 社区目前正在处理的项目想法列表: ERC20 代币 此代币将充当参与社区的...
  • 目标:模拟带有3可用区(AZ)的AWS数据中心(SG),该可用区运行带有服务器的3服务器Nomad + Consul群集,并带有工作节点。 Presentation @ 演示Nomadbox-LXD 先决条件 流浪汉 制作 设定说明 步骤#1:运行无业...
  • 一个用于定义项目首选项的json配置文件。 -可以与<template> AST一起使用的实用程序功能的集合,请以@babel/types但适用于Vue。 —一种检查类型的命令行工具,功能上与tsc --noEmit等效,但包括.vue支持。 —使...
  • 上传酒店图片,酒店管理,房间管理等。 很久以前做的了,看了一下私信发现有几位同学找我要项目源码,发上来给各位参考一下。
  • 建立在AWS Mobile Hub之上的awsmobile-CLI为前端JavaScript开发人员提供了一个命令行界面,以无缝地在其应用程序中启用和配置AWS服务。 通过最少的配置,您可以从您喜欢的终端程序开始使用AWS Mobile Hub提供的所有...
  • Kokkos教程 ... Kokkos讲座 我们目前正在运行Kokkos...制作文件 原始Makefile需要正确配置Makefile变量。 在大多数示例中,这是KOKKOS_PATH指向Kokkos源目录,而KOKKOS_DEVICES包含要构建的设备后端列表。 这将为每
  • 通过鼓励开发人员迈出第一步来使用Python,CPP,C,Java等编程语言进行编码,从而探索Vast开源生态系统的存储库。 要对此存储库做出贡献,我们建议您遵循以下格式- 步骤1 在Github上创建一个帐户 第2步 注册自己的...
  • 绝对原生态,苹果Mac OS X系统原版图标,制作而成的可以在Windows系统整体替换系统图标的图标包,win7,win8或者其他版本,安装iconpackager(自己找汉化破解)后应用图标包于系统,解压后既有各个图标,又有可以用...
  • Android开发学习

    千次阅读 多人点赞 2018-05-17 21:18:54
    Android开发学习 Android开发学习 什么是Android开发? Android开发用到的工具有哪些...    Android开发是指Android平台应用上的制作,是项包括需求捕捉,需求分析,设计,实现和测试的系统工程。Android...

    Android开发学习

    这里写图片描述

    什么是Android开发?

        Android开发是指Android平台应用上的制作,是一项包括需求捕捉,需求分析,设计,实现和测试的系统工程。Android开发通常采用开发工具进行开发。
    * 认识Android系统
        Android是一种基于Linux的自由及开放源代码的操作系统,主要使用于移动设备,如智能手机和平板电脑,由Google公司和开放手机联盟领导及开发。
        在这几年的发展过程中,Google公司为Android建立了一个完整的生态系统。同时,手机厂商、开发者、用户之间相互依存,共同推进着Android的蓬勃发展。
        Android系统架构可以分为Linux内核层、系统运行库层、应用框架层、应用层;Android系统四大组件为别是活动(Activity)、服务(Service)、广播接收器(Broadcast Rsceiver)和内容提供器(Content Provider)。
    这里写图片描述

        Google公司有个传统,就是每年都会举办一次Google I/O 大会,且一般在大会上推出新的Android版本。迄今,Google已经发行了17个版本(包括测试版本),目前最新的版本是Android Oreo(Android 8.0)。


    Android开发用到的工具有哪些?

        进行Android开发的工具主要有两种一是Eclipse+ADT+JDK+SDK,一是基于IntelliJ IDEA的Android Studio+SDK+JDK+Genymotion。
        目前,Android Studio是进行安卓开发的主流工具,它与Eclipse相比主要有以下优势:1.比Eclipse漂亮;2.比Eclipse速度快;3.提示,补全更加智能,更加人性化;4.整合了Gradle构建工具;5.支持Google Cloud Platform;6.强大的UI编辑器;7.更完善的插件系统;8.完美的整合版本控制软件;9.Android Studio是Google推出的。


    Android开发用到的知识有哪些?

    • Linux

        Android是基于Linux内核的,编译Android源码也必须在Linux上进行,所以开发者应熟练使用Linux的命令行,能够对Linux系统上的文件进行管理,对Linux进行网络配置、进程管理等。

    * 编程语言

         在Kotlin 语言出现之前,几乎所有的安卓应用程序都是使用Java语言编写的。但在2017年5月Google大会上,Google宣布Kotlin 成为安卓的官方语言后,经过快一年的发展,使用Kotlin 的开发者中5%增长到了15%,并且还在呈现上升趋势。
        无论是Java,还是Kotlin,我们Android开发者至少需要精通一门,当然,当熟练使用一门语言之后,再去更改转向另一门语言的这个过程是十分困难的。
    Java与Kotlin的创建类的简单代码示例:
    Java

    
    class Person{
            String name;
            int age;
    }
    
    

        Kotlin

    
    class Person{
        var name: String? = ""
        var age: Int = 0
    }
    
    

    Android开发学习路线

        Android基础阶段:平台架构特性(JAVA/C) ,Market应用程序组件, 环境搭建与部署、打包与发布, AVD/DDMS/AAPT 调试与测试 ,相关资源访问,资源制作, Activity/Service/Broadcast Receiver/Content Provider/原理(生命周期)及深层实现。

        Android进阶初级:组件(Widget),菜单(Menu),布局(Layout), 详解 Xml,解析(Pull/Dom/Sax)/JNI ,解析SQL数据库原理, SQLite /SharedPreferences/File详解 ,多媒体Audio/Video/Camera 详解。

        Android进阶高级:蓝牙/WIFI SMS/MMS 应用实现 ,深层次解析GPS原理,实现LocationManager/LocationProvider ,进行定位、跟踪、查找、趋近警告以及Geocoder正逆向编解码等技术细节, 2D图形库(Graphics/View)详解 ,SDCARD/传感器/手势 应用实现。


    Android开发学习资源

    相关书目相关网站视频教学
    《第一行代码》Linux公社网易云课堂
    《疯狂android讲义》CSDN慕课
    《Head First Java》Android吧
    《精通Android》GitHub
    展开全文
  • Arduino基础入门篇01—进入Arduino的世界

    万次阅读 多人点赞 2018-07-04 14:37:07
    我的电脑为Windows系统,Windows版本有三种下载方式,选择种下载即可。 关于IDE软件的介绍将在下一节中详细介绍。 更多内容,欢迎关注我的公众号。 微信扫扫下方二维码即可关注:

    欢迎来到Arduino的世界,本文主要介绍Arduino的优势,开发所涉及的硬件分类,开发语言及开发环境的下载。可登陆Arduino官网学习了解更多Arduino信息。

    什么是Arduino

    Arduino 是一款便捷灵活、方便上手的开源电子原型平台,包含硬件(各种型号的arduino板)和软件(arduino IDE),她适用于艺术家、设计师、爱好者和对于“互动”有兴趣的朋友们。

    Arduino能通过各种各样的传感器来感知环境,通过控制灯光、马达和其他的装置来反馈、影响环境。板子上的微控制器可以通过Arduino的编程语言来编写程序,编译成二进制文件,烧录进微控制器。

    对Arduino的编程是利用 Arduino编程语言 (基于 Wiring)和Arduino开发环境(based on Processing)来实现的。基于Arduino的项目,可以只包含Arduino,也可以包含Arduino和其他一些在PC上运行的软件,他们之间进行通信 (比如 Flash, Processing, MaxMSP)来实现。

    你可以自己动手制作,也可以购买成品套装。Arduino所使用到的软件都可以免费下载。硬件参考设计 (CAD 文件)也是遵循availableopen-source协议, 你可以非常自由地根据要求去修改他们。

    Arduino的优势

    目前市场上还有许多其他的单片机和单片机平台,例如51单片机、STM32单片机等。但他们对于普通开发者来说门槛相对较高,需要有一定编程和硬件相关基础,内部寄存器较为繁杂,主流开发环境Keil配置相对麻烦,特别是对于STM32的开发,即使使用官方库也少不了环境配置,还有就是开发环境是收费的。

    Arduino不但简化了使用单片机工作的流程,同时还为教师、学生以及兴趣爱好者提供了一些其他系统不具备的优势:

    • 便宜。相比于其他单片机平台而言,Arduino生态的各种开发板性价比相对较高。
    • 跨平台。Arduino软件(IDE)能在Windows、Mac OS X和Linux操作系统中运行,而大多数其他单片机系统仅限于在Windows操作系统中运行。
    • 开发环境简单。Arduino的编程环境易于初学者使用,同时对高级用户来讲也足够灵活,其安装和操作都非常简单。
    • 开源可扩展。Arduino软件硬件都是开源的,开发者可以对软件库进行扩展,也可以下载到千千万万的软件库来实现自己的功能。Arduino允许开发者对硬件电路进行修改和扩展来满足不同的需求。

    Arduino开发板类型

    Arduino生态包括多种开发板、模块、扩展板、工具和配件。官方将其大致分为五类:入门级、网络版、物联网版、教育版、可穿戴版。具体可从官网查看Arduino开发板类型。

    Arduino开发板类型

    其中入门级开发板易于使用。建议初学者使用入门级如Arduino UNO R3。

    在这里插入图片描述

    Arduino开发语言

    Arduino使用C/C++编写程序,虽然C++兼容C语言,但这是两种语言,C语言是一种面向过程的编程语言,C++是一种面向对象的编程语言。早期的Arduino核心库使用C语言编写,后来引进了面向对象的思想,目前最新的Arduino核心库采用C与C++混合编写而成。

    通常我们说的Arduino语言,是指Arduino核心库文件提供的各种应用程序编程接口(Application Programming Interface,简称API)的集合。这些API是对更底层的单片机支持库进行二次封装所形成的。例如,使用AVR单片机的Arduino的核心库是对AVR-Libc(基于GCC的AVR支持库)的二次封装。

    传统开发方式中,需要通过配置多个寄存器来实现相应功能,而在Arduino中,繁杂的寄存器被封装成简单的API,能进行直观控制,增强程序的可读性的同时也提高了开发效率。

    Arduino开发环境

    Arduino开发环境IDE可从官网进行下载,支持Windows、Mac OS X、Linux不同平台,对应PC平台进行下载。IDE下载地址
    当前最新版本为1.8.5。我的电脑为Windows系统,Windows版本有三种下载方式,选择一种下载即可。

    IDE下载

    关于IDE软件的介绍将在下一节中详细介绍。

    更多内容,欢迎关注我的公众号。 微信扫一扫下方二维码即可关注:
    扫码加入微信公众号:TonyCode

    展开全文
  • 解读OpenRTB(实时竞价)生态系统

    千次阅读 2013-11-30 15:07:33
    半壁江山生态系统总的来说分为2部分,卖方和买方。卖方:媒体,即拥有广告资源的人,如新浪这媒体有很多用户访问,有很多广告位。买方:广告主,即有钱人,准确的说是花钱买广告位置的人,如淘宝等电商,就需要...
  • 一个完整的APP项目一般包括Android和iOS两个客户端,外加一套后台管理系统。项目开发成本根据项目工期,需求复杂程度、质量要求来决定的。除此之外,个人兼职和公司的报价也是不同的。当然了,一
  • 如何设计一个系统

    万次阅读 2017-11-15 11:19:02
    正如生态系统、人的循环系统等一样复杂。 当事物复杂到一定程度的时候,我们就不能用过去暴力的方法进行求解了。这时候我们就需要借助完善的、系统的方法来进行求解,这将大大降低开发的代价。什么叫做
  • 点击“开发者技术前线”,选择“星标????”让部分开发者看到未来作者:若离链接:https://www.zhihu.com/question/420404904/answer/1465...
  • 生态环境敏感性是指生态系统对区域内自然和人类活动干扰的敏感程度,它反映区域生态系统在遇到干扰时,发生生态环境问题的难易程度和可能性的大小,并用来表征外界干扰可能造成的后果。即在同样干扰强度或外力作用下...
  • 2)数字高程模型子系统下,根据不同的情况制作坡度图的方式,即把栅格数据扫描并转变为矢量数据后转为GRD格网数据生成坡度图和把外部高程数据直接转为NIAPGIS明码格式*.DET数据而生成坡度图的制作过程,
  • 产品读书《小米生态链战地笔记》

    万次阅读 2019-09-03 22:57:39
    如何建设一个生态系统?什么样的生态能够发展壮大?近年来的各种企业模式复杂多变,但能让我们为之兴奋并充满好奇和信心的就是“生态”一说。 这次在有幸成为小米集团的一员,翻看各类小米相关的资讯书籍,看到了这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,602
精华内容 7,840
关键字:

如何制作一个生态系统