Bioinformatics/Sequence mutation: Difference between revisions

* Give more information on the individual mutations applied.

* Allow mutations to be weighted and/or chosen.

 

=={{header|C}}==

Adenine ( A ) is always swapped for Thymine ( T ) and vice versa. Similarly with Cytosine ( C ) and Guanine ( G ).

#include<stdlib.h>

#include<stdio.h>

return 0;

}

Sample run :

<pre>

Total:513

</pre>

=={{header|C++}}==

#include <iomanip>

#include <iostream>

sequence_generator::print_sequence(std::cout, sequence);

return 0;

 

{{out}}

A: 65, C: 66, G: 64, T: 56, Total: 251

</pre>

=={{header|Common Lisp}}==

<b>Usage :</b>

:: :genome <i><Genome Sequence></i>)

<b>All keys are optional. <i><Genome length></i> is discarded when :genome is set.</b>

(defun random_base ()

(random 4))

(t (delete_base genome)))))

(output_genome_info genome "MUTATED"))

{{out}}

<pre>

T : 137 G : 119

</pre>

=={{header|Factor}}==

macros math math.statistics namespaces prettyprint quotations

random sequences sorting ;

[ mutate ] curry times nl "MUTATED " write show-dna ;

 

{{out}}

<pre>

TOTAL: 204

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println()

prettyPrint(dna, 50)

 

{{out}}

</pre>

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

import System.Random (Random, randomR, random, newStdGen, randoms, getStdRandom)

data DNABase = A | C | G | T deriving (Show, Read, Eq, Ord, Enum, Bounded)

type DNASequence = [DNABase]

 

instance Random DNABase where

random = randomR (minBound, maxBound)

 

instance Random Mutation where

random = randomR (minBound, maxBound)

 

instance IsChar DNABase where

toChar = head . show

 

chunkedDNASequence :: DNASequence -> [(Int, [DNABase])]

newSequence n = take n . randoms <$> newStdGen

 

where

randomMutation = head . randoms <$> newStdGen

mutate xs m = do

i <- randomIndex (length xs)

where

randomDNA = head . randoms <$> newStdGen

 

 

main :: IO ()

main = do

putStrLn "\nMutated Sequence:" >> showSequence ms

putStrLn "\nBase Counts:" >> showBaseCounts ms

where

showSequence = mapM_ (uncurry (printf "%3d: %s\n")) . chunkedDNASequence

{{out}}

<pre>Initial Sequence:

 

Base Counts:

C: 53

 

 

Mutated Sequence:

 

Base Counts:

=={{header|J}}==

MUTS=: ;: 'del ins mut'

 

)

 

 

{{out}}

│ │ 200│GGC │

└─────┴────┴──────────────────────────────────────────────────┘</pre>

=={{header|Java}}==

import java.util.Random;

 

if (i != 0)

System.out.println();

}

char ch = sequence.charAt(i);

private static final int OP_COUNT = 3;

private static final char[] BASES = {'A', 'C', 'G', 'T'};

 

{{out}}

Base counts:

A: 71, C: 62, G: 58, T: 61, Total: 252

</pre>

 

=={{header|Julia}}==

randpos(seq) = rand(1:length(seq)) # 1

mutateat(pos, seq) = (s = seq[:]; s[pos] = rand(dnabases); s) # 2-1

 

testbioseq()

<pre>

500nt DNA sequence:

</pre>

 

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

say "Total bases: ". length $mutate;

say "$_: $cnt{$_}" for @bases;

{{out}}

<pre>Original DNA strand:

G: 51

T: 51</pre>

=={{header|Phix}}==

{{out}}

<pre>

Base counts: A:128, C:110, G:119, T:123, total:480

</pre>

 

=={{header|Python}}==

In function seq_mutate argument kinds selects between the three kinds of mutation. The characters I, D, and S are chosen from the string to give the kind of mutation to perform, so the more of that character, the more of that type of mutation performed.<br>

Similarly parameter choice is chosen from to give the base for substitution or insertion - the more any base appears, the more likely it is to be chosen in any insertion/substitution.

from collections import Counter

 

print(f" {kind:>10} @{index}")

print()

 

{{out}}

T: 72

TOT= 251</pre>

 

=={{header|Racket}}==

 

 

(define current-S-weight (make-parameter 1))

(define s+d (parameterize ((current-D-weight 5)) (for/fold ((s initial-sequence)) ((_ 10)) (mutate s))))

(newline)

 

{{out}}

T : 42

TOTAL: 193</pre>

=={{header|Raku}}==

(formerly Perl 6)

 

 

 

# The DNA strand

sub diff ($orig, $repl) {

($orig.comb Z $repl.comb).map( -> ($o, $r) { $o eq $r ?? $o !! $r.lc }).join

{{out}}

<pre>ORIGINAL DNA STRAND:

G 43

T 53</pre>

 

=={{header|Swift}}==

 

 

enum Action: CaseIterable {

}

 

 

{{out}}

G: 56

T: 45</pre>

 

=={{header|zkl}}==

dna:=(190).pump(Data().howza(3),(0).random.fp(0,4),bases.get); // bucket of bytes

 

[0..*,50].zipWith(fcn(n,bases){ println("%6d: %s".fmt(n,bases.concat())) },

dna.walker().walk.fp(50)).pump(Void); // .pump forces the iterator

{{out}}

<pre>