#!/usr/bin/awk -f

# Comments are like this


# AWK programs consist of a collection of patterns and actions.
pattern1 { action; } # just like lex
pattern2 { action; }

# There is an implied loop and AWK automatically reads and parses each
# record of each file supplied. Each record is split by the FS delimiter,
# which defaults to white-space (multiple spaces,tabs count as one)
# You can assign FS either on the command line (-F C) or in your BEGIN
# pattern

# One of the special patterns is BEGIN. The BEGIN pattern is true
# BEFORE any of the files are read. The END pattern is true after
# an End-of-file from the last file (or standard-in if no files specified)
# There is also an output field separator (OFS) that you can assign, which
# defaults to a single space

BEGIN {

    # BEGIN will run at the beginning of the program. It's where you put all
    # the preliminary set-up code, before you process any text files. If you
    # have no text files, then think of BEGIN as the main entry point.

    # Variables are global. Just set them or use them, no need to declare..
    count = 0;

    # Operators just like in C and friends
    a = count + 1;
    b = count - 1;
    c = count * 1;
    d = count / 1; # integer division
    e = count % 1; # modulus
    f = count ^ 1; # exponentiation

    a += 1;
    b -= 1;
    c *= 1;
    d /= 1;
    e %= 1;
    f ^= 1;

    # Incrementing and decrementing by one
    a++;
    b--;

    # As a prefix operator, it returns the incremented value
    ++a;
    --b;

    # Notice, also, no punctuation such as semicolons to terminate statements

    # Control statements
    if (count == 0)
        print "Starting with count of 0";
    else
        print "Huh?";

    # Or you could use the ternary operator
    print (count == 0) ? "Starting with count of 0" : "Huh?";

    # Blocks consisting of multiple lines use braces
    while (a < 10) {
        print "String concatenation is done" " with a series" " of"
            " space-separated strings";
        print a;

        a++;
    }

    for (i = 0; i < 10; i++)
        print "Good ol' for loop";

    # As for comparisons, they're the standards:
    # a < b   # Less than
    # a <= b  # Less than or equal
    # a != b  # Not equal
    # a == b  # Equal
    # a > b   # Greater than
    # a >= b  # Greater than or equal

    # Logical operators as well
    # a && b  # AND
    # a || b  # OR

    # In addition, there's the super useful regular expression match
    if ("foo" ~ "^fo+$")
        print "Fooey!";
    if ("boo" !~ "^fo+$")
        print "Boo!";

    # Arrays
    arr[0] = "foo";
    arr[1] = "bar";

    # You can also initialize an array with the built-in function split()

    n = split("foo:bar:baz", arr, ":");

    # You also have associative arrays (actually, they're all associative arrays)
    assoc["foo"] = "bar";
    assoc["bar"] = "baz";

    # And multi-dimensional arrays, with some limitations I won't mention here
    multidim[0,0] = "foo";
    multidim[0,1] = "bar";
    multidim[1,0] = "baz";
    multidim[1,1] = "boo";

    # You can test for array membership
    if ("foo" in assoc)
        print "Fooey!";

    # You can also use the 'in' operator to traverse the keys of an array
    for (key in assoc)
        print assoc[key];

    # The command line is in a special array called ARGV
    for (argnum in ARGV)
        print ARGV[argnum];

    # You can remove elements of an array
    # This is particularly useful to prevent AWK from assuming the arguments
    # are files for it to process
    delete ARGV[1];

    # The number of command line arguments is in a variable called ARGC
    print ARGC;

    # AWK has several built-in functions. They fall into three categories. I'll
    # demonstrate each of them in their own functions, defined later.

    return_value = arithmetic_functions(a, b, c);
    string_functions();
    io_functions();
}

