Esempio n. 1
0
        public Vector <double> Generate(Vector <double> init_op, ExtendRandom agent_gene_rand)
        {
            var             op_dim_size      = init_op.Count;
            var             init_belief_list = new List <double>();
            var             last_belief      = 0.0;
            var             remain_belief    = 1.0;
            var             bound_rate       = 0.8;
            var             mu                 = remain_belief / op_dim_size;
            double          stddev             = 0.1;
            Vector <double> init_belief_vector = init_op.Clone();

            switch (this.Mode)
            {
            case InitBeliefMode.NormalNarrow:
                //stddev = mu / this.NarrowDimSize;
                init_belief_list = agent_gene_rand.NextNormals(mu, stddev, op_dim_size - 1, bound_rate);
                last_belief      = remain_belief - init_belief_list.Sum();
                last_belief      = Math.Round(last_belief, 4);
                init_belief_list.Add(last_belief);
                break;

            case InitBeliefMode.Normal:
                stddev           = mu / this.NormalDimSize;
                init_belief_list = agent_gene_rand.NextNormals(mu, stddev, op_dim_size - 1, bound_rate);
                last_belief      = remain_belief - init_belief_list.Sum();
                last_belief      = Math.Round(last_belief, 4);
                init_belief_list.Add(last_belief);
                break;

            case InitBeliefMode.NormalWide:
                //stddev = mu / this.WideDimSize;
                stddev           = mu / this.NarrowDimSize;
                init_belief_list = agent_gene_rand.NextNormals(mu, stddev, op_dim_size, bound_rate, 1, 0.5);
                var sum = init_belief_list.Sum();
                init_belief_list = init_belief_list.Select(b => Math.Round(b / sum, 4)).ToList();
                //last_belief = remain_belief - init_belief_list.Sum();
                //last_belief = Math.Round(last_belief, 4);
                //init_belief_list.Add(last_belief);
                break;

            case InitBeliefMode.NoRandom:
                var one_init_belief = remain_belief / op_dim_size;
                one_init_belief  = Math.Round(one_init_belief, 4);
                init_belief_list = Enumerable.Repeat(one_init_belief, op_dim_size - 1).ToList();
                last_belief      = remain_belief - init_belief_list.Sum();
                last_belief      = Math.Round(last_belief, 4);
                init_belief_list.Add(last_belief);
                break;

            default:
                break;
            }

            for (int index = 0; index < init_belief_list.Count; index++)
            {
                init_belief_vector[index] = init_belief_list[index];
            }

            return(init_belief_vector);
        }
Esempio n. 2
0
        public void Generate(ExtendRandom agent_network_rand, Agent agent)
        {
            var init_belief = this.MyInitBeliefGene.Generate(this.InitOpinion, agent_network_rand); //信念値生成器

            agent.SetInitBelief(init_belief);                                                       //agentに各意見の信念値を設定
            agent.SetSubject(this.MySubject);
            agent.SetInitOpinion(this.InitOpinion);
            agent.SetThreshold(this.OpinionThreshold);
        }
Esempio n. 3
0
        public List <Message> SendMessages(List <Agent> sensor_agents, ExtendRandom update_step_rand, bool bad_sensor_mode, int sample_size = 1)               //観測したセンサ,乱数生成器
        {
            List <Message> messages = new List <Message>();                                                                                                    //メッセージのリスト

            foreach (var sensor_agent in sensor_agents)                                                                                                        //観測したセンサ1つずつ
            {
                var agent_link = this.EnvironmentAgent.AgentLinks.Where(link => link.SourceAgent == sensor_agent || link.TargetAgent == sensor_agent).First(); //観測したセンサと環境エージェントのリンク
                var opinion    = this.EnvironmentAgent.Opinion.Clone();                                                                                        //環境の意見コピー
                opinion.Clear();                                                                                                                               //初期化

                if (bad_sensor_mode)                                                                                                                           //バッドセンサモードの時
                {
                    if (!sensor_agent.IsBadSensor)
                    {
                        foreach (int i in Enumerable.Range(0, sample_size)) //0からsample_size(デフォで1)-1の間
                        {
                            int sample_index = -1;                          //初期化
                            if (sensor_agent.IsMalicious)
                            {
                                sample_index = this.MyMaliciousCustomDistribution.SampleCustomDistribution(update_step_rand);
                            }
                            else
                            {
                                sample_index = this.MyCustomDistribution.SampleCustomDistribution(update_step_rand); //閾値を乱数生成して,myDistributionを足し合わせてそれを超えたら
                            }
                            opinion[sample_index] += 1.0;                                                            //opinionの対象要素をインクリメント.おそらくそこで意見が形成されたことになる?
                        }
                    }
                    else
                    {
                        opinion[1] += 1.0;
                    }
                }
                else //確定で間違えるセンサがいないとき
                {
                    foreach (int i in Enumerable.Range(0, sample_size)) //0からsample_size(デフォで1)-1の間
                    {
                        int sample_index = -1; //初期化
                        if (sensor_agent.IsMalicious)
                        {
                            sample_index = this.MyMaliciousCustomDistribution.SampleCustomDistribution(update_step_rand);
                        }
                        else
                        {
                            sample_index = this.MyCustomDistribution.SampleCustomDistribution(update_step_rand); //閾値を乱数生成して,myDistributionを足し合わせてそれを超えたら
                        }
                        opinion[sample_index] += 1.0;                                                            //opinionの対象要素をインクリメント.おそらくそこで意見が形成されたことになる?
                    }
                }


                messages.Add(new Message(this.EnvironmentAgent, sensor_agent, agent_link, opinion)); //from, to, link, (subject),opinionの順にそのままセット
            }

            return(messages);
        }
