Rosetta Code

FASTA format: Difference between revisions

Page Discussion

FASTA format (view source)

Revision as of 08:53, 4 March 2024

13,329 bytes added ,  2 months ago
→‎version 2: rewritten
(→‎version 2: rewritten)
 
(14 intermediate revisions by 10 users not shown)
Line 27:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">V FASTA =
|‘>Rosetta_Example_1
THERECANBENOSPACE
Line 51:
R r
 
print(fasta_parse(FASTA).map((key, val) -> ‘#.: #.’.format(key, val)).join("\n"))</langsyntaxhighlight>
 
{{out}}
Line 61:
=={{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.
<langsyntaxhighlight Actionlang="action!">PROC ReadFastaFile(CHAR ARRAY fname)
CHAR ARRAY line(256)
CHAR ARRAY tmp(256)
Line 90:
 
ReadFastaFile(fname)
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/FASTA_format.png Screenshot from Atari 8-bit computer]
Line 102:
The simple solution just reads the file (from standard input) line by line and directly writes it to the standard output.
 
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO; use Ada.Text_IO;
 
procedure Simple_FASTA is
Line 129:
end loop;
 
end Simple_FASTA;</langsyntaxhighlight>
 
{{out}}
Line 142:
 
 
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO, Ada.Containers.Indefinite_Ordered_Maps; use Ada.Text_IO;
 
procedure FASTA is
Line 187:
Map.Iterate(Process => Print_Pair'Access); -- print Map
end FASTA;</langsyntaxhighlight>
 
=={{header|Aime}}==
 
<langsyntaxhighlight lang="aime">file f;
text n, s;
 
Line 205:
}
 
o_(n);</langsyntaxhighlight>
{{Out}}
<pre>>Rosetta_Example_1: THERECANBENOSPACE
>Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED</pre>
 
=={{header|ALGOL 68}}==
{{Trans|ALGOL W}}
<syntaxhighlight lang="algol68">
BEGIN # read FASTA format data from standard input and write the results to #
# standard output - only the ">" line start is handled #
 
BOOL at eof := FALSE;
on logical file end( stand in, ( REF FILE f )BOOL: at eof := TRUE );
 
WHILE STRING line;
read( ( line, newline ) );
NOT at eof
DO
IF line /= "" THEN # non-empty line #
INT start := LWB line;
BOOL is heading = line[ start ] = ">"; # check for heading line #
IF is heading THEN
print( ( newline ) );
start +:= 1
FI;
print( ( line[ start : ] ) );
IF is heading THEN print( ( ": " ) ) FI
FI
OD
END
</syntaxhighlight>
{{out}}
<pre>
Rosetta_Example_1: THERECANBENOSPACE
Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED
</pre>
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin
% reads FASTA format data from standard input and write the results to standard output %
% only handles the ">" line start %
Line 236 ⟶ 268:
readcard( line );
end while_not_eof
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 245 ⟶ 277:
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">parseFasta: function [data][
result: #[]
current: ø
Line 268 ⟶ 300:
}
 
inspect.muted parseFasta text</langsyntaxhighlight>
 
{{out}}
Line 278 ⟶ 310:
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">Data =
(
>Rosetta_Example_1
Line 291 ⟶ 323:
Gui, add, Edit, w700, % Data
Gui, show
return</langsyntaxhighlight>
{{out}}
<pre>>Rosetta_Example_1: THERECANBENOSPACE
Line 297 ⟶ 329:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f FASTA_FORMAT.AWK filename
# stop processing each file when an error is encountered
Line 349 ⟶ 381:
return
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 360 ⟶ 392:
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<langsyntaxhighlight lang="qbasic">FUNCTION checkNoSpaces (s$)
FOR i = 1 TO LEN(s$) - 1
IF MID$(s$, i, 1) = CHR$(32) OR MID$(s$, i, 1) = CHR$(9) THEN checkNoSpaces = 0
Line 389 ⟶ 421:
END IF
LOOP
CLOSE #1</langsyntaxhighlight>
 
==={{header|True BASIC}}===
{{trans|QBasic}}
<langsyntaxhighlight lang="qbasic">DEF EOF(f)
IF END #f THEN LET EOF = -1 ELSE LET EOF = 0
END DEF
Line 426 ⟶ 458:
LOOP
CLOSE #1
END</langsyntaxhighlight>
 
=={{header|BASIC256}}==
<langsyntaxhighlight BASIC256lang="basic256">open 1, "input.fasta"
 
first = True
Line 461 ⟶ 493:
next i
return True
end function</langsyntaxhighlight>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Line 501 ⟶ 533:
free(line);
exit(EXIT_SUCCESS);
}</langsyntaxhighlight>
{{out}}
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 508 ⟶ 540:
=={{header|C sharp|C#}}==
 
<langsyntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.IO;
Line 559 ⟶ 591:
Console.ReadLine();
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <fstream>
 
Line 602 ⟶ 634:
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 610 ⟶ 642:
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="clojure">(defn fasta [pathname]
(with-open [r (clojure.java.io/reader pathname)]
(doseq [line (line-seq r)]
(if (= (first line) \>)
(print (format "%n%s: " (subs line 1)))
(print line)))))</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">;; * The input file as a parameter
(defparameter *input* #p"fasta.txt"
"The input file name.")
Line 631 ⟶ 663:
:do (format t "~&~a: " (subseq line 1))
:else
:do (format t "~a" line)))</langsyntaxhighlight>
{{out}}
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 637 ⟶ 669:
=={{header|Crystal}}==
If you want to run below code online, then paste below code to [https://play.crystal-lang.org/#/cr <b>playground</b>]
<langsyntaxhighlight lang="ruby">
# create tmp fasta file in /tmp/
tmpfile = "/tmp/tmp"+Random.rand.to_s+".fasta"
Line 664 ⟶ 696:
# show fasta component
fasta.each { |k,v| puts "#{k}: #{v}"}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 672 ⟶ 704:
=={{header|Delphi}}==
See [https://rosettacode.org/wiki/FASTA_format#Pascal Pascal].
 
=={{header|EasyLang}}==
<syntaxhighlight>
repeat
s$ = input
until s$ = ""
if substr s$ 1 1 = ">"
if stat = 1
print ""
.
stat = 1
print s$
else
write s$
.
.
input_data
>Rosetta_Example_1
THERECANBENOSPACE
>Rosetta_Example_2
THERECANBESEVERAL
LINESBUTTHEYALLMUST
BECONCATENATED
 
</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
//FASTA format. Nigel Galloway: March 23rd., 2023.
let fN(g:string)=match g[0] with '>'->printfn "\n%s:" g[1..] |_->printf "%s" g
let lines=seq{use n=System.IO.File.OpenText("testFASTA.txt") in while not n.EndOfStream do yield n.ReadLine()}
printfn "%s:" ((Seq.head lines)[1..]); Seq.tail lines|>Seq.iter fN; printfn ""
</syntaxhighlight>
{{out}}
<pre>
Rosetta_Example_1:
THERECANBENOSPACE
Rosetta_Example_2:
THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED
</pre>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: formatting io kernel sequences ;
IN: rosetta-code.fasta
 
Line 683 ⟶ 755:
readln rest "%s: " printf [ process-fasta-line ] each-line ;
 
MAIN: main</langsyntaxhighlight>
{{out}}
<pre>
Line 692 ⟶ 764:
=={{header|Forth}}==
Developed with gforth 0.7.9
<langsyntaxhighlight lang="forth">1024 constant max-Line
char > constant marker
 
Line 708 ⟶ 780:
cr ;
Test
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 718 ⟶ 790:
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 :
<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Function checkNoSpaces(s As String) As Boolean
Line 755 ⟶ 827:
Print : Print
Print "Press any key to quit"
Sleep</langsyntaxhighlight>
 
{{out}}
Line 764 ⟶ 836:
 
=={{header|Gambas}}==
<langsyntaxhighlight lang="gambas">Public Sub Main()
Dim sList As String = File.Load("../FASTA")
Dim sTemp, sOutput As String
Line 779 ⟶ 851:
Print sOutput
 
End</langsyntaxhighlight>
Output:
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 786 ⟶ 858:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 828 ⟶ 900:
fmt.Println(err)
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 842 ⟶ 914:
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.
 
<langsyntaxhighlight lang="haskell">import Data.List ( groupBy )
 
parseFasta :: FilePath -> IO ()
Line 858 ⟶ 930:
pair :: [String] -> [(String, String)]
pair [] = []
pair (x : y : xs) = (drop 1 x, y) : pair xs</langsyntaxhighlight>
 
{{out}}
Line 868 ⟶ 940:
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.
 
<langsyntaxhighlight lang="haskell">import Text.ParserCombinators.ReadP
import Control.Applicative ( (<|>) )
import Data.Char ( isAlpha, isAlphaNum )
Line 885 ⟶ 957:
name = char '>' *> many (satisfy isAlphaNum <|> char '_') <* newline
code = concat <$> many (many (satisfy isAlpha) <* newline)
newline = char '\n'</langsyntaxhighlight>
 
{{out}}
Line 893 ⟶ 965:
=={{header|J}}==
Needs chunking to handle huge files.
<langsyntaxhighlight lang="j">require 'strings' NB. not needed for J versions greater than 6.
parseFasta=: ((': ' ,~ LF&taketo) , (LF -.~ LF&takeafter));._1</langsyntaxhighlight>
'''Example Usage'''
<langsyntaxhighlight lang="j"> Fafile=: noun define
>Rosetta_Example_1
THERECANBENOSPACE
Line 906 ⟶ 978:
parseFasta Fafile
Rosetta_Example_1: THERECANBENOSPACE
Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED</langsyntaxhighlight>
 
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:
 
<langsyntaxhighlight Jlang="j">bs=: 2
chunkFasta=: {{
r=. EMPTY
Line 937 ⟶ 1,009:
end.
r
}}</langsyntaxhighlight>
 
Here, we're using a block size of 2 bytes, to illustrate correctness. If speed matters, we should use something significantly larger.
Line 945 ⟶ 1,017:
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:
 
<langsyntaxhighlight Jlang="j"> fasta=: '~temp' chunkFasta '~/fasta.txt'</langsyntaxhighlight>
 
And, to complete the task:
 
<langsyntaxhighlight Jlang="j"> ;(,': ',,&LF)each/"1 fread each fasta
Rosetta_Example_1: THERECANBENOSPACE
Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED</langsyntaxhighlight>
 
=={{header|Java}}==
This implementation presumes the data-file is well-formed
<syntaxhighlight lang="java">
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
</syntaxhighlight>
<syntaxhighlight lang="java">
public static void main(String[] args) throws IOException {
List<FASTA> fastas = readFile("fastas.txt");
for (FASTA fasta : fastas)
System.out.println(fasta);
}
 
static List<FASTA> readFile(String path) throws IOException {
try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
List<FASTA> list = new ArrayList<>();
StringBuilder lines = null;
String newline = System.lineSeparator();
String line;
while ((line = reader.readLine()) != null) {
if (line.startsWith(">")) {
if (lines != null)
list.add(parseFASTA(lines.toString()));
lines = new StringBuilder();
lines.append(line).append(newline);
} else {
lines.append(line);
}
}
list.add(parseFASTA(lines.toString()));
return list;
}
}
 
static FASTA parseFASTA(String string) {
String description;
char[] sequence;
int indexOf = string.indexOf(System.lineSeparator());
description = string.substring(1, indexOf);
/* using 'stripLeading' will remove any additional line-separators */
sequence = string.substring(indexOf + 1).stripLeading().toCharArray();
return new FASTA(description, sequence);
}
 
/* using a 'char' array seems more logical */
record FASTA(String description, char[] sequence) {
@Override
public String toString() {
return "%s: %s".formatted(description, new String(sequence));
}
}
</syntaxhighlight>
<pre>
Rosetta_Example_1: THERECANBENOSPACE
Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED
</pre>
 
<br />
An alternate demonstration
{{trans|D}}
{{works with|Java|7}}
<langsyntaxhighlight lang="java">import java.io.*;
import java.util.Scanner;
 
Line 981 ⟶ 1,114:
System.out.println();
}
}</langsyntaxhighlight>
 
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 989 ⟶ 1,122:
=={{header|JavaScript}}==
The code below uses Nodejs to read the file.
<syntaxhighlight lang="javascript">
<lang JavaScript>
const fs = require("fs");
const readline = require("readline");
Line 1,018 ⟶ 1,151:
 
readInterface.on("close", () => process.stdout.write("\n"));
</syntaxhighlight>
</lang>
 
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 1,029 ⟶ 1,162:
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.
<syntaxhighlight lang="jq">
<lang jq>
def fasta:
foreach (inputs, ">") as $line
Line 1,040 ⟶ 1,173:
;
 
fasta</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="sh">$ jq -n -R -r -f FASTA_format.jq < FASTA_format.fasta
Rosetta_Example_1: THERECANBENOSPACE
Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED</langsyntaxhighlight>
 
=={{header|Julia}}==
{{works with|Julia|0.6}}
 
<langsyntaxhighlight lang="julia">for line in eachline("data/fasta.txt")
if startswith(line, '>')
print(STDOUT, "\n$(line[2:end]): ")
Line 1,055 ⟶ 1,188:
print(STDOUT, "$line")
end
end</langsyntaxhighlight>
 
=={{header|Kotlin}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight lang="scala">// version 1.1.2
 
import java.util.Scanner
Line 1,088 ⟶ 1,221:
}
sc.close()
}</langsyntaxhighlight>
 
