FASTA format: Difference between revisions

{{trans|Python}}

|‘>Rosetta_Example_1

THERECANBENOSPACE

R r

{{out}}

=={{header|Action!}}==

In the following solution the input file [https://gitlab.com/amarok8bit/action-rosetta-code/-/blob/master/source/fasta.txt fasta.txt] is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used.

CHAR ARRAY line(256)

CHAR ARRAY tmp(256)

ReadFastaFile(fname)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/FASTA_format.png Screenshot from Atari 8-bit computer]

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

=={{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>

=={{header|Arturo}}==

result: #[]

current: ø

}

{{out}}

=={{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>

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

FOR i = 1 TO LEN(s$) - 1

IF MID$(s$, i, 1) = CHR$(32) OR MID$(s$, i, 1) = CHR$(9) THEN checkNoSpaces = 0

END IF

LOOP

==={{header|True BASIC}}===

{{trans|QBasic}}

IF END #f THEN LET EOF = -1 ELSE LET EOF = 0

END DEF

LOOP

CLOSE #1

=={{header|BASIC256}}==

first = True

next i

return True

=={{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>

=={{header|Factor}}==

IN: rosetta-code.fasta

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

{{out}}

<pre>

=={{header|Forth}}==

Developed with gforth 0.7.9

char > constant marker

cr ;

Test

{{out}}

<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:

<pre>Rosetta_Example_1: THERECANBENOSPACE

=={{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

Nowadays, most machines have gigabytes of memory. However, if it's necessary to process FASTA content on a system with inadequate memory we can use files to hold intermediate results. For example:

chunkFasta=: {{

r=. EMPTY

end.

r

Here, we're using a block size of 2 bytes, to illustrate correctness. If speed matters, we should use something significantly larger.

Thus, if '~/fasta.txt' contains the example file for this task and we want to store intermediate results in the '~temp' directory, we could use:

And, to complete the task:

Rosetta_Example_1: THERECANBENOSPACE

=={{header|Java}}==

{{trans|D}}

{{works with|Java|7}}

import java.util.Scanner;

System.out.println();

}

<pre>Rosetta_Example_1: THERECANBENOSPACE

=={{header|JavaScript}}==

The code below uses Nodejs to read the file.

const fs = require("fs");

const readline = require("readline");

readInterface.on("close", () => process.stdout.write("\n"));

<pre>Rosetta_Example_1: THERECANBENOSPACE

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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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>

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

if(args->Size() = 1) {

}

}

{{out}}

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}}==

<span style="color: #004080;">bool</span> <span style="color: #000000;">first</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">true</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"fasta.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"r"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>

{{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.

parse arg iFID . /*iFID: the input file to be read. */

if iFID=='' then iFID='FASTA.IN' /*Not specified? Then use the default.*/

else $=$ || x

end /*j*/ /* [↓] show output of last file used. */

{{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; [''';''']

parse arg iFID . /*iFID: the input file to be read. */

if iFID=='' then iFID='FASTA2.IN' /*Not specified? Then use the default.*/

else $=space($ || translate(x, , '*'), 0)

end /*j*/ /* [↓] show output of last file used. */

<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|uBasic/4tH}}==

If Set(a, Open (Cmd(2), "r")) < 0 Then Print "Cannot open \q";Cmd(2);"\q" : End

Loop ' if not add the line to current string

{{out}}

<pre>Rosetta_Example_1: THERECANBENOSPACE

{{trans|Kotlin}}

More or less.

var checkNoSpaces = Fn.new { |s| !s.contains(" ") && !s.contains("\t") }

}

}

{{out}}

=={{header|XPL0}}==

int Ch;

def LF=$0A, EOF=$1A;

Echo;

];

{{out}}

=={{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>