# Here's how you define a function
function arithmetic_functions(a, b, c,     d) {

    # Probably the most annoying part of AWK is that there are no local
    # variables. Everything is global. For short scripts, this is fine, even
    # useful, but for longer scripts, this can be a problem.

    # There is a work-around (ahem, hack). Function arguments are local to the
    # function, and AWK allows you to define more function arguments than it
    # needs. So just stick local variable in the function declaration, like I
    # did above. As a convention, stick in some extra whitespace to distinguish
    # between actual function parameters and local variables. In this example,
    # a, b, and c are actual parameters, while d is merely a local variable.

    # Now, to demonstrate the arithmetic functions

    # Most AWK implementations have some standard trig functions
    localvar = sin(a);
    localvar = cos(a);
    localvar = atan2(b, a); # arc tangent of b / a

    # And logarithmic stuff
    localvar = exp(a);
    localvar = log(a);

    # Square root
    localvar = sqrt(a);

    # Truncate floating point to integer
    localvar = int(5.34); # localvar => 5

    # Random numbers
    srand(); # Supply a seed as an argument. By default, it uses the time of day
    localvar = rand(); # Random number between 0 and 1.

    # Here's how to return a value
    return localvar;
}

function string_functions(    localvar, arr) {

    # AWK, being a string-processing language, has several string-related
    # functions, many of which rely heavily on regular expressions.

    # Search and replace, first instance (sub) or all instances (gsub)
    # Both return number of matches replaced
    localvar = "fooooobar";
    sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
    gsub("e+", ".", localvar); # localvar => "m..t m. at th. bar"

    # Search for a string that matches a regular expression
    # index() does the same thing, but doesn't allow a regular expression
    match(localvar, "t"); # => 4, since the 't' is the fourth character

    # Split on a delimiter
    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3

    # Other useful stuff
    sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
    substr("foobar", 2, 3); # => "oob"
    substr("foobar", 4); # => "bar"
    length("foo"); # => 3
    tolower("FOO"); # => "foo"
    toupper("foo"); # => "FOO"
}

function io_functions(    localvar) {

    # You've already seen print
    print "Hello world";

    # There's also printf
    printf("%s %d %d %d\n", "Testing", 1, 2, 3);

    # AWK doesn't have file handles, per se. It will automatically open a file
    # handle for you when you use something that needs one. The string you used
    # for this can be treated as a file handle, for purposes of I/O. This makes
    # it feel sort of like shell scripting, but to get the same output, the string
    # must match exactly, so use a variable:

    outfile = "/tmp/foobar.txt";

    print "foobar" > outfile;

    # Now the string outfile is a file handle. You can close it:
    close(outfile);

    # Here's how you run something in the shell
    system("echo foobar"); # => prints foobar

    # Reads a line from standard input and stores in localvar
    getline localvar;

    # Reads a line from a pipe (again, use a string so you close it properly)
    cmd = "echo foobar";
    cmd | getline localvar; # localvar => "foobar"
    close(cmd);

    # Reads a line from a file and stores in localvar
    infile = "/tmp/foobar.txt";
    getline localvar < infile; 
    close(infile);
}

# As I said at the beginning, AWK programs consist of a collection of patterns
# and actions. You've already seen the BEGIN pattern. Other
# patterns are used only if you're processing lines from files or standard
# input.
#
# When you pass arguments to AWK, they are treated as file names to process.
# It will process them all, in order. Think of it like an implicit for loop,
# iterating over the lines in these files. these patterns and actions are like
# switch statements inside the loop. 

/^fo+bar$/ {

    # This action will execute for every line that matches the regular
    # expression, /^fo+bar$/, and will be skipped for any line that fails to
    # match it. Let's just print the line:

    print;

    # Whoa, no argument! That's because print has a default argument: $0.
    # $0 is the name of the current line being processed. It is created
    # automatically for you.

    # You can probably guess there are other $ variables. Every line is
    # implicitly split before every action is called, much like the shell
    # does. And, like the shell, each field can be access with a dollar sign

    # This will print the second and fourth fields in the line
    print $2, $4;

    # AWK automatically defines many other variables to help you inspect and
    # process each line. The most important one is NF

    # Prints the number of fields on this line
    print NF;

    # Print the last field on this line
    print $NF;
}

# Every pattern is actually a true/false test. The regular expression in the
# last pattern is also a true/false test, but part of it was hidden. If you
# don't give it a string to test, it will assume $0, the line that it's
# currently processing. Thus, the complete version of it is this:

$0 ~ /^fo+bar$/ {
    print "Equivalent to the last pattern";
}

a > 0 {
    # This will execute once for each line, as long as a is positive
}

# You get the idea. Processing text files, reading in a line at a time, and
# doing something with it, particularly splitting on a delimiter, is so common
# in UNIX that AWK is a scripting language that does all of it for you, without
# you needing to ask. All you have to do is write the patterns and actions
# based on what you expect of the input, and what you want to do with it.