{{out}}
Line 1,097 ⟶ 1,230:
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">local file = io.open("input.txt","r")
local data = file:read("*a")
file:close()
Line 1,120 ⟶ 1,253:
for k,v in pairs(output) do
print(k..": "..v)
end</langsyntaxhighlight>
 
{{out}}
Line 1,134 ⟶ 1,267:
 
 
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
Module CheckIt {
Class FASTA_MACHINE {
Line 1,238 ⟶ 1,371:
}
checkit
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Mathematica has built-in support for FASTA files and strings
<langsyntaxhighlight Mathematicalang="mathematica">ImportString[">Rosetta_Example_1
THERECANBENOSPACE
>Rosetta_Example_2
Line 1,248 ⟶ 1,381:
LINESBUTTHEYALLMUST
BECONCATENATED
", "FASTA"]</langsyntaxhighlight>
{{out}}
<pre>{"THERECANBENOSPACE", "THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED"}</pre>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">
<lang Nim>
import strutils
 
Line 1,274 ⟶ 1,407:
 
fasta(input)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Rosetta_Example_1: THERECANBENOSPACE
Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED
</pre>
=={{header|Oberon}}==
Works with A2 Oberon.
 
<syntaxhighlight lang="Oberon">
MODULE Fasta;
 
IMPORT Files, Streams, Strings, Commands;
 
PROCEDURE PrintOn*(filename: ARRAY OF CHAR; wr: Streams.Writer);
VAR
rd: Files.Reader;
f: Files.File;
line: ARRAY 1024 OF CHAR;
res: BOOLEAN;
BEGIN
f := Files.Old(filename);
ASSERT(f # NIL);
NEW(rd,f,0);
res := rd.GetString(line);
WHILE rd.res # Streams.EOF DO
IF line[0] = '>' THEN
wr.Ln;
wr.String(Strings.Substring2(1,line)^);
wr.String(": ")
ELSE
wr.String(line)
END;
res := rd.GetString(line)
END
END PrintOn;
 
PROCEDURE Do*;
VAR
ctx: Commands.Context;
filename: ARRAY 256 OF CHAR;
res: BOOLEAN
BEGIN
ctx := Commands.GetContext();
res := ctx.arg.GetString(filename);
PrintOn(filename,ctx.out)
END Do;
 
END Fasta.
</syntaxhighlight>
{{out}}
<pre>
Line 1,282 ⟶ 1,464:
 
=={{header|Objeck}}==
<langsyntaxhighlight lang="objeck">class Fasta {
function : Main(args : String[]) ~ Nil {
if(args->Size() = 1) {
Line 1,307 ⟶ 1,489:
}
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,320 ⟶ 1,502:
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+}}
<langsyntaxhighlight lang="ocaml">
(* This program reads from the standard input and writes to standard output.
* Examples of use:
Line 1,361 ⟶ 1,543:
let () =
print_fasta stdin
</syntaxhighlight>
</lang>
{{out}}
Rosetta_Example_1: THERECANBENOSPACE
Line 1,367 ⟶ 1,549:
 
=={{header|Pascal}}==
<syntaxhighlight lang="pascal">
<lang Pascal>
program FASTA_Format;
// FPC 3.0.2
Line 1,407 ⟶ 1,589:
Close(InF);
end.
</syntaxhighlight>
</lang>
 
FASTA_Format < test.fst
Line 1,416 ⟶ 1,598:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">my $fasta_example = <<'END_FASTA_EXAMPLE';
>Rosetta_Example_1
THERECANBENOSPACE
Line 1,434 ⟶ 1,616:
print;
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,442 ⟶ 1,624:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(notonline)-->
<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>
Line 1,466 ⟶ 1,648:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,474 ⟶ 1,656:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de fasta (F)
(in F
(while (from ">")
Line 1,481 ⟶ 1,663:
(prin (line T)) )
(prinl) ) ) )
(fasta "fasta.dat")</langsyntaxhighlight>
{{out}}
<pre>
Rosetta_Example_1: THERECANBENOSPACE
Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED
</pre>
 
=={{header|PL/M}}==
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
Reads the data from the file named on the command line, e.g., if the program is stored in D:FASTA.COM and the data in D:FSTAIN.TXT, the following could be used: <code>D:FASTA D:FASTAIN.TXT</code>.<br>
Restarts CP/M when the program finishes.
<syntaxhighlight lang="plm">
100H: /* DISPLAY THE CONTENTS OF A FASTA FORMT FILE */
 
DECLARE FALSE LITERALLY '0', TRUE LITERALLY '0FFH';
DECLARE NL$CHAR LITERALLY '0AH'; /* NEWLINE: CHAR 10 */
DECLARE CR$CHAR LITERALLY '0DH'; /* CARRIAGE RETURN, CHAR 13 */
DECLARE EOF$CHAR LITERALLY '26'; /* EOF: CTRL-Z */
/* CP/M BDOS SYSTEM CALL, RETURNS A VALUE */
BDOS: PROCEDURE( FN, ARG )BYTE; DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
/* CP/M BDOS SYSTEM CALL, NO RETURN VALUE */
BDOS$P: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
EXIT: PROCEDURE; CALL BDOS$P( 0, 0 ); END; /* CP/M SYSTEM RESET */
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS$P( 2, C ); END;
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS$P( 9, S ); END;
PR$NL: PROCEDURE; CALL PR$STRING( .( 0DH, NL$CHAR, '$' ) ); END;
FL$EXISTS: PROCEDURE( FCB )BYTE; /* RETURNS TRUE IF THE FILE NAMED IN THE */
DECLARE FCB ADDRESS; /* FCB EXISTS */
RETURN ( BDOS( 17, FCB ) < 4 );
END FL$EXISTS ;
FL$OPEN: PROCEDURE( FCB )BYTE; /* OPEN THE FILE WITH THE SPECIFIED FCB */
DECLARE FCB ADDRESS;
RETURN ( BDOS( 15, FCB ) < 4 );
END FL$OPEN;
FL$READ: PROCEDURE( FCB )BYTE; /* READ THE NEXT RECORD FROM FCB */
DECLARE FCB ADDRESS;
RETURN ( BDOS( 20, FCB ) = 0 );
END FL$READ;
FL$CLOSE: PROCEDURE( FCB )BYTE; /* CLOSE THE FILE WITH THE SPECIFIED FCB */
DECLARE FCB ADDRESS;
RETURN ( BDOS( 16, FCB ) < 4 );
END FL$CLOSE;
 
/* I/O USES FILE CONTROL BLOCKS CONTAINING THE FILE-NAME, POSITION, ETC. */
/* WHEN THE PROGRAM IS RUN, THE CCP WILL FIRST PARSE THE COMMAND LINE AND */
/* PUT THE FIRST PARAMETER IN FCB1, THE SECOND PARAMETER IN FCB2 */
/* BUT FCB2 OVERLAYS THE END OF FCB1 AND THE DMA BUFFER OVERLAYS THE END */
/* OF FCB2 */
 
DECLARE FCB$SIZE LITERALLY '36'; /* SIZE OF A FCB */
DECLARE FCB1 LITERALLY '5CH'; /* ADDRESS OF FIRST FCB */
DECLARE FCB2 LITERALLY '6CH'; /* ADDRESS OF SECOND FCB */
DECLARE DMA$BUFFER LITERALLY '80H'; /* DEFAULT DMA BUFFER ADDRESS */
DECLARE DMA$SIZE LITERALLY '128'; /* SIZE OF THE DMA BUFFER */
 
DECLARE F$PTR ADDRESS, F$CHAR BASED F$PTR BYTE;
 
/* CLEAR THE PARTS OF FCB1 OVERLAYED BY FCB2 */
DO F$PTR = FCB1 + 12 TO FCB1 + ( FCB$SIZE - 1 );
F$CHAR = 0;
END;
 
/* SHOW THE FASTA DATA, IF THE FILE EXISTS */
IF NOT FL$EXISTS( FCB1 ) THEN DO; /* THE FILE DOES NOT EXIST */
CALL PR$STRING( .'FILE NOT FOUND$' );CALL PR$NL;
END;
ELSE IF NOT FL$OPEN( FCB1 ) THEN DO; /* UNABLE TO OPEN THE FILE */
CALL PR$STRING( .'UNABLE TO OPEN THE FILE$' );CALL PR$NL;
END;
ELSE DO; /* FILE EXISTS AND OPENED OK - ATTEMPT TO SHOW THE DATA */
DECLARE ( BOL, GOT$RCD, IS$HEADING ) BYTE, DMA$END ADDRESS;
DMA$END = DMA$BUFFER + ( DMA$SIZE - 1 );
GOT$RCD = FL$READ( FCB1 ); /* GET THE FIRST RECORD */
F$PTR = DMA$BUFFER;
BOL = TRUE;
IS$HEADING = FALSE;
DO WHILE GOT$RCD;
IF F$PTR > DMA$END THEN DO; /* END OF BUFFER */
GOT$RCD = FL$READ( FCB1 ); /* GET THE NEXT RECORDD */
F$PTR = DMA$BUFFER;
END;
ELSE IF F$CHAR = NL$CHAR THEN DO; /* END OF LINE */
IF IS$HEADING THEN DO;
CALL PR$STRING( .': $' );
IS$HEADING = FALSE;
END;
BOL = TRUE;
END;
ELSE IF F$CHAR = CR$CHAR THEN DO; END; /* IGNORE CARRIAGE RETURN */
ELSE IF F$CHAR = EOF$CHAR THEN GOT$RCD = FALSE; /* END OF FILE */
ELSE DO; /* HAVE ANOTHER CHARACTER */
IF NOT BOL THEN CALL PR$CHAR( F$CHAR ); /* NOT FIRST CHARACTER */
ELSE DO; /* FIRST CHARACTER - CHECK FOR A HEADING LINE */
BOL = FALSE;
IF IS$HEADING := F$CHAR = '>' THEN CALL PR$NL;
ELSE CALL PR$CHAR( F$CHAR );
END;
END;
F$PTR = F$PTR + 1;
END;
/* CLOSE THE FILE */
IF NOT FL$CLOSE( FCB1 ) THEN DO;
CALL PR$STRING( .'UNABLE TO CLOSE THE FILE$' ); CALL PR$NL;
END;
END;
 
CALL EXIT;
 
EOF
</syntaxhighlight>
{{out}}
<pre>
Line 1,491 ⟶ 1,782:
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+}}
<syntaxhighlight lang="powershell">
<lang PowerShell>
$file = @'
>Rosetta_Example_1
Line 1,513 ⟶ 1,804:
 
