FASTA format: Difference between revisions

Note that a high-quality implementation will not hold the entire file in memory at once; real FASTA files can be multiple gigabytes in size.

<br><br>

 

=={{header|Ada}}==

The simple solution just reads the file (from standard input) line by line and directly writes it to the standard output.

 

 

procedure Simple_FASTA is

end loop;

 

 

{{out}}

 

 

 

procedure FASTA is

Map.Iterate(Process => Print_Pair'Access); -- print Map

 

=={{header|Aime}}==

 

text n, s;

 

}

 

{{Out}}

<pre>>Rosetta_Example_1: THERECANBENOSPACE

>Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED</pre>

 

=={{header|ALGOL W}}==

% reads FASTA format data from standard input and write the results to standard output %

% only handles the ">" line start %

readcard( line );

end while_not_eof

{{out}}

<pre>

Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED

</pre>

 

=={{header|AutoHotkey}}==

(

>Rosetta_Example_1

Gui, add, Edit, w700, % Data

Gui, show

{{out}}

<pre>>Rosetta_Example_1: THERECANBENOSPACE

 

=={{header|AWK}}==

# syntax: GAWK -f FASTA_FORMAT.AWK filename

# stop processing each file when an error is encountered

return

}

{{out}}

<pre>

Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED

</pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

free(line);

exit(EXIT_SUCCESS);

{{out}}

<pre>Rosetta_Example_1: THERECANBENOSPACE

=={{header|C sharp|C#}}==

 

using System.Collections.Generic;

using System.IO;

Console.ReadLine();

}

 

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

#include <fstream>

 

return 0;

 

{{out}}

 

=={{header|Clojure}}==

(with-open [r (clojure.java.io/reader pathname)]

(doseq [line (line-seq r)]

(if (= (first line) \>)

(print (format "%n%s: " (subs line 1)))

 

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

(defparameter *input* #p"fasta.txt"

"The input file name.")

:do (format t "~&~a: " (subseq line 1))

:else

{{out}}

<pre>Rosetta_Example_1: THERECANBENOSPACE

=={{header|Crystal}}==

If you want to run below code online, then paste below code to [https://play.crystal-lang.org/#/cr <b>playground</b>]

# create tmp fasta file in /tmp/

tmpfile = "/tmp/tmp"+Random.rand.to_s+".fasta"

# show fasta component

fasta.each { |k,v| puts "#{k}: #{v}"}

{{out}}

<pre>

Rosetta_Example_1: THERECANBENOSPACE

Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED

</pre>

 

=={{header|Factor}}==

IN: rosetta-code.fasta

 

readln rest "%s: " printf [ process-fasta-line ] each-line ;

 

{{out}}

<pre>

Rosetta_Example_1: THERECANBENOSPACE

Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED

</pre>

 

This program sticks to the task as described in the heading and doesn't allow for any of the (apparently) obsolete

practices described in the Wikipedia article :

 

Function checkNoSpaces(s As String) As Boolean

Print : Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Gambas}}==

Dim sList As String = File.Load("../FASTA")

Dim sTemp, sOutput As String

Print sOutput

 

Output:

Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println(err)

}

{{out}}

<pre>

We parse FASTA by hand (generally not a recommended approach). We use the fact that groupBy walks the list from the head and groups the items by a predicate; here we first concatenate all the fasta strings and then pair those with each respective name.

 

 

parseFasta :: FilePath -> IO ()

pair :: [String] -> [(String, String)]

pair [] = []

 

{{out}}

We parse FASTA using parser combinators. Normally you'd use something like Trifecta or Parsec, but here we use ReadP, because it is simple and also included in ghc by default. With other parsing libraries the code would be almost the same.

 

import Control.Applicative ( (<|>) )

import Data.Char ( isAlpha, isAlphaNum )

name = char '>' *> many (satisfy isAlphaNum <|> char '_') <* newline

code = concat <$> many (many (satisfy isAlpha) <* newline)

 

{{out}}

=={{header|J}}==

Needs chunking to handle huge files.

'''Example Usage'''

>Rosetta_Example_1

THERECANBENOSPACE

parseFasta Fafile

Rosetta_Example_1: THERECANBENOSPACE

 

=={{header|Java}}==

{{trans|D}}

{{works with|Java|7}}

import java.util.Scanner;

 

System.out.println();

}

 

<pre>Rosetta_Example_1: THERECANBENOSPACE

Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED

Rosetta_Example_3: THISISFASTA</pre>

 

=={{header|jq}}==

in each cycle, only as many lines are read as are required to compose an output line. <br>

Notice that an additional ">" must be provided to "foreach" to ensure the final block of lines of the input file are properly assembled.

def fasta:

foreach (inputs, ">") as $line

;

 

{{out}}

Rosetta_Example_1: THERECANBENOSPACE

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

if startswith(line, '>')

print(STDOUT, "\n$(line[2:end]): ")

print(STDOUT, "$line")

end

 

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

import java.util.Scanner

}

sc.close()

 

{{out}}

 

=={{header|Lua}}==

local data = file:read("*a")

file:close()

for k,v in pairs(output) do

print(k..": "..v)

 

{{out}}

 

 

