/// <summary>
/// Initialize dna, character and alive values
/// </summary>
public void Init()
{
dna = new Dna(DNALength, 6);
mCharacter = GetComponent <ThirdPersonCharacter>();
timeAlive = 0;
alive = true;
}
public async void AddAsync()
{
Dna dna = new Dna()
{
DnaSecuence = "AAAA", IsMutant = true
};
var dictionary = new Dictionary <string, object>
{
{ "@DnaSecuence", dna.DnaSecuence },
{ "@IsMutant", dna.IsMutant },
};
string sqlQuery = @"INSERT INTO [dbo].[Dna]
(ID, [DnaSecuence],[IsMutant])
VALUES(NEWID(), @DnaSecuence , @IsMutant)";
mockDapper.Setup(t => t.ExecuteAsync(It.Is <IDbConnection>(db =>
db.ConnectionString == _mockedConnString), sqlQuery, dictionary))
.ReturnsAsync(1);
var result = await _sut.AddAsync(dna);
Assert.True(result);
}
private void GeneLiveVision(CellBug cellBug)
{
if (nowCellBug == null ||
cellBug.GetAbility().GetGroup() != nowCellBug.GetAbility().GetGroup())
{
return;
}
int groupNum = 0;
int[] gene = new int[Const.DnaLineLength];
for (int i = 0; i < cellBugAllList.Count; i++)
{
CellBug bug = cellBugAllList[i] as CellBug;
if (bug.GetAbility().GetGroup() == nowCellBug.GetAbility().GetGroup())
{
groupNum++;
Dna tempDna = bug.GetAbility().GetDna();
for (int index = 0; index < gene.Length; index++)
{
gene[index] += (tempDna.GetDnaLine(Const.DnaLineEnum.OneEnum)[index] + tempDna.GetDnaLine(Const.DnaLineEnum.TwoEnum)[index]);
}
}
}
for (int m = 0; m < geneLabelArray.Length; m++)
{
geneLabelArray[m].text = Const.DnaName[m] + ":" + (int)(gene[m] / (2.0 * groupNum) * 100) + "%";
}
}
private void UpdatePosition(Point a, MoveDir dir)
{
//trim out redundant back and forth movement
if (Dna.Count() > 1 && (int)dir == (int)(Dna.Last() + 2) % 4)
{
//reset our position back
switch (Dna.Last())
{
case MoveDir.N:
Pos = new Point(Pos.X, Pos.Y + 1);
break;
case MoveDir.W:
Pos = new Point(Pos.X + 1, Pos.Y);
break;
case MoveDir.S:
Pos = new Point(Pos.X, Pos.Y - 1);
break;
case MoveDir.E:
Pos = new Point(Pos.X - 1, Pos.Y);
break;
}
//remove last dna record
Dna.RemoveAt(Dna.Count() - 1);
Path.RemoveAt(Path.Count() - 1);
return;
}
Path.Add(a);
Pos = a;
Dna.Add(dir);
}
public void DnaRepository_GetByChainString_ChainDoesNotExist_Succeeds()
{
//Arrange
DnaRepository repository = GetDnaRepository();
Mock <ISession> sessionMock = new Mock <ISession>();
IList <Dna> list = new List <Dna>()
{
new Dna()
{
ChainString = "AAA,CCC,TTT"
},
new Dna()
{
ChainString = "CCC,CCC,TTT"
},
new Dna()
{
ChainString = "TTT,TTT,TTT"
}
};
string chain = "AAA,AAA,AAA";
_dnaDaoMock.Setup(x => x.GetAll(It.IsAny <ISession>())).Returns(list.AsQueryable()).Verifiable();
//Action
Dna result = repository.GetByChainString(sessionMock.Object, chain);
//Asserts
Assert.IsNull(result);
_dnaDaoMock.Verify(x => x.GetAll(It.IsAny <ISession>()), Times.Once);
}
private void button1_Click(object sender, EventArgs e)
{
DnaAnalysisPerformer dnaAnalysis = new DnaAnalysisPerformer();
Dna dna = new Dna();
MessageBox.Show("WTF IS GOING ON???");
}
public Task SaveDna(Dna dna)
{
using ConnectionMultiplexer muxer = ConnectionMultiplexer.Connect(configuration.Value.RedisDb);
IDatabase conn = muxer.GetDatabase();
return(conn.SetAddAsync(Guid.NewGuid().ToString(), JsonConvert.SerializeObject(dna)));
}
public async Task <bool> AddAsync(Dna dna)
{
try
{
var dictionary = new Dictionary <string, object>
{
{ "@DnaSecuence", dna.DnaSecuence },
{ "@IsMutant", dna.IsMutant },
};
using (var connection = new SqlConnection(ConnectionString))
{
string sqlQuery = @"INSERT INTO [dbo].[Dna]
(ID, [DnaSecuence],[IsMutant])
VALUES(NEWID(), @DnaSecuence , @IsMutant)";
int rowsAffected = await _dapperWrapper.ExecuteAsync(
connection, sqlQuery, dictionary);
}
}
catch (Exception e)
{
throw e;
}
return(true);
}
public void Counts_a_nucleotide_only_once()
{
var dna = new Dna("GGTTGG");
dna.Count('T');
Assert.That(dna.Count('T'), Is.EqualTo(2));
}
public static uint LevenshteinDistance(Dna first, Dna second)
{
if (first.Length == 0) return second.Length;
if (second.Length == 0) return first.Length;
var lenFirst = first.Length;
var lenSecond = second.Length;
var d = new uint[lenFirst + 1, lenSecond + 1];
for (uint i = 0; i <= lenFirst; i++)
d[i, 0] = i;
for (uint i = 0; i <= lenSecond; i++)
d[0, i] = i;
for (uint i = 1; i <= lenFirst; i++)
{
for (uint j = 1; j <= lenSecond; j++)
{
var match = (first[i - 1] == second[j - 1]) ? 0 : 1;
d[i, j] = (uint)Math.Min(Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1), d[i - 1, j - 1] + match);
}
}
return d[lenFirst, lenSecond];
}
public async void CheckDnas(List <string> dnamock, bool expected)
{
CheckMutantCommand checkCommand = new CheckMutantCommand()
{
dna = dnamock
};
bool IsMutant = expected;
_processor.Setup(x => x.isMutant(checkCommand.dna)).Returns(IsMutant);
_mediator
.Setup(m => m.Publish(It.IsAny <DnaProcessedEvent>(), It.IsAny <CancellationToken>()))
.Verifiable();
Dna dna = new Dna()
{
DnaSecuence = string.Join("|", checkCommand.dna.ToArray()), IsMutant = IsMutant
};
_repository.Setup(x => x.AddAsync(It.IsAny <Dna>())).ReturnsAsync(true);
var result = await _sut.Handle(checkCommand, new System.Threading.CancellationToken());
Assert.Equal(IsMutant, result);
_repository.VerifyAll();
_processor.VerifyAll();
_mediator.VerifyAll();
}
public async Task MutantService_IsMutantAsync_ValidDnaAlreadySaved_Succeeds()
{
//Arrange
Mock <MutantService> serviceMock = GetMutantServiceMock();
MutantService service = serviceMock.Object;
Human human = new Human()
{
Dna = new string[] { "AAA", "CCC", "TTT" }
};
Dna savedDna = new Dna()
{
Id = Guid.NewGuid(),
ChainString = "AAA,CCC,TTT",
IsMutant = true
};
serviceMock.Setup(x => x.IsDnaValid(It.IsAny <string[]>())).Returns(true).Verifiable();
_memoryCacheServiceMock.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <Task <Dna> > >())).ReturnsAsync(savedDna).Verifiable();
serviceMock.Setup(x => x.VerifyIsMutant(It.IsAny <string[]>())).Returns(true).Verifiable();
//Action
bool result = await service.IsMutantAsync(human);
//Asserts
Assert.IsTrue(result);
serviceMock.Verify(x => x.IsDnaValid(It.IsAny <string[]>()), Times.Once);
_memoryCacheServiceMock.Verify(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <Task <Dna> > >()), Times.Once);
serviceMock.Verify(x => x.VerifyIsMutant(It.IsAny <string[]>()), Times.Never);
}
public override int GetSpeed(CellBug cellbug)
{
if (!cellbug)
{
return(0);
}
//需要访问dna
Dna dna = cellbug.GetAbility().GetDna();
int speedGeneTotal = dna.GetDnaIndex(Const.DnaLineEnum.OneEnum, Const.GenesEnum.SpeedEnum)
+ dna.GetDnaIndex(Const.DnaLineEnum.TwoEnum, Const.GenesEnum.SpeedEnum);
if (speedGeneTotal == 0)
{
nowSpeed = lowSpeed;
}
else if (speedGeneTotal == 1)
{
nowSpeed = middleSpeed;
}
else if (speedGeneTotal == 2)
{
nowSpeed = highSpeed;
}
return(nowSpeed);
}
void Start()
{
Game_Manger = GameObject.FindGameObjectWithTag("GameManger").GetComponent <GameManger>();
Population = new Dna[PopulationLength];
for (int i = 0; i < PopulationLength; i++)
{
Population[i] = new Dna();
Population[i].Weight = new float[WeightsLenght];
for (int j = 0; j < WeightsLenght; j++)
{
Population[i].Weight[j] = Random.Range(-1.0f, 1.0f);
}
Population[i].Fitness = 0;
GameObject prefab = (GameObject)Instantiate(FlappyBirdPrefab, new Vector3(-7, 0, 0), new Quaternion(0, 0, 0, 0));
Population[i].Prefab = prefab;
prefab.GetComponent <FlappyBirdObject>().ParentIndex = i;
}
//Start The Generation Test
GenerationNumberText.text = GenerationNumber.ToString();
Game_Manger.NumberOfFlappyBird = PopulationLength;
Game_Manger.TimerFitness = 0;
RePopulitionbool = false;
}
private static void CheckDnaIsNotReferentiallyEqual(Dna dna1, Dna dna2)
{
dna1.Should().NotBeSameAs(dna2); // NotBeSameAs = referential inequality
dna1.ActivationIndexes.Should().NotBeSameAs(dna2.ActivationIndexes);
dna1.WeightsAndBiases.Should().NotBeSameAs(dna2.WeightsAndBiases);
dna1.OutputsPerLayer.Should().NotBeSameAs(dna2.OutputsPerLayer);
}
public void CompareWeightsReturnsExpectedResultOfDifferent()
{
// Arrange
const int nInputs = 9;
const int nOutputs = 1;
int[] hiddenLayers = new int[] { 9 };
Dna dna1 = Dna.GenerateRandomDnaEncoding(nInputs, hiddenLayers, nOutputs, ActivationType.LeakyRelu, true);
dna1.WeightsAndBiases.Should().HaveCount(100);
dna1.WeightsAndBiases.Clear();
dna1.WeightsAndBiases.AddRange(Enumerable.Repeat(1.00, 100));
Dna dna2 = Dna.Clone(dna1);
dna1.WeightsAndBiases.Should().Equal(dna2.WeightsAndBiases);
dna2.WeightsAndBiases[2] = -49.00; // aggregate absolute weight difference of dna2 vs dna1 should now be 50
dna1.WeightsAndBiases.Should().NotEqual(dna2.WeightsAndBiases);
// Act
var comparisonResult = DnaUtils.CompareWeights(dna1, dna2);
// Assert
float percentWeightDiff = comparisonResult.Item1;
double percentWeightValueDiff = comparisonResult.Item2;
percentWeightDiff.Should().Be(0.01f); // ie. 1% of weights differ in value
percentWeightValueDiff.Should().Be(0.5f); // ie. total weight values of dna2 differ by 50% (NOT 50% bigger)
}
/// <summary>
/// Saves in the database a bunch of DNAs.
/// </summary>
/// <param name="dnas">Collection of DNAs to save</param>
/// <returns>void</returns>
public async Task SaveAsync(ICollection <Dna> dnas)
{
if (dnas == null)
{
throw new ArgumentException("DNA cannot be null");
}
await Task.Run(() =>
{
using (ISession session = SessionManager.GetSession())
{
using (ITransaction tx = session.BeginTransaction())
{
//TODO: I should only persist the entities that don't exist in DB
foreach (Dna dna in dnas)
{
//I need to check it again in the transaction to cover concurrency issues
Dna savedDna = _dnaRepository.GetByChainString(session, dna.ChainString);
if (savedDna == null)
{
_dnaRepository.Save(session, dna);
}
}
tx.Commit();
}
}
});
}
public void DnaRepository_GetByChainString_ChainDoesExist_Succeeds()
{
//Arrange
DnaRepository repository = GetDnaRepository();
Mock <ISession> sessionMock = new Mock <ISession>();
Guid foundId = Guid.NewGuid();
IList <Dna> list = new List <Dna>()
{
new Dna()
{
ChainString = "AAA,CCC,TTT"
},
new Dna()
{
Id = foundId,
ChainString = "CCC,CCC,TTT"
},
new Dna()
{
ChainString = "TTT,TTT,TTT"
}
};
string chain = "CCC,CCC,TTT"; //second one
_dnaDaoMock.Setup(x => x.GetAll(It.IsAny <ISession>())).Returns(list.AsQueryable()).Verifiable();
//Action
Dna result = repository.GetByChainString(sessionMock.Object, chain);
//Asserts
Assert.IsNotNull(result);
Assert.AreEqual(foundId, result.Id);
Assert.AreEqual(chain, result.ChainString);
_dnaDaoMock.Verify(x => x.GetAll(It.IsAny <ISession>()), Times.Once);
}
public void PrintIndividual()
{
Console.WriteLine("Individual");
Console.WriteLine("Weight:" + Weight);
Console.WriteLine("Value:" + Value);
Console.WriteLine("Profitability:" + Profitability);
Dna.PrintGenome();
}
static void Main(string[] args)
{
Dna temp = new Dna(5);
Genepool gpool = new Genepool(temp, 10);
gpool.Randomize();
gpool.Render();
}
public IEnumerable<Dna> Search(Dna word, uint d)
{
var rtn = new List<Dna>();
RecursiveSearch(_root, rtn, word, d);
return rtn;
}
// Use on construction of DNA. Blows away old changes.
public void SetDnaAndBuildAvatar(IEnumerable <AssetInfo> assetInfos, Action <AvatarEntity> avatarAssetsSet)
{
//mLoadAvatarCallback = avatarAssetsLoaded;
mAvatarDna = new Dna();
mChangesToDna = new Dna();
mAvatarDna.UpdateDna(assetInfos);
this.SetAssetsWithCallback(assetInfos, avatarAssetsSet);
}
public override bool Equals(object obj)
{
return(obj is MutantAnalysisLog log &&
Id == log.Id &&
Dna.SequenceEqual(log.Dna) &&
IsMutant == log.IsMutant &&
Count == log.Count);
}
public void DnaShouldHaveSameYCoordinateWithSperm_AfterMagnetActivated()
{
var sperm = new Sperm(500);
var dna = new Dna(0, 0, sperm);
sperm.IsMagnetActivated = true;
Assert.AreEqual(sperm.Location.Y, dna.GetLocation().Y);
}
public void Init()
{
// Initialize Dna. Both genes store values between 0 and 360.
// Gene 0 = move forward.
// Gene 1 = turn angle.
Dna = new Dna(DnaLength, 360);
distanceWalked = 0f;
}
/// <summary>
/// Solves the REVC problem (http://rosalind.info/problems/revc/).
/// </summary>
private static void SolveRevc()
{
var dna = new Dna(File.ReadAllText(@"Data\REVC\rosalind_revc.txt"));
var reverseComplement = dna.ReverseComplementDna();
SaveResult(@"Results\rosalind_revc_results.txt", reverseComplement.Symbols);
}
private Rabbit CreationOfRabbit()
{
var dnk = new Dna {
Gene = GenerateGene()
};
return(new Rabbit(dnk, _fitness.GetFitness(dnk)));
}
private void OnCreatureSelect(GameObject o)
{
Show();
_dna = o.GetComponent <Dna>();
_fov = o.GetComponent <CreatureFieldOfView>();
_movement = o.GetComponent <CreatureMovement>();
}
/// <summary>
/// Solves the RNA problem (http://rosalind.info/problems/rna/).
/// </summary>
private static void SolveRna()
{
var dna = new Dna(File.ReadAllText(@"Data\RNA\rosalind_rna.txt"));
var rna = dna.TranscribeRna();
SaveResult(@"Results\rosalind_rna_results.txt", rna.Symbols);
}
public void Has_no_nucleotides()
{
var dna = new Dna("");
var expected = new Dictionary <char, int> {
{ 'A', 0 }, { 'T', 0 }, { 'C', 0 }, { 'G', 0 }
};
Assert.That(dna.NucleotideCounts, Is.EqualTo(expected));
}
public void Counts_all_nucleotides()
{
var dna = new Dna("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC");
var expected = new Dictionary <char, int> {
{ 'A', 20 }, { 'T', 21 }, { 'C', 12 }, { 'G', 17 }
};
Assert.That(dna.NucleotideCounts, Is.EqualTo(expected));
}
public void Repetitive_sequence_has_only_guanosine()
{
var dna = new Dna("GGGGGGGG");
var expected = new Dictionary <char, int> {
{ 'A', 0 }, { 'T', 0 }, { 'C', 0 }, { 'G', 8 }
};
Assert.That(dna.NucleotideCounts, Is.EqualTo(expected));
}
public static IEnumerable<Dna> FindPatterns(Dna input, Peptide peptide)
{
var dnaComp = input.Complimentary();
var forward = match(input, peptide);
var backWard = match(dnaComp, peptide);
var resultMatches = forward.Concat(backWard.Select(d=>d.Complimentary()));
return resultMatches;
}
private void RecursiveSearch(Node node, List<Dna> rtn, Dna word, uint d)
{
var curDist = LevenshteinDistance(node.Word, word);
var minDist = Math.Max(0,(int)curDist - (int)d);
var maxDist = curDist + d;
if (curDist <= d)
rtn.Add(node.Word);
foreach (var key in node.Keys.Cast<uint>().Where(key => minDist <= key && key <= maxDist))
{
RecursiveSearch(node[key], rtn, word, d);
}
}
private static IEnumerable<Dna> match(Dna input, Peptide peptide)
{
var resultMatches = new List<Dna>();
var rna1 = input.Translate();
for (uint offset = 0; offset < 3; offset++)
{
var pep = rna1.Transcribe(offset, true);
var matches = DnaPattern.FindAllMatches(pep, peptide);
foreach (uint match in matches)
{
var of = match * 3 + offset;
var transDna = input.Substring(of, 3 * peptide.Length);
resultMatches.Add(transDna);
}
}
return resultMatches;
}
public void Add(Dna word)
{
if (_root == null)
{
_root = new Node(word);
return;
}
var curNode = _root;
var dist = LevenshteinDistance(curNode.Word, word);
while (curNode.ContainsKey(dist))
{
if (dist == 0) return;
curNode = curNode[dist];
dist = LevenshteinDistance(curNode.Word, word);
}
curNode.AddChild(dist, word);
}
// Range: -1 Access: 0 Flags: ( 0, 4, 255 )
public static void hgibs( dynamic location = null, ByTable viruses = null, Dna MobDNA = null ) {
new Ent_Effect_Gibspawner_Human( location, viruses, MobDNA );
return;
}
public FastaEntry(string label, Dna dna)
{
Label = label;
Dna = dna;
}
public Node(Dna word)
{
Word = word;
}
public void AddChild(uint key, Dna word)
{
if (Children == null)
Children = new HybridDictionary();
Children[key] = new Node(word);
}