$output | Format-List
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 1,521 ⟶ 1,812:
 
===Version 3.0 Or Less===
<syntaxhighlight lang="powershell">
<lang PowerShell>
$file = @'
>Rosetta_Example_1
Line 1,543 ⟶ 1,834:
 
$output | Format-List
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 1,551 ⟶ 1,842:
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">EnableExplicit
Define Hdl_File.i,
Frm_File.i,
Line 1,579 ⟶ 1,870:
CloseFile(Hdl_File)
Input()
EndIf</langsyntaxhighlight>
{{out}}
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 1,589 ⟶ 1,880:
and I use a generator expression yielding key, value pairs
as soon as they are read, keeping the minimum in memory.
<langsyntaxhighlight lang="python">import io
 
FASTA='''\
Line 1,613 ⟶ 1,904:
yield key, val
 
print('\n'.join('%s: %s' % keyval for keyval in fasta_parse(infile)))</langsyntaxhighlight>
 
{{out}}
Line 1,620 ⟶ 1,911:
 
=={{header|R}}==
<langsyntaxhighlight lang="rsplus">
library("seqinr")
 
Line 1,633 ⟶ 1,924:
cat(attr(aline, 'Annot'), ":", aline, "\n")
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,641 ⟶ 1,932:
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">
#lang racket
(let loop ([m #t])
Line 1,651 ⟶ 1,942:
(current-output-port)))))
(newline)
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" perl6line>grammar FASTA {
 
rule TOP { <entry>+ }
Line 1,675 ⟶ 1,966:
for $/<entry>[] {
say ~.<title>, " : ", .<sequence>.made;
}</langsyntaxhighlight>
{{out}}
<pre>Rosetta_Example_1 : THERECANBENOSPACE
Line 1,684 ⟶ 1,975:
===version 1===
This REXX version correctly processes the examples shown.
<langsyntaxhighlight lang="rexx">/*REXX program reads a (bio-informational) FASTA file and displays the contents. */
parseParse argArg iFIDifid . /* iFID: the input file to be read. */
If ifid=='' Then
if iFID=='' then iFID='FASTA.IN' /*Not specified? Then use the default.*/
name= ifid='FASTA.IN' /* Not specified? Then use /*the namedefault of an output file (so far). */
$name='' /* the name of an output file (so far) /*the value of the output file's stuff.*/
d='' do while lines(iFID)\==0 /*process the value FASTAof the output file's contents. */
Do While lines(ifid)\==0 x=strip( linein(iFID), 'T') /* process the FASTA file /*readcontents a line (a record) from the file,*/
x=strip(linein(ifid),'T') /* read a line (a record) from the input */
/*───────── and strip trailing blanks. */
/* and strip trailing blanks */
if left(x, 1)=='>' then do
If left(x,1)=='>' Then Do /* a new file id if $\=='' then say name':' $*/
Call out /* show output name=substr(x, and data 2)*/
name=substr(x,2) /* and get the new (or first) $=output name */
d='' end /* start with empty contents */
End
else $=$ || x
Else end /*j*/ /* a line with data /* [↓] show output of last file used. */
if $\= d=''d||x then say name':' $ /*stick aappend it to output fork in it, we're all done. */</lang>
End
Call out /* show output of last file used. */
Exit
 
out:
If d\=='' Then /* if there ara data */
Say name':' d /* show output name and data */
Return</syntaxhighlight>
{{out|output|text=&nbsp; when using the default input filename:}}
<pre>
Line 1,712 ⟶ 2,011:
::* &nbsp; sequences that contain blanks, tabs, and other whitespace
::* &nbsp; sequence names that are identified with a semicolon &nbsp; [''';''']
<langsyntaxhighlight lang="rexx">/*REXX program reads a (bio-informational) FASTA file and displays the contents. */
parseParse argArg iFID . /*iFID: the input file to be read. */
ifIf iFID=='' thenThen iFID='FASTA2.IN' /*Not specified? Then use the default.*/
name= '' /*the name of an output file (so far). */
data=''
$= /*the value of the output file's stuff.*/
do while lines(iFID)\==0 /*process the value FASTAof the output file's contentsstuff. */
Do While x=strip( lineinlines(iFID),\==0 'T') /*readprocess athe line (aFASTA record) fromfile contents. the file,*/
x=strip(linein(iFID),'T') /*read a line (a record) from the file,*/
/*───────── and strip trailing blanks. */
if x=='' then iterate /*If the line is all blank, ignore it /*--------- and strip trailing blanks. */
Select
if left(x, 1)==';' then do
When x=='' Then /* ifIf name==''the thenline name=substr(xis all blank,2) */
Nop say x /* ignore it. */
When left(x,1)==';' Then Do
iterate
If name=='' Then name=substr(x,2)
end
if left(Say x, 1)=='>' then do
End
if $\=='' then say name':' $
When left(x,1)=='>' Then Do
name=substr(x, 2)
If data\=='' Then
$=
Say name':' enddata
name=substr(x,2)
else $=space($ || translate(x, , '*'), 0)
data=''
end /*j*/ /* [↓] show output of last file used. */
End
if $\=='' then say name':' $ /*stick a fork in it, we're all done. */</lang>
Otherwise
data=space(data||translate(x, ,'*'),0)
End
End
If data\=='' Then
Say name':' data /* [?] show output of last file used. */
</syntaxhighlight>
<pre>
'''input:''' &nbsp; The &nbsp; '''FASTA2.IN''' &nbsp; file is shown below:
Line 1,766 ⟶ 2,072:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : FAST format
 
Line 1,789 ⟶ 2,095:
i = i + 1
end
</syntaxhighlight>
</lang>
Output:
<pre>
Line 1,797 ⟶ 2,103:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">def fasta_format(strings)
out, text = [], ""
strings.split("\n").each do |line|
Line 1,819 ⟶ 2,125:
EOS
 
puts fasta_format(data)</langsyntaxhighlight>
 
{{out}}
Line 1,828 ⟶ 2,134:
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">a$ = ">Rosetta_Example_1
THERECANBENOSPACE
>Rosetta_Example_2
Line 1,845 ⟶ 2,151:
end if
i = i + 1
wend</langsyntaxhighlight>
{{out}}
<pre>>Rosetta_Example_1: THERECANBENOSPACE
Line 1,854 ⟶ 2,160:
This example is implemented using an [https://doc.rust-lang.org/book/iterators.html iterator] to reduce memory requirements and encourage code reuse.
 
<langsyntaxhighlight lang="rust">
use std::env;
use std::io::{BufReader, Lines};
Line 1,918 ⟶ 2,224:
}
}
</syntaxhighlight>
</lang>
{{out}}
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 1,924 ⟶ 2,230:
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">import java.io.File
import java.util.Scanner
 
Line 1,942 ⟶ 2,248:
 
println("~~~+~~~")
}</langsyntaxhighlight>
 
=={{header|Scheme}}==
<langsyntaxhighlight lang="scheme">(import (scheme base)
(scheme file)
(scheme write))
Line 1,960 ⟶ 2,266:
(display (string-copy line 1)) (display ": "))
(else ; display the string directly
(display line))))))</langsyntaxhighlight>
{{out}}
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 1,966 ⟶ 2,272:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const proc: main is func
Line 1,992 ⟶ 2,298:
end if;
writeln;
end func;</langsyntaxhighlight>
 
{{out}}
Line 2,002 ⟶ 2,308:
=={{header|Sidef}}==
{{trans|Ruby}}
<langsyntaxhighlight lang="ruby">func fasta_format(strings) {
var out = []
var text = ''
Line 2,026 ⟶ 2,332:
THERECANBESEVERAL
LINESBUTTHEYALLMUST
BECONCATENATED</langsyntaxhighlight>
{{out}}
<pre>
Rosetta_Example_1: THERECANBENOSPACE
Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED
</pre>
 
=={{header|Smalltalk}}==
Works with Pharo Smalltalk
<syntaxhighlight lang="smalltalk">
FileLocator home / aFilename readStreamDo: [ :stream |
[ stream atEnd ] whileFalse: [
| line |
((line := stream nextLine) beginsWith: '>')
ifTrue: [
Transcript
cr;
show: (line copyFrom: 2 to: line size);
show: ': ' ]
ifFalse: [ Transcript show: line ] ] ]
</syntaxhighlight>
{{out}}
<pre>
Line 2,034 ⟶ 2,360:
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">proc fastaReader {filename} {
set f [open $filename]
set sep ""
Line 2,049 ⟶ 2,375:
}
 
fastaReader ./rosettacode.fas</langsyntaxhighlight>
{{out}}
<pre>
Line 2,058 ⟶ 2,384:
=={{header|TMG}}==
Unix TMG: <!-- C port of TMG processes 1.04 GB FASTA file in 38 seconds on a generic laptop -->
<langsyntaxhighlight UnixTMGlang="unixtmg">prog: ignore(spaces)
loop: parse(line)\loop parse(( = {*} ));
line: ( name | * = {} | seqns );
Line 2,071 ⟶ 2,397:
spaces: << >>;
 
f: 1;</langsyntaxhighlight>
 
=={{header|uBasic/4tH}}==
<syntaxhighlight lang="text">If Cmd (0) < 2 Then Print "Usage: fasta <fasta file>" : End
If Set(a, Open (Cmd(2), "r")) < 0 Then Print "Cannot open \q";Cmd(2);"\q" : End
 
Line 2,095 ⟶ 2,421:
Local (4)
 
b@ := Dup("") ' start with an empty string
 
Do
Line 2,105 ⟶ 2,431:
Loop ' if not add the line to current string
 
Return (b@) ' return the string</langsyntaxhighlight>
{{out}}
<pre>Rosetta_Example_1: THERECANBENOSPACE
Line 2,111 ⟶ 2,437:
 
0 OK, 0:431 </pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="Vlang">
const data = (
">Rosetta_Example_1
THERECANBENOSPACE
>Rosetta_Example_2
THERECANBESEVERAL
LINESBUTTHEYALLMUST
BECONCATENATED"
)
 
fn main() {
mut i := 0
for i <= data.len {
if data.substr_ni(i, i + 17) == ">Rosetta_Example_" {
print("\n" + data.substr_ni(i, i + 18) + ": ")
i = i + 17
}
else {
if data.substr_ni(i, i + 1) > "\x20" {print(data[i].ascii_str())}
}
i++
}
}
</syntaxhighlight>
 
{{out}}
<pre>
>Rosetta_Example_1: THERECANBENOSPACE
>Rosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED
</pre>
 
=={{header|Wren}}==
{{trans|Kotlin}}
More or less.
<langsyntaxhighlight ecmascriptlang="wren">import "io" for File
 
var checkNoSpaces = Fn.new { |s| !s.contains(" ") && !s.contains("\t") }
Line 2,153 ⟶ 2,512:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 2,162 ⟶ 2,521:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">proc Echo; \Echo line of characters from file to screen
int Ch;
def LF=$0A, EOF=$1A;
Line 2,184 ⟶ 2,543:
Echo;
];
]</langsyntaxhighlight>
 
{{out}}
Line 2,194 ⟶ 2,553:
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn fasta(data){ // a lazy cruise through a FASTA file
fcn(w){ // one string at a time, -->False garbage at front of file
line:=w.next().strip();
Line 2,201 ⟶ 2,560:
})
}.fp(data.walker()) : Utils.Helpers.wap(_);
}</langsyntaxhighlight>
*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:
<langsyntaxhighlight lang="zkl">foreach l in (fasta(File("fasta.txt"))) { println(l) }</langsyntaxhighlight>
FASTA data blob:
<langsyntaxhighlight lang="zkl">data:=Data(0,String,
">Rosetta_Example_1\nTHERECANBENOSPACE\n"
">Rosetta_Example_2\nTHERECANBESEVERAL\nLINESBUTTHEYALLMUST\n"
"BECONCATENATED");
foreach l in (fasta(data)) { println(l) }</langsyntaxhighlight>
{{out}}
<pre>
Walterpachl
2,295

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/228845...361165"