sqlitemgr package¶
Submodules¶
sqlitemgr module¶
-
class
sqlitemgr.
SQLiteMgr
(db='')[source]¶ SQLite Manager class for managing databases, connections and tables.
-
add_table_column
(column_name, column_data_type, column_table_constraint='')[source]¶ - Composes a part of self.table_statement needed for creating a single column. The basic syntax for creating a column for sqlite is:
- column name datatype TABLE CONSTRAINT.
- Args:
- column_name (str): the name of the column column_data_type (str): values: null, integer, real, text, blob column_table_constraint (str): values: NOT NULL, UNIQUE, PRIMARY KEY, FOREIGN KEY, CHECK, DEFAULT
- Returns:
- self (for method chaining)
One or more calls to add_table_column (and create_table) methods can be chained one after the other:
sqlmgrObject.add_table_column(“id”, “integer”, “NOT NULL”).add_table_column(“some_name”, text, “UNIQUE”).add_table_column(“owner”, text).create_table()
-
consecutive_reindex
(renumber_column, table=None, start_number=1)[source]¶ Re-index all of the numbers in a number column of a table after one or more row deletions so that they are all consecutives. Example: After deleting some rows from a table, we are left with rows whose numbers are 1, 3, 4, 7, 8, 10. This method will re-number all of the numbers so that they are 1, 2, 3, 4, 5, 6.
Uses the _ROWID_ column as a reference for updating the value in the renumber_column. (Every sqlite database row is automatically given a _ROWID_.)
- Args:
- number_column (string): The name of the row that has the actual row number for each row. return_all_reordered (Boolean): If True, returns the dictionary used to keep track of old and new renumber_column numbers start_number (int): The number to start with when re-ordering the renumber_column.
-
create_db
(db=None)[source]¶ Create a new database file. The path/name of the database must first be assigned to self.db by the constructor or directly.
- Args:
- db_name (str): The name of the database file to be created. (This should have a ‘.db’ extension at the end of it.)
-
create_table
()[source]¶ Create a table in the database. This method executes the sql to create the table in the database. It sets self.status to the error message thrown by the Exception if there was any problem.
-
delete_db
(db_name)[source]¶ Delete a database file. The path/name of the database must first be assigned to self.db either by the constructor or directly assigning a value to the attribute.
- Args:
- db_name (str): The name of the database file to be created. (This should have a ‘.db’ extension at the end of it.)
-
delete_table
()[source]¶ Delete a table in the database. The names of the table which will be deleted and the database in which the table resides are those stored in self.table and self.db.
-
get_cursor
()[source]¶ This method creates and returns a cursor for executing SQL statements with the database connection. A connection must first have been created. Returns:
cursor: A cursor which can then be used by calling code elsewhere.
-
get_number_rows_in_table
(table)[source]¶ Return the number of rows in table, assuming table is actually in self.db.
- Args:
- table (str): The name of the table whose rows are to be counted.
- Returns:
- None (NoneType): (if there was a problem obtaining the connection or the cursor.)
-
get_number_tables_db
()[source]¶ Executes a query against the database sqlite_master to the names of all the tables in the database. Returns:
the total number of all tables in the object’s database (resulting from calling len() on the structure returned by cursor.fetchall())..
-
new_table
(table)[source]¶ Start the process to create a new table in the database. (The name of the database to add the table to is the one assigned to self.db.) This method adds the beginning of an sql create statement to self.table_statement. self.table_statement is the query that is executed to actually create the table. If self.table_statement is composed by calling the methods of this class, it always starts with “CREATE TABLE IF NOT EXISTS table (. Note the double quote at the beginning of the table_statement: the table_statement is always preceded and concluded by double quotes.
- Args:
- table (str): the name for the table
- Returns:
- self (for method chaining)
-
Module contents¶
-
class
sqlitemgr.
SQLiteMgr
(db='')[source] SQLite Manager class for managing databases, connections and tables.
-
add_table_column
(column_name, column_data_type, column_table_constraint='')[source] - Composes a part of self.table_statement needed for creating a single column. The basic syntax for creating a column for sqlite is:
- column name datatype TABLE CONSTRAINT.
- Args:
- column_name (str): the name of the column column_data_type (str): values: null, integer, real, text, blob column_table_constraint (str): values: NOT NULL, UNIQUE, PRIMARY KEY, FOREIGN KEY, CHECK, DEFAULT
- Returns:
- self (for method chaining)
One or more calls to add_table_column (and create_table) methods can be chained one after the other:
sqlmgrObject.add_table_column(“id”, “integer”, “NOT NULL”).add_table_column(“some_name”, text, “UNIQUE”).add_table_column(“owner”, text).create_table()
-
close_db
()[source] Close the connection to the database.
-
consecutive_reindex
(renumber_column, table=None, start_number=1)[source] Re-index all of the numbers in a number column of a table after one or more row deletions so that they are all consecutives. Example: After deleting some rows from a table, we are left with rows whose numbers are 1, 3, 4, 7, 8, 10. This method will re-number all of the numbers so that they are 1, 2, 3, 4, 5, 6.
Uses the _ROWID_ column as a reference for updating the value in the renumber_column. (Every sqlite database row is automatically given a _ROWID_.)
- Args:
- number_column (string): The name of the row that has the actual row number for each row. return_all_reordered (Boolean): If True, returns the dictionary used to keep track of old and new renumber_column numbers start_number (int): The number to start with when re-ordering the renumber_column.
-
create_db
(db=None)[source] Create a new database file. The path/name of the database must first be assigned to self.db by the constructor or directly.
- Args:
- db_name (str): The name of the database file to be created. (This should have a ‘.db’ extension at the end of it.)
-
create_table
()[source] Create a table in the database. This method executes the sql to create the table in the database. It sets self.status to the error message thrown by the Exception if there was any problem.
-
delete_db
(db_name)[source] Delete a database file. The path/name of the database must first be assigned to self.db either by the constructor or directly assigning a value to the attribute.
- Args:
- db_name (str): The name of the database file to be created. (This should have a ‘.db’ extension at the end of it.)
-
delete_table
()[source] Delete a table in the database. The names of the table which will be deleted and the database in which the table resides are those stored in self.table and self.db.
-
get_cursor
()[source] This method creates and returns a cursor for executing SQL statements with the database connection. A connection must first have been created. Returns:
cursor: A cursor which can then be used by calling code elsewhere.
-
get_number_rows_in_table
(table)[source] Return the number of rows in table, assuming table is actually in self.db.
- Args:
- table (str): The name of the table whose rows are to be counted.
- Returns:
- None (NoneType): (if there was a problem obtaining the connection or the cursor.)
-
get_number_tables_db
()[source] Executes a query against the database sqlite_master to the names of all the tables in the database. Returns:
the total number of all tables in the object’s database (resulting from calling len() on the structure returned by cursor.fetchall())..
-
make_conn
()[source] This method creates and returns a connection.
-
new_table
(table)[source] Start the process to create a new table in the database. (The name of the database to add the table to is the one assigned to self.db.) This method adds the beginning of an sql create statement to self.table_statement. self.table_statement is the query that is executed to actually create the table. If self.table_statement is composed by calling the methods of this class, it always starts with “CREATE TABLE IF NOT EXISTS table (. Note the double quote at the beginning of the table_statement: the table_statement is always preceded and concluded by double quotes.
- Args:
- table (str): the name for the table
- Returns:
- self (for method chaining)
-
set_table_statement
(table_statement)[source] This method allows self.table_statement to be set directly rather than by method calls. Follow this with a call to create_table to execute the sql and add the table to the database.
- Returns:
- self (for method chaining)
-


|
|
tuple | aqua = (77, 184, 100) |
| |
|
tuple | beige = (255, 250, 200) |
| |
|
tuple | black = (0, 0, 0) |
| |
|
tuple | blue = (0, 100, 255) |
| |
|
tuple | brown = (170, 110, 40) |
| |
|
tuple | coral = (255, 215, 180) |
| |
|
tuple | cyan = (70, 240, 240) |
| |
|
tuple | darkgray = (64, 64, 64) |
| |
|
tuple | green = (60, 180, 75) |
| |
|
tuple | granite = (60, 60, 60) |
| |
|
tuple | gray = (128, 128, 128) |
| |
|
tuple | lavender = (230, 190, 255) |
| |
|
tuple | lime = (210, 245, 60) |
| |
|
tuple | magenta = (240, 50, 230) |
| |
|
tuple | maroon = (128, 0, 0) |
| |
|
tuple | mint = (170, 255, 195) |
| |
|
tuple | navy = (0, 0, 128) |
| |
|
tuple | olive = (128, 128, 0) |
| |
|
tuple | orange = (255, 115, 15) |
| |
|
tuple | pink = (255, 66, 138) |
| |
|
tuple | purple = (191, 2, 255) |
| |
|
tuple | red = (255, 0, 0) |
| |
|
tuple | sand = (255, 215, 96) |
| |
|
tuple | stone = (20, 20, 20) |
| |
|
tuple | teal = (0, 128, 128) |
| |
|
tuple | white = (255, 255, 255) |
| |
|
tuple | yellow = (255, 239, 17) |
| |
◆ __init__()
| def aecSpace.aecColor.aecColor.__init__ |
( |
|
self | ) |
|
Constructor sets color to white and alpha to opaque.
◆ alpha()
| def aecSpace.aecColor.aecColor.alpha |
( |
|
self, |
|
|
|
int |
|
) |
| |
Returns the color's alpha component.
◆ alpha_01()
| def aecSpace.aecColor.aecColor.alpha_01 |
( |
|
self, |
|
|
|
int |
|
) |
| |
Returns the color's alpha component as a value between 0 and 1.
◆ color()
| def aecSpace.aecColor.aecColor.color |
( |
|
self, |
|
|
|
Tuple, |
|
|
|
int, |
|
|
|
int, |
|
|
|
int |
|
) |
| |
Returns the current color as integer RGB values from 0 to 255.
◆ color_01()
| def aecSpace.aecColor.aecColor.color_01 |
( |
|
self, |
|
|
|
Tuple, |
|
|
|
float, |
|
|
|
float, |
|
|
|
float |
|
) |
| |
Returns the color as RGB values from 0 to 1.
The documentation for this class was generated from the following file:


Gujrat, India
According to New Delhi Television Limited, "The official death toll from the floods in Gujarat stands at 111, with more than 36,000 people evacuated to safe areas as helicopters and boats try to reach those still stranded."
Learn More


The formats will sometimes be given with notation such as '%d' to indicate a decimal integer; '%6.3f' for a floating point number with up to 6 characters and 3 digits after the decimal place; or '%-7s' for a left-justified string 7 characters wide. This notation is compatible with C, C++, awk/nawk/gawk, and with a slight modification, Python.
The "" symbol is used to indicate one space.
The type of an argument is described using the following style:
<string>
= an alphanumeric string. In most cases, this is a valid filename;
<character>
= a single letter;
<integer>
= a decimal integer;
<positive_integer>
= a decimal integer greater than zero;
<long_integer>
= a decimal integer in the "long" range (depends on computer);
<float>
= a floating point or real number.
The name 'PDBQ' derives from 'PDB', the Protein DataBank, and 'Q', a common symbol for partial charge. As the name suggests, the PDBQ format is very similar to the PDB format for ATOM records, with a modification in columns 71-76 (counting the first column as 1, not 0) to carry the partial charge, as %6.3f. Thus, the format of the whole line is as follows:
"ATOM%5d%-4s%1s%-3s%1s%4d%1s%8.3f%8.3f%8.3f%6.2f%6.2f%4s%6.3f\n", atom_serial_num, atom_name, alt_loc, res_name, chain_id, res_num, ins_code, x, y, z, occupancy, temp_factor, footnote, partial_charge
In addition to this, there are various records (ROOT, TORSION and BRANCH, for example) in the ligand PDBQ file that specify which portion of the molecule is rigid and which is flexible.
This format is derived from the PDBQ format, and is used to specify the atomic solvation parameters for the macromolecule, hence the "S". The format of the lines is:
"ATOM%5d%-4s%1s%-3s%1s%4d%1s%8.3f%8.3f%8.3f%6.2f%6.2f%4s%6.3f%8.2f%8.2f\n", atom_serial_num, atom_name, alt_loc, res_name, chain_id, res_num, ins_code, x, y, z, occupancy, temp_factor, footnote, partial_charge, atomic_fragmental_volume, atomic_solvation_parameter
The atomic fragmental volume and solvation parameters are derived from the method of Stouten et al . 1
The input file is often referred to as a "grid parameter file" or "GPF" for short. The scripts described in the appendices give these files the extension ".gpf". In the grid parameter file, the user must specify the following spatial attributes of the grid maps:
1. the center of the grid map;
2. the number of grid points in each of the x -, y - and z -directions; and
3. the separation or spacing of each grid point.
In addition, the pairwise-atomic interaction energy parameters must be specified. The following lines are required for each ligand atom type, Y :
4. the grid map filename for atom type Y ;
5. seven lines containing the non-bonded parameters for each pairwise-atomic interaction, in the following order: Y -C, Y -N, Y -O, Y -S, Y -H, Y - X , ( X is any other atom type) and Y - M ( M is a metal, say).
Using coefficients C n , C m , n and m , the pairwise interaction energy, V ( r ) is given by:
Alternatively, the user can specify reqm, e, n and m :
This latter method of specification is more intuitive for the user, while AutoGrid handles the calculation of the coefficients. By default, the Y - X and Y - M lines are copies of the Y -H line. But in some systems, such as receptors which consist of DNA/protein complexes, both sulphur and phosphorus can be present. In this scenario, the Y - X line can be used for modeling interactions with receptor-phosphorus atoms. A very rough approximation for phosphorus parameters is to borrow those of carbon.
The "elecmap" line in the grid parameter file is the filename of the electrostatic potential grid map. The following parameter, "dielectric", if negative, indicates that the distance-dependent dielectric function of Mehler and Solmajer 3 will be used. If positive, however, the value of that number will be used as a constant dielectric. For example, if the value were 40.0, then a constant dielectric of 40 would be used.
The AutoGrid parameter file format is described below.
Macromolecule filename, in PDBQ format.
The grid field filename, which will be written in a format readable by AutoDock and AVS 2 . The filename extension must be `.fld'.
npts <integer> <integer> <integer>
Number of x -, y - and z -grid points. Each must be an even integer number. When added to the central grid point, there will be an odd number of points in each dimension. The number of x -, y - and z -grid points need not be equal.
The grid point spacing, in Å (see the diagram on page 8). Grid points must be uniformly spaced in AutoDock: this value is used in each dimension.
gridcenter <float> <float> <float>
The user can explicitly define the center of the grid maps, respectively the x , y and z coordinates of the center of the grid maps (units: Å, Å, Å.) Or the keyword "auto" can be given, in which case AutoGrid will center the grid maps on the center of mass of the macromolecule.
1-letter names of the atom types present in the ligand; e.g. if there are carbons, nitrogens, oxygens and hydrogens, then this line will be "CNOH"; there are no delimiters.
This is always 0.5Å, when using the AutoDock 3.0 free energy function. It is used to smooth the pairwise atomic affinity potentials (both van der Waals and hydrogen bonds). See the Theory section for more details.
Filename of the grid map, for ligand atom type Y; the extension is usually ".map".
nbp_coeffs <float> <float> <integer> <integer>
Either "nbp_coeffs" or "nbp_r_eps" keywords can be used to define Lennard-Jones or hydrogen bond interaction energy parameters. The keyword "nbp_coeffs" specifies coefficients and exponents, in the order "C n C m n m ", delimited by spaces; n and m are integer exponents. The units of C n and C m must be kcal mol -1 Å n and kcal mol -1 Å m respectively; n and m have no units.
nbp_r_eps <float> <float> <integer> <integer>
Alternatively, the user can employ "nbp_r_eps" to specify the equilibrium distance and well depth, epsilon, for the atom pair. The equilibrium separation has units of Å and the well depth, epsilon, units of kcal mol -1 . The integer exponents n and m must be specified too.
In either case, the order of the parameters must be: Y -C, Y -N, Y -O, Y -S, Y -H, Y -X, and Y -M. Repeat 1 "map" line and the 7 "nbp_coeffs"or "nbp_r_eps" lines, for each atom type, Y , present in the ligand being docked.
This is used to define the atomic fragmental volume and solvation parameters, and should not be changed from the Stouten values used to calibrate the AutoDock 3.0 free energy function.
This is added to all the values in a grid map, and is only set to a non-zero, positive number for hydrogen bonding maps. This value is essentially the penalty for un-formed hydrogen bonds in the complex.
Filename for the electrostatic potential energy grid map to be created; filename extension `.map'.
Dielectric function flag: if negative, AutoGrid will use distance-dependent dielectric of Mehler and Solmajer 3 ; if the float is positive, AutoGrid will use this value as the dielectric constant.
(Optional.) Filename for the so-called "floating" grid map 3 ; filename extension `.map'. In such floating grids, the scalar at each grid point is the distance to the nearest atom in the receptor. These values could be used to guide the docking ligand towards the receptor's surface, thus avoiding non-interesting, empty regions.
The first six lines of each grid map hold header information which describe the spatial features of the maps and the files used or created. These headers are checked by AutoDock to ensure that they are appropriate for the requested docking. The remainder of the file contains grid point energies, written as floating point numbers, one per line. They are ordered according to the nested loops z( y( x ) ). A sample header from a grid map is shown below:
______________________________________________________________________________
GRID_PARAMETER_FILE vac1.nbc.gpf
GRID_DATA_FILE 4phv.nbc_maps.fld
MACROMOLECULE 4phv.new.pdbq
SPACING 0.375
NELEMENTS 50 50 80
CENTER -0.026 4.353 -0.038
125.095596
123.634560
116.724602
108.233879
:
______________________________________________________________________________
This is essentially two files in one. It is both an AVS field file, and and
AutoDock
input file with
AutoDock
-specific information `hidden' from AVS in the comments at the head of the file.
AutoDock
uses this file to check that all the maps it reads in are compatible
with one-another and itself. For example, in this file, the grid spacing
is 0.375 Angstroms, there are 60 intervals in each dimension, the grid
is centered near (46,44,14), it was calculated around the macromolecule `
2cpp.pdbqs
', and the
AutoGrid
parameter file used to create this and the maps was `
2cpp.gpf
'. This file also points to a second file, `
2cpp.maps.xyz
', which contains the minimum and maximum extents of the grid box in each dimension,
x, y,
and
z
. Finally, it lists the grid map files that were calculated by
AutoGrid
, here `
2cpp.C.map
', `
2cpp.O.map
' and `
2cpp.e.map
'.
______________________________________________________________________________
# AVS field file
#
# AutoDock Atomic Affinity and Electrostatic Grids
#
# Created by autogrid3.
#
#SPACING 0.375
#NELEMENTS 60 60 60
#CENTER 46.508 44.528 14.647
#MACROMOLECULE 2cpp.pdbqs
#GRID_PARAMETER_FILE 2cpp.gpf
#
ndim=3 # number of dimensions in the field
dim1=61 # number of x-elements
dim2=61 # number of y-elements
dim3=61 # number of z-elements
nspace=3 # number of physical coordinates per point
veclen=3 # number of affinity values at each point
data=float # data type (byte, integer, float, double)
field=uniform # field type (uniform, rectilinear, irregular)
coord 1 file=2cpp.maps.xyz filetype=ascii offset=0
coord 2 file=2cpp.maps.xyz filetype=ascii offset=2
coord 3 file=2cpp.maps.xyz filetype=ascii offset=4
label=C-affinity # component label for variable 1
label=O-affinity # component label for variable 2
label=Electrostatics # component label for variable 2
#
# location of affinity grid files and how to read them
#
variable 1 file=2cpp.C.map filetype=ascii skip=6
variable 2 file=2cpp.O.map filetype=ascii skip=6
variable 3 file=2cpp.e.map filetype=ascii skip=6
______________________________________________________________________________
AutoDock 3.0 has an interface based on keywords. This is intended to make it easier for the user to set up and control a docking job, and for the programmer to add new commands and functionality. The input file is often referred to as a "docking parameter file" or "DPF" for short. The scripts described in the appendices give these files the extension ".dpf".
All delimiters where needed are white spaces. Default values, where
applicable, are given in square brackets [thus]. A comment must be
prefixed by the "
#
" symbol, and can be placed at the end of a parameter line, or on a line of its own.
Although ideally it should be possible to give these keywords in any order, not every possible combination has been tested, so it would be wise to stick to the following order.
seed <long_integer> <long_integer>
There are two possible random number generator libraries. One is the
system's own implementations, and the second is the platform-independent
library from the University of Texas Biomedical School. If the user
gives just one argument to "
seed
", then AutoDock will use the system's implementation of the random
number generator and corresponding system seed call. On most platforms,
these are "drand48" and "srand48". The platform-independent library,
however, requires two seed values. Giving two arguments to "seed" tells
AutoDock to use the platform-independent library for random number
generation.
The random-number generator (RNG) for each docking job can be `seeded'
with either a user-defined, a time-dependent, or process-ID-dependent
seed. These two seeds can be any combination of explicit long integers,
the keyword "
time
" or the keyword "
pid
". When two arguments to seed are given, the portable RNG is used; when
one is given, the built-in RNG (usually the "drand48" C-function) is
used. The portable RNG is required for the genetic algorithm and the
Solis and Wets routines. The portable RNG cannot be used with the
simulated annealing routine: this needs just one seed parameter. The
keyword, "time" gives the number of seconds since the epoch. The epoch
is referenced to 00:00:00 CUT (Coordinated Universal Time) 1 Jan 1970.
The "pid" gives the UNIX process ID of the currently executing AutoDock
process, which is reading this parameter file.
Atom names for all atom types present in ligand. Each must be a single character, and only one of: C, N, O, S, H, X, or M. The maximum number of characters allowed in this line is ATOM_MAPS, which is defined in the "autodock.h" include file. Do not use any spaces to delimit the types: they are not needed.
Grid data field file created by AutoGrid and readable by AVS (must have the extension ".fld").
Filename for the first
AutoGrid
affinity grid map of the 1st atom type. This keyword plus filename must
be repeated for all atom types in the order specifed by the "
types
" command. In all map files a 6-line header is required, and energies must be ordered according to the nested loops z( y( x ) ).
Filename for the electrostatics grid map. 6-line header required, and energies must be ordered according to the nested loops z( y( x ) ).
Filename for the ligand to be docked. This contains most importantly, atom names, xyz-coordinates, anb partial atomic charges in PDBQ format. (Filename extension should be ".pdbq").
Use this keyword to specify the center of the ligand,
about
which rotations will be made. (The coordinate frame of reference is
that of the ligand PDBQ file.) Usually the rotation center of the ligand
is the mean x,y,z-coordinates of the molecule. Inside
AutoDock
, the "
about
" xyz-coordinates are
subtracted
from each atom's coordinates in the input PDBQ file. So internally, the
ligand's coordinates become centered at the origin. Units: Å, Å, Å.
Initial coordinates for the center of the ligand, in the same frame of
reference as the receptor's grid maps. The ligand, which has been
internally centered using the "about" coordinates, has the
xyz-coordinates of the initial translation "
tran0 x y z
"
added
on. Every run starts the ligand from this location.
Alternatively, the user can just give the keyword "random" and AutoDock will pick random initial coordinates instead.
If there are multiple runs defined in this file, using the keyword "runs", then each new run will begin at this same location.
The user must specify the absolute starting coordinates for the ligand, used to start each run. The user should ensure that the ligand, when translated to these coordinates, still fits within the volume of the grid maps. If there are some atoms which lie outside the grid volume, then AutoDock will automatically correct this, until the ligand is pulled completely within the volume of the grids. (This is necessary in order to obtain complete information about the energy of the initial state of the system.) The user will be notified of any such changes to the initial translation by AutoDock. (Units: Å, Å, Å.)
quat0 <float> <float> <float> <float>
[1, 0, 0, 0°]
Respectively: Qx, Qy, Qz
, Q
w.
Initial quaternion (applied to ligand) - Qx, Qy, Qz define the unit vector of the direction of rigid body rotation, and
Q
w
defines the angle of rotation about this unit vector, in ° . (Units: none,none,none, °.)
Alternatively, the user can just give the keyword "random" and AutoDock will pick a random unit vector and a random rotation (between 0° and 360°) about this unit vector. Each run will begin at this same random rigid body rotation.
Number of dihedrals or rotatable bonds in the ligand. This may be
specifed only if rotatable bonds have been defined using ROOT, BRANCH,
TORS
etc
. keywords in the PDBQ
file named on the "
move
" line. The number supplied to this command must agree with the number
of torsions defined in this ligand PDBQ file. If this keyword is used,
then the next keyword,
dihe0
, must also be specified. Note that if
ndihe
and
dihe0
are not specified and there are defined torsions in the ligand PDBQ file,
AutoDock
assumes that the
chi
1
,
chi
2
,
chi
3
,
etc.
are all zero, and does not change the initial ligand torsion angles. (See also "torsdof" below).
Initial
relative
dihedral angles; there must be
ndihe
floating point numbers specified on this line. Each value specified
here will be added to the corresponding torsion angle in the input PDBQ
file, at the start of each run. Torsion angles are only specified by two
atoms, so the definition of rotations is relative. Units: °.
[2.0 Å]
The first form, with one argument, defines the maximum translation jump
for the first cycle that the ligand may make in one simulated annealing
step. When "trnrf" is less than 1, the reduction factor is multiplied
with the tstep at the end of each cycle, to give the new value for the
next cycle. The second form allows the user to specify the value for the
first cycle and the last cycle: AutoDock then calculates the reduction
factor that satisfies these constraints. Units: Å.
[50.0°]
Maximum orientation step size for the angular component,
w
, of quaternion. Units: °.
[10000.0]
(Optional)
This defines the energy-barrier height applied to constrained torsions.
When the torsion is at a preferred angle, there is no torsion penalty:
this torsion's energy is zero. If the torsion angle falls within a
disallowed zone, however, it can contribute up to the full barrier
energy. Since the torsion-energy profiles are stored internally as
arrays of type `unsigned short', only positive integers between 0 and
65535 are allowed.
gausstorcon <integer> <float> <float>
(Optional) Adds a constraint to a torsion. The torsion number is identified by an integer. This identifier comes from the list at the top of the AutoTors-generated input ligand PDBQ file (on the REMARK lines). An energy profile will be calculated for this torsion. An inverted Gaussian bell curve is added for each new constraint. To completely specify each Gaussian, two floating point numbers are needed: the preferred angle and the half-width respectively (both in degrees). Note that the preferred angle should be specified in the range -180 ° to +180 ° ; numbers outside this range will be wrapped back into this range. This angle, c, is relative to the original torsion angle in the input structure. The half-width is the difference between the two angles at which the energy is half the barrier (B/2 in the diagram above). The smaller the half-width, the tighter the constraint.
If you wish to constrain to absolute-valued torsion angles, it will be necessary to zero the initial torsion angles in the ligand, before input to AutoTors . The problem arises from the ambiguous 2-atom definition of the rotatable bond B-C . To identify a torsion angle unambiguously, 4 atoms must be specified: A-B-C-D :
The sign convention for torsion angles which we use is anti-clockwise (counter-clockwise) are positive angles, clockwise negative. In the above diagram, looking down the bond B-C , the dihedral angle A-B-C-D would be positive.
There is no limit to the number of constraints that can be added to a given torsion. Each new torsion-constraint energy profile is combined with the pre-existing one by selecting the minimum energy of either the new or the existing profiles.
(Optional) (Use only with "gausstorcon") This switches on the storage and subsequent output of torsion energies. During each energy evaluation, the penalty energy for each constrained torsion, as specified by the "gausstorcon" command, will be stored in an array. At the end of each run, the final docked conformation's state variables are output, but with this command, the penalty energy for each torsion will be printed alongside its torsion angle.
hardtorcon <integer> <float> <float>
(Optional) This command also adds a torsion constraint to the <integer>-th torsion, as numbered in the AutoTors-generated REMARKs. The first float defines the preferred relative angle , and the second specifies the full width of the allowed range of torsion angles (both in degrees). This type of torsion constraint is "hard" because the torsion is never allowed to take values beyond the range defined. For example, " hardtorcon 3 60. 10." would constrain the third torsion to values between 55° and 65°.
[0, 0.3113]
This specifies respectively the number and the coefficient of the
torsional degrees of freedom (DOF) for the estimation of the change in
free energy upon binding, D
G
binding
. For the purposes of AutoDock 3.0, the number of torsional DOF is the
number of rotatable bonds in the ligand, excluding any torsions that
rotate one or more hydrogen atoms,
e.g.
hydroxyls, amines, methyls. By default, the coefficient is 0.3113 kcal mol
-1
, although the user can override this as necessary. (Units: none; kcal mol
-1
).
intnbp_coeffs <float> <float> <integer> <integer>
Respectively: Cn; Cm; n; m. This command specifies the internal pairwise non-bonded energy parameters for flexible ligands, where:
These parameters are needed even if no rotatable bonds were defined in the ligand-PDBQ file. They are only used in the internal energy calculations for the ligand and must be consistent with those used in calculating the grid maps. (Units: kcal mol -1 Å n ; kcal mol -1 Å m ; none; none, respectively).
intnbp_r_eps <float> <float> <integer> <integer>
Respectively: reqm; e; n; m, This command is an alternative way of specifying the internal pairwise non-bonded energy parameters for flexible ligands, where AutoDock calculates the pairwise atomic potential using:
The first two arguments specify the equilibrium distance and well depth, epsilon, for the atom pair. The equilibrium separation has units of Å and the well depth, epsilon, units of kcal mol -1 . The integer exponents n and m must be specified too. Obviously, n m . (Units: Å; kcal mol -1 ; none; none, respectively).
(Optional) Internal ligand electrostatic energies will be calculated; the products of the partial charges in each non-bonded atom pair are pre-calculated, and output. Note that this is only relevant for flexible ligands.
[500. cal mol
-1
].
Initial "annealing temperature"; this is actually the absolute temperature multiplied by the gas constant
R
.
R
= 8.314 J mol
-1
K
-1
= 1.987 cal mol
-1
K
-1
. (Units: cal mol
-1
.)
Annealing temperature reduction factor, g [0.95 cycle -1 ]. See the equation at the bottom of page 5. At the end of each cycle, the annealing temperature is multiplied by this factor, to give that of the next cycle. This must be positive but < 1 in order to cool the system. Gradual cooling is recommended, so as to avoid " simulated quenching ", which tends to trap systems into local minima.
These keywords are all synonymous, and instruct
AutoDock
to use a linear or
arithmetic
temperature reduction schedule during
Monte Carlo
simulated annealing. Unless this keyword is given, a
geometric
reduction schedule is used, according to the
rtrf
parameter just described. If the linear schedule is requested, then any
rtrf
parameters will be ignored. The first simulated annealing cycle is carried out at the annealing temperature
rt0
. At the end of each cycle, the temperature is reduced by (
rt0/cycles
). The advantage of the linear schedule is that the system samples
evenly across the temperature axis, which is vital in entropic
calculations. Geometric temperature reduction schedules on the other
hand, under-sample high temperatures and over-sample low temperatures.
[10]
Number of automated docking runs.
[50]
Number of temperature reduction cycles.
[100]
Maximum number of accepted steps per cycle.
[100]
Maximum number of rejected steps per cycle.
[m]
State selection flag. This character can be either
m
for the
minimum
state, or
l
for the
last
state found during each cycle, to begin the following cycle.
[1.0]
Per-cycle reduction factor for translations.
[1]
Diagnostic output level. For SA (simulated annealing): 0 = no output, 1 =
minimal output, 2 = full state output at end of each cycle; 3 =
detailed output for each step. For GA and GA-LS (genetic algorithm-local
search): 0 = minimal output, 1 = write minimum, mean, and maximum of
each state variable at the end of every generation. Use "outlev 1" for
SA, and "outlev 0" for GA and GA-LS. If you use "outlev 1" with GA-LS,
you will generate very large log files.
[0]
Output frequency,
n
, for trajectory of ligand, in steps. If
n
= 0, then no trajectory states will be output; otherwise, every
n
th state will be output. The
state
consists of 7 floats describing the
x,y,z
translation, the
x,y,z
components of the quaternion unit vector, the angle of rotation about
the quaternion axis; and any remaining floats describing the torsions,
in the same order as described in the input ligand PDBQ file).
[1]
Begin sampling states for trajectory output at the cycle with this value.
[50]
End trajectory output at this cycle.
[lig.trj]
Trajectory filename. AutoDock will write out state variables to this
file every "trjfrq" steps. Use the "traj" command in AutoDock's command
mode to convert this trajectory of state-variables into a series of PDB
frames. The "traj" command is described in § "Using the Command Mode in
AutoDock"; see also § "Trajectory Files".
[E]
Trajectory output flag, can be either `
A
' or `
E
'; the former outputs only
accepted
steps, while the latter outputs
either
accepted or rejected steps.
( Optional) Creates a "watch" file for real-time monitoring of an in-progress simulated annealing job. This works only if the "trjfrq" parameter is greater than zero. The watch file will be in PDB format, so give a ".pdb" extension. This file has an exclusive lock placed on it, while AutoDock is writing to it. Once the file is closed, the file is unlocked. This can signal to a watching visualization program that the file is complete and can now be read in, for updating the displayed coordinates. This file is written at exactly the same time as the trajectory file is updated
[1000.]
External grid energy assigned to any atoms that stray outside the volume of the grid during a docking. Units: kcal mol-1.
e0max <float> <positive_integer>
[0., 10000]
This is only used by the simulated annealing method. This keyword
stipulates that the ligand's initial state cannot have an energy greater
than the first value, nor can there be more than the second value's
number of retries. Typical energy values range from 0 to 1000 kcal/mol.
If the initial energy exceeds this value, a new random state is
generated and tested. This process is iterated until the condition is
satisfied. This can be particularly useful in preventing runs starting
in exceptionally high energy regions. In such cases, the ligand can get
trapped because it is unable to take a long enough translational jump.
In those grids were the ligand is small enough to fit into the low
energy regions with ease, there will not be many iterations before a
favorable location is found. But in highly constrained grids, with large
ligands, this initialization loop may run almost indefinitely.
The root mean square deviation (rmsd) of the docked conformations will
be calculated with respect to the coordinates in the PDB or PDBQ file
specified here. This is useful when the experimentally determined
complex conformation of the ligand is known. The order of the atoms in
this file must match that in the input PDBQ file given by the
move
command. These values of rmsd will be output in the last column of the
final PDBQ records, after the clustering has been performed.
[0.5Å]
rms deviation tolerance for cluster analysis or `structure binning' ,
carried out after multiple docking runs. If two conformations have an
rms less than this tolerance, they will be placed in the same cluster.
The structures are ranked by energy, as are the clusters. The lowest
energy representative from each cluster is output in PDBQ format to the
log file. To keep the ligand's residue number in the input PDBQ file,
use the `
-k
' flag; otherwise the clustered conformations are numbered incrementally from 1. (Units: Å).
When more than one run is carried out in a given job, cluster analysis
or `structure binning' will be performed, based on structural rms
difference, ranking the resulting families of docked conformations in
order of increasing energy. The default method for structure binning
allows for atom similarity, as in a tertiary-butyl which can be rotated
by +/-120°, but in other cases it may be desirable to bypass this
similar atom type checking and calculate the rms on a one-for-one basis.
The symmetry checking algorithm scans all atoms in the reference
structure, and selects the nearest atom of identical atom type to be
added to the sum of squares of distances. This works well when the two
conformations are very similar, but this assumption breaks down when the
two conformations are translated significantly. Symmetry checking can
be turned off using the
rmsnosym
command; omit this command if you still want symmetry checking.
(Clustering multi-job output only.)
AutoDock
will go into `cluster mode'. Use this command only to perform cluster analysis on the combined output,
<PDBQfilename>
, of several jobs. This command can be very useful when many jobs have
been distributed to several machines and run in `parallel'. The docking
parameter file will need the following keywords:
rmstol
and
types
; and optionally write_all_cluster_members and/or
rmsnosym
.
It is necessary to
grep
the USER lines along with the ATOM records, since
AutoDock
parses the these lines to determine what the energy of that particular
conformation was. For more information, see the example DPF files given
later.
(Clustering multi-job output only.) This command is used only with the cluster command, to write out all members of each cluster instead of just the lowest energy from each cluster. This affects the cluster analysis PDBQ output at the end of each job.
ga_pop_size <positive_integer>
[50]
This is the number of individuals in the population. Each individual is
a coupling of a genotype and its associated phenotype. Usually, this
number is fixed throughout the run. Typical values range from 50 to
200.
ga_num_evals <positive_integer>
[250000]
This is the maximum number of energy evaluations that a GA run should make.
ga_num_generations <positive_integer>
[27000]
This is the maximum number of generations that a GA or LGA run should last.
[1]
This is used in the selection mechanism of the GA. This is the number of
top individuals that are guaranteed to survive into the next
generation.
[0.02]
This is a floating point number from 0 to 1, representing the
probability that a particular gene is mutated. This parameter is
typically small.
[0.80]
This is a floating point number from 0 to 1 denoting the crossover rate.
Crossover rate is the expected number of pairs in the population that
will exchange genetic material. Setting this value to 0 turns the GA
into the evolutionary programming (EP) method, but EP would probably
require a concomitant increase in the ga_mutation_rate in order to be
effective.
ga_window_size <positive_integer>
[10]
This is the number of preceding generations to take into consideration
when deciding the threshold for the worst individual in the current
population.
[1]
These are floating point parameters used in the mutation of real number
genes. They correspond to the alpha and beta parameters in a Cauchy
distribution. Alpha roughly corresponds to the mean, and beta to
something like the variance of the distribution. It should be noted,
though, that the Cauchy distribution doesn't have finite variance. For
the mutation of a real valued gene, a Cauchy deviate is generated and
then added to the original value.
This command sets the global optimizer to be a genetic algorithm [GA].
This is required to perform a GA search. This passes any '
ga_
' parameters specified
before
this line to the global optimizer object. If this command is omitted, or it is given before the '
ga_
' parameters, your choices will not take effect, and the default values for the optimizer will be used.
To use the traditional genetic algorithm, do not specify the local search parameters, and do not use the "
set_sw1
" or "
set_psw1
" commands.
To use the
Lamarckian genetic algorithm
, you
must
also specify the parameters for local search, and then issue either the '
set_sw1
' or '
set_psw1
' command. The former command uses the strict Solis and Wets local
search algorithm, while the latter uses the pseudo-Solis and Wets
algorithm: see earlier for details about how they differ.
[50]
This is the maximum number of iterations that the local search procedure
apply to the phenotype of any given individual. This is an unsigned
integer. In Bill's experiments, he used a combination of iterations and
function evaluations. It seems to me, that a value around 30 should be
fine.
sw_max_succ <positive_integer>
[4]
This is the number of successes in a row before a change is made to the
rho parameter in Solis & Wets algorithms. This is an unsigned
integer and is typically around four.
sw_max_fail <positive_integer>
[4]
This is the number of failures in a row before Solis & Wets
algorithms adjust rho. This is an unsigned integer and is usually
around four.
[1.0]
This is a parameter of the Solis & Wets algorithms. It defines the
initial variance, and specifies the size of the local space to sample.
[0.01]
This is the lower bound on rho, the variance for making changes to genes (
i.e.
translations, orientation and torsions). rho can never be modified to a value smaller than "
sw_lb_rho
".
This is the probability of any particular phenotype being subjected to local search.
Both of these commands, '
set_sw1
' and '
set_psw1
', pass any '
sw_
' parameters set before this line to the local searcher. If you forget to use this command, or give it before the '
sw_
' keywords, your choices will not take effect, and the default values for the optimizer will be used.
Instructs AutoDock to use the classical Solis and Wets local searcher, using the method of uniform variances for changes in translations, orientations and torsions.
Instructs AutoDock to use the pseudo-Solis and Wets local searcher. This method maintains the relative proportions of variances for the translations in Å and the rotations in radians. These are typically 0.2 Å and 0.087 radians to start with, so the variance for translations will always be about 2.3 times larger than that for the rotations ( i.e. orientation and torsions).
This command instructs AutoDock to do the specifed number of docking
runs using the simulated annealing (SA) search engine. This uses the
value set by the "
runs
" keyword as the number of SA docking runs to carry out. All relevant
parameters for the simulated annealing job must be set first. These are
indicated above by
[SA]
in each keyword description.
This keyword instructs AutoDock to carry out only the local search of a
global-local search; the genetic algorithm parameters are ignored, with
the exception of the population size. This is an ideal way of carrying
out a minimization using the same force field as is used during the
dockings. The "
ga_run
" keyword should not be given. The number after the keyword determines how many dockings will be performed.
This keyword instructs AutoDock to carry out dockings using only a
global search, i.e. the traditional genetic algorithm. The local search
parameters are ignored. The "
ga_run
" keyword should not be given. The number after the keyword determines how many dockings will be performed.
[10]
This command invokes the new hybrid, Lamarckian genetic algorithm search
engine, and performs the requested number of dockings. All appropriate
parameters must be set first: these are listed above by "
ga_
".
This performs a cluster analysis on results of a docking, and outputs the results to the log file. The docked conformations are sorted in order of increasing energy, then compared by root mean square deviation. If the conformer is within the "rmstol" threshold, it is placed into the same cluster. A histogram is printed showing the number in each cluster, and if more than one member, the cluster's mean energy. Furthermore, a table is printed to the docking log file of cluster rmsd and reference rmsd values.
1. Stouten, P. F. W., Frömmel, C., Nakamura, H. and Sander, C. (1993). "An effective solvation term based on atomic occupancies for use in protein simulations", Molecular Simulations , 10 , 97-120.


NEW WEBSITE!!
CHECK OUT OUR CATALOG!
-
SNIPERS!!
Let The Wolves Eat Themselves | CD -
GOODRIDDLER
The Strength of Weak Ties | 12" EP -
BUILD US AIRPLANES
At The End Of The Day LP | 12" LP -
MÆRE
The Architect | CD -
EARLY AND OFTEN
Present No Fiction. Fear No Tense | CD -
OVER THE FALLS
Yes, Have Some | CD -
STARSKATE
Goodnight Nobody | 12" LP -
ATLAS AMPED
Sonoma County Compilation | 12" LP -
HANALEI/SUNDOWNER
Split 7"


For alternate themes, add the class to the playlist UL - eg.
 or
; the base default is
.
A reminder that if loading from the local filesystem, Flash will deny access to remote (network/internet) URLs by default unless whitelisted via the Flash Player Global Security Settings Page. Some URLs in this example are remote to demonstrate this.
Note that by default, the Flash 8 version is used and therefore Flash 9-only features such as the VU meter, waveform etc. are not available. Refer to the main "page player" demo for configuration examples, or view the source of page-player.js for the configuration object (similar to that used in SoundManager 2 itself.)


Exodus 40:30
And he set the laver between the tent of the congregation and the altar, and put water there, to wash withal.


Direct Activity For Subject
Defining Diagram
"Activity For Subject" not acting as the context for any other.
Supertypes:
Activity For Subject


Learning Competencies for my Technical Blog
My reflections
Learning Competencies for my Cultrual Blog
Reflect on my learning journey into the Core Skills covered in the Foundations curriculum to date
My reflections
Reflect on my learning journey into the Core Skills covered in the Foundations curriculum to date


Cancel the judgment
{% elseif data['radio-app-type'] == 'vary' or data['radio-app-type'] == 'general' %}Change the judgment
{% else %}Respond to the judgment
{% endif %} {% if data['justvaryonly'] != 'true' %}| Your contact details | task status |
|---|---|
| Confirm your details | {% if data.confirmdetails=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
{% if data['alreadysettled'] == 'false' and data['fulldefence'] == 'false' and data['canpaynow'] != 'false'%}
| About the claim | task status |
|---|---|
| Tell us how much you've paid | {% if data.how_much_paid=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Will you pay {{ partyName( 'claimant' ) }}? | {% if data.canpaynowanswered=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Consider settling the claim | {% if data.contactedclaimantanswered=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
{% endif %} {% endif %} {% if data['canpaynow'] == 'true' and data['paidclaimant'] == "complete" or data['alreadysettled'] == 'true' or data['fulldefence'] == 'true' or data['has-settled'] == 'false' and data['loweramount'] == 'true' and data['contactclaimantstarted'] != 'true' %}
| {% if data['radio-app-type'] == 'set-aside' %} Apply to cancel the judgment {% elseif data['radio-app-type'] == 'vary' or data['radio-app-type'] == 'general' %} Apply to change the judgment {% else %} Respond to the judgment {% endif %} | |
|---|---|
| {% if data['fulldefence'] == 'true' or data['alreadysettled'] == 'false' and data['loweramount'] == 'true' %} Decide whether to apply {% else %} Decide whether to apply {% endif %} | {% if data.cancelccjanswer == 'complete' %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Get the claimant to agree | {% if data.claimantagree == 'complete' %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Explain why you didn't respond | {% if data.explainreason == 'complete' %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Submit any evidence | {% if data.evidencesection=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Other information | {% if data.otherinfosection=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Give us details in case there's a hearing | {% if data.hearing=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
{% endif %} {% if data['fulldefence'] == 'false' and data['loweramount'] == 'false' and data['canpaynow'] == 'false' or data['justvaryonly'] == 'true' or data['cancelccjanswer'] == 'complete' and data['cancelccj'] == 'false' %}
| Change how you pay | |
|---|---|
| Ask to change the judgment | {% if data.varyanswered=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Request new payment terms | {% if data.newpaymentterms=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Your financial details | {% if data.financialdetails=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
{% endif %} {% if data['cancelccj'] == 'true' and data['fulldefence'] == 'true' or data['cancelccj'] == 'true' and data['loweramount'] == 'true' %}
| {% if data['radio-app-type'] == 'set-aside' %} Respond to the original claim {% else %} Respond to claim {% endif %} | |
|---|---|
| Reason for not owing money | {% if data.reasonfornotowe=="complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
| Tell us why you disagree with the claim | {% if data.your_defence=="complete" or data.your_defence_pa == "complete" %} {% include "includes/task_status_finished.html" %} {% else %} {% include "includes/task_status_incomplete.html" %} {% endif %} |
{% endif %}
| Submit | |
|---|---|
| {% if data.varyselected=="true" %} {% else %} {% endif %} | |
|
|


I can only repro this sometimes. I have not found a way to do it deterministically.
Repro steps:
Expected: JAWS reads "Second"
Actual: JAWS reads "First Second"
Alternate button navigation method: Use B and Shift+B to move between buttons. Or use tab and shift+tab to move the focus. These methods do not seem to ever trigger the behavior.


Money Play. Should Red redouble? If redoubled, should White take?
pips Red=89 White=33
(CorrectAnswer= 0/0, ErrorScore= 0)
Note: this should have been posed as a redoubling rather than a doubling question.
The standard reference position has White with five checkers borne off and one checker closed out. That would be a redouble and a close take.
 How does that change things?
The position is very volatile so the redouble is justified but it is close. White has a very easy take because he lots of ways to win, including creating an anchor and then roiling boxes! If the second checker is not hit Red is under immediate pressure to perform.
This is a great practical redouble because many would drop because of the second exposed checker.
The standard reference position has White with five checkers borne off and one checker closed out. That would be a redouble and a close take.
 How does that change things?
The position is very volatile so the redouble is justified but it is close. White has a very easy take because he lots of ways to win, including creating an anchor and then roiling boxes! If the second checker is not hit Red is under immediate pressure to perform.
This is a great practical redouble because many would drop because of the second exposed checker.
Cube analysis 2-ply cubeless equity +0.407 0.726 0.000 0.000 - 0.274 0.044 0.001 Cubeful equities: 1. Double, take +0.629 2. Double, pass +1.000 (+0.371) 3. No double +0.571 (-0.058) Proper cube action: Double, take


My Settings
Profile
Profile
Main settings
This information will appear on your profile.
First name
First name error.
Your first name as displayed on your profile.
Last name
Last name error.
Your last name as displayed on your profile.
Email
Email error.
Your registered Email address.
Update


Before writing this blogpost I did very little with object oriented code in R. I never really saw it as a useful feature because I am mostly using R as an analysis tool. The power of R comes partly from the fact that other people have done this work for you. Recently though, I've been tasked to write a custom machine learning library that needed to support the predict
function.
This document will describe the simplest machine learning method ever and some quick details on how to implement it in R via object oriented coding. This post is heavily inspired by this pdf and this tutorial. My goal is to have a similar document but a bit shorter to make it easier for my own reference. I will try to compare python to R wherever possible such that other people may find it useful too.
S3 Classes
Where python has dictionaries, R has lists.
obj <- list(a = 1, b = 2)
Instead of having methods within these objects, R uses functions that can accept many different types of objects. Notice below that I am using the same function on a list as I am on a dataframe.
names(obj)
# "a" "b"
names(ChickWeight)
# "weight" "Time" "Chick" "Diet"
Where python has polymorphism, R (and Julia by the way) has multiple dispatch. Methods do not belong to objects, they belong to functions. Instead of binding a method to an object, R allows you to write many functions that share the same name but refer to different objects. For example, if you want to check out what objects can be handed to summary
:
> methods(summary)
[1] summary.aov summary.aovlist* summary.aspell*
[4] summary.check_packages_in_dir* summary.connection summary.data.frame
[7] summary.Date summary.default summary.ecdf*
...
You could also check for all methods that below to a certain class.
> methods(class = "Date")
[1] - [ [[ [<- + as.character
[7] as.data.frame as.list as.POSIXct as.POSIXlt Axis c
[13] coerce cut diff format hist initialize
[19] is.numeric julian Math mean months
...
If the function mean()
were called on a Date
object it would internally call mean.Date()
. To keep track of what method a function should use R looks at the name of the function. In the case of mean.Date()
the S3 class in R would recognize that the function mean
can be used for Date
by looking at the name. A silly example; foo.bar()
would allow R to recognize that the function foo
can be used on a bar
object.
This should feel very odd if you are a python programmer because it puts a lot of functions in the global namespace.
Let's create an object of type foo again, just to be explicit.
obj <- list(a = 1, b = 2)
class(obj) <- 'foo'
> class(obj)
"foo"
We will now create a method mean.foo
which will be called by the generic function mean
if it is passed an object of class foo
.
mean.foo <- function(x){
(x$a + x$b)/2
}
> mean(obj)
1.5
The only thing missing right now is a way to generate our own generic function. Just like mean
was a generic function here, we might want to create a generic function that can be used on multiple objects.
f <- function(x) UseMethod("f")
f.foo <- function(x){
paste(x$a, "and", x$b, "are in this foo obj")
}
f.numeric <- function(x){
paste("this numeric has value", x)
}
> f(obj)
[1] "1 and 2 are in this foo obj"
> f(2)
[1] "this numeric has value 2"
The model
I want to make a model that assumes a continous variable $y$ and a discrete input $X$. It will average $y$ over all the $X$ combinations.
To create this machine learnin model I want a generic function that returns an object with a class. As long as I create a function via UseMethod
that returns a list
with an assigned class this should work.
library(dplyr)
aggmod <- function(x, ...) UseMethod("aggmod")
aggmod.default <- function(form, data, ...){
res <- list()
agg <- aggregate(formula = form, FUN = mean, data = data)
colnames(agg) <- c(form %>% all.vars %>% tail(-1), "pred")
res$agg <- agg
res$call <- match.call()
res$formula <- form
res$fitted.values <- data %>% left_join(res$agg) %>% .$pred
res$y <- data %>% select_(form %>% all.vars %>% head(1))
res$residuals <- res$y - res$fitted.values
res$mae <- mean(sum(abs(res$residuals)/length(res$residuals)))
res$mse <- mean(sum(res$residuals^2)/length(res$residuals))
class(res) <- "aggmod"
res
}
The .default
method can be seen as a constructor. When we call aggmod()
function it will point to the aggmod.default
method and return a list of class aggmod
. This object still needs some utility generics. Currently, this object has no pretty print representation and can also not be passed into the predict
function.
print.aggmod <- function(x, ...){
cat("Call:\n")
print(x$call)
cat("\nMSE:")
print(x$mse)
cat("MAE:")
print(x$mae)
}
predict.aggmod <- function(x, newdata = NULL, ...){
if(is.null(newdata)) return(fitted(x))
newdata %>% left_join(x$agg) %>% .$pred
}
With this in place, it starts to feel like using the lm
function.
modl <- aggmod(weight ~ Time + Diet, ChickWeight)
> modl %>% print
Call:
aggmod.default(form = weight ~ Time + Diet, data = ChickWeight)
MSE:[1] 631109.7
MAE:[1] 11692.11
> predict(modl, newdata = ChickWeight %>% sample_n(5))
Joining by: c("Time", "Diet")
[1] 187.70000 47.25000 79.68421 64.50000 66.78947
Conclusion
I found this exercize very helpful in understanding the R way of dealing with objects. If you are from a different programming language this may feel like a very strange way of doing things but it has it's benefits. By allowing our code to be written this way, we can do the following;
formulas <- c(weight ~ Time, weight ~ Time + Diet, weight ~ Diet)
ml_methods <- list(lm, aggmod)
df <- data.frame(variables = as.character(), model = as.character(), median_mse = as.numeric())
mse <- function(x,y){
diff <- x - y
mean(sum(diff^2)/length(diff))
}
for(f in formulas){
for(m in ml_methods){
mod <- m(f, ChickWeight)
df <- df %>% rbind(data.frame(
variables = f %>% all.vars %>% tail(-1) %>% paste(collapse=' '),
model = mod$call %>% as.character %>% .[1],
median_mse = mse(mod %>% predict, ChickWeight$weight)
))
}
}
Having a generic predict
allows an R user to focus on the statistics because there is a common expectation of how an object should interact with it. Not all programmers will like this style, some may say that it offers too much sugar. Another example of things that feel trippy to programmers;
`%+%` <- function(a, b){
paste(a,b, sep ='')
}
> 'a' %+% 'b' %+% 'c'
[1] "abc"
Where python can make use of polymorphism for it's operators, R imposes different rules, but allows you to write your own operators. Most statistician will enjoy this because this syntax allows them only worry about doing statistics with code that feels natural to them.


{% extends 'report/layouts/base.html' %} {% block body %}
| {{ _('Sample') }} | {{ _('Group') }} | {{ _('Cutoff') }} [x] | {% if includes_splice_sites %}{{ _('Included splice sites') }} | {% endif %}
|---|---|---|---|
| {{ sample.id }} | {{ sample.group_id }} | {{ sample.cutoff }} | {% if includes_splice_sites %}{{ sample.extension }} | {% endif %}
| {{ _('Sample') }} | {{ _('Average coverage') }} [x] | {{ _('Average completeness') }} [%] |
|---|---|---|
| {{ sample_id }} | {{ coverage|round(3) }} | {{ (completeness * 100)|round(3) }} |
| {{ _('Sample') }} | {{ _('Diagnostic yield') }} [%] |
|---|---|
| {{ sample_id }} | {{ (value * 100)|round(3) }} |
| {{ _('Sample') }} | {{ _('Gender') }} | {{ _('Average coverage') }} [x] | |
|---|---|---|---|
| {{ _('Chromosome') }} X | {{ _('Chromosome') }} Y | ||
| {{ sample_id }} | {{ _(gender) }} | {{ x_coverage|round(3) }} | {{ y_coverage|round(3) }} |
{{ _('The parts of the genome that has been analyzed') }} {{ _('is composed of all protein coding, exonic intervals') }} {{ _('referenced in the') }} {{ _('CCDS database') }}. {% if includes_splice_sites %} {{ _('Additionally, the data also includes spicing sites') }} ({{ _('donator and acceptor positions') }}, {{ splice_site_interval }} {{ _('bases on either of each exon') }}). {% endif %}
{% if config.CHANJO_PANEL %}
{{ _('Final coverage metrics were calculated for genes from the clinical panels') }}:
{{ config.CHANJO_PANEL_NAME }}
.
{{ _('Note that estimations were made regarding coverage and completeness') }}
{{ _('on the level of transcripts') }}.
{{ _('Coverage') }}: {{ _('An alternative measure of sequence depth') }}. {{ _('It is defined as the ratio of bases') }} {{ _('sequenced deeper than a specified cutoff') }}, {{ _('e.g. 10x') }}. {{ _('The current cutoff is defined per sample') }} {{ _('and is found i the "Cutoff" column (first table)') }}.
{{ _('Completeness') }}: {{ _('gives an overview of the success of sequencing') }}. {{ _("It's defined as the ratio of transcripts") }} {{ _('with a completeness of') }} 100%.
{{ _('Gender prediction from data') }}: {{ _('calculated by comparing relative chromosome coverage') }} (X/Y). {{ _('Some reads randomly map to the Y chromosome') }}. {{ _('Therefore, a less than 10 fold difference is used to infer a "male" sample') }}.


Transliteration scheme
+
Let's contribute!
For you developers out there, I uploads the whole code of this app on github as open source project. So, by simply forking it, you could help me extend the features and functionality of this keyboard app, including adding more transliteration system. The transliteration files is in JSON format so you could just copy the existing transliteration files and edit it from there.
So that's it, I'll be waiting for your pull request ;)
https://github.com/emkamal/angular-arabic-keyboard ×


9
For to Us a Child Is Born
1 But there will be no gloom for her who was in anguish. In the former time he brought into contempt the land of Zebulun and the land of Naphtali, but in the latter time he has made glorious the way of the sea, the land beyond the Jordan, Galilee of the nations.
2 The people who walked in darkness
have seen a great light;
those who dwelt in a land of deep darkness,
on them has light shined.
3 You have multiplied the nation;
you have increased its joy;
they rejoice before you
as with joy at the harvest,
as they are glad when they divide the spoil.
4 For the yoke of his burden,
and the staff for his shoulder,
the rod of his oppressor,
you have broken as on the day of Midian.
5 For every boot of the tramping warrior in battle tumult
and every garment rolled in blood
will be burned as fuel for the fire.
6 For to us a child is born,
to us a son is given;
and the government shall be upon his shoulder,
and his name shall be called
Wonderful Counselor, Mighty God,
Everlasting Father, Prince of Peace.
7 Of the increase of his government and of peace
there will be no end,
on the throne of David and over his kingdom,
to establish it and to uphold it
with justice and with righteousness
from this time forth and forevermore.
The zeal of the LORD of hosts will do this.
Judgment on Arrogance and Oppression
8 The Lord has sent a word against Jacob,
and it will fall on Israel;
9 and all the people will know,
Ephraim and the inhabitants of Samaria,
who say in pride and in arrogance of heart:
10 “The bricks have fallen,
but we will build with dressed stones;
the sycamores have been cut down,
but we will put cedars in their place.”
11 But the LORD raises the adversaries of Rezin against him,
and stirs up his enemies.
12 The Syrians on the east and the Philistines on the west
devour Israel with open mouth.

For all this his anger has not turned away,
and his hand is stretched out still.
18 For wickedness burns like a fire;
it consumes briers and thorns;
it kindles the thickets of the forest,
and they roll upward in a column of smoke.
19 Through the wrath of the LORD of hosts
the land is scorched,
and the people are like fuel for the fire;
no one spares another.
20 They slice meat on the right, but are still hungry,
and they devour on the left, but are not satisfied;
each devours the flesh of his own arm,
21 Manasseh devours Ephraim, and Ephraim devours Manasseh;
together they are against Judah.


Angular is a Typescript based framework for building UIs, and at the core, it is simply a component based UI library.
Typescript is a superset of Javascript, adding static type definitions. Types provide a way to describe the shape of an object, providing better documentation, and allowing TypeScript to validate that your code is working correctly.
To learn more about RxJS, you can visit the documentation here and Angular specific notes here.
Basically, RxJS is a library that makes it easier to write asynchronous code. It also makes state management easier to write cleaner, more managable code.
To understand what asynchronous programming is and what it's used for, check out this article by mozilla.
But basically, JavaScript in its most basic form is synchronous, blocking, and single-threaded, where only one operation can be in progress at one time. But if for example there is a task that takes a lot of time, it is better to not use the main thread and do the task asynchronously (on a different thread).
In vanilla JavaScript, we'd typically see two main types of asynchronous code - old-style callbacks and newer promise code. However, in Angular, we can use RxJS.
The following is a code snippet of the .ts file for a component that observes the World Time API and updates the time, and the actual compnent itself.
import { Component, OnInit } from '@angular/core';
import { CurrentTime, CurrentTimeService } from './current-time.service'
@Component({
selector: 'app-current-time',
templateUrl: './current-time.component.html',
providers: [ CurrentTimeService ],
styleUrls: ['./current-time.component.scss']
})
export class CurrentTimeComponent implements OnInit {
error: any;
currentTime: CurrentTime | undefined;
constructor(private currentTimeService: CurrentTimeService
) { }
ngOnInit(): void {
this.showTime()
}
showTime() {
this.currentTimeService.getTime()
.subscribe(
data => {
this.currentTime = { ...data }
},
error => this.error = error
);
}
}
import { Injectable } from '@angular/core';
// http
import { HttpClient } from '@angular/common/http';
import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
// rxjs
import { Observable, throwError } from 'rxjs';
import { catchError, retry } from 'rxjs/operators';
export interface CurrentTime {
datetime: string;
timezone: string;
}
@Injectable({
providedIn: 'root'
})
export class CurrentTimeService {
private timeUrl = 'http://worldtimeapi.org/api/ip';
constructor(private http: HttpClient) { }
getTime() {
return this.http.get<CurrentTime>(this.timeUrl)
}
private handleError (error: HttpErrorResponse){
console.error();
}
}
The timezone
and datetime
:
NgRx store = aNgular + RxJS


Optimal Length of Random Wire Antenna
J. C. Sprott
Department of Physics, University of Wisconsin,
Madison, WI 53706, USA
April 26, 2012
Much has been written about the optimal length of a random wire
antenna (sometimes called a long wire antenna), some of which is
contradictory. An antenna that will tune to an acceptable SWR
using a common antenna tuner throughout the amateur radio bands of
1.8-2, 3.5-4, 7-7.3, 10.1-10.15, 14-14.350, 18.068-18.168,
21-21.45, 24.89-24.99, and 28-29.7 MHz would at a minimum entail
using a quarter wave resonance frequency lower than the lowest
operating frequency and avoiding lengths that are even multiples
of a half wavelength on any of the higher frequencies.
I wrote a program in PowerBASIC to calculate
the gaps in the quarter-wavelength frequency spectrum over the
range 0-30 MHz in 10 Hz steps where such resonances would be
absent and the corresponding required electrical lengths of the
antenna. Running the program produced
the following output:
Gap = 1 kHz at .874265 MHz (281 feet)
Gap = 4 kHz at 1.07472 MHz (229 feet)
Gap = 24 kHz at 1.15449 MHz (213 feet)
Gap = 7 kHz at 1.241005 MHz (198 feet)
Gap = 13 kHz at 1.256005 MHz (196 feet)
Gap = 4 kHz at 1.27074 MHz (194 feet)
Gap = 33 kHz at 1.366395 MHz (180 feet)
Gap = 12 kHz at 1.39417 MHz (176 feet)
Gap = 15 kHz at 1.492505 MHz (165 feet)
Gap = 23 kHz at 1.543855 MHz (159 feet)
Gap = 33 kHz at 1.666675 MHz (148 feet)
Gap = 58 kHz at 1.720835 MHz (143 feet)
Gap = 114 kHz at 2.20176 MHz (112 feet)
Gap = 62 kHz at 2.30217 MHz (107 feet)
Gap = 14 kHz at 2.482005 MHz (99 feet)
Gap = 26 kHz at 2.512005 MHz (98 feet)
Gap = 88 kHz at 2.58125 MHz (95 feet)
Gap = 119 kHz at 2.74063 MHz (90 feet)
Gap = 41 kHz at 2.990675 MHz (82 feet)
Gap = 83 kHz at 3.069625 MHz (80 feet)
Gap = 376 kHz at 3.311875 MHz (74 feet)
Gap = 436 kHz at 3.930425 MHz (63 feet)
Gap = 352 kHz at 4.341005 MHz (57 feet)
Gap = 125 kHz at 4.604335 MHz (53 feet)
Gap = 100 kHz at 5.00001 MHz (49 feet)
Gap = 175 kHz at 5.1625 MHz (48 feet)
Gap = 860 kHz at 5.792505 MHz (42 feet)
Gap = 752 kHz at 6.62375 MHz (37 feet)
Gap = 1609 kHz at 8.22951 MHz (30 feet)
Gap = 1416 kHz at 9.792 MHz (25 feet)
Gap = 1720 kHz at 11.585 MHz (21 feet)
Gap = 1505 kHz at 13.2475 MHz (19 feet)
In general, wider gaps are preferred. The shortest antenna that has
a chance of tuning all bands has an electrical length of 143 feet
and should be trimmed to give a quarter wave resonance at 1.72 MHz.
If one were to forgo 160 meter (1.8-2 MHz) operation, an antenna
with an electrical length of 74 feet should suffice and should be
trimmed to give a quarter wave resonance at 3.31 MHz. These values
assume that the antenna tuner is placed at the feed point of the
antenna and that a suitable ground is provided.
If there is a feedline between the antenna and the tuner, it is
better to design the antenna to be resonant at the lowest desired
frequency of operation, and then choose the feedline length between
the antenna and the tuner to bring the total electrical length to
one of the above values. Suppose, for example that one wants the
antenna to operate at the center of the 80 meter band (3.75 MHz).
Then the antenna must have an electrical length of 66 feet, and
suitable feedlines would have electrical lengths of 8, 14, 16, 24,
25, 41, 46, 77, ... feet. The required physical lengths are shorter
as determined by the velocity factor of the feedline.
Back to Sprott's Technical Notes


Cynosure
The Power of Cynosure Discover it on March. Best Tech Fest in DU
Events
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
Code Freeze
12th March, 2:00-4:00pm
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters,
Web Development
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters,
Logo Desinging
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters,
Our Sponsors
About Us
Content about Team


1/2 cup roasted and salted peanuts, plus more for garnish
2 Tbsp. extra virgin olive oil
1 Tbsp. fresh lemon juice
1 Tbsp. white balsamic vinegar
1 tsp. agave nectar
1 tsp. dijon mustard
sea salt and pepper
Instructions
When a dressing is this simple, I (lazily, because I don't want to wash another bowl) drizzle everything on top and just toss it well to distribute. Do as I say, not as I do and whisk it all before it that sounds a little haphazard to you. I like to live on the edge and risk a mouthful of mustard in one bite.
in a small pan, heat the coconut oil over medium high heat. Cut the corn kernels away from the cob and add them to the hot pan with a sprinkle or salt and the smoked paprika. Saute, only moving once or twice so the edges char, for 2 minutes. Turn off the heat and let the corn cool completely.
In a large salad bowl, combine both greens, cilantro, the diced nectarine, shallot and half of the feta, peanuts and cooled corn. Whisk the olive oil, lemon juice, white balsamic, agave, mustard and a pinch of both salt and pepper. Dress the salad as desired and sprinkle the remaining feta, peanuts and corn on top. Serve immediately.


Issue 132
Welcome to another issue of Haskell Weekly!  This is a weekly summary of what’s going on in its community.
Survey
The second annual state of Haskell survey started last week on the 1st and continues until the 15th. More than 2,800 people filled out the survey already. If you already filled it out: Thank you! Please share it so we can get a good picture of the Haskell community. If you have not filled it out yet: We want to hear from you! Please take a few minutes to fill it out.
Featured
-
GHC 8.6.2 released by Ben Gamari
The GHC team is very happy to announce the availability of GHC 8.6.2, a bugfix release to GHC 8.6.1. The 8.6 release fixes several regressions present in 8.6.1.
-
Hakyll part 1: Setup & initial customization by Robert Pearce
First post in a series on making & customizing a static site with Hakyll.
-
Exceptionally monadic error handling by Jan Malakhovski
We notice that the type of
catch :: c a -> (e -> c a) -> c a
operator is a special case of monadic bind operator(>>=) :: m a -> (a -> m b) -> m b
and the semantic (surprisingly) matches. -
Lambda the Ultimate pattern factory by Thomas Mahler
Recently, while re-reading through the Typeclassopedia I thought it would be a good exercise to map the structure of software design-patterns to the concepts found in the Haskell type class library and in functional programming in general.
-
Haskell at FINN.no by Sjur Millidahl
Haskell is a purely functional programming language, with a powerful type system. The ability to express intent using types brings correctness, and the composition of a large program as small, independent building blocks makes it easy to reason about the code.
-
Haskell by example: Utopian tree by Jan van Brügge
In this series we solve coding challenges from Hackerrank in Haskell in a proper, functional way. A Utopian Tree has two growth spurts every year, one in spring and one in summer.
-
My experience upgrading GHC, build tools, and dev tools by Matt Renaud
I went through the process of setting up my environment again and wanted to document my process and the pain points I ran into.
-
Signal processing in Haskell by Rinat Stryungis
Today I would like to tell you about my work in the laboratory of the Physics Department of Moscow State University, where I study for a Master’s degree.
-
The trouble with typed errors by Matt Parsons
What we really want is: Order independence, no boilerplate, easy composition, and easy decomposition.
-
Waargonaut the JSONer by Sean Chalmers
Waargonaut is a Haskell library for encoding/decoding/manipulating JSON. The design and development of which has been driven by a dissatisfaction with the current status quo of JSON libraries in Haskell.
Jobs
-
Engineer at Mercury in San Francisco
Mercury is building a bank for businesses. We are currently 8 people and have raised $6m. We are close to alpha launch and are looking to grow our team.
-
We are creating the next generation AI chip. Our software team is looking for exceptional compiler experts to help us create the software on the chip.
-
Compiler developer at Crowdstrike
We’re looking for a talented colleague to join our small language and data tools team. The ontology team at Crowdstrike researches, develops, and maintains tooling central to the data model used throughout our engineering department, including custom languages and compiler environments.
-
Formal methods engineer in Zurich
Work as part of the globally distributed engineering team, together with the product and design teams, to define, develop and deliver on products.
-
Senior software engineer at Bloomberg in New York
You are passionate about build systems that can manage a large-scale, multi-language codebase. You are interested in building tools that can prevent complex bugs and keep our code clean.
In brief
- A tale on semirings
- An answer to “The Trouble with Typed Errors”
- Announce:
strict-tuple
- Applicative validation
- Benchmarks for Haskell serialization libraries
- Carnap.io: A formal logic framework for Haskell
- Darcs Hub future
- Eliminating run time errors in OCaml and Haskell
- Elm part 3: Adding effects
- Hacktoberfest 2018 wrap-up
- Haskell implementations archive
- Haskell vs. Go vs. OCaml vs. …
- Hasktorch v0.0.1
- How can I become comfortable with laziness in Haskell?
- Journal of Functional Programming: Call for PhD abstracts
- Moving towards dialogue
- Pandoc donation from Handshake
- Pandoc for Italy, exploratory post
- Proposal: Stack code of conduct
- Proving monoids with Idris
- The
EventHandlers
pattern
Package of the week
This week’s package of the week is QuickCheck, a library for random testing of program properties.
Call for participation
- Amazonka and Gogol project status update
- hs-web3: Hashable instances for Solidity primitive types
- stack: Simple commands should work without ghc installed
Events
North America
- 2018-11-08 in Raleigh, NC, USA by Raleigh Haskell Meetup: (hack . yack)
- 2018-11-08 in Durham, NC, USA by Durham Haskell Meetup: Morning Haskell (and Rust!) coding session
- 2018-11-09 in Austin, TX, USA by Austin Types, Theorems, and Programming Languages: Going through Software Foundations by Benjamin Pierce et al
- 2018-11-10 in Chilliwack, BC, Canada by ChilliHask Haskell User Group: Weekly Haskell Coding Meetup
- 2018-11-10 in Norcross, GA, USA by Norcross Haskathon: Norcross Haskathon
- 2018-11-10 in Boston, MA, USA by Weekly Functional Programming Meetup: Hang out, chat FP, work on some code
- 2018-11-12 in Irvine, CA by Orange Combinator - Functional Programming In OC: Combinating - The Weekly Function
- 2018-11-12 in Pittsburgh, PA, USA by Pittsburgh Functional Programming Meetup: Type Providers - F#
- 2018-11-13 in Vancouver, BC, Canada by Vancouver Functional Programmers: Haskell Lunch Study Group • Fall ’18 Cohort
- 2018-11-13 in Santa Monica, CA, USA by Santa Monica Haskell Users Group: Haskell Study Group: Applicatives
- 2018-11-14 in Portland, OR, USA by Portland Functional Programming Study Group: PDX Func Theory Track - Logic and Proof
- 2018-11-14 in Houston, TX, USA by Houston Functional Programmers: Symbolic Boolean Computation and Set-Theoretic Empirical Research in OCaml
Europe
- 2018-11-08 in Graz, Austria by Functional Programming Graz: Functional Programming Meetup
- 2018-11-08 in London, United Kingdom by Hoodlums: Hoodlums Meetup
- 2018-11-08 in Gdańsk, Poland by Functional Tricity: Haskell&Rust! Functional Tricity #14
- 2018-11-08 in Warszawa, Poland by warsaw.ex: warsaw.ex meetup #1
- 2018-11-12 in Karlsruhe, Germany by Karlsruhe Haskell Meetup: Haskell Monday
- 2018-11-13 in Bristol, United Kingdom by CodeHub Bristol: Hack Night + Haskell Study Group
- 2018-11-14 in Stuttgart, Germany by Lambda Stuttgart: Lambda Stuttgart Meetup #10
- 2018-11-14 in Berlin, Germany by Berlin Haskell Users Group: Haskell Wednesday
- 2018-11-14 in Amsterdam, Netherlands by FP AMS: CT study group: Representable Functors
- 2018-11-14 in Prague, Czech Republic by Prague Lambda Meetup: Clojure Wednesday
- 2018-11-14 in London, United Kingdom by Skills Matter - X Matters Series - Free Developer Events: JavaScript Matters with Sara Vieira
Asia
- 2018-11-08 in Taipei, Taiwan by Functional Thursday: Functional Thursday #69 （時間更動：11/8）
- 2018-11-11 in Bangalore, India by Bangalore Functional Programmers Meetup: Parser Combinators in Haskell
- 2018-11-13 in Brisbane, Australia by Brisbane Functional Programming Group (BFPG): BFPG Monthly Meetup (last one of 2018!)
Africa
- 2018-11-12 in Sandton, South Africa by Lambda Luminaries: Functional Aspects of Kotlin in Android Development by Chester Cobus


Sign In
Email:
Password:
ISSUE: sign in not implemented@@
Not a member yet? Please
register
.
ISSUE: TODO: style, copyright, privacy policy


This garden is covered mostly in water, a pond which contains a small island. Also known as the ‘Supplementary Garden’, it is only about half the size of the central garden. The main feature of this garden other than the pond is Mandarin Duck (Yuanyang) Hall, from which the pond’s ducks can be fed. This section is entered through a traditional 'moon gate'. From here, a series of meandering pathways follow the edge of the lake and link the various buildings of this garden together.
At first glance this building seems to stand out from the other pavilions in the garden. It has a novel layout, with four small pavilions attached at the corners of the main building. This section is itself subdivided into northern and southern halves by a partition board. However, these features do not isolate the user from the rest of the garden. Instead, they integrate this building into the climate around it.
Here is how it works: different sides of the hall are meant to be used at different times of year. The north side receives less sunlight, and is preferable as a cool spot during the summer. It also faces the pond, allowing one to feed the ducks which occupy it during this time of year. The south side however faces the sun, and faces away from the water. Both of these act to keep the occupants comfortable during the fall and winter.
The flora around the hall is placed to take advantage of these two use cases. The pond to the north not only houses ducks but also a variety of lily plants. These bloom from June to August; perfect for the northern ‘summer’ side. Similarly, the southern ‘winter’ side faces a garden of camellias, which bloom from October to April.
Either side of the hall is covered with panels that can be opened to let the fragrance of the flowers inside. The aforementioned pagodas at the corners of the hall add additional surface area for fragrance to enter. They also could act as ‘turrets’ from which one can get a larger field of view of the surrounding landscape.
This moon gate links the western and central gardens. This structure is highly symbolic within chinese culture, and is a common feature as an entryway.
One interpretation is that is represents the cyclical nature of the world. The portal itself is a circle, through which people come and go in a cycle. The sloping roof is supposed to represent the half moon of the chinese summer, connecting it into the cycle of the seasons. The slopes of the roof can also be seen as the flow of waves, air, or time. All of these connect into the Taoist philosophy of cycles of change, like those of the dynasties.
Other than the portal, the flat stone wall is only penetrated by two ‘leaking windows’. These windows are filled with decorative patterns, and only give the user a tiny glimpse of the other side of the wall. This helps build anticipation for when they pass through to the other side.
This structure incorporates a few common elements of the garden. Firstly, it’s zigzagging path give the user a variety of views of the garden. It also works to slow down their pace, making the journey across more meditative.
The way the pathway dips down to the water adds to this effect. It seems like it is bending under its own weight, supported only by the natural rock formations on either side. The path must submit to the forces of nature. This dip also serves the practical purpose of allowing the user to get closer to the pond to feed the ducks.
The wall of the path is dotted with more ‘leaking windows’, giving glimpses to the central part of the garden. You can see that each window has a unique pattern, adding to the irregular and organic feel of the pathway.


Library: Foundation
Package: Logging
Header: Poco/PurgeStrategy.h
Description
The PurgeStrategy is used by FileChannel to purge archived log files.
Inheritance
Known Derived Classes: PurgeByAgeStrategy, PurgeByCountStrategy
Member Summary
Constructors
PurgeStrategy
Destructor
~PurgeStrategy
virtual ~PurgeStrategy();
Member Functions
purge
virtual void purge(
const std::string & path
) = 0;
Purges archived log files. The path to the current "hot" log file is given. To find archived log files, look for files with a name consisting of the given path plus any suffix (e.g., .1, .20050929081500, .1.gz). A list of archived files can be obtained by calling the list() method.
list
void list(
const std::string & path,
std::vector < File > & files
);
Fills the given vector with a list of archived log files. The path of the current "hot" log file is given in path.
All files with the same name as the one given in path, plus some suffix (e.g., .1, .20050929081500, .1.gz) are considered archived files.


Personal information:
First name (Optional):
Last name (Optional):
E-mail Address:
Weight (Note: Please measure your weight (lbs) in the morning before your first meal and drink):
Number of Meals:
How many meals did you have today?
0
1
2
3


Security should be foreseen as part of the system from the very beginning, not added as a layer at the end.
An inspiring week with the ICON Sofia team! I really encourage all companies considering out/near-shore development scenarios to get on the plane and be sure you know the people writing your code.
Drupal, Magnolia CMS, WordPress, iOS and Android Development
ICON Ranked 4th for Software Development Best Practices and Processes
According to the official 2019 software development company rankings, ICON Worldwide ranks number 20 for PHP development
ICON Worldwide is proud to announce its ranking of number 14 globally and only Swiss agency to rank.
Recent Healthcare & Pharma Case studies.
The combined effect of integrated digital marketing can be best explained by the idea of supporting the customer journey.
Capturing leads in a post-GDPR world demands a highly synchronized customer journey.
In its' third year, Iron Deficiency Day continued to gain traction on an increasingly global scale reaching over 22 countries.
How to Lead Enterprise Scale AI, IoT and Blockchain Projects.
The Future is Built Here: Introducing ICON Worldwide Bulgaria
We have created several tools which are already in use which have the potential for massive improvement using AI technologies.
We developed the SAMS, Saccades Analysis Made Simple, application as part of a clinical study conducted by medical expert centers.
Developed for the Frankfurt School of Finance & Management, the ZielAbi app is a native iOS & Android phone application for Abitur tracking.
We’d love to hear from you.
Independent and International


GoWin2 Admin SignUp
supervisor_account
Account
vpn_key
Password
vpn_key
Confirm Password
perm_identity
Choose your permission
SuperAdmin
Admin
User
Register
Already have an account?
Login


Silver State Marathon
Reno NV/USA
Website: www.silverstatestriders.com
Race Winners
(25 runnings)
2007
---
---
20 Aug
2006
2:44:52
3:49:09
21 Aug
2005
3:06:06
3:46:56
22 Aug
2004
2:58:59
3:30:27
17 Aug
2003
2:45:32
3:22:46
25 Aug
2002
2:48:39
3:25:50
26 Aug
2001
3:08:42
3:30:14
27 Aug
2000
2:55:47
3:35:34
29 Aug
1999
2:48:47
3:24:16
30 Aug
1998
2:47:48
3:00:44
24 Aug
1997
2:42:44.4
3:04:57.6
25 Aug
1996
2:38:59
3:22:24
27 Aug
1995
2:53:01
3:24:00
28 Aug
1994
2:39:26
3:37:41
29 Aug
1993
2:37:58
3:07:27
30 Aug
1992
2:42:02
3:28:45
25 Aug 1991
2:44:06
3:52:56
1985-1990
---
---
02 Sep
1984
2:35:32
3:08:36
04 Sep
1983
2:34:31
3:14:35
05 Sep
1982
2:33:00
2:58:41
06 Sep
1981
2:28:13
3:12:00
31 Aug
1980
2:27:26
3:04:13
02 Sep
1979
2:35:36
3:23:31
03 Sep
1978
2:30:44.0
3:17:50
04 Sep
1977
2:30:19
3:10:26
05 Sep
1976
2:39:09
3:37:11
Notes: 1976 was the inaugural year. For 1985-1987, only the half marathon and 10 km races were held; for 1988-1989,
no races were held. The 1976 race (and possibly other years) was held in Washoe Valley, south of Reno.
cancelled
cancelled
Chuck Engle (OH/USA)
Megan Curtis (CA/USA)
Yevgeniy Gorkov (RUS)
Karen Themka (CA/USA)
Michael Cook (CA/USA)
Laura Bleakley (CA/USA)
Damian Baldovino (OR/USA)
Erinn Wells (CA/USA)
Phil Ware (CO/USA)
Juliet Michelsen (CA/USA)
Rae Clark (CA/USA)
Denise Gilroy (CA/USA)
Ted Rasoumoff (NV/USA)
Susan Enlow (CA/USA)
Eric Larson (UT/USA)
Susan Verona (WV/USA)
Mark Godale (IL/USA)
Zorica Rahovic (SER)
Nick Bingham (NV/USA)
Jeanett Gunnarson (NV/USA)
Miguel Tibaduiza-2
Evelyn Reed (CA/USA)
Tom O'Mara (USA)
Diane Dangler (USA)
Miguel Tibaduiza (NV/COL)
Geri Kilgariff (USA)
Bill Devine-3
Sharlet Gilbert (CA/USA)
Bill Devine-2
Rachel Atchley (NV/USA)
Bill Devine (USA)
Jessie Stratton (USA)
not held
not held
Skip Houk-2
Susan King-2
Dave Carlsen (NV/USA)
Susan King (CA/USA)
Skip Houk (CA/USA)
Jill Silva-2
Brad Roy-2
Jill Silva (NV/USA)
George Hernandez (NV/USA)
Pamela Schmidt-2
Ted Pawlak (CA/USA)
Nancy Berndt
Brad Roy (CA/USA)
Pamela Schmidt (NV/USA)
Ron Zarate (CA/USA)
Joan Ullyot (CA/USA)
Robert Cooper (CA/USA)
Debbie Rudolph (CA/USA)
Most Wins
(1976-date)
Men
3
Bill Devine
1991-93
Women
2
Pamela Schmidt (NV/USA)
1978,1980
.
Jill Silva (NV/USA)
1981-82
.
Susan King (CA/USA)
1983-84
Prize Money
No information on prize money has been received for this race.
Race Time Bias
Insufficient data to calculate the race time bias.
Competitive Level
(1990-date)
Insufficient data to calculate competitive levels.
Quality Performances
Men No men under 2:20 Women No women under 2:50
Last Updated on 25 Oct 2007
Contributor: Jack Leydig (4)


Poll List
Thoughts Submission
Thoughts Page
Github
{{ question.question_text }}
{% for choice in question.choice_set.all %}
{{ choice.choice_text }} -- {{ choice.votes }} vote{{ choice.votes|pluralize }}
{% endfor %}
Vote again?


jl777c
08-Oct-18 02:44 PM
if realtime monitors were installed in all the active miners' systems and reported to a central location, then you could get an accurate overall nethash
but I think there would be some objections to this
the pool can get a pretty good estimate of the realtime hashrate based on the sum of each workers results
the sum of all pools realtime hashrate is therefore knowable and it is consistently above the 120 block average hashrate that is the Msols, when the estimated solo mining is added. I have a feeling it isnt a 1:1 and that it takes more hashrate to get the 120 block average to register it
this is likely approx a 10% increased cost over what the instantaneous estimate would create
tl:dr it likely costs 10% more to mine PIRATE than any Msols based estimate would calculate
1
1


There are several ways to create a Kitura server:
To work with SPM we need to use the command line.
If you're new to this simply open the Terminal (on mac or Linux) to get started.
Create a directory for our project
mkdir MyKituraApp && cd MyKituraApp
The name of the directory will also be the name of the generated project.
Initialise the directory as a Swift project:
swift package init --type executable
SPM creates a Swift project stub. All we need to do is add our project dependencies, like Kitura, to the project.
To add Kitura to our dependencies we need to edit the Package.swift
Open Package.swift in your default text editor:
open Package.swift
Add Kitura to our dependencies so the Package.swift file looks like this:
// swift-tools-version:4.2
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "MyKituraApp",
dependencies: [
// Dependencies declare other packages that this package depends on.
// .package(url: /* package url */, from: "1.0.0"),
.package(url: "https://github.com/IBM-Swift/Kitura", from: "2.6.0")
],
targets: [
// Targets are the basic building blocks of a package. A target can define a module or a test suite.
// Targets can depend on other targets in this package, and on products in packages which this package depends on.
.target(
name: "MyKituraApp",
dependencies: ["Kitura"]),
.testTarget(
name: "MyKituraAppTests",
dependencies: ["MyKituraApp"]),
]
)
Now we can build the project to pull down our new dependency:
swift build
Open `main.swift` in our text editor.
open Sources/MyKituraApp/main.swift
If you are using a Mac you can work in Xcode instead. To do this you first need to generate an Xcode project:
swift package generate-xcodeproj
Then just open the Xcode project that is generated:
open MyKituraApp.xcodeproj
Delete the `print("Hello, world!")` line from the file.
To make use of the methods in Kitura we first need to import it.
import Kitura
You may get an error here such as 'No such module Kitura'.
This is a bug within Xcode, simply build your Xcode project and the error should disappear.
Now that we have access to Kitura's methods we can create a Router:
let router = Router()
Next we need to define a port for our HTTP Server using the router we just created:
Kitura.addHTTPServer(onPort: 8080, with: router)
Finally we need to ensure our Kitura server can actually run:
Kitura.run()
That's it! We've created a simple Kitura server.
Since we've added code to the `main.swift` file we need to recompile the project:
swift build
To run the project:
swift run
To run the project in Xcode ensure your build target is set to `My Mac` then simply run the project.
You may be prompted to allow the app to accept incoming connections.
Navigate to http://localhost:8080
You should be able to see the Kitura landing page.
Add logging: Get useful feedback from your server about startup and errors
Kitura CLI needs to be run in an empty directory so you will need to create a new directory for your project:
mkdir KituraExample && cd KituraExample
Create a Kitura application using the Kitura CLI:
kitura init
`kitura init` will create a cloud ready Kitura application in your current directory and also builds your application.
The name of your project will be the same as the directory name.
Add routing: Add REST APIs, such as HTTP GET, to your server
Open the Kitura macOS app from your application folder.
Hover over the starter tile and click create:
Enter the following for Project Name and Where:
The following guides will assume you've chosen the above destination and name.
However you can use whatever destination and name you'd like, just substitute those in throughout the rest of the guides.
Once you click create the app will create and build your project. It will also generate you an xcode project.
Add routing: Add REST APIs, such as HTTP GET, to your server


Pick the answer that you think is in the majority
If your answer is in the majority, you get a point!
If your answer is not in the majority, you get no points