# Here's a quick example of a simple script, the sort of thing AWK is perfect
# for. It will read a name from standard input and then will print the average
# age of everyone with that first name. Let's say you supply as an argument the
# name of a this data file:
#
# Bob Jones 32
# Jane Doe 22
# Steve Stevens 83
# Bob Smith 29
# Bob Barker 72
#
# Here's the script:

BEGIN {

    # First, ask the user for the name
    print "What name would you like the average age for?";

    # Get a line from standard input, not from files on the command line
    getline name < "/dev/stdin";
}

# Now, match every line whose first field is the given name
$1 == name {

    # Inside here, we have access to a number of useful variables, already
    # pre-loaded for us:
    # $0 is the entire line
    # $3 is the third field, the age, which is what we're interested in here
    # NF is the number of fields, which should be 3
    # NR is the number of records (lines) seen so far
    # FILENAME is the name of the file being processed
    # FS is the field separator being used, which is " " here
    # ...etc. There are plenty more, documented in the man page.

    # Keep track of a running total and how many lines matched
    sum += $3;
    nlines++;
}

# Another special pattern is called END. It will run after processing all the
# text files. Unlike BEGIN, it will only run if you've given it input to
# process. It will run after all the files have been read and processed
# according to the rules and actions you've provided. The purpose of it is
# usually to output some kind of final report, or do something with the
# aggregate of the data you've accumulated over the course of the script.

END {
    if (nlines)
        print "The average age for " name " is " sum / nlines;
}

Find binding specificity information about DNA-protein complexes.

Find information about the binding specificity of DNA-binding proteins.

Predict interacting partners and binding models.

Use this web-based sequence motif visualization system to display sequence motif information in its appropriate three-dimensional (3D) context.

Protein function prediction and annotation in an integrated environment powered by web service.

Find information about protein binding.

Use to predict function from de novo protein sequences.

Search for short active protein sequences with demonstrated biological activities.

Search for ungapped segments corresponding to the most highly conserved regions of proteins.

Identify and measure surface accessible pockets as well as interior inaccessible cavities, for proteins and other molecules.

To search for catalytic residue annotation for enzymes in the Protein Data Bank.

Predict protein function using Gene Ontology.

Automatically calculate evolutionary conservation scores of key amino acid residues and map them on protein structures.

Mine the protein structure space.

Predict short linear motifs (3-8 residues) in a set of protein sequences.

A web client for visualizing protein sequence feature information using DAS.

Identify the domain architecture within a protein sequence.

Predict enzyme catalytic site.

Predict functional sites in eukaryotic proteins.

Use a collection of tools for protein analyses.

Predict potential protein post-translational modifications and find potential single amino acid substitutions in peptides.

Search for information related to the catalytic mechanisms of enzymes.

An integrated feature-based function prediction server for vertebrate proteomes.

Identify the closest matching PRINTS sequence motif fingerprints in a protein sequence.

Search for functional annotation of important sites in proteins with known structures.

Produce 3D conformations of small drug compounds.

A database presenting experiment-based results in human proteomics.

Conduct exhaustive intermediate profile searches of a set of homologous protein sequences.

Design protein mutations in site-directed mutagenesis.

Use for protein functional site identification.

Annotate protein using this integrated annotation resource.

Identify protein family (and DNA) domains, patterns, motifs, protein families, and functional sites.

Interactive forecasting of protein interaction hot spots.

Discover long patterns in protein sequences.

Database containing pairs of structural analogs and their alignments.

Find sequence patterns in DNA and protein sequences.

A web server for knowledge-based modeling of protein-peptide complexes, specifically peptides in complex with major histocompatibility complex (MHC) proteins and kinases.

Predict protein methylation sites.

Find structural segments or motifs for protein structures.

Find motifs in a protein sequence.

Visualize protein sequence motifs on the 3D protein structures.

Find presence of any known protein motif (Prosite and Pfam) in a protein sequence.

Recognize spatial chemical binding patterns common to a set of protein structures.

Analyze proteins for the presence of N-terminal N-myristoylation site.

Find the presence of N-Glycosylation sites in human proteins.

Find the presence of O-GalNAc (mucin type) glycosylation sites in mammalian proteins.

