text:
# glm-client [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

The client css and base plugin map code. Most client side maps should use this codebase for interacting with
plugins and the server.

## Prerequisites
**Note:** In order to build this project you will need the following installed. Some applications might also need to be
on the system path.
* [git](https://git-scm.com/)
* [Node.js](https://nodejs.org/en/)

## Building
To build the project, run the `build.bat` or `build.sh` file. The results will be outputted to the `release` folder.

repository: WebGL-Map/glm-client

repo_name: WebGL-Map/glm-client


text:
# Polymorphism

Polymorphism is the provision of a single interface to entities of different types or the use of a single symbol to represent multiple different types.

## Types of Polymorphism

### Ad-Hoc Polymorphism

Ad-hoc polymorphism is a a type where functions can be applied to arguments of different types. It is sometimes known as function overloading or operator overloading. A simple example would be a function that replicates existing syntax. That is, if you had an `add()` function, it would perform addition for integer types, and concatenation for strings, and other collection types.

### Parametric Polymorphism

Parametric polymorphism maintains full static type-safety where a data type is written genrically so that it can handle values identically without depending on their type. An example would be a function that combines two lists without caring about the type of elements. That is, it consists of arrays of generic types. Parametric polymorphism is sometimes referred to as generic programming.

### Subtype Polymorphism

Subtype polymorphism is where a subtype is a datatype related to another datatype (the supertype). Elements written to operate on the supertype can also operate on the subtype, but not vice versa. This is typically how the term *polymorphism* is used in the context of object oriented programming. Note that subtype polymorphism differs from inheritance since it is a relationship between types rather than a relationship between types of classes/objects. Rust's enums perform a subtype polymorphism as each variant of the enum is a subtype of the enum supertype.

license: MIT

repository: pauljickling/notes

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: pauljickling/notes


text:
---
layout: default
---

# 1994-01-13 - Digest of droped messages

## Header Data

From<EMAIL_ADDRESS>(Hugh Daniel)

To<EMAIL_ADDRESS>Message Hash: 78211c56eac2f0bb6fd93ac9ad77cab9643f2cb94f92c3cad34adde62ca66e09

Message ID: \<9401132142.AA04999@ ecotone.toad.com\>

Reply To: _N/A_

UTC Datetime: 1994-01-13 21:45:34 UTC

Raw Date: Thu, 13 Jan 94 13:45:34 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Hugh Daniel)
Date: Thu, 13 Jan 94 13:45:34 PST
To<EMAIL_ADDRESS>Subject: Digest of droped messages
Message-ID: <9401132142.AA04999@ ecotone.toad.com>
MIME-Version: 1.0
Content-Type: text/plain

  (The list was broken last night, here are the 6 postings that ended
up on the floor before I fixed it.  --||ugh Daniel)

Date: Thu, 13 Jan 1994 00:45:04 -0400 (EDT)
From: Mike Ingle<EMAIL_ADDRESS>Subject: Crypto & Taxes
To<EMAIL_ADDRESS>Message-Id<EMAIL_ADDRESS>X-Vms-To<EMAIL_ADDRESS>Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT

<EMAIL_ADDRESS>wrote:

>Government tax policies are extremely susceptible to the "tipping
>factor."  Initially, non-compliance is addressed by simply hiking
>up collections across the boards.  When non-compliance reaches
>some critical factor, however, such techniques become counter-
>productive.  Previously compliant taxpayers begin to chaff at
>higher taxes and more aggressive collection.  More and more
>become non-compliant as taxes go higher and higher.  Eventually,
>the runaway chain reaction either causes the government to cut
>back or the system undergoes a core melt-down.  Non-crypto
>versions of this scenario have occurred repeatedly in countries
>around the world.

This is true of government in general. As it gets bigger, government
becomes more oppressive and hostile to the people. It also becomes
more hypocritical, ignoring its own laws and violating its own ideals.
The people then become less obedient, as they realize that the
government is taking advantage of them, and does not care about their
interests. The government becomes more and more oppressive in an
effort to force the people to obey. It soon turns into a police state,
and if the people can become organized enough, they will all refuse to
obey, and there will be a revolution. Communism is the best example.
Most people in those countries did not pick up guns and fight. They
just stopped obeying the government.

Computers, networks, and encryption are powerful organizing tools.
The Chinese have been known to put guards in front of fax machines
in government offices, because dissidents outside the country fax in
political information and news.

--- Mike

From<EMAIL_ADDRESS>(Frode Odegard)
Message-Id<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Subject: Re: Crypto & Taxes

Mike Ingle writes about the government growing bigger and more
oppressive.

Has anyone given any thought to why this happens?  Any ideas?
Is it related to the ethics of the people in a country?  And
if yes, how?  And where does ethics come from anyway?

From: Hal<EMAIL_ADDRESS>Message-Id<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Subject: Court decision re 'willfulness'

A few months ago I posted some information on the statutes criminalizing
unauthorized export of cryptographic software.  (As far as I know, an
investigation into the export of PGP is still being carried on by a
federal grand jury in northern California.)  One of the key aspects of
the law, IMO, is that it states that it is illegal to "willfully" violate
the restrictions.  Several courts have held that this word means that the
government has to prove that the accused knew that his action was illegal.
Contrary to the general rule, this would be a case where ignorance of the
law actually is an excuse.

Tuesday, the Supreme Court overturned a conviction based on the same
principle: the use of the word "willfully" to mean that there had to be
proven knowledge that the action was illegal.  In this case, the accused
had paid a debt using a series of just-under-$10,000 payments, each of which
is small enough to avoid triggering reporting requirements.  "Structuring"
payments in this way to avoid reporting is illegal.  In this case, there
was no question that the accused was trying to violate the requirements, and
he was convicted on that basis.  But the Supreme Court overturned the
conviction because the statute requires "willfully" violating the law, and
in this case the government had not proven that the accused knew that his
actions were illegal.

This is promising with regard to any attempts to crack down on naive crypto
users who, say, put PGP up on the local BBS or FTP site.  As long as they
don't know that what they are doing is illegal (assuming it is), they are
not violating the law.

Here is a summary of the Supreme Court decision from usenet:

NOTE: Where it is feasible, a syllabus (headnote) will be released, as is
being done in connection with this case, at the time the opinion is issued.
The syllabus constitutes no part of the opinion of the Court but has been
prepared by the Reporter of Decisions for the convenience of the reader.
See United States v. Detroit Lumber Co., 200 U. S. 321, 337.

SUPREME COURT OF THE UNITED STATES

Syllabus

RATZLAF v. UNITED STATES
certiorari to the united states court of appeals for
the ninth circuit
No. 92-1196.   Argued November 1, 1993-Decided January 11, 1994

As here relevant, federal law requires a domestic bank involved in
 a cash transaction exceeding $10,000 to file a report with the
 Secretary of the Treasury, 31 U. S. C. 5313(a), 31 CFR
 103.22(a); makes it illegal to ``structure'' a transaction-i.e., to
 break up a single transaction above the reporting threshold into
 two or more separate transactions-``for the purpose of evading the
 reporting requiremen[t],'' 31 U. S. C. 5324(3); and sets out crimi-
 nal penalties for ``[a] person willfully violating'' the antistructuring
 provision, 5322(a).  After the judge at petitioner Waldemar
 Ratzlaf's trial on charges of violating 5322(a) and 5324(3) in-
 structed the jury that the Government had to prove both that the
 defendant knew of the 5313(a) reporting obligation and that he
 attempted to evade that obligation, but did not have to prove that
 he knew the structuring in which he engaged was unlawful,
 Ratzlaf was convicted, fined, and sentenced to prison.  In affirm-
 ing, the Court of Appeals upheld the trial court's construction of
 the legislation.
Held:  To give effect to 5322(a)'s ``willfulness'' requirement, the
 Government must prove that the defendant acted with knowledge
 that the structuring he or she undertook was unlawful, not simply
 that the defendant's purpose was to circumvent a bank's reporting
 obligation.  Section 5324 itself forbids structuring with a ``purpose
 of evading the [5313(a)] reporting requirements,'' and the lower
 courts erred in treating the ``willfulness'' requirement essentially
 as words of no consequence.  Viewing 5322(a) and 5324(3) in
 light of the complex of provisions in which they are embedded, it
 is significant that the omnibus ``willfulness'' requirement, when
 applied to other provisions in the same statutory subchapter,
 consistently has been read by the Courts of Appeals to require
 both knowledge of the reporting requirement and a specific intent
 to commit the crime or to disobey the law.  The ``willfulness''
 requirement must be construed the same way each time it is called
 into play.  Because currency structuring is not inevitably nefari-
 ous, this Court is unpersuaded by the United States' argument
 that structuring is so obviously ``evil'' or inherently ``bad'' that the
 ``willfulness'' requirement is satisfied irrespective of the defendant's
 knowledge of the illegality of structuring.  The interpretation
 adopted in this case does not dishonor the venerable principle that
 ignorance of the law generally is no defense to a criminal charge,
 for Congress may decree otherwise in particular contexts, and has
 done so in the present instance.  Pp. 5-15.
976 F. 2d 1280, reversed and remanded.
 Ginsburg, J., delivered the opinion of the Court, in which
Stevens, Scalia, Kennedy, and Souter, JJ., joined.  Blackmun, J.,
filed a dissenting opinion, in which Rehnquist, C. J., and O'Connor
and Thomas, JJ., joined.

Date: Thu, 13 Jan 94 09:41:08 -0800
From<EMAIL_ADDRESS>(Eric Hughes)
Message-Id<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Subject: crypto point of sale

Sandy hinted that I should explain my 'crypto point-of-sale' idea.  So
I will.

The idea is a mostly a social structure, adjoining existing (or
soon-to-be) pieces of technology and setting them in a particular
environment.  The technological pieces are

  1. the Newton -- one for the buyer, one for the seller
  2. one radio data link for the seller's machine, either
    a. a cell phone, cellular modem, and a corresponding host
    b. a cellular data service
  3. the Internet
  4. packet forwarding services
  5. an online bank
  6. public keys
  7. authenticated Diffie-Hellman key exchange

Or, to be short, "two Newtons, one radio".

Preparations in the form of assertions about the time of transaction:

1. The seller has an account at the online bank.  This entails that
  the bank and the customers have each other's public keys.

2. The buyer has an account at the online bank with funds sufficient
  for purchase.

3. The seller has an arrangement with a packet forwarding service.
  This may not need to be instantiated before transaction (i.e.
  software vending machine), although it will likely be cheaper to do
  so.

4. Software as described below is installed on all the machines
  mentioned.

Steps in the transaction:

1. The Newton has an infrared interface with a range of about three
  feet.  The buyer and the seller start an infrared connection between
  their two Newtons.  A Diffie-Hellman key exchange protocol over that
  link is the first step in securing the link against eavesdropping.

  Regular D-H is good enough in this case because there is no way to
  put a machine in the middle of the infrared link.  I suppose someone
  with a very powerful IR beacon could spoof one of the machines, but
  likely not both.  Regular D-H also means that there is no need for
  the buyer and the seller to have each other's public keys at
  transaction time.

2. The seller establishes a data connection with his packet forwarder
  on the Internet.  This allows the seller to (at minimum) instantiate
  multiple outgoing TCP connections from the forwarding machine.

3. If necessary, the seller allows the buyer to go online by allowing
  the seller's Newton to forward packets for the buyer's Newton.  The
  buyer, if not in possession of enough digital notes, can go online
  with the bank and purchase notes now.  The flow of data is buyer's
  Newton -> seller's Newton -> forwarding machine -> bank.

  The buyer goes online by instantiating outgoing TCP connections from
  the forwarding service hired by the seller.  The buyer connects to
  the bank.  This secure connection uses an authenticated D-H key
  exchange, which prevents the interposition attack.  Public keys are
  necessary for this protocol, but the bank and its customers have
  already exchanged them.

4. The buyer, now with digital notes in hand, so to speak, offers them
  to the seller for payment.  The seller, as part of this protocol,
  goes online with the bank to check the validity of the notes.  The
  seller also uses the authenticated D-H key exchange.  The bank OK's
  the notes (presumably) and credit is made to the seller's account.

Advantages, or, why should I use this?

1. The radio means that business need not be conducted indoors, where
the telephones are usually wired.  Of course, if you have a wired
telephone, you can also use the basic schema of the system, allowing
the same software on the buyer's machine to be used for a wide variety
of transactions.

2. Only one party to the transaction needs the relatively expensive
radio link but that both parties, if necessary, can use it.  Since the
seller is in business, the cost of the radio link is just a cost of
business.

3. The buyer, on the other hand, has not bought a single-purpose machine.
Many existing projects have created single purpose computers which
purpose is to do money transactions.  A single purpose machine is too
expensive to use for just transactions, especially when its so easy to
use the manufacturing for general purposes.

4.  In situations where paper cash in not convenient, this protocol
allows for the instantaneity and anonymity of cash without its
physicality.  Signals cost a lot less to move than paper, in several
different ways.

Comments are welcome.

Eric

Date: Thu, 13 Jan 1994 12:48:38 -0600
Message-Id<EMAIL_ADDRESS>From: Anonymous<EMAIL_ADDRESS>To<EMAIL_ADDRESS>X-Remailed-By: Anonymous<EMAIL_ADDRESS>X-Ttl: 0
X-Notice: This message was forwarded by a software-
	automated anonymous remailing service.

Everyone who is unaware of it should know that<EMAIL_ADDRESS>regardless of what he set his "name" field to for the day, is
"L.Detweiler", whos first name is apparently "Lance" or "Lawrence"
depending on whom you ask. He's a psychotic or a good mimic of one --
I say that not to slander him but as a simple statement of fact. He's
been filling every cryptography mailing list and newsgroup with rants,
and I suppose he has now decided to disrupt this mailing list too.

He has mailed death threats in anonymous mail. He forges mail, spreads
rumors, rants, makes paranoid claims (i.e. he believes lots of people
are the same person all trying to plot against him; he believes there
is a nationwide conspiracy attempting to sully his name, etc.), posts
dozens of messages at a time to lists in order to disrupt them, and
overall behaves far worse than his alleged "CRYPTOANARCHIST
CONSPIRACY" does.

I would ask in the interest of sanity that people not reply to his
messages. Obviously there is little that I can do beside request
people's cooperation, but if we spend time discussing Mr. Detweiler,
there will be no time to discuss internet mercantile protocols.

--
Perry Metzger<EMAIL_ADDRESS>--
"I can't go out and save every undercapitalized entrepreneur in America."
  -- Hillary Clinton, when asked about the impact of her health care
     "plan" on small business (Wall Street Journal, 9/24/93, pg A10, col. 3)

Message-Id<EMAIL_ADDRESS>Date: Thu, 13 Jan 1994 14:08:06 -0500 (EST)
From: Matthew J Ghio<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Subject: Re: Non-techie Crypto book?

Awhile back I wrote a little FAQ for cypherpunks that I hadn't posted.
After the current discussions, I figured some of you might be
interested.  It is designed to be a non-technical introduction to
cryptography as well as a FAQ for cypherpunks.  It's not really
completely finished, so comments or suggestions in email are welcomed.

------------------------------

Who are the cypherpunks?

As the name might imply, the cypherpunks are cyberpunks interested in
ciphers, or encryption technology.  Cypherpunks seek to develop new
encryption techiques, and to find new methods of utilizing existing
technology to ensure privacy and honesty in the computer age.
Cypherpunks want to make cryptographic technology to be availiable to
everyone.  This is reflected in our motto: "Cypherpunks write code."

Why encryption?

In the past, encryption was only needed and used by very few people.
People didn't have any need to be so secretive.  If something was
private, it was kept sealed or locked.  It wasn't easy to steal
information, because it could be kept physically secure.  But the
computer age has changed that.  Now, information travels all over the
world at the speed of light.  No more is there localized physical
security.  A hacker could potentially invade a computer system halfway
around the world and steal proprietary information.  Volumes of private
data can be copied in seconds.  Worse, the victim might not even know
that the data had been copied.  No longer with physical security to
protect privacy, we must use mathematical security: Cryptography.

I don't have anything to hide, why should I use encryption?

Something doesn't have to be a big secret for you to want to keep it
private.  You don't send all your mail on postcards.  You certainly
wouldn't want someone at the post office to be able to read your monthly
financial statements.  An envelope provides a barrier which allows you
to maintain your privacy.  If you put your postal mail in a paper
envelope, why not put electronic mail in a cryptographic envelope?
Many people fear cryptography because it conjures up images of
espionage, secrecy, and the CIA and KGB.  Cypherpunks want to encourage
public awareness of cryptography and the benefits thereof.  People need
to realize that using encryption should be as commonplace and natural as
putting a letter into an envelope before mailing it.  It's not that
everything has to be a secret, but that people are just more comfortable
keeping certain things private.

What are the basic types of ciphers?

Traditional ciphers consisted of rearranging and substituting letters,
words and numbers for other letters or symbols, so as to make the
message unintelligible.  A secret key was necessary to decode the
message  With the use of computers, this process is can be improved,
allowing stronger ciphers, and new types of ciphers, such as public-key
cryptography.

What is a strong cipher?

A good cipher should meet two main criteria.  First, after the data is
encrypted, it should not "leak" information which would give clues as to
what the decrypted message was.  For example, simply flipping bits (XOR)
or replacing letters in an ascii text file is not a good cipher because,
although the words are scrambled, the spacing and formatting information
is still clearly visible, giving an attacker clues about what was
encoded, which would enable them to break the cipher more easily.  A
good cipher should impart a randomness upon the data to defeat such
cryptanalysis.  Second, looking at an encrypted and decrypted version of
the same data should not reveal what key or method was used to encrypt
the data.  That way, if the security of one peice of data is
compromised, it can't be used to reveal the rest of the data.
Cypherpunks want to make people aware that just because a program
encrypts data, it isn't necessarily a good encryption program.  Many
programs which offer data encryption can actually be broken easily
because they leave too many clues in the encrypted data.  Know the
source of your software, and know what kind of encryption it uses.
Cypherpunks know that a good encryption algorithm can be described
openly without compromising its security.  If a software author claims
they can't reveal their encryption method, it's probably because it's
weak and they're afraid someone might break it, so look somewhere else.

What is public-key cryptography?

In a traditional cryptosystem, the people communicating must keep the
key to the cipher secret.  If someone gets the key, they can decode the
message.  Public key cryptography is a new method of cryptography which
uses pairs of two keys, one for encryption, and one for decryption.  To
generate a keypair, someone picks a random number or numbers, and uses a
mathematical formula to generate two numeric cryptographic keys from the
random numbers.  One of these keys is the used as the encryption key,
and the other is the decryption key.  After the keys have been created,
the numbers used to create them can be discarded.  The formula works one
way only- one key can not be used to find the other.  Therefore, someone
can generate a pair of keys, and give someone (or everyone) the
encryption key, while keeping the decryption key to himself.  That way,
anyone can send him an encrypted message, and only the holder of the
private key can decode it.  In this way, someone can communicate
securely with someone they've never met to exchange keys with, and know
that nobody else could be intercepting the message.

What are other uses of cryptographic technologies?

The mathematics of cryptography have many other uses besides secrecy and
privacy.  One development is the one-way hash or digest.  In a one-way
hash, a data file or message is scrambled and reduced to a small numeric
identification string.  Such hash functions are designed such that the
output from the hash can not be used to reconstruct the original
message, and it is virtually impossible to find another message which
matches the same hash value.  Therefore, data can be tagged with an
identification string which is unique to that file.  If the data file is
altered, the hash will produce a different value.  In this way,
sensitive data can be protected from tampering, because any alterations
to the file would affect the hash.  (For technical description, see
RFC1186.)

Another possibility is to use public-key cryptography in reverse; that
is, the decode key is made public and the encode key is kept private.
(Each key in a P-K pair can be used for encryption or decryption, with
the other key necessary for the reverse operation.)  This doesn't hide
anything, since anyone could decode the message; however, although
anyone can read the message, only the holder of the secret key could
create it.  Therefore, anything encrypted in this manner is
authenticated, since there is only one person, the holder of the secret
key, who could have encrypted the message.

By combining a message digest with public-key authentication, it is
possible to create a unforgeable digital signature identifying the
sender of the message.  (PGP does this.)  This makes it possible to
combat electronic forgery and unauthorized access into remotely accessed
databases.  You can keep your secret key secure on your machine, but
anyone in the world could verify that you have it, since only you, the
holder of the secret key, could be signing or encrypting the messages
the messages you send.

What is the cypherpunks political agenda?

Although cypherpunks is not really a political group, cryptography can
be a hotly debated political issue.  Frankly, cryptography scares
governments.  The thought that an international criminal orginazation
could use advanced encryption to communicate secretly and securely,
scares many people.  As a result, many governments want to ban or
restrict use of encryption.  But, as the saying goes, when encryption is
outlawed, only outlaws will have encryption.  Banning encryption will
not stop criminals from using it.  Therefore, cypherpunks want to make
encryption availiable to everyone, so that we can concentrate on the
positive aspects of encryption, to promote privacy and to prevent crime.
 Cryptography can prevent much more crime than it can conceal.  By using
cryptography, we can create secure databases and prevent digital forgery
and theft.

What do people mean when they talk about "cryptoanarchy"?

Cryptographers scare governments, so governments scare cryptographers.
For this reason, many cypherpunks favor more libertarian governments.
Cypherpunks would rather rely on cryptography for protection, instead of
men with guns from some government agency.  It's much better to deter or
prevent a crime than to try to clean up after the fact.  And, after all,
people make mistakes and computers don't, and the police are people.
Some believe that one day everyone will or will be able to handle all
their business, finances, and communication needs online, and protect
them with strong cryptography, virtually eliminating criminals and the
need for police to chase them.  The belief in this state of affairs is
known as cryptoanarchy - the elimination of the need for cyberspacial
government through cryptography.

What are some of the other goals of the Cypherpunks?

Cypherpunks would like to further their pursuit of privacy by setting up
anonymous remailers (see listing by Karl Lui Barrus), by writing and
distributing cryptographic software (such as PGP), by setting up secure,
encrypted communications channels, and by working to create a secure
digital cash system, based on cryptography, instead of current credit
card systems which use insecure methods, and are easy to defraud.

{% endraw %}
```

## Thread

+ Return to [January 1994](/archive/1994/01)

+ Return to<EMAIL_ADDRESS>(Hugh Daniel)](/authors/hugh_at_ecotone_toad_com_hugh_daniel_)"

+ 1994-01-13 (Thu, 13 Jan 94 13:45:34 PST) - Digest of droped messages -<EMAIL_ADDRESS>(Hugh Daniel)_

gha_license_id: MIT


text:
DESCRIPTION:
-----------
ASTRAL is a tool for estimating an unrooted species tree given a set of unrooted gene trees.
ASTRAL is statistically consistent under the multi-species coalescent model (and thus is useful for handling incomplete lineage sorting, i.e., ILS).
ASTRAL finds the species tree that has the maximum number of shared induced quartet trees with the set of gene trees, subject to the constraint that the set of bipartitions in the species tree comes from a predefined set of bipartitions. This predefined set is empirically decided by ASTRAL (but see tutorial on how to expand it). The current code corresponds to **ASTRAL-III** (see below for the publication).

The algorithm was designed by Tandy Warnow and Siavash Mirarab originally. ASTRAL-III incorporates many ideas by Chao Zhang and Maryam Rabiee.
[Code developers](https://github.com/smirarab/ASTRAL/graphs/contributors) are mainly Siavash Mirarab, Chao Zhang, Maryam Rabiee, and Erfan Sayyari.

### Bug Reports:

Contact<EMAIL_ADDRESS>or post on [ASTRAL issues page](https://github.com/smirarab/ASTRAL/issues).

### Other branches

**NOTE**:
Several new  features of ASTRAL are not merged in this branch and are available in other branches or git pages.
Please use those branches if you find these features useful.

* **ASTRAL-Pro (Astral for paralogs)**: This new tool, which builds on ASTRAL, can handle multiple copy genes. You can find it here: https://github.com/chaoszhang/A-pro
* **ASTRAL-MP (Multi-threaded ASTRAL)**: A multi-threaded version of ASTRAL is available on [this branch](https://github.com/smirarab/ASTRAL/tree/MP)
    * Note: the  link https://github.com/smirarab/ASTRAL/tree/MP-similarity should be replaced with https://github.com/smirarab/ASTRAL/tree/M.
* **Astral with user constraints**: A version of ASTRAL that can satisfy user constraints is available [here](https://github.com/maryamrabiee/Constrained-search)
* **Tree updates**:  An ASTRAL-based algorithm called INSTRAL enables inserting  new species onto and existing ASTRAL tree is available [here](https://github.com/maryamrabiee/INSTRAL)

## Publications

#### Papers on the current version:
- Since version 5.1.1, the code corresponds to **ASTRAL-III**, described in:
    * Zhang, Chao, Maryam Rabiee, Erfan Sayyari, and Siavash Mirarab. 2018. “ASTRAL-III: Polynomial Time Species Tree Reconstruction from Partially Resolved Gene Trees.” BMC Bioinformatics 19 (S6): 153. [doi:10.1186/s12859-018-2129-y](https://doi.org/10.1186/s12859-018-2129-y).
- For **multi-individual** datasets, the relevant paper to cite is:
	* Rabiee, Maryam, Erfan Sayyari, and Siavash Mirarab. 2019. “Multi-Allele Species Reconstruction Using ASTRAL.” Molecular Phylogenetics and Evolution 130 (January). 286–96. [doi:10.1016/j.ympev.2018.10.033](https://doi.org/10.1016/j.ympev.2018.10.033).
- Since version 4.10.0, ASTRAL can also compute branch length (in coalescent units) and a measure of support called **local posterior probability**, described here:
    * Sayyari, Erfan, and Siavash Mirarab. 2016. “Fast Coalescent-Based Computation of Local Branch Support from Quartet Frequencies.” Molecular Biology and Evolution 33 (7): 1654–68.  [doi:10.1093/molbev/msw079](http://mbe.oxfordjournals.org/content/early/2016/05/12/molbev.msw079.short?rss=1)
- ASTRAL can also perform a **polytomy test** (`-t 10` option):
    * Sayyari, Erfan, and Siavash Mirarab. 2018. “Testing for Polytomies in Phylogenetic Species Trees Using Quartet Frequencies.” Genes 9 (3): 132. [doi:10.3390/genes9030132](http://www.mdpi.com/2073-4425/9/3/132).

- For practical tips on using ASTRAL see [this preprint book chapter](https://arxiv.org/pdf/1904.03826.pdf).

#### Papers on older versions:

- The original algorithm (ASTRAL-I) is described in:
    - Mirarab, Siavash, Rezwana Reaz, Md. Shamsuzzoha Bayzid, Théo Zimmermann, M. S. Swenson, and Tandy Warnow. 2014. “ASTRAL: Genome-Scale Coalescent-Based Species Tree Estimation.” Bioinformatics 30 (17): i541–48. [doi:10.1093/bioinformatics/btu462](doi.org/10.1093/bioinformatics/btu462).
- All the versions between 4.7.4  and 5.1.0 correspond to ASTRAL-II, described in:
    * Mirarab, Siavash, and Tandy Warnow. 2015. “ASTRAL-II: Coalescent-Based Species Tree Estimation with Many Hundreds of Taxa and Thousands of Genes.” Bioinformatics 31 (12): i44–52. [doi:10.1093/bioinformatics/btv234](http://bioinformatics.oxfordjournals.org/content/31/12/i44)

#### Papers with relevance to ASTRAL:

These papers do not describe features in ASTRAL, but are also relveant and we encourage you to read them:

1. **ASTRAL-Pro**: This paper extends the ASTRAL methodology to multiple copy genes.
	- Zhang, Chao, Celine Scornavacca, Erin K Molloy, and Siavash Mirarab. “ASTRAL-Pro: Quartet-Based Species-Tree Inference despite Paralogy.” Edited by Jeffrey Thorne. Molecular Biology and Evolution, September 4, 2020, msaa139. https://doi.org/10.1093/molbev/msaa139.
- **ASTRAL-constrained**: This paper shows how to impose user-defined constraints on ASTRAL
	- Rabiee, Maryam, and Siavash Mirarab. “Forcing External Constraints on Tree Inference Using ASTRAL.” BMC Genomics 21, no. S2 (April 16, 2020): 218. https://doi.org/10.1186/s12864-020-6607-z.
- **DiscoVista**: This paper shows how quartet scores (more broadly, genome discordance) can be visualized in interpretable ways. The visualization of quartet scores, in particular, is closely tied to the ASTRAL method.
    - Sayyari, Erfan, J.B. James B. Whitfield, and Siavash Mirarab. 2018. “DiscoVista: Interpretable Visualizations of Gene Tree Discordance.” Molecular Phylogenetics and Evolution 122 (May): 110–15. [doi:10.1016/j.ympev.2018.01.019](https://doi.org/10.1016/j.ympev.2018.01.019).
- **Fragmentary data**: The following paper made the case that before inferring gene trees, removing fragmentary data (e.g., those that have uncharacteristically large numbers of gaps) should be removed. It also showed RAxML gene trees are preferable to FastTree trees.
    - Sayyari, Erfan, James B Whitfield, and Siavash Mirarab. 2017. “Fragmentary Gene Sequences Negatively Impact Gene Tree and Species Tree Reconstruction.” Molecular Biology and Evolution 34 (12): 3279–91. [doi:10.1093/molbev/msx261](https://doi.org/10.1093/molbev/msx261).
- **Missing data**: The following paper showed that excluding genes because they have missing data is often detrimental to accuracy.
	- Molloy, Erin K., and Tandy Warnow. 2018. “To Include or Not to Include: The Impact of Gene Filtering on Species Tree Estimation Methods.” Systematic Biology 67 (2): 285–303. [doi:10.1093/sysbio/syx077](https://doi.org/10.1093/sysbio/syx077).
- **TreeShrink**: This paper introduced a method for removing very long branches from gene trees in a statistically motivated way. These branches make gene trees less accurate.
	-  Mai, Uyen, and Siavash Mirarab. 2018. “TreeShrink: Fast and Accurate Detection of Outlier Long Branches in Collections of Phylogenetic Trees.” BMC Genomics 19 (S5): 272. [doi:10.1186/s12864-018-4620-2](https://doi.org/10.1186/s12864-018-4620-2).
- **Sample Complexity**: This paper established the theoretical sample complexity (i.e., number of required genes) for ASTRAL.
    - Shekhar, Shubhanshu, Sebastien Roch, and Siavash Mirarab. 2018. “Species Tree Estimation Using ASTRAL: How Many Genes Are Enough?” IEEE/ACM Transactions on Computational Biology and Bioinformatics 15 (5): 1738–47. [doi:10.1109/TCBB.2017.2757930](https://doi.org/10.1109/TCBB.2017.2757930).
- **INSTRAL**: introduces an ASTRAL-based algorithm for adding new species unto an existing species tree; so, the phylogenetic placement problem but for species trees.
	- Rabiee, Maryam, and Siavash Mirarab. 2018. “INSTRAL: Discordance-Aware Phylogenetic Placement Using Quartet Scores.” BioRxiv 432906. [doi:10.1101/432906](https://doi.org/10.1101/432906).
- **BestML:** This paper was published before ASTRAL but showed that using best ML gene trees is often preferable to using the consensus of running summary methods on bootstrapped gene trees.
	- Mirarab, Siavash, Md Shamsuzzoha Bayzid, and Tandy Warnow. 2016. “Evaluating Summary Methods for Multilocus Species Tree Estimation in the Presence of Incomplete Lineage Sorting.” Systematic Biology 65 (3). Oxford University Press: 366–80. [doi:10.1093/sysbio/syu063](https://doi.org/10.1093/sysbio/syu063).

Documentations
-----------

- The rest of this README file
- **Our [tutorial](astral-tutorial.md)**.
- For practical tips on using ASTRAL, including on how to prepare input and interpret output, see [this paper](https://arxiv.org/pdf/1904.03826.pdf).
- Forums:
	- [User group discussions](https://groups.google.com/forum/#!forum/astral-users)
	- [ASTRAL issues page](https://github.com/smirarab/ASTRAL/issues)
- Publications shown above have scientific details. The chapter of Siavash Mirarab's dissertation that describes ASTRAL in detail is provided [here](thesis-astral.pdf).
- A [developer guide](developer-guide.md).

INSTALLATION:
-----------
* There is no installation required to run ASTRAL.
* Download using one of two approaches:
    * You simply need to download the [zip file](https://github.com/smirarab/ASTRAL/raw/master/__astral.zip__) and extract the contents to a folder of your choice.
    * Alternatively, you can clone the [github repository](https://github.com/smirarab/ASTRAL/). Then, either:
    	* simply uncompress the zip file that is included with the repository, or
    	* run `make.sh` to build the project.
* ASTRAL is a java-based application, and should run in any environment (Windows, Linux, Mac, etc.) as long as java is installed.
  Java 1.6 or later is required. We have tested ASTRAL only on Linux and MAC but others have used it on Windows with no reported issues.
* To test your installation, go to the place where you put the uncompressed ASTRAL, and run:

  ``` bash
   java -jar __astral.jar__ -i test_data/song_primates.424.gene.tre
   ```

  This should quickly finish. There are also other sample input files under `test_data/` that can be used.

* ASTRAL can be run from any directory (e.g., `/path/to/astral/`). Then, you just need to run:

  ``` bash
  java -jar /path/to/astral/__astral.jar__
  ```

* Also, you can move `__astral.jar__` to any location you like and run it from there, but note that you need to move the `lib` directory with it as well.

EXECUTION:
-----------
ASTRAL currently has no GUI. You need to run it through the command-line. In a terminal, go the location where you have downloaded the software, and issue the following command:

```
  java -jar __astral.jar__
```

This will give you a list of options available in ASTRAL.

To find the species tree given a set of gene trees in a file called `in.tree`, use:

```
java -jar __astral.jar__ -i in.tree
```

The results will be outputted to the standard output. To save the results in a file use the `-o` option (**Strongly recommended**):

```
java -jar __astral.jar__ -i in.tree -o out.tre
```
To save the logs (**also recommended**), run:

```
java -jar __astral.jar__ -i in.tree -o out.tre 2>out.log
```

###### Input:
* The input gene trees are in the Newick format
* The input trees can have missing taxa, polytomies (unresolved branches), and multiple individuals per species.
*  Taxon names cannot have quotation marks in their names (sorry!). This means you also cannot have weird characters like ? in the name (underscore is fine).
* When multiple individuals from the same species are available, you can ask ASTRAL to force them to be together in the species tree. To do this, a mapping file needs to be provided using the `-a` option. This mapping file should have one line per species, and each line needs to be in one of two formats:

```
species_name [number of individuals] individual_1 individual_2 ...

species_name:individual_1,individual_2,...
```
   Note that when multiple individuals exist for the same species, your species name should be different from the individual names.

###### Output:
The output in is Newick format and gives:

* the species tree topology,
* branch lengths in coalescent units (only for internal branches or for terminal branches if that species has multiple individuals),
* branch supports measured as [local posterior probabilities](http://mbe.oxfordjournals.org/content/early/2016/05/12/molbev.msw079.short?rss=1).
* It can also annotate branches with other quantities, such as quartet support, as described in the [tutorial](astral-tutorial.md).

The ASTRAL tree leaves the branch length of terminal branches empty. Some tools for visualization and tree editing do not like this (e.g., ape). In FigTree, if you open the tree several times, it eventually opens up (at least on our machines). In ape, if you ask it to ignore branch lengths all together, it works. In general, if your tool does not like the lack of terminal branches, you can add a dummy branch length, [as in this script](https://github.com/smirarab/global/blob/master/src/mirphyl/utils/add-bl.py).

### Other features (local posterior, bootstrapping):
Please refer to the [tutorial](astral-tutorial.md) for all other features, including bootstrapping, branch annotation, and local posterior probability.

### Memory:
For big datasets (say more than 1000 taxa), increasing the memory available to Java can result in speedups. Note that you should give Java only as much free memory as you have available on your machine. So, for example, if you have 8GB of free memory, you can invoke ASTRAL using the following command to make all the 8GB available to Java:

```
java -Xmx8000M -jar __astral.jar__ -i in.tree
```

Acknowledgment
-----------
ASTRAL code uses bytecode and some reverse engineered code from PhyloNet package (with permission from the authors). Code is contributed by Siavash Mirarab, Maryam Rabiee, Chao Zhange, Erfan Sayyari, and John Yin.

repository: smirarab/ASTRAL

gha_language: Java

repo_name: smirarab/ASTRAL


text:
---
slug: /1214/migrate-from-dagger-0.1
displayed_sidebar: '0.2'
---

# Migrate from Dagger 0.1

{@include: ../../../partials/_caution-old-version.md}

This is the documentation for dagger 0.2, codename Europa. This release has one focus: improve the developer experience. It features a redesigned CLI and powerful new APIs. The result is a completely new way to develop CI/CD pipelines: more productive, more portable… and way more fun!

However, there is a downside: unfortunately, this release is not backwards compatible: plans written for dagger 0.1 will not run on version 0.2. Automatic migration is not supported, but manual migration is relatively straightforward.

If you need help migrating your plan, we will be happy to assist you! Simply reply to [this thread](https://github.com/dagger/dagger/discussions/1772) with a description of your configuration. If you've already started migrating, please let us know and share details of your progress and issues you're encountering. We will do our best to assist you!

 But we will do our very best to help you get there. We are making this work our priority.

We apologize once again for breaking compatibility. We hope you will find that the new features of Europa are worth it 😁

repository: dgageot/dagger

branch_name: refs/heads/main

repo_name: dgageot/dagger


text:
# Useful links

Information sources for COVID-19

 * Updates from WHO Regarding Novel Coronavirus [WHO](https://www.who.int/emergencies/diseases/novel-coronavirus-2019)

 * Chinese Center for Disease Control and Prevention [中国疾病预防控制中心](http://www.chinacdc.cn/)

 * The Latest COVID-19 Public Health Information from [CDC](https://www.coronavirus.gov)

 * Chinese COVID-19 Real-time Report from DXY [疫情实时动态](https://ncov.dxy.cn/ncovh5/view/pneumonia?scene=2&clicktime=1579579384&enterid=1579579384&from=timeline&isappinstalled=0)

 * COVID-19 Global Pandemic Real-time Report from [Johns Hopkins University](https://gisanddata.maps.arcgis.com/apps/opsdashboard/index.html#/bda7594740fd40299423467b48e9ecf6)

 * Chinese Government’s New Coronavirus Pneumonia Diagnosis and Treatment Plan (Trial Version 7) [Chinese original version](https://ghddiai.oss-cn-zhangjiakou.aliyuncs.com/file/Chinese_COVID19_diagnosis_and_treatment_plan_v7.pdf)
 , [English translation version](https://www.chinalawtranslate.com/en/coronavirus-treatment-plan-7/)

 * Internet Book of Critical Care (IBCC) [COVID-19 Review](https://emcrit.org/ibcc/COVID19/)

 * [Industry Updates from Biocentury](https://www.biocentury.com/coronavirus)

 * Research Updates from [Elsevier](https://www.elsevier.com/connect/coronavirus-information-center), [THE LANCET](https://www.thelancet.com/coronavirus), [JAMA](https://jamanetwork.com/journals/jama/pages/coronavirus-alert), and [NIH](https://www.nih.gov/coronavirus).

 * The scientists from the Swiss Institute of Bioinformatics provided 2019-nCoV genome analysis on [**ViralZone**](https://viralzone.expasy.org/8996) and allow to track the current outbreak on [**Nextstrain**](https://nextstrain.org/ncov).

 * Scientific Intelligence from Clarivate on 2019-nCoV
 [科睿唯安](http://clarivate.com.cn/coronavirus-resources/)
 , [Clarivate English Site](https://clarivate.com/coronavirus-resources/)

 * Chinese Novel Coronavirus National Science and Techonology Resource Service System [新冠状病毒国家科技资源服务系统](http://nmdc.cn/nCov/en)

 * 2019nCoVR from Chinese National Genomics Data Center [2019新型冠状病毒信息库(国家生物信息中心)](https://bigd.big.ac.cn/ncov)

---

Useful sites for drug discovery researchers

 * Clinical Trial Information [Clinical Trials](https://clinicaltrials.gov/)

 * China Drug Trial Information [药物临床试验登记与信息公示平台](http://www.chinadrugtrials.org.cn/)

 * Drug Information [Drugbank](https://www.drugbank.ca/)

 * Drug Side Effect Resource [SIDER](http://sideeffects.embl.de/)

 * Protein Structure Information [RCSB PDB](https://www.rcsb.org)

 * Protein Gene Information [UniProt](https://www.uniprot.org/)

 * The National Center for Biotechnology Information Advances Science and Health [NCBI](https://ncbi.nlm.nih.gov/)

 * PRoteomics IDEntifications Database from EMBL-EBI [PRIDE](https://www.ebi.ac.uk/pride/)

 * European Molecular Biology Laboratory [ChEMBL](https://www.ebi.ac.uk/chembl/)

 * BindingDB contains 1,819,720 binding data, for 7,470 protein targets and 804,949 small molecules. [BindingDB](https://www.bindingdb.org/bind/index.jsp)

 * Gene Expression Omnibus from NCBI [GEO](https://www.ncbi.nlm.nih.gov/geo/)

 * ZINC database for docking [ZINC15](http://zinc15.docking.org/)


text:
# Neth-strap-ium
A straightforward CSS framework to bootstrap your project.
The aim of this framework is to provide clear, visible markup without any javascript.
Heavenly inspired by [Google Material Design](https://material.google.com/) and [Bootstrap](http://getbootstrap.com/).

## Quick start
1. Clone this repo: `git clone https://github.com/Netherium/neth-strap-ium.git`
2. Include Roboto Font (Recommended): `<link href="https://fonts.googleapis.com/css?family=Roboto" rel="stylesheet">`
3. Include CSS: `<link rel="stylesheet" href="./dist/neth-strap-ium.min.css">`

## Issues/Bugs
* Inputs out of focus will not work (should be fixed at [Firefox 51.0](https://developer.mozilla.org/en-US/docs/Web/CSS/:placeholder-shown))

## Docs
* [https://netherium.github.io/neth-strap-ium/docs/](https://netherium.github.io/neth-strap-ium/docs/)

## Authors
**Netherium**

## Copyright and license
Code released under [the MIT license](https://github.com/Netherium/neth-strap-ium/blob/master/LICENSE)

repository: Netherium/neth-strap-ium

repo_name: Netherium/neth-strap-ium


text:
# Contributing guideline
Dear contributor, first of all we're glad to see you on this page. Your contribution is very important for us. This project has been designed to be a community-driven application, so every time you're making an issue or opening a pull request you make this project better. We appreciate any kind of contribution, big or small - it doesn't matter. But make sure, that before you submit something, you've read our [Code of Conduct](https://github.com/rnpm/rnpm/blob/master/CODE_OF_CONDUCT.md).

# Getting started
In the case you want to submit a pull request, we recommend you to follow this instruction:

1. [Fork a repo](https://github.com/rnpm/rnpm#fork-destination-box)
2. Clone your fork
  ```bash
$ git clone https://github.com/<username>/rnpm.git
  ```

3.  Install development dependencies
  ```bash
$ npm i
  ```

5. Link rnpm so it's available globally
  ```bash
$ npm link
  ```

6. Checkout to the new branch
  ```bash
$ git checkout -b <branch_name>
  ```
7. Make an awesome changes!

Don't forget to change a `<username>` to your real github username and a `<branch_name>` to something meaningful. We recommend using following convention for new branches: `<type>/<caption>`, like
- `feature/add-ignore-flag` for a new feature;
- `chore/improve-documentation` for a technical chore
- `bug/missing-dependencies` for bugfix.

We'll review / answer your issues faster, if you will provide some examples, screenshots and all the information we may need.

# Questions
We'd like to keep issues for bug reports and feature proposals only. If you have any questions regarding `rnpm` work, please, don't hesistate to contact us directly:
- reactiflux#rnpm on Discord
- [Gitter](https://gitter.im/rnpm?utm_source=share-link&utm_medium=link&utm_campaign=share-link)
- [Kureev's twitter](https://twitter.com/kureevalexey)
- [Grabbou's twitter](https://twitter.com/grabbou)

With :heart: form @kureev and @grabbou

license: Unlicense,MIT

repository: abhishekbhalani/chatabox

detected_licenses: Unlicense MIT

gha_license_id: Unlicense

repo_name: abhishekbhalani/chatabox


text:
---
layout: post
title:  "ML Foundations: Models"
date:   2020-02-09
excerpt: "Overview of the must-know ML models"
tags: [machine learning]
comments: true
---

# Supervised Learning

## Linear Regression

Given feature vector \\(\mathbf{x} \in \mathbb{R}^d\\) and parameters \\(\mathbf{\beta} \in \mathbb{R}^d\\), predicts scalar \\(y \in \mathbb{R}\\) via:

\\[y = \mathbf{\beta}^T\mathbf{x}\\]

## Logistic Regression

Essentially an extension of linear regression for classification (discrete labels). Let \\(K\\) denote the number of classes.

\\[\begin{align}
    y &= arg\max_k Pr(k \mid x)
    \\\\
    Pr(k \mid x) &= \frac{\exp{\mathbf{\beta}_k^T\mathbf{x}}}{1+\sum\_{\ell=1}^{K-1} \exp{\mathbf{\beta}\_{\ell}^T\mathbf{x}}}  \quad (1 \le k \le K -1)
    \\\\
    Pr(K \mid x) &= \frac{1}{1+\sum\_{\ell=1}^{K-1} \exp{\mathbf{\beta}\_{\ell}^T\mathbf{x}}}
\end{align}\\]

## Support Vector Machine (SVM)

Extension of the _support vector classifier_ (SVC) in order to accomodate non-linear class boundaries. The SVC is itself an extension of the _maximum margin classifier_ that drops the constraint that all classes are linearly separable. SVMs are intended for binary classification, but they can be extended for the multi-class case.

In \\(\mathbb{R}^n\\), a __hyperplane__ is a flat affine subspace of dimension \\(n-1\\). It is defined as the set of points \\(\mathbf{x} \in \mathbb{R}^n\\) for which

\\[ \beta_0 + \mathbf{\beta}^T \mathbf{x} = 0\\]

Without loss of generality, we will be enforcing the constraint that \\(\|\|\mathbf{\beta}\|\|_2 = 1\\). Note that \\(\|\beta_0\|\\) is the absolute distance from the origin to the hyperplane, along the direction \\(\beta\\). When \\(\beta_0 = 0\\) (i.e. the hyperplane goes through the origin), this is all vectors \\(\mathbf{x}\\) that are orthogonal to \\(\mathbf{\beta}\\). More generally, regardless of the value of \\(\beta_0\\), the vector \\(\mathbf{\beta}\\) is orthogonal to the hyperplane. Note that this is NOT the same as saying "\\(\mathbf{\beta}\\) is orthogonal to all vectors \\(\mathbf{x}\\) on the hyperplane".

A key property of a hyperplane is that it divides the space in two. Suppose, instead of having binary labels 0 and 1 like we did in logistic regression, our labels are -1 and +1. Also suppose that all of our labeled data points \\(\mathbf{x}\\) can be perfectly separated by a hyperplane, such that all points with label -1 are on one side and all points with label +1 are on the other side. We can state this formally as, for any labeled example \\((\mathbf{x}_i, y_i)\\)
\\[y_i(\beta_0 + \mathbf{\beta}^T\mathbf{x}_i) > 0\\]

In general, if our data is linearly separable, many such hyperplanes will exist. The _maximum margin classifier_ tries to find the separating hyperplane that is farthest from the training observations. The *margin* is defined as the smallest distance from the hyperplane to a training data point. For any input \\(\mathbf{x}\\), the MMC predicts \\(y=sign(\beta_0 + \mathbf{\beta}^T\mathbf{x})\\)

What if our data isn't linearly separable but we still want to classify points using the notion of a maximum margin (in some sense)? Clearly, we will need to relax the constraint that every single training point must be on one side of the hyperplane corresponding to its class label. In other words, we'll have to use a "soft margin". This describes the __Support Vector Classifier__ (SVC). It classifies using inner products over the set of _support vectors_ \\(\mathcal{S}\\):
\\[f(x)=\beta_0 + \sum\_{i \in \mathcal S} \alpha_i \langle x, x_i\rangle\\]

Finally, we can further generalize the SVC to handle data that is non-linearly separable. As is often done, this is accomplished with _kernels_. The SVC is just a special case where the linear kernel is used. SVMs generalize this to any (possibly non-linear) kernel K:
\\[f(x)=\beta_0 + \sum\_{i \in \mathcal S} \alpha_i K(x, x_i)\\]

* KNN
* Linear Discriminant Analysis (LDA) (generative)
* Quadratic Discriminant Analysis (QDA) (generative)
* Neural Networks
* Decision Trees / Random Forests / boosting / etc
* Perceptron
* Naive Bayes

# Unsupervised Learning

* K-Means
* PCA
* SVD / matrix factorization

Less must-know but still important:
* Hierarchical Clustering
* Spectral Clustering

# Reinforcement Learning

* MDPs
* Games

# Generative Models

* Autoregressive
    * Masked Autoencoder for Distribution Estimation (MADE)
* Latent Variable Models
    * Mixture of Gaussians (MoG)
    * Variational Autoencoder (VAE)
* Normalizing Flow Models
    * Nonlinear Independent Components Estimation (NICE)
    * Real-NVP
    * Masked Autoregressive Flow (MAF)
    * Inverse Autoregressive Flow (IAF)
* GANs
* Energy-Based Models
* Linear Discriminant Analysis
* Latent Dirichlet Allocation

# Graphical Models

* Bayesian Networks
* Undirected Graphical Models
* Hidden Markov Models

# Feature Stuff?
where should this even go

* Kernel stuff
* Splines

# Other (TODO)

* CSPs

# Review of Where Stuff Overlaps

TODO

gha_language: HTML


text:
# Creating Organizations in Snyk

## Table of Contents
- Generating the data to create Organizations in Snyk
  - [Github](#githubcom--github-enterprise)
  - [Gitlab](#gitlabcom--hosted-gitlab)
- [Creating the organizations](#creating-organizations-in-snyk-1)
  - [via the API](#via-api)
  - [via the `orgs:create` util](#via-orgscreate-util)
- [Recommendations](#recommendations)

Before an import can begin Snyk needs to be setup with the Organizations you will populate with projects.

It is recommended to have as many Organizations in Snyk as you have in the source you are importing from. So for Github this would mean mirroring the Github organizations in Snyk. The tool provides a utility that can be used to make this simpler when using Groups & Organizations in Snyk.

# Generating the data required to create Organizations in Snyk with `orgs:data` util
This util helps generate data needed to mirror the Github.com / Github Enterprise organization structure in Snyk.
This is an opinionated util and will assume every organization in Github.com / Github Enterprise should become an organization in Snyk. If this is not what you are looking for, please look at using the [Organizations API](https://snyk.docs.apiary.io/#reference/groups/organizations-in-a-group/create-a-new-organization-in-a-group) directly to create the structure you need.

## Github.com / Github Enterprise
1. set the [Github.com personal access token](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token) as an environment variable: `export GITHUB_TOKEN=your_personal_access_token`
2. Run the command to generate organization data:
 - **Github.com:** `snyk-api-import orgs:data --source=github --groupId=<snyk_group_id>`
 - **Github Enterprise:** `snyk-api-import orgs:data --source=github-enterprise --groupId=<snyk_group_id> -- sourceUrl=https://ghe.custom.github.com/`

This will create the organization data in a file `group-<snyk_group_id>-github-<com|enterprise>-orgs.json`

## Gitlab.com / Hosted Gitlab
1. set the [Gitlab personal access token](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html) as an environment variable: `export GITLAB_TOKEN=your_personal_access_token`
2. Run the command to generate organization data:
 - **Gitlab:** `snyk-api-import orgs:data --source=gitlab --groupId=<snyk_group_id>`
 - **Hosted Gitlab:** `snyk-api-import orgs:data --source=gitlab --groupId=<snyk_group_id> -- sourceUrl=https://gitlab.custom.com`

This will create the organization data in a file `group-<snyk_group_id>-gitlab-orgs.json`

# Creating Organizations in Snyk
Use the generated data file to help create the organizations via API or use the provided util.
## via API
Use the generated data to feed into Snyk [Orgs API](https://snyk.docs.apiary.io/#reference/groups/organizations-in-a-group/create-a-new-organization-in-a-group) to generate the organizations within a group.

## via `orgs:create` util
1. set the `SNYK_TOKEN` environment variable - your [Snyk api token](https://app.snyk.io/account)
2. Run the command to create Orgs:
`snyk-api-import orgs:create --file=group-<snyk_group_id>-github-<com|enterprise>-orgs.json`

## Recommendations
- have [notifications disabled](https://snyk.docs.apiary.io/#reference/organizations/notification-settings/set-notification-settings) for emails etc to avoid receiving import notifications
- have the [fix PRs and PR checks disabled](https://snyk.docs.apiary.io/#reference/integrations/integration-settings/update) until import is complete to avoid sending extra requests to SCMs (Github/Gitlab/Bitbucket etc)

repository: evanshay/snyk-api-import

repo_name: evanshay/snyk-api-import


text:
# The Webpack Config
Complete configuration documentation: http://webpack.js.org/configuration

In Webpack version 4, no configuration file is needed, but going that route just uses a bunch of defaults.  Create webpack.config.js

### `mode`
Webpack 4 has two modes: `development` and `production`.  `development` mode enables greater debugging, faster compilation and runtime error messages.  `production` mode creates smaller bundles, faster at runtime and drops dead code.

If `mode` is not in the config, Webpack will default to `production`.

### `entry`
This is the first JavaScript file that loads to "kick off" your app. Webpack uses this as the starting point for dependency tree traversal. Webpack scans this file looking for other dependencies, then goes into them and repeats.  This builds the dependency tree (an understanding of what code depends on other code).

If `entry` is not in the config, Webpack looks for `./src/index.js` as the entrypoint.

If your app has multiple entry points (e.g. not a SPA), the `entry` property is an object:
entry: {
  accounts: "./src/index.js",
  results: "./src/index2.js"
}

### `output`
Webpack generates the bundle(s) here.

If `output` is not in the config and there is a single entry point, Webpack generates the bundle in `./dist/main.js`.  If there are multiple entry points, the filename will remain the same.

### Loaders and `rules`
Loaders are middleware.  They are functions that take in a source file, and return it in a modified state _before_ it gets into the dependency graph. They run on each matching file and transform everything into JS (CSS, HTML, SVGs) [not fully true in v4].  The available props for loaders are:
  - test
  - use
  - [include]
  - [exclude]
  - [issuer]
  - [enforce]

### `plugins`
Plugins allow you to hook into the compilation lifecycle.  They are the foundation of Webpack - 80% of Webpack runs on its own plugins. They are just objects with an `apply` on the prototype chain.

### Pro Tips

- You can pipe in environment variables by passing in `--env.key value`, eg:
```
scripts: {
  "webpack-dev": "npm run webpack -- --env.name jamie",
}
```
Then in the config:
```
module.exports = (env) => {
  //can access `env.name`
}
```

- Using `webpack-dev-server` and `html-webpack-plugin` in combination doesn't write anything to `/dist`, it does it all from memory and the page reloads super quickly whenever a file changes.
- In package.json use `--hot` flag in development mode for hot module reloading (single component refresh)
- In package.json use `--watch` flag to rebuild when files change (full page refresh)
- In package.json use `--verbose` flag to see some details of bundling.


text:
## Thinkpad Turtle
Originally published: 2009-12-15 19:20:03
Last updated: 2010-03-26 20:04:05
Author: Michael Grünewald

A small program utilizing the `ctypes` and `turtle` modules. You can *drive* the little turtle by turning your Thinkpad (which must have APS).

*Requirements:*

You need a newer Thinkpad (T41, T42, T43, T6x, R5x, R6x or any newer) and need to have the Active Protection System drivers (now called Lenovo Airbag Protection) installed.

gha_language: Python


text:
# Comparing string processing performance of programming languages

... using a simple bioinformatics task: Computing the GC fraction of DNA. It is based on the [GC content problem at Rosalind](http://rosalind.info/problems/gc/).

## Usage

```
make all
cat report.csv
```

## More info

This is a continuation of a previous benchmarking project, covered in [this blog post](http://saml.rilspace.com/moar-languagez-gc-content-in-python-d-fpc-c-and-c).

The idea is to compare the string processing performance of different programming languages
by implementing a very small a very simple algorithm and task: Read a [specific file](http://ftp.ensembl.org/pub/release-67/fasta/homo_sapiens/dna/Homo_sapiens.GRCh37.67.dna_rm.chromosome.Y.fa.gz)
containing DNA sequence in the [FASTA format](https://en.wikipedia.org/wiki/FASTA_format),
and compute the GC content in this file.

Two requirements apply:

1. The file must be read line by line (since DNA files are in reality ofter
   bigger than RAM, and this also helps make the implementations remotely
   comparable)
2. For each line, the program has to check if it starts with a `>` character,
   which if so means it is a header row and should be skipped.

The FASTA file can contain DNA letters (A,C,G,T) or unknowns (N), or new-lines
(Unix style `\n` ones).

This is it. Please have a look in the Makefile, and the various implementations
in the code directories, or send a pull request with your own implementation
(if the language already exists, increase the number one step, so for a new Go
implementation, you would create a `golang.001` folder, optionally with some
tag appended to it, like: `golang.001.table-optimized`, etc).

## Current results

These are some results (Execution times in seconds, smaller is better) from
running some of the tests in the Makefile, on a Dell Inspiron laptop with an
Intel(R) Core(TM) i7-8650U CPU @ 1.90GHz, with Xubuntu 18.04 Bionic LTS 64bit
as operating system:

| Language                                                                                | Execution time (s) | Compiler versions                                                         |
|-------------------------------------------------------------------------------------------------|-------------------:|---------------------------------------------------------------------------|
| [Rust.001](rust.001/src/main.rs)
Contributed by [@sstadick](https://github.com/sstadick)     |              0.067 | Rust 1.52.0-nightly (152f66092 2021-02-17)                                |
| [C](c/gc.c)                                                                                |              0.080 | gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0                                   |
| [D](d/gc.d)                                                                                |              0.080 | The LLVM D compiler (1.22.0) (LLVM 10.0.0)                                |
| [Rust](rust/src/main.rs)
With improvements contributed by [@rob-p](https://github.com/rob-p) |              0.100 | Rust 1.52.0-nightly (152f66092 2021-02-17)                                |
| [Go](go/gc.go)                                                                                |              0.110 | Go 1.14.4 linux/amd64                                                     |
| [C++](cpp/gc.cpp)                                                                               |              0.157 | g++ (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0                                   |
| [Crystal](crystal/gc.cr)                                                                        |              0.213 | Crystal 0.35.1 [5999ae29b] (2020-06-19) LLVM: 8.0.0                       |
| [PyPy](pypy/gc.py)                                                                              |              0.227 | PyPy 5.10.0 with GCC 7.3.0 (Python 2.7.13)                                |
| [Nim](nim/gc.nim)                                                                               |              0.243 | Nim Compiler Version 0.17.2 (2018-02-05)                                  |
| [FPC](gc.pas)                                                                                |              0.350 | Free Pascal Compiler version 3.0.4+dfsg-18ubuntu2 [2018/08/29] for x86_64 |
| [Cython](cython/gc.pyx)                                                                         |              0.710 | Cython version 0.29.17                                                    |
| [Python](python/gc.py)                                                                          |              0.747 | Python 3.7.0                                                              |

## Acknowledgements

I got tons of help with the [previous blog post](http://saml.rilspace.com/moar-languagez-gc-content-in-python-d-fpc-c-and-c),
and I'm afraid I might miss to mention some people here who have helped out,
but see the below list as an (incomplete) start at collecting contributors, and
feel free to add any missing info, including yourself, here.

## Incomplete list of contributions

- [Seth "ducktape programmer"](https://github.com/sstadick)
  [contributed](https://github.com/samuell/gccontent-benchmark/pull/2) the top
  Rust version ([rust.001](rust.001/src/main.rs)).
- [Rob Patro](https://github.com/rob-p) contributed
  [improvements](https://github.com/samuell/gccontent-benchmark/pull/1) to the
  main Rust version, making it bump upward the list a few steps.
- Daniel Spångberg (working at UPPMAX HPC center at the time) contributed
  numerous, extremely fast implementations in C, including the one above (c),
  which is constrained by the requirement to process the file line by line.
- [Roger Peppe](https://github.com/rogpeppe)
  ([twitter](https://twitter.com/rogpeppe)) contributed the fastest Go
  implementation, including pointers in combination with a table lookup.
- [Mario Ray Mahardhika (aka leledumbo)](https://github.com/leledumbo)
  contributed the fastest FreePascal implementation, which is the one above
  (fpc.000).
- [Harald Achitz](https://www.linkedin.com/in/harald-achitz-860657139/)
  provided the C++ implementation used above (cpp.000).
- (Who is missing here?)

repository: pythseq/gccontent-benchmark

repo_name: pythseq/gccontent-benchmark


text:
# Specifications for the CLI Assessment

Specs:
- [x] Have a CLI for interfacing with the application
Created a user-friendly CLI with a main menu and help menu, that allows the user to go back and forth between levels of data and exit at any time from any point in the program.
- [x] Pull data from an external source
Uses Nokogiri to scrape content from NPR's Podcast Directory
  - Pulls category data from http://www.npr.org/podcasts
  - Pulls podcast data from individual category pages
  - Pulls episode data from individual podcast pages
- [x] Implement both list and detail views
  - Uses OO to associate podcasts with categories and episodes with podcasts, so that the user can view any of the following:
    - list of categories
    - lists of podcasts by category
    - descriptions of podcasts
    - lists of episodes for podcasts
    - descriptions of individual episodes, their runtimes, and links to listen and download when available


text:
title: User Guide
author: Sarit Dutta

This is BROWNPAK. It can perform the following kinds of simulations:

- Energy minimization (also called structure relaxation) via steepest
  descent.
- Brownian dynamics (BD)
- Multiparticle collision dynamics (MPCD)

The source code is written in F2008 compliant fortran. There is a dependency on
the Intel Math Kernel Library (MKL). I have compiled the code with gfortran-8.3
compiler and MKL 2019 Update 4.

Getting the source files
------------------------
The simplest way is to clone using `git`. Of course, this requires `git` to be
installed on your system. If you do not want to clone, it is possible to
download a *zip* file containing the source. Let's say you want to clone.

Create a directory where you want the files to live. Say this directory is `foo`.
```bash
mkdir foo
cd foo
```
Then clone the repo from [GitHub](https://github.com/saridut/BROWNPAK) thus:
```bash
git clone https://github.com/saridut/BROWNPAK.git .
```
That's it.

Directory structure
--------------------

The directory structure is as follows:

- *src* contains the Fortran source files. There are some unused (not required/buggy?)
 source files in *src/extra*.
- *bin* contains the compiled executable, named *brownpak*. The executable can
  be run directly from here, or from some other location with appropriately
  specified path to the executable. It is best not to move around the
executable, rather invoke the executable from the directory where you want to
run it.
- *build* is the build directory. It contains a makefile. It is necessary to
  update the paths in the makefile to suit the local system.
- *utils* contains several utilities. There are python scripts the generate
  initial configuration, fortran routines to extract configurations, etc.
- *tests* contains testing routines for development purposes. This need not be
  necessarily present.
- *docs* contain files for generating autogenerated Fortran documentation (using
 [FORD](https://github.com/Fortran-FOSS-Programmers/ford). To read the
 documentation, see [here](https://saridut.github.io/BROWNPAK/index.html).

Input and output files
----------------------

BROWNPAK reads several input files and produces several output files. The input
files are:

- `fn_control`: This file contains various directives on what simulation to run,
  time steps, etc. The directives are provided as a list of key-value pairs. The default name
 for this file is *control.txt*.
- `fn_config`: This file specifies the configuration of the system of be
  simulated, i.e. atom positions, interactions, etc. The extension for this file
  is *.cfg*, though it is not mandatory.

The output files are:

- `fn_traj`: This is a binary file containing the trajectory data. These have
  extension of *.bin*, though not mandatory.
- `fn_stats`: This is a text file containing a minimal set of statistics.
  Further statistics may be obtained by post processing `fn_traj`. During
  equilibration, the statistics will be written to a file called `fn_stats.eq`.
-  *brownpak.log*: Log file. Check this for progress and error messsages
- For energy-minimization, two other files with `-rlx` in their names will be
  produced. The file `fn_config-rlx.cfg` contains the minimized configuration,
and the file `fn_config-rlx.txt` contains the same configuration in LAMMPS data
format for visualization in Ovito.

Compilation and running
-----------------------
There is a makefile in *build*. In the makefile, the `DEBUG` flag should be set
to `false` for production builds. For testing purposes, set `DEBUG = true`.

The compiler name is specified via the variable `FC`. e.g. for intel it will be
appropriate to use `FC = ifort`. I use fortran95 wrappers to MKL as well. If one
is using a non-Intel compiler, these wrappers need to be built (see the MKL
documentation on how to do this). Anyways, since I am using gfortran, I specify the location of the
wrappers through the variable `MKL_INTRFC`. Furthermore, `MKLROOT` is the root
directory of the MKL installation. For an Intel compiler, `MKL_INTRFC` is not
necessary, but `MKLROOT` must be specified. It may be helpful to use the [Intel
Link Line Advisor](https://software.intel.com/en-us/articles/intel-mkl-link-line-advisor)
for looking up appropriate flags. Appropriate compilation flags must be
specified via `FCFLAGS`. The current flags pertain to gfortran. For debug
builds, the flags should turn off optimization, raise all warnings, check
bounds, etc.; for production builds do turn on necessary optimization (without
being too aggressive), loop unrolling, interprocedural optimizations, inlining,
etc.

```bash
make
```

To clean all `.o` and `.mod` files, do
```bash
make clean
```

To remove all `.o`, `.mod`, and the executable, do
```bash
make clobber
```

To run, the simplest way is to go to *bin* and
```bash
./brownpak fn_control=controlfile.txt  job_tag=some_number
```

Both the arguments `fn_control` and `job_tag` are optional.
If you do not specify the name of the control file, it will be assumed to be
`control.txt`. The `job_tag` argument is there to help running array jobs on a
cluster. For example, with SGE job scheduler I can request array jobs numbered
from 1-16 and specify `job_tag=$SGE_TASK_ID`. Then all output files will have
the numbers 1-16 appended to their file names, like traj.bin.1, traj.bin.2, etc.

Instead to running the executable from *bin*, you can run it from some other
directory as
```bash
path_to_bin/brownpak fn_control=controlfile.txt  job_tag=some_number
```
The above is more convenient with running multiple jobs on a cluster.

Note that once compiled, if you change the source files a recompilation is
necessary. Unlike some codes that you may be familiar with, changing input files
do not require recompilation.

Structure of the control file
-----------------------------
Here is a sample control file. It is called `control.txt.

```
sim_style           2
use_verlet_tab      F
rcutoff             5.25D0
tskin               2.1D0
use_cell_list       T
excluded_atoms      1
lvdw                T
lhdia               F
mob_fctr            KRYL
lelectrostatics     F

tim_stp             1.0D-2
nts_md              100
nts_eql             0.0D0
nts_eql_samp        10
nts_sim             2.0D3
nts_samp            10
nts_dump            10
nts_log             10

fn_cfg              sample.cfg
fn_revive           revive.bin
fn_stats            stats.txt
fn_traj             traj.bin

lrevive             F
read_seed           F
write_seed          T
write_eql_stats     T
write_traj          T
traj_frmcmp         1 0 0 1
traj_wmpcd          F
```

As you can see, it lists a number of keywords and their corresponding values
separated by whitespace. The maximum length of a line is as specified in
[[m_globals:mxrdln]].

@note Each of the keywords in the control file is a variable listed in
[[m_globals]]. Please look up the detailed description and possible set
of allowed values there.

@warning There are no checks performed on the consistency of the values provided
in the control file. If you use unphysical values, your results may be incorrect
or the program may crash.

There can be blank lines between the keywords. Comments begin with `#`. If the
`#` character is found on any line the rest of the line after `#` will be
discarded. The keywords and the values must be separated by one or more whitespaces.

I will elaborate on some specific aspects of the value format:

- Strings need not be quoted
- Booleans may be simply given as T or F instead of .true. or .false.
- Floats are always double precision, so please use `*.D*` fortran format. For
  example, a value of `2.1` is single precision; instead specify it at `2.1D0`.
  Other exponents are similar, e.g., `1.0D-2` for `0.01`.
- Values requiring uppercase letters must be given in that form, e.g. `KRYL` is
  not the same a `kryl`.
- All the keywords starting with `nts` except `nts_md` are long ints. For
  convenience these values may be given in `*.D*` format. Internally they will
  be cast as long ints. `mts_md` is not a long int because it does not make
  sense for it to be a large number, else the simulation will never complete.
- `traj_frmcmp`: See [[m_globals:traj_frmcmp]] for details. Each element of the
  sequence can be either 0 or 1 (separated by whitespaces), e.g. 1 1 1 1 or 1 0 0 1.
  All four being zero is allowed, but makes no sense.
- Choosing `nts_dump <= nts_samp` is a good idea, but do not dump too frequently
  either.

Structure of the trajectory file
---------------------------------
The trajectory file is a binary file, i.e. it is a stream of bytes. The byte
order is native. It can be read back in python (using *struct* to unpack), in
fortran (opening the file with `form='unformatted, access='stream'`), or in any
other language.

@warning If `traj_wmpcd = T` in the control file, the trajectory file can be
extremely large. Explicit data for the position and velocities of MPCD atoms are
rarely needed. MPCD atoms do not have forces or charge on them.

I will call the trajectory file as `traj.bin`. It contains a header, followed by
a sequence of frames. The structure of the header is:

- *header_size*: 1 int (32 bits)
- *frame_size*: 1 int (32 bits)
- *num_atoms*: 1 int (32 bits). Number of non-MPCD atoms in the trajectory.
- *num_mpcd_atoms*: 1 int (32 bits). Number of MPCD atoms in the trajectory.
- *frmcmp*: 4 ints (32 bits each). Components of each frame, as specified by
  `traj_frmcmp` in the control file.

During creation of a trajectory, *num_atoms* and *num_mpcd_atoms* are given
to [[m_trajectory:traj_create]]. Depending on [[m_globals:traj_wmpcd]], it is
possible for an MPCD simulation to not write any MPCD data to `traj.bin`. This
should be the commonly used case. For BD/energy-minimization the value of
[[m_globals:traj_wmpcd]] does not matter.

Following the header, there is a sequence of frame data, written according to
[[m_globals:traj_wmpcd]] and [[m_globals:traj_frmcmp]].

Structure of the revive file
----------------------------

The revive file is a binary dump. It contains enough information to restart the
simulation if `lrevive = T` in the control file. To see what gets dumped, please
examine the source for [[m_config_io:write_dump]].

Interactions
------------

The following kinds of interactions are available (or can be made available with
minimal effort):

- *Bonds*

    All bonds have a *type* called *bond_type*.  *bond_type*s are assigned
    by the user. For example, in a A-B diblock polymer, the user may choose A-A bonds
    as type 1, B-B bonds as type 2, and the A-B bond as type 3.

    Each *bond_type* is completely determined by a *style*, called *bond_style*,
    and a set of parameters, called *bond_params*. *bond_style*s are chosen from the
    list of available styles, as specified in [[m_ia_bond]]. The number of required
    parameters depend on the chosen style. The maximum number of parameters is
    [[m_globals:mxparam]].  For example, in our A-B diblock, the A-A bonds can be
    of type 1, with style 3 (corresponding to Kremer-Grest bond), and a set of four
    parameters; the B-B bonds can be of type 2, and also of style 3, with a set
    of four parameters, same as or different from the parameters of A-A bonds.

- *Angles*

    Similar to bonds, angles have types and styles as well. See [[m_ia_angle]].
    Only one non-trivial style is available, as this is the most commonly used
    style for polymers. However, more styles can be added if necessary.

- *Dihedrals*

    Dihedrals are not typically used in the kind of polymer models I deal with.
    So, only the trivial style is present. In case you need a dihedral, add the
    appropriate routines to [[m_ia_dihedral]].

- *Tethers*

    Tethers are pointwise restraints on one or more atoms. There can be multiple
    tethers, see [[m_ia_tether]].

- *Pairwise*: See [[m_ia_vdw]] for a list.

- *External*: There is no working implementation of external interactions. The
  idea is this: I do not know what kind of external interactions you need, but I
do not want to restrict you into a set of predefined interactions. So, please
modify the module [[m_ia_external]] to your choice, while keeping the interface
intact.  A guiding principle is
that external interactions are generally fields that act on all the atoms in the
sytem, but in some sense this covers everything. Remember to update the
stress as you add external interactions.

Structure of the config file
----------------------------

Here is an extremely basic *config* file for a bunch of MPCD atoms.
```
Sample
SIMBOX
20  0.0  0.0
0.0  20  0.0
0.0  0.0  20

IMCON  1

ATOM_TYPES  0

MPCD_ATOMS  40000  5

ATOMS  0

MOLECULE_TYPES  0

MOLECULES  0
```

Please see the other examples in *utils/models*. It is best to use the python
scripts to generate your *config* files. These scripts are self-explanatory.

Restarting a simulation
-----------------------
To restart a simulation, set `nts_sim` to a higher value in the *control* file
and start the simulations. Note that an unusual situation may happen if you are
restarting after your job got killed/you deliberately killed it. In this case,
it is possible that the data written in *fn_stats* and *fn_traj* are a few time
steps ahead of what is in *fn_dump*. This is most annoying; to get rid of such
unwanted annoyances, I have written a small python script called `sync.py` that
lives at `utils/sync`. This script basically compares both *fn_traj*  and
*fn_stats* with *fn_dump* and shaves off the extra records. You can run it
before resubmitting a killed job. Use it with care, you *may* lose data.

Workflow: Energy minimization
-----------------------------

1. Create an intial configuration. Say it is in file `sample.cfg`.

2. Run the programme with `sim_style = 0`.

3. Monitor *fn_stats*, here the output energies will be written. The minimized
   configuration will be written to `sample-rlx.cfg`. Moreover `sample-rlx.txt`
(in LAMMPS data format) will be created, which you can visualize in Ovito. If
necessary, rerun by setting `nts_sim` to a higher value.

Workflow: BD/MPCD
------------

1. Create an initial configuration.

2. Minimize energy if you think this will be useful. It is usually useful. Use
   the minimized configuration as the stating configuration for BD/MPCD
simulation.

3. Set `sim_style = 1`(for BD) or `sim_style = 2`(for MPCD) and run.

4. Rerun if necessary.

Updating documentation (for developers)
=======================================

- API documentation (Fortran files) is generated using
 [FORD](https://github.com/Fortran-FOSS-Programmers/ford). As required by FORD,
the documentation is written in Markdown. All versions of Markdown may not be
supported, please experiment to see what works. Whole of GFM definitely doesn't.

- FORD also processes a User's Guide page, also written in Markdown. The source
for this is `index.md` in `docs/pages`. This may change in future, as I would
prefer this to be in reStructuredText.

- The *html* pages generated by FORD is hosted on GitHub Pages for this
  repository. For a number of reasons, pushing newly generated *html* pages is
not straightforward. These pages are pushed to the *gh-pages* branch, not to
*master*.

- Assume that you have cloned the repo as usual, worked on it, and now you wish to update
the documentation. This will be done via git worktree, as discussed by
[Sangsoo Nam](https://sangsoonam.github.io/2019/02/08/using-git-worktree-to-deploy-github-pages.html).

- Commit your current work and push. From the root of the repo, first create a
linked worktree as follows:
```bash
cd docs
git worktree add html gh-pages
cd html
```
This will create a linked worktree in the directory `docs/html` and enter it. If
you do
```bash
git branch
```
now, you will see the current branch to be *gh-pages*.

- `docs/html` is where the *html* pages will finally live. Now, clean it.
```bash
git rm -rf .
```

- Next, create an empty file `.nojekyll`. This prevents Jekyll from fiddling
  with stuff inside `html`.
```bash
touch .nojekyll
```

- Change directory to `docs`.
```bash
cd ../docs
```

- Create a temporary directory called `docs/tmp`. FORD will generate the *html*
  files here, which will be copied to `docs/html`. This is necessary because
FORD deletes everything inside its output directory, including `.git`.
```bash
mkdir tmp
```

- Run FORD. Move the *html* pages to `html`.  Then get rid of the worktree.
```bash
cd ../docs
git worktree remove html
```

repository: saridut/BROWNPAK

repo_name: saridut/BROWNPAK


text:
# packer-mysql64
firedot-mysql64

**This repository is based on [that](https://github.com/nabels-coolblue/packer-xenial64) repository.**

**This repository creates base Ubuntu Vagrant box with MySQL installed.**

Here you could find instructuions how to create a basic Vagrant box with Packer.

You could learn more about Vagrant [here](https://www.vagrantup.com/intro/index.html)

## Used technologies

**Packer**
You could learn more about packer by visiting: https://www.packer.io/intro/

**VirtualBox**
You could learn more about VirtualBox by visiting: https://www.virtualbox.org/

### VirtualBox phase
Install VirtualBox on your machine.
Instructions on how it's done may be found [here](https://www.virtualbox.org/manual/ch02.html)

### Packer phase
1. Download and install [packer](https://www.packer.io/downloads.html)
2. Run the following command in the directory where you have cloned the repository:

````
packer build template.json
````
3. You could upload the box created by you during the packer phase to the [VagrantCloud](https://app.vagrantup.com/boxes/search)

gha_language: Shell


text:
# Street-level Simulator for SCENTS(collaborative sensing in proximity IoT networks)
[![License](https://img.shields.io/badge/license-BSD-blue.svg)](LICENSE)

## Getting Started

**(Jan 2020) Updated the simulator to work with OMNeT(v5.6) and INeT(v4.2)**

(Oct 2019) Updated the simulator to work with OMNeT(v5.5.1) and INeT(v4.1.1).

### Prerequisites
- [OMNeT++ v5.6](https://omnetpp.org/download/)

- [INeT Framework v4.2](https://github.com/inet-framework/inet)

- [Eigen3](http://eigen.tuxfamily.org) C++ template library for linear algebra.

- Include the 3rd party libraries in project path (shown in below fig)

### Experiment Scenarios

Config: `simulations/scents/omnetpp.ini`
Run Script: `simulations/scents/run.sh`

### Customize the simulation

You can download the data of your target geographical region in OSM
format and convert the buildings using the osm parser
script. Waypoints used in the mobility model are also GPS
coordinates. Other things are mostly configurable through
`omnetpp.ini`.

## Screenshots

[(YouTube vid)](https://youtu.be/KPqtK9t2efs)

## License and Citation
This simulator is released under the BSD 3-Clause license.

Please use the following reference in your publications if this project helps your research:
```
@inproceedings{liu2019scents,
  title={SCENTS: Collaborative Sensing in Proximity IoT Networks},
  author={Liu, Chenguang and Hua, Jie and Julien, Christine},
  booktitle={Proceedings of the 17th IEEE International Conference on Pervasive Computing and Communications Workshops (PerCom Workshops)},
  year={2019},
  organization={IEEE},
}
```

repository: UT-MPC/collab-sensing-simulation

repo_name: UT-MPC/collab-sensing-simulation


text:
# WISE QUOTES
#### Author: **Alfred Warui**
##
Wise Quotes is an application where users can view quotes and their details present.They are also given privileges of inputting quotes from an author they know,like or dislike quotes as well as deleting quotes.The application also highlights the quote with the highest vote.
## Installation
  Clone this repository into your computer using this command:git clone https://github.com/WaruiAlfred/Quotes.git
## Screenshot
![ScreenShot](https://raw.github.com/WaruiAlfred/Quotes/master/src/assets/screenshot.png)
## Known Bugs
There are known bugs.
## My contacts
Email<EMAIL_ADDRESS>My phone number:0740365281
### License
* *License under [MIT License](LICENSE)*
* Copyright (c) 2021 **Alfred Warui**

repository: WaruiAlfred/Quotes

repo_name: WaruiAlfred/Quotes


text:
# Operations

Operations are an advanced topic which most users of TezosKit will not need to know about.

Any injectable operation in the Tezos blockchain is represented by an object that inherits from `AbstractOperation`, which conforms to the `Operation` protocol.

## Supported Operations

Common operations on Tezos are supported out of the box on TezosKit. These operations include:
* Sending Tezzies
* Calling Smart Contracts
* Delegating the Balance of an Account
* Originating a new Account

Users of these common operations will never have to work with `Operation` objects directly and can instead call associated methdos on `TezosNodeClient`.

## Custom Operations

Users of TezosKit can create and inject custom operations. Creating a custom operation requires some wiring, but is fairly straightforward.

### Creating an Operation

TezosKit can inject any operation which conforms to the `Operation` protocol. Users can wire up custom operations. In most cases, you'll want to subclass `AbstractOperation` to get baseline functionality.

The `Operation` protocol requires three properties to be implemented:
* `requiresReveal`: If `true` then TezosKit will automatically add a reveal operation any time this operation is applied to an unrevealed account.
* `defaultFees`: An `OperationFees` object which represents the default fees for the operation.
* `dictionaryRepresentation`: A representation of the dictionary in a `Dictionary`.

Note that `dictionaryRepresentation` contains only the values represented by the operation. Values like `signature` and `branch` are not required. For instance, a `dictionaryRepresentation` of a `TransactionOperation` looks like:
```swift
[
  "source": "tz1...",
  "destination": "tz1...",
  "amount": "123",
  "kind": "transaction",
  "fee": "1",
  "gas_limit": "1",
  "storage_limit": "1"
]
```

### Injecting an Operation

`TezosNodeClient` provides a method which lets you inject a custom operation. Injecting a custom operation in the node is easy:

```swift
let wallet = Wallet(...)
let tezosNodeClient = TezosNodeClient(...)
let customOperation = MyCustomOperation(...)

tezosNodeClient.forgeSignPreapplyAndInject(
  customOperation,
  source: wallet.address,
  keys: wallet.keys
) { result in
  // Handle result hash
}

```

Or if you'd like to inject multiple operations, pass them as an array. Operations are processed in the order they are inserted into the array:

```swift
let wallet = Wallet(...)
let tezosNodeClient = TezosNodeClient(...)
let transactionOperation = TransactionOperation(...)
let customOperation = MyCustomOperation(...)

tezosNodeClient.forgeSignPreapplyAndInject(
  [customOperation, transactionOperation],
  source: wallet.address,
  keys: wallet.keys
) { result in
  // Handle result hash
}

```

Like all `TezosNodeClient` methods, injection of single and multiple operations is supported with closure based callbacks or with Promises.

repository: keefertaylor/TezosKit

gha_language: Swift

repo_name: keefertaylor/TezosKit


text:
## P16 - Simple 16bit image format
 >version 1

Simple image format for use with low performance devices, mainly for storage of system icons etc. In basic compression mode can greatly reduce size of images with large areas of same color pixels. It is intended to use it with some filesystem.

### Usage and performance
Uncompressed images are 2/3 size of the same image in PPM, because of native 16bit colors.
Compressed images can further reduce overall file size to about 1/2 of the uncompressed file. This is content-dependent and in the worst case the compressed image is larger than the uncompressed, in that case disable the compression when encoding the images.
P16 is used as the default image format for the SDA_OS.
### Spec:
|  Byte no.: | Value | Description: |
|--|--|--|
| 0 | 0x1b | Initial byte |
| 1 - 5 | PSM16 | ASCII: PSM16 |
| 6 | 1 |  Format version: (1 for this spec) |
| 7 |  | Image width LSB |
| 8 |  | Image width MSB |
| 9 |  | Image height LSB |
| 10 |  | Image height MSB |
| 11 |  | storage mode 0 - uncompressed 1 - basic compression |
| 12 |  | Data section offset |

Remaining 255 or so bytes of offset could be used for some additional info. Otherwise set the offset to 1 and start the data section on byte 13.
### Data section:
  Field of 16 bit values interpreted depending upon the storage mode.
#### Normal mode
  In normal mode (0) those are 16bit RGB565 values for each pixel of the screen.
#### Compressed mode
  In compressed mode (1) if two pixels in a row have the same color, the third 16bit value  is count of how many more pixels have the same color, if there is zero, then no more  same colored pixels will be drawn. This method of compression is super simple and performs greatly if there are large areas of pixels with the same color,  but if there are many occurrences of just two pixels with the same color, the final storage  size of those pixels will be larger than when left uncompressed.
  Anyway, even in a worst case scenario this compression method can not create  file larger than the original PPM file, so that is good.

### Reference implementation
If my implementation is working according to this spec, then it is the reference, but I never actually checked that. Anyway this repo contains tool for converting gimp-generated ppm to p16 and p16view utility.


text:
# SolarNetwork DER Challenge: Facility SolarNetwork

This repository contains a proof-of-concept Protobuf/gRPC based server implementation of the
`DerFacility` defined in [der_facility_service][der_facility_service] that integrates with
SolarNetwork for operational management.

## Building

Gradle is used for building. Run the `build` task via `gradlew`:

	$ ../gradlew build

This will generate a `build/libs/esi-solarnet-facility-cli-X.jar` where `X` is a version number.

## Integration with SolarNetwork

This application relies on ESI metadata published by the [SolarNode ESI Facility Integration][esi-sn-control]
plugin. Once that has been deployed and configured, then run this application with a user-level
SolarNetwork security token by supplying these runtime properties:

| Property | Description |
|:---------|:------------|
| `esi.facility.solarnetwork.tokenId` | The user-level security token ID. |
| `esi.facility.solarnetwork.tokenSecret` | The security token's secret value. |
| `esi.facility.solarnetwork.url` | **Optional:** the SolarNetwork base URL to use. Defaults to `https://data.solarnetwork.net`. |

For example:

```sh
java -Desi.facility.solarnetwork.tokenId=SlKJD93jLDKjD \
     -Desi.facility.solarnetwork.tokenSecret=jlksjd9083hj3lkwej039 \
     -jar build/libs/esi-solarnet-facility-cli-0.1.0.jar
```

# Facility CLI via SSH

The facility provides a CLI application you can access via SSH. By default it listens on port
**2224**. To connect, use `ssh` like this:

```shell
ssh user@localhost -p 2224
Password authentication
Password:
 :: ESI Facility SolarNetwork CLI :: (0.1.0)

Please type `help` to see available commands
SNFac>
```

The password will have been printed on the exchange's console when it started up, like this:

```
--- Generating password for ssh connection: e73d4bfb-d89f-4873-b10c-d87a08998702
```

[der_facility_service]: ../api/src/main/proto/solarnetwork/esi/service/der_facility_service.proto
[esi-sn-control]: https://github.com/SolarNetwork/solarnetwork-node/tree/develop/net.solarnetwork.node.control.esi
[sim-intro]: ../README.md#simulation-example-register-a-facility-with-an-exchange

repository: bellmit/der-challenge-prototype

repo_name: bellmit/der-challenge-prototype


text:
# SpaceX Launch Tracker
## By Sam Girshovich

##### Do `pip install -r requirements.txt` to install dependecies
##### You can acces the site by going to [spacexlaunchdata.com](http://spacexlaunchdata.com)


text:
### [CVE-2002-2048](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2002-2048)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Buffer overflow in PFinger 0.7.8 client allows remote attackers to execute arbitrary code via a long query value passed to the (1) finger program, (2) -l, (3) -d, and (4) -t options.  NOTE: if PFinger is not setuid or setgid, then this issue would not cross privilege boundaries and would not be considered a vulnerability.

### POC

#### Reference
- http://marc.info/?l=vuln-dev&m=102321152215055&w=2

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
# Migration to V1.0.0
esdoc2 v1.0 adopts plugin architecture. So, almost all features are provided as plugins.

Please change your config to load plugins.

## Using esdoc2-standard-plugin
Main features of esdoc2 were carved out to [esdoc2-standard-plugin](https://github.com/esdoc2/esdoc2-plugins/tree/master/packages/esdoc2-standard-plugin)

Please use the plugin with the following config.

`npm install esdoc2-standard-plugin`

```json
{
  "source": "./src",
  "destination": "./docs",
  "plugins": [{"name": "esdoc2-standard-plugin"}]
}
```

The full config description is [here](./config.html#full-config).

Especially [integration test codes](./config.html#integrate-test-codes-config) and [integration manual](./config.html#integrate-manual-config) were big changed.

## Using Other Plugins
The following features were carved out to each plugins. If you want to use the features, please use the plugins.

- `config.includeSource` => [esdoc2-exclude-source-plugin](https://github.com/esdoc2/esdoc2-plugins/tree/master/packages/esdoc2-exclude-source-plugin)
- `config.styles` => [esdoc2-inject-style-plugin](https://github.com/esdoc2/esdoc2-plugins/tree/master/packages/esdoc2-inject-style-plugin)
- `config.scripts` => [esdoc2-inject-script-plugin](https://github.com/esdoc2/esdoc2-plugins/tree/master/packages/esdoc2-inject-script-plugin)
- `config.experimentalProposal` => [esdoc2-ecmascript-proposal-plugin](https://github.com/esdoc2/esdoc2-plugins/tree/master/packages/esdoc2-ecmascript-proposal-plugin)
- Parsing JSX => [esdoc2-jsx-plugin](https://github.com/esdoc2/esdoc2-plugins/tree/master/packages/esdoc2-jsx-plugin)

gha_language: JavaScript


text:
---
title: "Vectors"
date: 2018-09-01
tags: [maths]
excerpt: "Revision notes on Vectors!"
mathjax: true
---

Numbers are great. 5 is is a fantastic example of a number, as is 7. 1024 is a handy number too. Numbers provide us with information about the magnitude of a quantity of interest. It is often very useful though to talk about magnitude in a particular direction. We gain extra information by stating 7 Mph North, or 5 metres at a 45 degree angle. In mathematical language we call quantities which only describe magnitude as scalars and quantities which convey magnitude and direction, vectors.

Vectors allow us to represent a magnitude with an associated direction. We might think of a vector as a displacement from one point in space to another or as a position in space with respect to a point of origin.

Algebraically we denote a a vector using bold text e.g. $$\bf{a}$$, underlining $$\underline{a}$$ or $$\vec{a}$$ to distinguish it from a scalar $$a$$. Hence; the vector $$\vec{a} = 3$$ Metres North is the vector labelled 'a' which has a magnitude of $$3$$ 'Metres' and a direction of 'North'. The scalar $$a=3$$ Metres tells us a magnitude.

1. Representation
2. Algebraic Manipulation; dot product; cross product
3. Vector Space
4. Unit Vectors
5. Vectors -> Matrices -> Linear Algebra


text:
Disallows the declaration of an empty enum

An enum with no members serves no purpose. This rule will capture these
situations as either unnecessary code or a mistaken empty implementation.

### Invalid:

```typescript
enum Foo {}
```

### Valid:

```typescript
enum Foo {
  ONE = "ONE",
}
```

gha_language: Rust