Esempio n. 4
0
 public void SetRand(ExtendRandom update_step_rand)
 {
     this.UpdateStepRand = update_step_rand;
     return;
 }
Esempio n. 5
0
        public void Register(SeedEnum seed_enum, int seed)
        {
            ExtendRandom extended_random = new ExtendRandom(seed_enum, seed);

            this.RandomDictionary[seed_enum] = extended_random;
        }
Esempio n. 6
0
 public AgentNetwork SetRand(ExtendRandom agent_gene_rand) //ランダム生成器セット
 {
     this.AgentGenerateRand = agent_gene_rand;
     return(this);
 }
Esempio n. 7
0
        public void Generate(ExtendRandom agent_network_rand, List <Agent> agents, bool bad_sensor_mode, SensorArrangementEnum sensor_arrange, List <List <int> > communityList = null)
        {
            foreach (var agent in agents) //全てのエージェントを初期化
            {
                agent.SetSensor(false);
            }
            List <int> sensor_list = new List <int>();

            int bad_sensor = -1;

            if (communityList.Count != 0 && sensor_arrange == SensorArrangementEnum.Each) //ネットワークがコミュニティ構造を持つとき
            {
                int rest = 0;
                if (this.SensorSize > communityList.Count) //コミュニティの数よりセンサの数の方が多いとき
                {
                    for (var i = 0; i < this.SensorSize; i++)
                    {
                        //sensor_list = agents.Select(agent => agent.AgentID).OrderBy(id => agent_network_rand.Next()).Take(this.SensorSize).ToList();
                        var sensors = agents.Where(agent => communityList[i % communityList.Count].Contains(agent.AgentID));                    //コミュニティのメンバー.センサ候補
                        var sensor  = sensors.Select(agent => agent.AgentID).OrderBy(id => agent_network_rand.Next()).Take(1).ToList().First(); //一人センサを選ぶ
                        sensor_list.Add(sensor);
                    }
                    rest = this.SensorSize % communityList.Count;
                }
                else //コミュニティの数がセンサの数以下の時
                {
                    for (var i = 0; i < this.SensorSize; i++)
                    {
                        //sensor_list = agents.Select(agent => agent.AgentID).OrderBy(id => agent_network_rand.Next()).Take(this.SensorSize).ToList();
                        var sensors = agents.Where(agent => communityList[i].Contains(agent.AgentID));                                          //コミュニティのメンバー.センサ候補
                        var sensor  = sensors.Select(agent => agent.AgentID).OrderBy(id => agent_network_rand.Next()).Take(1).ToList().First(); //一人センサを選ぶ
                        sensor_list.Add(sensor);
                    }
                }

                if (bad_sensor_mode)
                {
                    if (rest != 0)
                    {
                        while (true)
                        {
                            int  candidate = agent_network_rand.Next(0, sensor_list.Count);
                            bool flag      = false;
                            for (var j = 0; j < rest; j++)
                            {
                                if (candidate % communityList.Count == j)
                                {
                                    flag = true;
                                }
                            }
                            if (!flag)
                            {
                                bad_sensor = candidate;
                                break;
                            }
                        }
                    }
                    else
                    {
                        bad_sensor = agent_network_rand.Next(0, sensor_list.Count);
                    }
                    agents.Where(agent => sensor_list[bad_sensor] == agent.AgentID).ToList().ForEach(agent => agent.SetBadSensor(true));
                    this.BadCommunityIndex = bad_sensor;
                    agents.Where(agent => communityList[bad_sensor].Contains(agent.AgentID)).ToList().ForEach(agent => agent.SetBadCommunity(true));
                }
            }
            else //ネットワークがコミュニティ構造を持たないとき
            {
                sensor_list = agents.Select(agent => agent.AgentID).OrderBy(id => agent_network_rand.Next()).Take(this.SensorSize).ToList();
                if (bad_sensor_mode)
                {
                    bad_sensor = agent_network_rand.Next(0, sensor_list.Count);
                    agents.Where(agent => sensor_list[bad_sensor] == (agent.AgentID)).ToList().ForEach(agent => agent.SetBadSensor(true));
                    this.BadCommunityIndex = bad_sensor;
                }
            }

            var malicious_sensor_list = sensor_list.OrderBy(id => agent_network_rand.Next()).Take(this.MaliciousSensorSize).ToList();

            agents.Where(agent => sensor_list.Contains(agent.AgentID)).ToList().ForEach(agent => agent.SetSensor(true, false));          //センサエージェントに選ばれたエージェントをセンサとして認定
            agents.Where(agent => malicious_sensor_list.Contains(agent.AgentID)).ToList().ForEach(agent => agent.SetSensor(true, true)); //誤情報センサに選ばれたエージェントを認定
        }