Module CheckIt {

Class FASTA_MACHINE {

}

checkit

 

Mathematica has built-in support for FASTA files and strings

THERECANBENOSPACE

>Rosetta_Example_2

LINESBUTTHEYALLMUST

BECONCATENATED

{{out}}

<pre>{"THERECANBENOSPACE", "THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED"}</pre>

 

=={{header|Nim}}==

import strutils

 

 

fasta(input)

{{out}}

<pre>

The program reads and processes the input one line at a time, and directly prints out the chunk of data available. The long strings are not concatenated in memory but just examined and processed as necessary: either printed out as is in the case of part of a sequence, or formatted in the case of the name (what I call the label), and managing the new lines where needed.

{{works with|OCaml|4.03+}}

(* This program reads from the standard input and writes to standard output.

* Examples of use:

let () =

print_fasta stdin

{{out}}

Rosetta_Example_1: THERECANBENOSPACE

 

=={{header|Pascal}}==

program FASTA_Format;

// FPC 3.0.2

Close(InF);

end.

 

FASTA_Format < test.fst

 

=={{header|Perl}}==

>Rosetta_Example_1

THERECANBENOSPACE

print;

}

{{out}}

<pre>

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(in F

(while (from ">")

(prin (line T)) )

(prinl) ) ) )

{{out}}

<pre>

When working with a real file, the content of the <code>$file</code> variable would be: <code>Get-Content -Path .\FASTA_file.txt -ReadCount 1000</code>. The <code>-ReadCount</code> parameter value for large files is unknown, yet sure to be a value between 1,000 and 10,000 depending upon the length of file and length of the records in the file. Experimentation is the only way to know the optimum value.

{{works with|PowerShell|4.0+}}

$file = @'

>Rosetta_Example_1

 

$output | Format-List

{{Out}}

<pre>

 

===Version 3.0 Or Less===

$file = @'

>Rosetta_Example_1

 

$output | Format-List

{{Out}}

<pre>

 

=={{header|PureBasic}}==

Define Hdl_File.i,

Frm_File.i,

CloseFile(Hdl_File)

Input()

{{out}}

<pre>Rosetta_Example_1: THERECANBENOSPACE

and I use a generator expression yielding key, value pairs

as soon as they are read, keeping the minimum in memory.

 

FASTA='''\

yield key, val

 

 

{{out}}

 

=={{header|R}}==

library("seqinr")

 

cat(attr(aline, 'Annot'), ":", aline, "\n")

}

{{out}}

<pre>

 

=={{header|Racket}}==

#lang racket

(let loop ([m #t])

(current-output-port)))))

(newline)

 

=={{header|Raku}}==

(formerly Perl 6)

 

rule TOP { <entry>+ }

for $/<entry>[] {

say ~.<title>, " : ", .<sequence>.made;

{{out}}

<pre>Rosetta_Example_1 : THERECANBENOSPACE

===version 1===

This REXX version correctly processes the examples shown.

{{out|output|text=&nbsp; when using the default input filename:}}

<pre>

::* &nbsp; sequences that contain blanks, tabs, and other whitespace

::* &nbsp; sequence names that are identified with a semicolon &nbsp; [''';''']

<pre>

'''input:''' &nbsp; The &nbsp; '''FASTA2.IN''' &nbsp; file is shown below:

 

=={{header|Ring}}==

# Project : FAST format

 

i = i + 1

end

Output:

<pre>

 

=={{header|Ruby}}==

out, text = [], ""

strings.split("\n").each do |line|

EOS

 

 

{{out}}

 

=={{header|Run BASIC}}==

THERECANBENOSPACE

>Rosetta_Example_2

end if

i = i + 1

{{out}}

<pre>>Rosetta_Example_1: THERECANBENOSPACE

This example is implemented using an [https://doc.rust-lang.org/book/iterators.html iterator] to reduce memory requirements and encourage code reuse.

 

use std::env;

use std::io::{BufReader, Lines};

}

}

{{out}}

<pre>Rosetta_Example_1: THERECANBENOSPACE

 

=={{header|Scala}}==

import java.util.Scanner

 

 

println("~~~+~~~")

 

=={{header|Scheme}}==

(scheme file)

(scheme write))

(display (string-copy line 1)) (display ": "))

(else ; display the string directly

{{out}}

<pre>Rosetta_Example_1: THERECANBENOSPACE

 

=={{header|Seed7}}==

 

const proc: main is func

end if;

writeln;

 

{{out}}

=={{header|Sidef}}==

{{trans|Ruby}}

var out = []

var text = ''

THERECANBESEVERAL

LINESBUTTHEYALLMUST

{{out}}

<pre>

 

=={{header|Tcl}}==

set f [open $filename]

set sep ""

}

 

{{out}}

<pre>

=={{header|TMG}}==

Unix TMG: <!-- C port of TMG processes 1.04 GB FASTA file in 38 seconds on a generic laptop -->

loop: parse(line)\loop parse(( = {*} ));

line: ( name | * = {} | seqns );

spaces: << >>;

 

 

=={{header|zkl}}==

fcn(w){ // one string at a time, -->False garbage at front of file

line:=w.next().strip();

})

}.fp(data.walker()) : Utils.Helpers.wap(_);

*This assumes that white space at front or end of string is extraneous (excepting ">" lines).

*Lazy, works for objects that support iterating over lines (ie most).

*The fasta function returns an iterator that wraps a function taking an iterator. Uh, yeah. An initial iterator (Walker) is used to get lines, hold state and do push back when read the start of the next string. The function sucks up one string (using the iterator). The wrapping iterator (wap) traps the exception when the function waltzes off the end of the data and provides API for foreach (etc).

FASTA file:

FASTA data blob:

">Rosetta_Example_1\nTHERECANBENOSPACE\n"

">Rosetta_Example_2\nTHERECANBESEVERAL\nLINESBUTTHEYALLMUST\n"

"BECONCATENATED");

{{out}}

<pre>