Analyze eukaryotic proteins for the presence of serine, threonine and tyrosine phosphorylation sites.

Find possible kinase specific phosphorylation sites in eukaryotic proteins.

Predict cleavage sites at basic amino acid locations in neuropeptide precursor sequences.

Find information about patented nucleotide and protein sequences.

Search for information about glycoproteins with O-linked and C-linked glycosylation sites.

Find information about protein sequence annotations.

A server to predict protein active site residues.

Search for structural and functional information on the protein functional sites.

Search 3D protein fragments similar in structure to known active, binding and posttranslational modification sites.

Conduct genome wide functional and structural analysis.

Search for phosphorylation data of any protein of interest.

Search for information on prokaryotic proteins that undergo serine, threonine, or tyrosine phosphorylation.

Determine correct names for proteins.

Web application for predicting protein disorder by using physicochemical features and reduced amino acid set of a position-specific scoring matrix.

Find homologous protein-protein interactions across multiple species.

Search your query sequence against PROSITE pattern database for protein motifs.

Find information about protein-RNA complexes from the Protein Data Bank (PDB).

Search for protein fingerprints.

Identify protein families and domains for a given protein sequence.

A comprehensive database of pattern-recognition receptors and their ligands.

Search for short nucleotide or peptide sequences such as cis-elements in nucleotide sequences or small domains and motifs in protein sequences.

Database specialized in documenting human PPBD-containing proteins and PPBD-mediated interactions.

Predicts potential protease cleavage sites and sites cleaved by chemicals in a given protein sequence.

Predict combined transmembrane topology and signal peptides.

Search for eukaryotic phosphorylation sites.

Search for 3D structure and functional annotation of phosphorylation sites in proteins.

Search the database of in vivo phosphorylation sites of human and mouse proteins

Find information about polyglutamine (polyQ) repeats.

Find the presence of protein motifs and patterns in an amino acid sequence.

Predict signal peptide sequences and their cleavage positions in bacterial and eukaryotic amino acid sequences.

Predict protein functions based on known structures.

Predict the location of potential protein-protein binding sites for unbound proteins.

Identify short linear signatures in protein termini.

Analyze and identify newly obtained protein sequences.

Predict protein binding sites in a protein sequence based on geometrical analysis of protein tertiary substructures.

Search for evolutionarily conserved motif-like patterns in protein sequences.

Web-based server for analyzing and predicting RNA binding sites in proteins.

Search for similarities between proteins by simultaneous matching of multiple motifs.

Predict residues in protein sequences that determine the proteins' functional specificity.

Predict specificity-determining residues in protein families.

Find shared motifs in proteins with a common attribute.

Conduct in silico sumoylation sites prediction.

Detect protein sequence section under positive evolution selection.

Search for motifs and patterns within protein sequences.

Detect patterns, profiles and motifs in a protein sequence.

Search for motifs within proteins that are likely to be phosphorylated by specific protein kinases or bind to domains such as SH2 domains, 14-3-3 domains or PDZ domains.

Find information about populations carrying polymorphisms within protein binding pockets that make them susceptible to serious adverse drug reaction (SADR).

Search the presence of a motif in either amino acid sequence or nucleotide sequence.

Predict signal peptides.

Predict signal peptides and their cleavage sites.

Predict the presence of tyrosine sulfation sites in protein sequences

Look at protein structure from a ligand and binding site perspective.

Use a collection of bioinformatics tools at this portal site.

Find information about tandem repeats in proteins that carry fundamental biological functions and are related to a number of human diseases.

Find information about functional residues in alpha-helical and beta-barrel membrane proteins.

Database of domains and motifs with conservative location in transmembrane proteins.

Search for highly conserved and specific protein sequence motifs.

Predict functional sites in protein sequence alignments use different methodologies.

Find de novo protein motifs from chromatin immunoprecipitation data.

Scan query structures for functional sites in both proteins and nucleic acids.

Analyze quantitative structure-activity relationship of related protein families.

Search for ungapped alignments of highly conserved regions among a protein family or superfamily.

Predict the functional sites of proteins.

An expert system for predicting ligand-binding residues in protein structures.

Automatically identify spatially interacting motifs among distantly related proteins sharing similar folds and possessing common ancestral lineage.