My MSYS branch now properly differentiates between the MSYS and MINGW32 subsystems, but both options still have issues.
The MINGW32 build creates a native Windows binary, which doesn't play well with the virtual paths used by msys-perl. I'm getting around that by monkey patching the core modules Cwd
and File::Spec
.
That's clearly a hack, but there does not seem to be a silver bullet for this particular problem, and this approach has been suggested previously during a related discussion.
I did not yet fix the test regressions introduced by commit ad25aa9 as I was busy setting up a vanilla MSYS environment for work on the MSYS subsystem (had some issues compiling git, but got it to work eventually).
The MSYS build currently compiles, but make
fails due to path mismatches. Fixing these might call for introduction of a new platform built from the win32
and generic
ones. Alternatively, some new #ifdef __MSYS__
blocks could probably be added to the win32
code.


|
|
def | __init__ |
| |
|
def | name_size |
| |
|
def | name_list |
| |
|
def | name |
| |
|
def | set_name |
| |
|
def | add_name |
| |
|
def | clear_name |
| |
|
def | expression_size |
| |
|
def | expression_list |
| |
|
def | expression |
| |
|
def | mutable_expression |
| |
|
def | add_expression |
| |
|
def | clear_expression |
| |
|
def | MergeFrom |
| |
|
def | Equals |
| |
|
def | IsInitialized |
| |
|
def | ByteSize |
| |
|
def | ByteSizePartial |
| |
|
def | Clear |
| |
|
def | OutputUnchecked |
| |
|
def | OutputPartial |
| |
|
def | TryMerge |
| |
|
def | __str__ |
| |
|
|
int | kname = 1 |
| |
|
int | kExpressionGroup = 2 |
| |
|
int | kExpressionname = 3 |
| |
|
int | kExpressionexpression = 4 |
| |
The documentation for this class was generated from the following file:
- code/googleappengine-read-only/python/google/appengine/api/search/search_service_pb.py


This document defines a standard set of data types and data structures, to aid interoperability of peers at the application level of an EPICS V4 network.
The types described here are approximately equivalent to EPICS V3 "DBR types", though Normative Types extend the concept to structured data. Additionally, these types may be used to define pvIOC records, or may be used purely for data exchange though the dynamic data exchange interfaces offered by pvAccess and pvData.
The function of each Normative Types is described, and their type data structures are defined.
For more information about EPICS, please refer to the home page of the Experimental Physics and Industrial Control System.
This is the 12 April 2012 version of the Normative Types document. This version reverts NTNamedValue to a congruent array system, rather than one in which the value is itself an array type; NTMatrix is max 2-dimentional, and much text has been added to describe alarms, display and control standard optional fields.
A continuing notable absence from this document is how Normative Types should identify themselves as such. At present, the name of the structure which encapsulates the type conforming to a Normative Type, may be named with the name of the type. For instance, a structure that should be interpreted as a NTTable, should be named "NTTable." But whether this shall be the standard for self-identity is not yet decided.
This version is an editors draft towards the First Public Working Draft. The First Public Working Draft will be intended for the EPICS community to review and comment. Resulting comments will drive subsequent revisions of the Normative Types specification and the EPICS V4 Working Group's reference implementations of software that helps create, populate and exchange Normative Type PVData.
Comments are welcome, though bear in mind this is a pre-public release version.
The terms MUST, MUST NOT, SHOULD, SHOULD NOT, REQUIRED, and MAY when highlighted (through style sheets, and in uppercase in the source) are used in accordance with RFC 2119 [RFC2119]. The term NOT REQUIRED (not defined in RFC 2119) indicates exemption.
The Normative Types described in this document are a set of software designs for high level composite data types suitable for the application level data exchange between EPICS V4 network endpoints. In particular, they are intended for use in online scientific instrument operations. The intention is that where the endpoints in an EPICS V4 network all use only Normative Types, each peer in the network should be able to understand all the data transmitted to it, at least syntactically, and be able to take processing steps appropriate to that data.
The EPICS version 4 module PVData bib:pvdata supplies a typing mechanism and object management API for efficiently defining, creating, accessing and updating memory resident structured data. EPICS V4 module PVAccess bib:pvaccess supports the efficient exchange of PVData defined data between EPICS V4 network peers. EPICS V4 Normative Types, defines some general purpose data types, that build on the PVData. These are designed to be generally applicable to controls and the application level of scientific instruments.
The simplest example is the Normative Type "NTScalar". When a client receives a PVData datum which identifies itself as being of type NTScalar, the client will know to expect the scalar's value will be accompanied by an indication of alarm severity and a timestamp (see example below).
An example of a simple normative type is the NTScalar:
structure NTScalar time_t timeStamp alarm_t alarm double value
A more complex example; if a client receives a PVData datum which identifies itself as being of type NTTable, this document specifies that it should expect the datum to contain 0 or more arrays of different types. The definition of NTTable below will say that the client should interpret the arrays as the columns of a table, and should render appropriately as a table, with rows being the same numbered elements of each array.
structure NTTable string[] labels // Very short text describing each field below, i.e. column labels {scalar_t[] colname}0+ // 0 or more scalar array type instances, the columns. string descriptor : opt alarm_t alarm : opt time_t timeStamp : opt
A Normative Type can be used both for sending data from client to service and from service to client. In this document we refer generally to an agent, being either a client or a server. If the agent is specifically at the user's end, we call it the user agent. Client and server refer to the directionality of the transaction, server being the agent that is doing the sending.
All the EPICS V4 Normative Types are defined as particular structure instance definitions of a PVData structure. This is true even of the Normative Types describing simple values like a single int, since a given Normative Type defined datum may include alarm or timestamp. Hence, all Normative Types are structures. The fields of a given Ntype then, can be ascertained at runtime by the pvData Field introspection interface bib:pvdata.
Definition: Normative Type
The Normative Types defined in this document each have the following general form:
The Normative Type data descriptions are given with the syntactic conventions and grammar given below. This is a hybrid of the pvData "Meta" Language and BNF, in order to add clear distinctions between symbol types, particularly terminality, recurrence, which names a user is expected to add and which are predefined.
italics - a non-terminal. Used to stand for a choice of pvData type, or named sequence of fields, or for fields that are themselves defined as structures, and hence non-terminal. In implementation the latter will have pvData field Type structure
plaintext - terminals, either a terminal pvData type name or a label. In the case of terminal pvData type, in implementation these will be instances of pvData Field types scalar or scalarArray, eg double or int [].
name - A user provided label name. This is a kind of terminal. A programmer using the Normative Type will choose what goes in the <>.
{ } - a sequence of occurrences of the item or items in the braces. The number of occurrences is given in the following subscript, 0+ means 0 or more, 1+ means 1 or more.
The grammar for a normative type definition follows the pattern below. That is, a Normative Type is defined as a structure composed of fields. A field may be optional, and may be described along with a comment:
structure NTname { ( ntfield fieldName [:opt] [// comment text] ) }1+
where:
This section defines the fields that may appear in a Normative Type's definition.
Each field of a normative type ( ntfield_t ) will be one of the following:
ntfield := scalar_t // a simple numerical, boolean, or string value | scalar_t[] // an array of simple values | enum_t // an enumeration | enum_t[] // an array of enumerations | time_t // a point in time, used for timestamps | time_t[] // an array of points in time | alarm_t // a summary diagnostic of a control system event | alarm_t[] // an array of summary diagnostics | alarmlimit_t // value thresholds for a control system diagnostic report | alarmlimit_t[] // an array of threshold values | display_t // meta data of displayed data | display_t[] // an array of display mata data | control_t // control setpoint range boundaries | control_t[] // an array of control setpoint range boundaries
Note that of all the Normative Type fields only scalar_t is of simple type, that is, having a single or array value. All the others are represented by a structure (see Structure Normative Fields below).
The field is a scalar value. Scalar fields would be implemented with PVData field Type "scalar":
scalar_t :=
boolean // true or false
| byte // 8 bit signed integer
| short // 16 bit signed integer
| int // 32 bit signed integer
| long // 64 bit signed integer
| float // single precision IEEE 754
| double // double precision IEEE 754
| string // UTF-8 *
The field is an array of scalars. Scalar array fields would be implemented with PVData field Type "scalarArray":
scalar_t[] :=
boolean[] // array of true or false
| byte[] // array of 8 bit signed integer
| short[] // array of 16 bit signed integer
| int[] // array of 32 bit signed integer
| long[] // array of 64 bit signed integer
| float[] // array of single precision IEEE 754
| double[] // array of double precision IEEE 754
| string[] // array of UTF-8 *
This subsection defines those fields of a Normative Type structure definition, that are themselves structures or arrays of structures.
The structured normative fields would be implemented with type PVData field Type "structure" or "structureArray".
An enum_t[] describes an enumeration. The field is a structure describing a value drawn from a given set of valid values also given. It is implemented as a pvData Field of Type "structure" with the following form:
enum_t :=
structure enum
int index
string[] choices
where:
An enum_t[] describes an array of enumerations. The field is an array of structures each describing a value drawn from a given set of valid values also given in each. It is implemented as a PVData field of Type "structureArray" each element of which with the form of enum_t above.
A time_t describes a defined point in time. The field is a structure describing a time relative to midnight on January 1st, 1970 UTC. It is implemented as a pvData field of Type "structure" with the following form:
time_t :=
structure timeStamp
long secsPastEpoch
int nanoseconds
int userTag
where:
Interpretation: The point in time being identified by a time_t, is given by Jan 1, 1970 00:00:00 UTC plus some nanoseconds given by its secsPastEpoch times 109 plus its nanoseconds.
pvData provides two helper classes for a timeStamp structure: timeStamp, and PVTimeStamp.
A time_t[] describes an array of points in time. The field is an array of structures each describing a time relative to January 1st, 1970 UTC. It is implemented as a PVData field of Type "structureArray" each element of which with the form of time_t above.
An alarm_t describes a diagnostic of the value of a control system process variable. It indicates essentially whether the associated value is good or bad, and whether agent systems should alert people to the status of the process.
Processes in EPICS V3 and V4 IOCs include extensive support for evaluating alarm conditions. The definition of the fields in an alarm are given in bib:epicsrecref. The field is a structure describing an alarm. It is implemented as a PVData field of Type "structure" with the following form:
alarm_t :=
structure alarm
int severity
int status
string message
where:
Interpretation MUST be as with V3 IOC record processing, as described in the epicsrecref.
pvData provides two helper classes for an alarm structure: alarm, and PVAlarm.
An alarm_t[] is an array of alarm conditions. The field is an array of structures each describing an alarm condition. It is implemented as a PVData field of Type "structureArray" each element of which with the form of alarm_t above.
An alarmlimit_t is a structure that gives the numeric intervals to be used for the high and low limit ranges of an associated limit type alarm. The specific instance of the alarm to which the alarmlimit refers, is not specified in the alarmlimit structure, it may be any EPICS alarm. alarmlimit_t is implemented as a PVData field of Type "structure" with the following form:
alarmlimit_t :=
structure alarmlimit
double highalarm
double highwarning
double lowwarning
double lowalarm
where:
The interpretation is that where the Normative Type instance's value field is:
Since the above conditions do not at all form a three valued function over all possible values of the limits, the invariant lowalarm <= lowwarning <= highwarning <= highalarm SHOULD be observed when setting the those thresholds.
Code in both V3 IOC record support and in V4 IOC raises alarms based on how the alarm limits are valued according to the following algorithm:
If the value is >= highalarm then a major alarm is raised else if value>=highwarning then a minor alarm is raised else if value<= lowalarm then a major alarm is issued else if value<=lowwarning then a minor alarm is raised else do not raise an alarm.
Where an alarmlimit_t structure instance is present in a Normative Type structure, it MUST be interpreted as referring to that Normative Type's field named "value". Therefore it is only used in Normative Types that have a single numeric "value" field.
An alarmlimit_t[] is an array of alarm limit conditions. The field is an array of structures each describing an alarm limit. It is implemented as a PVData field of Type "structureArray" each element of which with the form of alarmlimit_t above.
A display_t is a structure that describes some typical attributes of a numerical value that are of interest when displaying the value on a computer screen or similar medium. The units field SHOULD contain a string representation of the physical units for the value, if any. The description field SHOULD contain a short (one-line) description of what the value represents, such as can be used as a label in a display. The fields lowlimit and highlimit represent the range in between which the value should be presented as adjustable.
The field is a structure describing a display_t. It is implemented as a PVData field of Type "structure" with the following form:
display_t :=
structure display
double lowlimit
double highlimit
string description
string format
string units
where:
Where an display_t structure instance is present in a Normative Type structure, it MUST be interpreted as referring to that Normative Type's field named "value". Therefore it is only used in Normative Types that have a single numeric "value" field.
A display_t[] is an array of display_t. The field is an array of structures each describing the display media oriented metadata of some corresponding process variable value, as described by display_t above. It is implemented as a PVData field of Type "structureArray" each element of which with the form of display_t above.
An control_t is a structure that describes a range, given by the interval (limitlow,limithigh), within which it is expected some control software or hardware shall bind the control PV to which this Normative Type instance's value field refers.
The field is a structure describing a control_t. It is implemented as a PVData field of Type "structure" with the following form:
control_t :=
structure control
double lowlimit
double highlimit
where:
A control_t[] is an array of control_t. The field is an array of structures each describing the setpoint range interval of some process variable. It is implemented as a PVData field of Type "structureArray" each element of which with the form of control_t above.
Since a primary reason for Normative Types is to interoperably pass data between EPICS V4 agents, particularly where the receiver may be generic code that takes action on the data alone with no context (think caget), some support for optional meta data are included.
There is no required interpretation of these fields, and therefore their meaning is not further described in the Normative Type definitions below.
An object of Normative Type may optionally include a field named "descriptor" and of type string, to be used to give identity, name, or sense information. For instance, it may be valued with the name of a device associated with control data, or the run number of a table of model data.
string descriptor :opt // Contextual information
An object of Normative Type may optionally include an alarm field.
alarm_t alarm :opt // Control system event summary
An object of Normative Type may optionally include a timeStamp field.
time_t timeStamp :opt // Event time
The General Normative Types are for encapsulating data of any kind of application or use case. Compare to Specific Normative Types defined later in this document, and which are oriented to particular use cases.
NTScalar is an EPICS V4 Normative Type that describes a single scalar value plus metadata:
structure NTScalar scalar_t value string descriptor :opt time_t timeStamp :opt alarm_t alarm :opt display_t display :opt control_t control :opt
where:
NTEnum is an EPICS V4 Normative Type that describes an enumeration (a closed set of possible values each described by an n-tuple).
structure NTEnum enum_t value string[] longdescriptions :opt string descriptor :opt time_t timeStamp :opt alarm_t alarm :opt
where:
NTMatrix is an EPICS V4 Normative Type used to define a matrix, specifically a 2-dimensional array of real numbers.
structure NTMatrix
double[] value
int[2] dim :opt
string descriptor :opt
time_t timeStamp :opt
alarm_t alarm :opt
display_t display :opt
where:
User agents that print or otherwise render an NTMarix SHOULD print row vector, column vector, and non-vector matrices appropriately.
Presently, Normative Types are intended only to specify interoperable data types of PVAccess data exchanges of PVData. As such, all data manipulation of the values in a PVData datum are through the methods of PVStructure. Since Normative Types do not specify agent implementation details, the layout of an NTMatrix's value array data in memory is not defined, and should not be expected to be reliably dependent on the language interface. For instance, expecting row-major order in memory when using the C binding, or column-major at other times (Fortran, Matlab), would not be sensible.
NTVariantArray is an EPICS V4 Normative Type to define a single structure which contains an number of arrays, each of different type, but where the value of the NTVariantArray as a whole is taken to be the value of only one of the arrays at a time. In that way, it can be used to encode data in arrays whose type may be changed according to runtime conditions and the data to be expressed.
NTVariantArray is defined with arrays of each pvData scalar type. At any
particular time its value MUST be interpreted to be only one of these arrays. The
dataType
member specifies which array MUST be taken to be the
NTVariantArray's type. The data arrays need not be all the same length. Arrays other
than that presently selected by dataType
MAY be populated; in this way
dataType
can be used as a value selector.
structure NTVariantArray int dataType // Identifies which scalar array defines the present value boolean [] booleanValue // Defines the NTVariantArray's value if dataType == 0 byte [] byteValue // Defines the NTVariantArray's value if dataType == 1 short [] shortValue // Defines the NTVariantArray's value if dataType == 2 int [] intValue // Defines the NTVariantArray's value if dataType == 3 long [] longValue // Defines the NTVariantArray's value if dataType == 4 float [] floatValue // Defines the NTVariantArray's value if dataType == 5 double [] doubleValue // Defines the NTVariantArray's value if dataType == 6 string [] stringValue // Defines the NTVariantArray's value if dataType == 7 timestamp_t[] timeStampValue // Defines the NTVariantArray's value if dataType == 8 alarm_t [] alarmValue // Defines the NTVariantArray's value if dataType == 9 string descriptor :opt time_t timeStamp :opt alarm_t alarm :opt display_t display :opt
where:
0 - booleanValue 1 - byteValue 2 - shortValue 3 - intValue 4 - longValue 5 - floatValue 6 - doubleValue 7 - stringValue 8 - timeStampValue 9 - alarmValue
NTNameValue is an EPICS V4 Normative Type that describes a system of name and scalar values.
For the related problem of expressing a key-value system where each value may be array valued, see NTVariantArray or NTTable.
Use cases: In a school, a single NTNamedValue might describe the grades from a number of classes for for one student.
structure NTNameValue string[] name scalar_t[] value string descriptor :opt time_t timeStamp :opt alarm_t alarm :opt
where:
Each name (or "key") in the array of names, MUST be interpreted as being associated with its same indexed element of the value array.
NTTable is the EPICS V4 Normative Type for "2-d" tabular datasets.
An NTTable is made up of a number of arrays, each array being of a scalar type. Each array can be thought of as a column. Each ith array member makes up one row, or n-tuple.
Use case examples: a table of twiss paramaters of all lattice elements in an accelerator section. Another example, where the columns might vary call-to-call would be that of an EPICS V4 SQL database service. In that example one NTTable returned by the service would contain all the tabular results of a SQL SELECT, essentially a recoded JDBC or ODBC ResultSet - see the rdbService.
structure NTTable string[] labels // Very short text describing each field below, i.e. column labels {scalar_t[] colname}0+ // 0 or more scalar array type instances, the columns. string descriptor : opt alarm_t alarm : opt time_t timeStamp : opt
where:
This represents a table. The number of "columns" is equal to the number of fields which follows field "labels." Each colname[] field has the data for its "column." The value of each element of labels SHOULD be used as a column heading for the corresponding colname field.
Note that the above description is given in terms of a table and its columns, but there is nothing specifically columnar about how this data may be rendered. A user may choose to print the fields row wise. For instance, if there are many fields, but each has only length 1 or 2. E.g., if you wanted to give all the scalar data related to one device, then you might use an NTTable rendered in such a way. Note that one column of a table would also be easily described by NTNameValue.
The number of scalar_t fields and the length of labels MUST be the same. All scalar_t fields MUST have the same length, being the number of "rows" in the table.
The "specific normative types" below are types oriented towards application level scientific and engineering use cases. Compare to General Normative Types defined above. The currently defined types are each described in a section below.
Unless otherwise stated:
MultichannelArray is an EPICS V4 Normative Type that aggregates an array of scalar values from different EPICS Process Variable (PV) channel sources, into a single variable.
Use cases; in a particle accelerator, a single NTMultichannelArray might include the data of a number of Beam Positon Monitors' X offset values, or of a number of quadrupoles' desired field values.
structure NTMultichannelArray scalar_t[] value // The channel values string[] PVnames // Process Variable names time_t timeStamp // Base value time stamp int[] severities :opt // Alarm severity associated with each value double[] positions :opt // The position of each value element double[] deltaTimes :opt // The time relative to the timeStamp, in seconds string descriptor :opt alarm_t alarm :opt
where:
The above descriptions of the optional fields, pertain in particular to when a NTMultichannelArray expresses measured values, but a NTMultichannelArray can be used to express desired values or setpoint values too.
NTTimeDomainArray is an EPICS V4 Normative Type that expresses an array of values from a single signal, where there has been a constant time between each sample; for instance from a PV that has been sampled at a given single frequency.
The data in a NTTimeDomainArray show how the associated signal changes over time. Should the name of the PV be included?
Need use cases. Also, is this definition realistic? Seems to me you'd also want to have an indication of the sampling time error. That is, if the deltaTime was .5, that would be an ideal, and you'd want also to record what was an estimate of when the corresponding sample was really taken, with reference to that notional deltaTime. Need an expert.
structure NTTimeDomainArray
(boolean [] | byte[] | short[] | int[] | long[] | float[] | double[]) value
double deltaTime // Time in seconds between each sample
string descriptor :opt
alarm_t alarm :opt
time_t timeStamp :opt
where:
Need to include units?
NTFrequencyDomainArray is the EPICS V4 Normative Type for expressing the values of a signal with respect to frequency.
Needs an expert to check this. Our proto from PSI meeting defined two numbers firstFrequency and deltaFrequency as a single numbers, but surely they must be an array of frequencies? Changed it to array, with 0 index being base freq. Maybe harmonics should be given as deltas to the base. So we need to be more specific about whether harmonics' frequencies are absolute or relative to frequencies[0].
structure NTFrequencyDomainArray
(boolean [] | byte[] | short[] | int[] | long[] | float[] | double[]) value
double[] frequencies // frequencies[0] = base, [>0] = harmonics
string descriptor :opt
alarm_t alarm :opt
time_t timeStamp :opt
where:
Need to include units?
NTHistogram is the EPICS V4 Normative Type used to encode the data and representation of a (1 dimensional) histogram. Specifically, it encapsulates frequency binned data.
For 2d histograms (i.e. both x and y observations are binned) and n-tuple data (e.g. land masses of different listed countries) see NTMatrix or NTTable.
structure NTHistogram
double [] ranges // The start and end points of each bin
long [] counts // The frequency count, or value of each bin
string descriptor :opt
alarm_t alarm :opt
time_t timeStamp :opt
One NTHistogram gives the information required to convey a histogram representation of some underlying observations. It does not convey the values of each of the observations themselves.
The number of bins is given by the length of the counts array. ranges indicates the low value and high value of each bin. The range for bin(i) is given by range(i) to range(i+1). Specifically, since we want end points of both the first bin and last bin included, all bin intervals except the last one, MUST be right half open; from that bin's low value range(i) (included) to that bin's high value range(i+1) (excluded). The last bin MUST be fully open (low and high value included).
A log plot histogram (in which the independent variable x is binned on a log scale), would be communicated using a range array of decades (1.0E01, 1.0E02, 1.0E03 etc).
The array length of range
MUST be the array length of counts + 1.
NTAggregate is the EPICS V4 Normative Type to compactly convey data which combines, several measurements, or observations. An NTAggregate would give a simple summary statistic bib:agg about the central tendency and dispersion of a set of data points.
Use cases: for instance, an NTAggreagte could be used to summarize the value of one beam position offset reading over some number of pulses (N). It also includes the time range of the sampled points, so it could be used for time domain rebasing. For instance, an FPGA sending data at 10KHz, and you want to display its output, but you don't want to display at the native rate. Also, it could be used for transmitting or storing compressed archive data.
NTAggregate doesn't cover the shape of a distribution so it only reasonably helps you do symmetrical distributions (no skewness or kurtosis), and it doesn't include any help for indicating the extent of dependency on another variable (correlation).
structure NTAggregate double mean // Average value of observations double sd // Standard Deviation of observations, or RMS about the mean long N // Number of observations double first opt // Initial observation value time_t firstTimeStamp opt // Time of initial observation double last opt // Final observation value time_t lastTimeStamp opt // Time of final observation double max opt // Highest value in the N observations double min opt // Lowest value in the N observations string descriptor opt alarm_t alarm opt time_t timeStamp opt
Where:
One NTAggregate instance describes some number (given by N) of observations. If firstTimeStamp and lastTimeStamp are given, then the N observations MUST have been taken over the period of time specified. If first, last, max or min are given, they MUST refer to the actual values of the N observations being summarized.
The mean
field value computed by server agents SHOULD be the
arithmetic mean of the observation data being summarized by this NTAggregate.
Which estimator of the standard deviation [1/N or 1/(N-1)] is to be used by
service agents to compute the value of the sd
field, is not defined.
NTImage is the EPICS V4 Normative Type to express image data, particularly camera images. One NTImage gives one frame.
The EPICS V3 image type is provided by areaDetector. See the NDArray class declaration for details of the image properties. The EPICS V4 image type (NTImage) is a superset of this functionality.
Byte [] data may contain a
compressed image so the size may not be at least prod(dim) *
element_size(datatype)
.
An NTImage is composed of three parts:
structure NTImage Arraypart Imagepart Metadatapart
Each of these will be discussed separately.
The Arraypart of an NTImage is composed of the following fields:
(boolean [] | byte[] | short[] | int[] | long[] | float[] | double[]) value
int[] dim
string descriptor :opt
time_t timeStamp :opt
alarm_t alarm :opt
display_t display :opt
These fields are the same as for NTMatrix defined previously.
A generic tool that operates on NTMatrixs will be able to use the image as long as compression is not used.
The Imagepart of an NTImage is composed of the following fields:
int colorMode int bayerPattern char [4] fourcc int [] offset // same length as dim, start of readout int [] binning int [] reverse int [] fullDim
where:
NDColorModeMono = 0, /** Monochromatic image */ NDColorModeBayer = 1, /** Bayer pattern image, 1 value per pixel but with color filter on detector */ NDColorModeRGB1 = 2, /** RGB image with pixel color interleave, data array is [3, NX, NY] */ NDColorModeRGB2 = 3, /** RGB image with row color interleave, data array is [NX, 3, NY] */ NDColorModeRGB3 = 4, /** RGB image with plane color interleave, data array is [NX, NY, 3] */ NDColorModeYUV444 = 5, /** YUV image, 3 bytes encodes 1 RGB pixel */ NDColorModeYUV422 = 6, /** YUV image, 4 bytes encodes 2 RGB pixel */ NDColorModeYUV411 = 7 /** YUV image, 6 bytes encodes 4 RGB pixels */
NDBayerRGGB = 0, /** First line RGRG, second line GBGB... */ NDBayerGBRG = 1, /** First line GBGB, second line RGRG... */ NDBayerGRBG = 2, /** First line GRGR, second line BGBG... */ NDBayerBGGR = 3 /** First line BGBG, second line GRGR... */
The Metadatapart of an NTImage is composed of the following fields:
int uniqueId string [] attributeDescriptions int [] attributeSourceTypes string [] attributeSources NTVariantArray [] attributes
where:
NDAttrSourceDriver = 0, /** Attribute is obtained directly from driver */ NDAttrSourceParam, /** Attribute is obtained from parameter library */ NDAttrSourceEPICSPV /** Attribute is obtained from an EPICS PV */
Users and developers using EPICS V4 are free to define their own special purpose types on top of PVStructure (or the other PV Types) but should note that only the Normative Types defined here (NT*) above, are intended to be understood by all general purpose EPICS V4 services and clients.


Check out past events that happened.
To raise awareness about vaccination, we have dedicated Codeflix Season 2 Episode 3 to the topic of "VACCINATION". Take out your laptops and code to solve the problems of this amazing episode. 5 problems are waiting to be answered by you, & obviously there is nothing to lose! As usual, there will be certificates for top 5 participants and great learning opportunity for all.
DSC RNSIT is going to organize the first session of "Explore ML" workshop. This is the first session of the Explore ML program. Where we'll be dealing with the basics of python and the libraries required for Machine Learning. So Buckle UP and Join DSC RNSIT on this thrilling session of the Explore ML Program.
Just take out your laptops and code to solve the mystery of "The Family Man" during Codeflix Season 2 Episode 2! 5 problems are waiting to be answered by you, there is nothing to lose, and there will be immense fun! As usual, there will be certificates for top 5 participants and great learning opportunity for all. Participants must register on both the links.
We taught concepts of HTML5, CSS, JS, Bootstrap. Participants gained hands-on experience in front-end development by completing a project, which was building college website
We are back with another exciting season of Codeflix! Codeflix
season 2 will be more challenging and thrilling! So keep
participating! Episode 1 is going to be astounding because it
will be all about IPL!🏏
Don't wait... Register now for the Episode 1 of season 2!💻
The Google Developer Student Clubs 2021 Solution Challenge mission is to solve for one of the United Nations’ 17 Sustainable Development Goals using Google technology. Created by the United Nations in 2015 to be achieved by 2030, the 17 Sustainable Development Goals (SDGs) agreed upon by all 193 United Nations Member States aim to end poverty, ensure prosperity, and protect the planet.
DSC RNSIT, with collaboration with other DSCs across the country, presents Android study jam session 3! Let's dive more deeper into topics regarding Kotlin and Android application development. Participants just need to be enthusiastic throughout the session as it's going to be astounding.
This track of Web Development Workshop will take your development skills to an advanced level and help you to gain knowledge in numerous topics that are going to be covered in this track. All the participants will get E-certificates.
This track of Web Development Workshop will take your
development skills to an advanced level and help you to gain
knowledge in numerous topics that are going to be covered in
this track.
Speaker for the session: Deepika Bagaria
Software Developer (Java Developer @ Walmart)
This track of Web Development Workshop will take your development skills to an advanced level and help you to gain knowledge in numerous topics that are going to be covered in this track. All the participants will get E-certificates.
DSC WOW will bring Industry leaders as mentors and college students from all over the country and beyond to compete over 48 hours to develop creative solutions to real-world problems. There are multiple prizes and swags to be won!
A healthy competition has always been a good method to self analyse your skills and grow at a rapid rate. With the spirit of a healthy competition, Developer Student Clubs Chapter RNSIT is organising a coding competition only for the students of RNSIT. Apart from gaining knowledge and experience. Top 5 participants who complete the competition in the best possible way will get a E-certificates and a shoutout on our social media handle and direct entry into the Season Finale.
DSC RNSIT is organizing a three day "Workshop on Web
Development" accompanied by a project.
Speaker for the sessions:
Shivank Kumar, Associate Consultant - Product Engineering
Services, Bristlecone India Limited
A healthy competition has always been a good method to self analyse your skills and grow at a rapid rate. With the spirit of a healthy competition, Developer Student Clubs Chapter RNSIT is organising a coding competition only for the students of RNSIT. Apart from gaining knowledge and experience. Top 5 participants who complete the competition in the best possible way will get a E-certificates and a shoutout on our social media handle and direct entry into the Season Finale.
A healthy competition has always been a good method to self analyse your skills and grow at a rapid rate. With the spirit of a healthy competition, Developer Student Clubs Chapter RNSIT is organising a coding competition only for the students of RNSIT. Apart from gaining knowledge and experience. Top 5 participants who complete the competition in the best possible way will get a E-certificates and a shoutout on our social media handle and direct entry into the Season Finale.
Greetings from DSC RNSIT!! As we promised, we have come up with a mega event in collaboration with 14 other DSCs. This online event "Insight into DSC" is going to be a grand informative session with 4 amazing speakers! It will give you a better idea about Developer Student Club and the things we do to bring a change. We hope that after this event, many of you will join us with more energy and be a part of our journey!


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| account.js | 85.71% | 42/49 | 90% | 18/20 | 90.91% | 10/11 | 61.11% | 11/18 | |
| asset.js | 98.75% | 79/80 | 95.65% | 44/46 | 100% | 15/15 | 97.78% | 44/45 | |
| base58.js | 65.63% | 42/64 | 40% | 12/30 | 57.14% | 4/7 | 56.86% | 29/51 | |
| hashing.js | 100% | 7/7 | 100% | 0/0 | 100% | 1/1 | 100% | 5/5 | |
| index.js | 100% | 68/68 | 100% | 9/9 | 100% | 21/21 | 100% | 1/1 | |
| keypair.js | 93.26% | 83/89 | 90% | 27/30 | 88.89% | 24/27 | 86.96% | 40/46 | |
| memo.js | 97.37% | 74/76 | 95.45% | 42/44 | 100% | 12/12 | 94.87% | 37/39 | |
| network.js | 100% | 38/38 | 100% | 10/10 | 100% | 13/13 | 100% | 13/13 | |
| operation.js | 95.54% | 343/359 | 88.89% | 152/171 | 100% | 28/28 | 94.72% | 287/303 | |
| signing.js | 64.44% | 29/45 | 50% | 3/6 | 77.78% | 7/9 | 60% | 24/40 | |
| strkey.js | 96.77% | 60/62 | 92.31% | 24/26 | 100% | 5/5 | 95.65% | 44/46 | |
| transaction.js | 100% | 67/67 | 95.45% | 21/22 | 92.86% | 13/14 | 100% | 31/31 | |
| transaction_builder.js | 98.75% | 79/80 | 96.43% | 27/28 | 100% | 11/11 | 96.77% | 30/31 |


CAGR is the yearly return that would be required to generate the return over the backtest period. CAGR is calculated as
$$ (\frac{e}{s})^{\frac{1}{y}}-1 $$where $s$ is starting equity, $e$ is ending equity, and $y$ is the number of years in the backtest period. The benefit of using CAGR as the objective is that it maximizes the return of your algorithm over the entire backtest. The drawback of using CAGR is that it may cause your algorithm to have more volatile returns, which increases the difficulty of keeping your algorithm deployed in live mode.


In a piece on the Guardian Books Blog, Lee Rourke identifies “the greatest first line of any novel I have ever read”, the opening of Ann Quin's Berg: “A man called Berg, who changed his name to Greb, came to a seaside town intending to kill his father . . .” Some of the commenters propose their own favourite first lines, and one links to a list of the “hundred best” from a website called LitLine. There is no explanation of how the hundred were selected, or by whom, but it makes for an occasionally intriguing read.
I had been thinking of compiling a list of the hundred best opening lines from out of print pamphlets by Dobson, and maybe one day I will do so. Certainly near the top of the list would be “There was a thunderstorm, and I discovered I had mislaid my bus pass” from How I Mislaid My Bus Pass During A Thunderstorm.
Meanwhile, having managed to type a couple of paragraphs while wheezing and spluttering due to my fever-racked condition, I am going to reward myself with A Nice Cup Of Tea And A Sit Down.


Would you like to flag existing voice-over audio as 'may not match content'? This informs the voice-artists to record new audio that reflects any changes in translation.


Table of Contents - Rails Application Documentation
Pages
README_FOR_APP
Classes/Modules
AboutController
ApplicationController
ApplicationHelper
Authorization
CalendarController
CalendarHelper
DailyWod
DashboardHelper
DashboardsController
Event
EventColor
EventsController
EventsHelper
Exercise
ExerciseCategory
ExerciseWorkout
ExercisesController
ExercisesHelper
Goal
GoalsController
GoalsHelper
HealthRecord
HealthRecordsController
HealthRecordsHelper
HomeController
HomeHelper
InjuryRecord
InjuryRecordsController
InjuryRecordsHelper
PasswordResetsHelper
PersonalRecord
PersonalRecordsController
PersonalRecordsHelper
Profile
ProfileHelper
ProfilesController
SessionsController
SessionsHelper
ShareController
ShareHelper
StatsController
StatsHelper
Trainer
TrainerHelper
TrainersController
User
UserHelper
UserSessionHelper
UserSessionsHelper
Workout
WorkoutCategory
WorkoutHelper
WorkoutRecord
WorkoutRecordsController
WorkoutRecordsHelper
WorkoutsController
Methods
::blue — EventColor
::calculate_bmi — HealthRecord
::create_from_hash — Authorization
::create_from_hash! — User
::fetch_fb_graph_user — Profile
::fetch_latest — PersonalRecord
::find_from_hash — Authorization
::find_or_new_by_attributes — Exercise
::find_or_new_by_category — WorkoutCategory
::find_or_new_by_category — ExerciseCategory
::get_all_records_for — PersonalRecord
::get_bmi_series_for_chart — HealthRecord
::get_bp_series_for_chart — HealthRecord
::get_calories_series_for_chart — HealthRecord
::get_heart_rate_series_for_chart — HealthRecord
::get_record_for — PersonalRecord
::get_series_for_chart — WorkoutRecord
::get_weight_series_for_chart — HealthRecord
::green — EventColor
::latest — DailyWod
::latest — WorkoutRecord
::open_graph — Profile
::pink — EventColor
::red — EventColor
::select_custom_exercises — Exercise
::select_custom_workouts — Workout
::select_official_categories — WorkoutCategory
::select_official_categories — ExerciseCategory
::select_official_exercises — Exercise
::select_official_workouts — Workout
::series_from_collection — HealthRecord
::with_category — Exercise
#associate_exercises_with — Workout
#at_least_one_health_metric — HealthRecord
#at_least_one_metric — WorkoutRecord
#at_least_one_metric — Exercise
#check_status? — Goal
#complete? — Goal
#create — SessionsController
#create — ExercisesController
#create — WorkoutsController
#create — InjuryRecordsController
#create — ProfilesController
#create — TrainersController
#create — GoalsController
#create — ShareController
#create — HealthRecordsController
#create — WorkoutRecordsController
#destroy — WorkoutRecordsController
#destroy — SessionsController
#destroy — ExercisesController
#destroy — GoalsController
#destroy — InjuryRecordsController
#destroy — TrainersController
#destroy — HealthRecordsController
#destroy — WorkoutsController
#edit — HealthRecordsController
#edit — InjuryRecordsController
#edit — WorkoutRecordsController
#edit — TrainersController
#edit — ExercisesController
#edit — GoalsController
#edit — ProfilesController
#edit — WorkoutsController
#end_at — Event
#event_calendar — CalendarHelper
#event_calendar_opts — CalendarHelper
#exercise_category_attributes= — Exercise
#failure — SessionsController
#get_name — User
#height — Profile
#height= — Profile
#height_str — Profile
#index — AboutController
#index — GoalsController
#index — WorkoutRecordsController
#index — ExercisesController
#index — TrainersController
#index — StatsController
#index — EventsController
#index — WorkoutsController
#index — CalendarController
#index — HealthRecordsController
#index — PersonalRecordsController
#index — InjuryRecordsController
#index — HomeController
#month_link — CalendarHelper
#needs_units — Exercise
#new — WorkoutRecordsController
#new — WorkoutsController
#new — ExercisesController
#new — InjuryRecordsController
#new — TrainersController
#new — HealthRecordsController
#new — GoalsController
#new — ProfilesController
#new — SessionsController
#severity_within_bounds — InjuryRecord
#show — PersonalRecordsController
#show — InjuryRecordsController
#show — GoalsController
#show — DashboardsController
#show — EventsController
#show — HealthRecordsController
#show — TrainersController
#show — WorkoutRecordsController
#show — ProfilesController
#show — WorkoutsController
#show — ExercisesController
#systolic_and_diastolic_present_together — HealthRecord
#time — WorkoutRecord
#time= — WorkoutRecord
#update — HealthRecordsController
#update — WorkoutRecordsController
#update — ProfilesController
#update — ExercisesController
#update — TrainersController
#update — InjuryRecordsController
#update — GoalsController
#update — WorkoutsController
#workout_category_attributes= — Workout


Steffen Hedegaard, Jakob Grue Simonsen
Dimensions (satisfaction measures) of interactive products discussed. Should bottom this out. Need a source of critical design in the context of firmware. This is close - in the context of software/video games, but uses an interesting technique - harvesting from online reviews (similar to source based on bike light review).
They adopt textual analysis of online reviews as a basis for figuring out how much information content online-reviews might provide for UX and usability feedback. This is linked to sentiment analysis but (they claim) is a much more focused science on UX.
They cover the nomenclature and categories of 'usability' found in the literature extensively from many authors and further literature surveys, as a basis for introducing their own statistical aggregation measures.
They reference an ISO standard around usability which should play a part in the literature review.
UX, User Experience, Usability, Text corpus analysis, natural language processing, end user reviews
"We (a) find that 13%–49% of sentences in our online reviews pool contain
usability or UX information; (b) chart the distribution of four sets of
dimensions of usability and UX across reviews from two product
categories; (c) extract a catalogue of important word stems for a number
of dimensions."
"The aim of this paper is to quantify the amount of UUX information and
dimensions in online reviews from the specific domains of software and
video games. We also implement and test a machine-learning-based
classifier that tags sentences in reviews according to whether they
contain usability or UX-related information and according to the
dimensions of usability or UX they pertain to."
"traditional studies focus on short term product use (median 30 minutes duration [19]) and conducted in lab settings; few studies stretch across longer time periods and then only weeks [19]." [citing Hornbæk, K. 2006]
"There are important caveats when assessing the potential usefulness of online reviews: It is not clear whether online reviews are written by users typical of the user base; in addition, very few details about reviewers (e.g. gender, age, preferences) are available, in contrast to standard usability studies. Furthermore, some reviews may be fake."
"A more fine-grained description of usability is obtained by the following five dimensions which, with some variation in the naming of the aspects, are often used for measuring and describing usability in models and literature: (i) Effectiveness/Errors, (ii) Efficiency, (iii) Satisfaction, (iv) Learnability, (v) Memorability." [CH: extensive referencing removed]
Hornbæk, K. 2006 "Current practice in measuring usability: Challenges to usability studies and research."


It has been a while, but testtools 0.9.13 is finally out! Lots more matchers and bug fixes, as well as improved error reporting. Full release notes on Launchpad.
Thanks to James Westby, Graham Binns, Francesco Banconi and Robert Collins for making this release possible.


Databases
Contents
Databases #
Introduction#
Many of you will deal with complex data — and often, lots of it. Ecological and Evolutionary data are particularly complex because they contain large numbers of attributes, often measured in very different scales and units for individual taxa, populations, etc. In this scenario, storing the data in a database makes a lot of sense! You can easily include the database in your analysis workflow — indeed, that’s why people use databases. And you can use python (and R) to build, manipulate and use your database.
Relational databases#
A relational database is a collection of interlinked (related) tables that altogether store a complex dataset in a logical, computer-readable format. Dividing a dataset into multiple tables minimizes redundancies. For example, if your data were sampled from three sites — then, rather than repeating the site name and description in each row in a text file, you could just specify a numerical “key” that directs to another table containing the sampling site name and description.
Finally, if you have many rows in your data file, the type of sequential access we have been using in our python
and R
scripts is inefficient — you should be able to instantly access any row regardless of its position
Data columns in a database are usually called fields, while the rows are the records. Here are a few things to keep in mind about databases:
Each field typically contains only one data type (e.g., integers, floats, strings)
Each record is a “data point”, composed of different values, one for each field — somewhat like a python tuple
Some fields are special, and are called keys:
The primary key uniquely defines a record in a table (e.g., each row is identified by a unique number)
To allow fast retrieval, some fields (and typically all the keys) are indexed — a copy of certain columns that can be searched very efficiently.
Foreign keys are keys in a table that are primary keys in another table and define relationships between the tables
The key to designing a database is to minimize redundancy and dependency without losing the logical consistency of tables — this is called normalization (arguably more of an art than a science!)
Let’s look at a simple example.
Imagine you recorded body sizes of species from different field sites in a single text file (e.g., a .csv
file) with the following fields:
Field |
Definition |
|---|---|
|
Unique ID for the record |
|
Name of the site |
|
Longitude of the site |
|
Latitude of the site |
|
Date of the sample |
|
Hour of the sampling |
|
Average air temperature on the sampling day |
|
Temperature of the water |
|
PH of the water |
|
Species of the sampled individual |
|
Latin binomial of the species |
|
Width of the individual |
|
Weight of the individual |
It would be logical to divide the data into four tables:
Site table:
Field |
Definition |
|---|---|
|
ID for the site |
|
Name of the site |
|
Longitude of the site |
|
Latitude of the site |
Sample table:
Field |
Definition |
|---|---|
|
ID for the sampling date |
|
Date of the sample |
|
Hour of the sample |
|
Average air temperature |
|
Temperature of the water |
|
PH of the water |
Species table:
Field |
Definition |
|---|---|
|
ID for the species |
|
Species name |
|
Latin binomial of the species |
Individual table:
Field |
Definition |
|---|---|
|
ID for the individual sampled |
|
ID for the species |
|
ID for the sampling day |
|
ID for the site |
|
Width of the individual |
|
Weight of the individual |
In each table, the first ID field is the primary key. The last table contains three foreign keys because each individual is associated with one species, one sampling day and one sampling site.
These structural features of a database are called its schema.
SQLite#
SQLite
is a simple (and very popular) SQL (Structured Query Language)-based solution for managing localized, personal databases. I can safely bet that most, if not all of you unknowingly (or knowingly!) use SQLite
— it is used by MacOSX, Firefox, Acrobat Reader,iTunes, Skype, iPhone, etc. SQLite is also the database “engine” underlying your Silwood Masters Web App
We can easily use SQLite through Python scripts. First, install SQLite by typing in the Ubuntu terminal:
sudo apt install sqlite3 libsqlite3-dev
Also, make sure that you have the necessary package for python by typing import sqlite3
in the python or ipython shell. Finally, you may install a GUI for SQLite3 :
sudo apt install sqliteman
Now type sqlite3
in the Ubuntu terminal to check if SQLite successfully launches.
SQLite has very few data types (and lacks a boolean and a date type):
Field Data Type |
Definition |
|---|---|
|
The value is a NULL value |
|
The value is a signed integer, stored in up to or 8 bytes |
|
The value is a floating point value, stored as in 8 bytes |
|
The value is a text string |
|
The value is a blob of data, stored exactly as it was input (useful for binary types, such as bitmap images or pdfs) |
Typically, you will build a database by importing csv data — be aware that:
Headers: the csv should have no headers
Separators: if the comma is the separator, each record should not contain any other commas
Quotes: there should be no quotes in the data
Newlines: there should be no newlines
Now build your first database in SQLite! We will use as example a global dataset on metabolic traits called Biotraits that we are currently developing in our lab (should be in your Data
directory). This dataset contains 164 columns (fields). Thermal response curves for different traits and species are stored in rows. This means
that site description or taxonomy are repeated as many times as temperatures are measured in the curve. You can imagine how much redundacy can be here!!!
For this reason, it is easier to migrate the dataset to SQL and split it into several tables:
TCP: Includes the thermal curve performance for each species and trait (as many rows per trait and species as temperatures have been measured within the TCP)
TraitInfo: Contains site description and conditions under the traits were measured (one row per thermal curve)
Consumer: Consumer description including taxonomy (one row per thermal curve).
Resource: Resource description including taxonomy (one row per thermal curve).
Size: Size data for each species (one row per thermal curve)
DataSource: Contains information about the data source (citation, contributors) (one row per thermal curve).
So all these tables compose the Biotraits schema
.
In an Linux/Unix terminal, navigate to your data
directory:
Now, launch a new database using sqlite:
sqlite3 Biotraits.db
This should return something like:
SQLite version 3.11.0 2016-02-15 17:29:24
Enter ".help" for usage hints.
This creates an empty database in your data
directory.
You should now see the sqlite cursor (sqlite>
), and will be entering your commands there.
Now we need to create a table with some fields. Let’s start with the TraitInfo table (enter these one line at a time, without the ...>
):
sqlite> CREATE TABLE TraitInfo (Numbers integer primary key,
...> OriginalID text,
...> FinalID text,
...> OriginalTraitName text,
...> OriginalTraitDef text,
...> Replicates integer,
...> Habitat integer,
...> Climate text,
...> Location text,
...> LocationType text,
...> LocationDate text,
...> CoordinateType text,
...> Latitude integer,
...> Longitude integer);
Note that I am writing all SQL commands in upper case, but it is not necessary. I am using upper case here because SQL syntax is long and clunky, and it quickly becomes hard to spot (and edit) commands in long strings of complex queries.
Now let’s import the dataset:
sqlite> .mode csv
sqlite> .import TraitInfo.csv TraitInfo
So we built a table and imported a csv file into it. Now we can ask SQLite to show all the tables we currently have:
sqlite> .tables
Let’s run our first Query (note that you need a semicolon to end a command):
sqlite> SELECT * FROM TraitInfo LIMIT 5;
Let’s turn on some nicer formatting:
sqlite> .mode column
sqlite> .header ON
sqlite> SELECT * FROM TraitInfo LIMIT 5;
You should see something like:
Numbers OriginalID FinalID OriginalTraitName ...
------- ---------- ---------- ------------------------- ...
1 1 MTD1 Resource Consumption Rate ...
4 2 MTD2 Resource Consumption Rate ...
6 3 MTD3 Resource Consumption Rate ...
9 4 MTD4 Resource Mass Consumption ...
12 5 MTD5 Resource Mass Consumption ...
The main statement to select records from a table is
SELECT
:
sqlite> .width 40 ## NOTE: Control the width
sqlite> SELECT DISTINCT OriginalTraitName FROM TraitInfo; # Returns unique values
Which gives:
OriginalTraitName
----------------------------------------
Resource Consumption Rate
Resource Mass Consumption Rate
Mass-Specific Mass Consumption Rate
Voluntary Body Velocity
Forward Attack Distance
Foraging Velocity
Resource Reaction Distance
....
Now try these:
sqlite> SELECT DISTINCT Habitat FROM TraitInfo
...> WHERE OriginalTraitName = "Resource Consumption Rate"; # Sets a condition`
Habitat
----------------------------------------
freshwater
marine
terrestrial
sqlite> SELECT COUNT (*) FROM TraitInfo; # Returns number of rows
Count (*)
--------------------
2336
sqlite> SELECT Habitat, COUNT(OriginalTraitName) # Returns number of rows for each group
...> FROM TraitInfo GROUP BY Habitat;
Habitat COUNT(OriginalTraitName)
---------- ------------------------
NA 16
freshwater 609
marine 909
terrestria 802
sqlite> SELECT COUNT(DISTINCT OriginalTraitName) # Returns number of unique values
...> FROM TraitInfo;
COUNT(DISTINCT OriginalTraitName)
---------------------------------
220
sqlite> SELECT COUNT(DISTINCT OriginalTraitName) TraitCount # Assigns alias to the variable
...> FROM TraitInfo;
TraitCount
----------
sqlite> SELECT Habitat,
...> COUNT(DISTINCT OriginalTraitName) AS TN
...> FROM TraitInfo GROUP BY Habitat;
Habitat TN
---------- ----------
NA 7
freshwater 82
marine 95
terrestria 96
sqlite> SELECT * # WHAT TO SELECT
...> FROM TraitInfo # FROM WHERE
...> WHERE Habitat = "marine" # CONDITIONS
...> AND OriginalTraitName = "Resource Consumption Rate";
Numbers OriginalID FinalID OriginalTraitName ...
---------- ---------- ---------- ------------------------- ...
778 308 MTD99 Resource Consumption Rate ...
798 310 MTD101 Resource Consumption Rate ...
806 311 MTD102 Resource Consumption Rate ...
993 351 MTD113 Resource Consumption Rate ...
The structure of the SELECT
command is as follows (Note: all characters are case insensitive):
SELECT [DISTINCT] field
FROM table
WHERE predicate
GROUP BY field
HAVING predicate
ORDER BY field
LIMIT number
;
Let’s try some more elaborate queries:
sqlite> SELECT Numbers FROM TraitInfo LIMIT 5;
Numbers
----------
1
4
6
9
12
sqlite> SELECT Numbers
...> FROM TraitInfo
...> WHERE Numbers > 100
...> AND Numbers < 200;
Numbers
----------
107
110
112
115
sqlite> SELECT Numbers
...> FROM TraitInfo
...> WHERE Habitat = "freshwater"
...> AND Number > 700
...> AND Number < 800;
Numbers
----------
704
708
712
716
720
725
730
735
740
744
748
You can also match records using something like regular expressions. In SQL, when we use the command LIKE
, the percent % symbol matches any sequence of zero or more characters and the underscore matches any single character. Similarly, GLOB
uses the asterisk and the underscore.
sqlite> SELECT DISTINCT OriginalTraitName
...> FROM TraitInfo
...> WHERE OriginalTraitName LIKE "_esource Consumption Rate";
OriginalTraitName
-------------------------
Resource Consumption Rate
sqlite> SELECT DISTINCT OriginalTraitName
...> FROM TraitInfo
...> WHERE OriginalTraitName LIKE "Resource%";
OriginalTraitName
----------------------------------------
Resource Consumption Rate
Resource Mass Consumption Rate
Resource Reaction Distance
Resource Habitat Encounter Rate
Resource Consumption Probability
Resource Mobility Selection
Resource Size Selection
Resource Size Capture Intent Acceptance
Resource Encounter Rate
Resource Escape Response Probability
sqlite> SELECT DISTINCT OriginalTraitName
...> FROM TraitInfo
...> WHERE OriginalTraitName GLOB "Resource*";
OriginalTraitName
----------------------------------------
Resource Consumption Rate
Resource Mass Consumption Rate
Resource Reaction Distance
Resource Habitat Encounter Rate
Resource Consumption Probability
Resource Mobility Selection
Resource Size Selection
Resource Size Capture Intent Acceptance
Resource Encounter Rate
Resource Escape Response Probability
# NOTE THAT GLOB IS CASE SENSITIVE, WHILE LIKE IS NOT
sqlite> SELECT DISTINCT OriginalTraitName
...> FROM TraitInfo
...> WHERE OriginalTraitName LIKE "resource%";
OriginalTraitName
----------------------------------------
Resource Consumption Rate
Resource Mass Consumption Rate
Resource Reaction Distance
Resource Habitat Encounter Rate
Resource Consumption Probability
Resource Mobility Selection
Resource Size Selection
Resource Size Capture Intent Acceptance
Resource Encounter Rate
Resource Escape Response Probability
We can also order by any column:
sqlite> SELECT OriginalTraitName, Habitat FROM
...> TraitInfo LIMIT 5;
OriginalTraitName Habitat
------------------------- ----------
Resource Consumption Rate freshwater
Resource Consumption Rate freshwater
Resource Consumption Rate freshwater
Resource Mass Consumption freshwater
Resource Mass Consumption freshwater
sqlite> SELECT OriginalTraitName, Habitat FROM
...> TraitInfo ORDER BY OriginalTraitName LIMIT 5;
OriginalTraitName Habitat
-------------------------- ----------
48-hr Hatching Probability marine
Asexual Reproduction Rate marine
Attack Body Acceleration marine
Attack Body Velocity marine
Attack Body Velocity marine
Until now we have just queried data from one single table, but as we have seen, the point of storing a database in SQL is that we can use multiple tables minimizing redundancies within them. And of course, querying data from those different tables at the same time will be necessary at some point.
Let’s import then one more table to our database:
sqlite> CREATE TABLE Consumer (Numbers integer primary key,
...> OriginalID text,
...> FinalID text,
...> Consumer text,
...> ConCommon text,
...> ConKingdom text,
...> ConPhylum text,
...> ConClass text,
...> ConOrder text,
...> ConFamily text,
...> ConGenus text,
...> ConSpecies text);
sqlite> .import Consumer.csv Consumer
Now we have two tables in our database:
sqlite> .tables
Consumer TraitInfo
These tables are connected by two different keys: OriginalID
and FinalID
. These are unique IDs for each thermal curve. For each FinalID
we can get the trait name (OriginalTraitName
) from the TraitInfo
table and the corresponding species name (ConSpecies
) from the Consumer
table.
sqlite> SELECT A1.FinalID, A1.Consumer, A2.FinalID, A2.OriginalTraitName
...> FROM Consumer A1, TraitInfo A2
...> WHERE A1.FinalID=A2.FinalID LIMIT 8;
FinalID Consumer FinalID OriginalTraitName
---------- --------------------- ---------- -------------------------
MTD1 Chaoborus trivittatus MTD1 Resource Consumption Rate
MTD2 Chaoborus trivittatus MTD2 Resource Consumption Rate
MTD3 Chaoborus americanus MTD3 Resource Consumption Rate
MTD4 Stizostedion vitreum MTD4 Resource Mass Consumption
MTD5 Macrobrachium rosenbe MTD5 Resource Mass Consumption
MTD6 Ranatra dispar MTD6 Resource Consumption Rate
MTD7 Ceriodaphnia reticula MTD7 Mass-Specific Mass Consum
MTD8 Polyphemus pediculus MTD8 Voluntary Body Velocity
# In the same way we assign alias to variables, we can use them for tables.
This example seems easy because both tables have the same number of rows. But the query is still as simple when we have tables with different rows.
Let’s import the TCP table:
sqlite> CREATE TABLE TCP (Numbers integer primary key,
...> OriginalID text,
...> FinalID text,
...> OriginalTraitValue integer,
...> OriginalTraitUnit text,
...> LabGrowthTemp integer,
...> LabGrowthTempUnit text,
...> ConTemp integer,
...> ConTempUnit text,
...> ConTempMethod text,
...> ConAcc text,
...> ConAccTemp integer);
sqlite> .import TCP.csv TCP
sqlite> .tables
Consumer TCP TraitInfo
Now imagine we want to query the thermal performance curves that we have stored for the species Mytilus edulis. Using the FinalID to match the tables, the query can be as simple as:
sqlite> CREATE TABLE TCP (Numbers integer primary key,
...> OriginalID text,
...> FinalID text,
...> OriginalTraitValue integer,
...> OriginalTraitUnit text,
...> LabGrowthTemp integer,
...> LabGrowthTempUnit text,
...> ConTemp integer,
...> ConTempUnit text,
...> ConTempMethod text,
...> ConAcc text,
...> ConAccTemp integer);
sqlite> .import TCP.csv TCP
sqlite> .tables
Consumer TCP TraitInfo
sqlite> SELECT A1.ConTemp, A1.OriginalTraitValue, A2.OriginalTraitName, A3.Consumer
...> FROM TCP A1, TraitInfo A2, Consumer A3
...> WHERE A1.FinalID=A2.FinalID AND A3.ConSpecies="Mytilus edulis" AND A3.FinalID=A2.FinalID LIMIT 8
ConTemp OriginalTraitValue OriginalTraitName Consumer
---------- -------------------- ------------------------------ --------------------
25 2.707075 Filtration Rate Mytilus edulis
20 3.40721 Filtration Rate Mytilus edulis
5 3.419455 Filtration Rate Mytilus edulis
15 3.711165 Filtration Rate Mytilus edulis
10 3.875465 Filtration Rate Mytilus edulis
5 0.34 In Vitro Gill Particle Transpo Mytilus edulis
10 0.46 In Vitro Gill Particle Transpo Mytilus edulis
15 0.595 In Vitro Gill Particle Transpo Mytilus edulis
So on and so forth (joining tables etc. would come next…). But if you want to keep practicing and learn more about sqlite commands, this is a very useful site: http://www.sqlite.org/sessions/sqlite.html. You can
store your queries and database management commands in an .sql
file (geany
will take care of syntax highlighting etc.)
SQLite with Python#
It is easy to access, update and manage SQLite databases with Python (you will find this script file in the code
directory):
import sqlite3
conn = sqlite3.connect(":memory:")
c = conn.cursor()
c.execute("CREATE TABLE tt (Val TEXT)")
conn.commit()
z = [('a',), ('ab',), ('abc',), ('b',), ('c',)]
c.executemany("INSERT INTO tt VALUES (?)", z)
conn.commit()
c.execute("SELECT * FROM tt WHERE Val LIKE 'a%'").fetchall()
conn.close()
You can create a database in memory, without using the disk — thus you can create and discard an SQLite database within your workflow!
Readings and Resources#
“The Definitive Guide to SQLite” is a pretty complete guide to SQLite and freely available from here
For databses in general, try the Stanford Introduction to Databases course
A set of sqlite tutorials in Jupyter: https://github.com/royalosyin/Practice-SQL-with-SQLite-and-Jupyter-Notebook


Trying out a different flavor of unit testing on a similar patch of code to what I wrote yesterday. Practice, practice, practice.
3/18/2009, 9:29:36 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Trying out a different flavor of unit testing on a similar patch of code to what I wrote yesterday. Practice, practice, practice.
3/18/2009, 9:29:36 AM
Favs: 0
Retweets: 0
link


Sun TV Network Standalone September 2019 Net Sales at Rs 795.58 crore, up 6.14% Y-o-Y
Reported Standalone quarterly numbers for Sun TV Network are:
Net Sales at Rs 795.58 crore in September 2019 up 6.14% from Rs. 749.55 crore in September 2018.
Quarterly Net Profit at Rs. 366.51 crore in September 2019 up 4.32% from Rs. 351.32 crore in September 2018.
EBITDA stands at Rs. 540.88 crore in September 2019 down 12.21% from Rs. 616.09 crore in September 2018.
Sun TV Network EPS has increased to Rs. 9.30 in September 2019 from Rs. 8.91 in September 2018.
Sun TV Network shares closed at 529.15 on November 11, 2019 (NSE) and has given -1.21% returns over the last 6 months and -14.38% over the last 12 months.
| Sun TV Network | |
| Standalone Quarterly Results | in Rs. Cr. |
| Sep'19 | Jun'19 | Sep'18 | |
| Net Sales/Income from operations | 795.58 | 1,101.36 | 749.55 |
| Other Operating Income | -- | -- | -- |
| Total Income From Operations | 795.58 | 1,101.36 | 749.55 |
| EXPENDITURE | |||
| Consumption of Raw Materials | -- | -- | -- |
| Purchase of Traded Goods | -- | -- | -- |
| Increase/Decrease in Stocks | -- | -- | -- |
| Power & Fuel | -- | -- | -- |
| Employees Cost | 74.84 | 73.49 | 73.47 |
| Depreciation | 144.41 | 158.46 | 81.89 |
| Excise Duty | -- | -- | -- |
| Admin. And Selling Expenses | -- | -- | -- |
| R & D Expenses | -- | -- | -- |
| Provisions And Contingencies | -- | -- | -- |
| Exp. Capitalised | -- | -- | -- |
| Other Expenses | 252.00 | 344.96 | 122.11 |
| P/L Before Other Inc. , Int., Excpt. Items & Tax | 324.33 | 524.45 | 472.08 |
| Other Income | 72.14 | 56.71 | 62.12 |
| P/L Before Int., Excpt. Items & Tax | 396.47 | 581.16 | 534.20 |
| Interest | 1.98 | 2.08 | 0.57 |
| P/L Before Exceptional Items & Tax | 394.49 | 579.08 | 533.63 |
| Exceptional Items | -- | -- | -- |
| P/L Before Tax | 394.49 | 579.08 | 533.63 |
| Tax | 27.98 | 197.21 | 182.31 |
| P/L After Tax from Ordinary Activities | 366.51 | 381.87 | 351.32 |
| Prior Year Adjustments | -- | -- | -- |
| Extra Ordinary Items | -- | -- | -- |
| Net Profit/(Loss) For the Period | 366.51 | 381.87 | 351.32 |
| Equity Share Capital | 197.04 | 197.04 | 197.04 |
| Reserves Excluding Revaluation Reserves | -- | -- | -- |
| Equity Dividend Rate (%) | -- | -- | -- |
| EPS Before Extra Ordinary | |||
| Basic EPS | 9.30 | 9.69 | 8.91 |
| Diluted EPS | 9.30 | 9.69 | 8.91 |
| EPS After Extra Ordinary | |||
| Basic EPS | 9.30 | 9.69 | 8.91 |
| Diluted EPS | 9.30 | 9.69 | 8.91 |
| Public Share Holding | |||
| No Of Shares (Crores) | -- | -- | -- |
| Share Holding (%) | -- | -- | -- |
| Promoters and Promoter Group Shareholding | |||
| a) Pledged/Encumbered | |||
| - Number of shares (Crores) | -- | -- | -- |
| - Per. of shares (as a % of the total sh. of prom. and promoter group) | -- | -- | -- |
| - Per. of shares (as a % of the total Share Cap. of the company) | -- | -- | -- |
| b) Non-encumbered | |||
| - Number of shares (Crores) | -- | -- | -- |
| - Per. of shares (as a % of the total sh. of prom. and promoter group) | -- | -- | -- |
| - Per. of shares (as a % of the total Share Cap. of the company) | -- | -- | -- |
| Source : Dion Global Solutions Limited |


\usepackage[vmargin=1in,hmargin=1in]{geometry}
| Function name | What it does | Source |
|---|---|---|
| classification | Upstream classification | Various |
| col_children | Direct children | Catalogue of Life |
| col_downstream | Downstream taxa to specified rank | Catalogue of Life |
| eol_hierarchy | Upstream classification | Encyclopedia of Life |
| eol_search | Search EOL taxon information | Encyclopedia of Life |
| ncbi_search | Get NCBI sequences | National Center for Biotechnology Information |
| get_ids | Get taxonomic identifiers | Five sources |
| comm2sci | Get scientific from common names | EOL, NCBI, ITIS, Tropicos |
| sci2comm | Get common from scientific names | EOL, NCBI, ITIS |
| gisd_isinvasive | Invasiveness status | Global Invasive Species Database |
| gni_parse | Parse scientific names into components | Global Names Index |
| gni_search | Search EOL's global names index | Global Names Index |
| gnr_resolve | Resolve names using EOL's global names index | Global Names Resolver |
| itis_downstream | Downstream taxa to specified rank | Integrated Taxonomic Information System |
| iucn_summary | Get IUCN status for a species | IUCN Red List |
| phylomatic_tree | Get a plant Phylogeny | Phylomatic |
| plantminer | Search Plantminer | Plantminer |
| tax_name | Get taxonomic name for specific rank | Various |
| tax_rank | Get rank of a taxonomic name | Various |
| tnrs | Resolve names using Taxosaurus/iPlant | Taxosaurus Taxonomic Name Resolution Service |
| tp_accnames | Check for accepted names using Tropicos | Tropicos |
| ubio_namebank | Search uBio | uBio |


{% assign speakers = "" | split: "" %} {% assign years = include.years | split: ',' %} {% for year in years %} {% for speaker in site.data.speakers[year].speakers %} {% assign speakers = speakers | push: speaker %} {% endfor %} {% endfor %}
Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum
We are always on the look for new, gifted speakers. Apply to speak at DEVit and become part of our cozy little family.
Apply to speak


--- layout: post tags: [Productivity, Unit Testing] date: 2009-03-03 20:01:29 UTC title: "Derived Values Ensure Executable Specification" description: "In unit tests, derived values can make the relationship between test input and expected outcome more explicit." --- {% include JB/setup %}
In this Zero-Friction TDD post, I'd like to take a detour around the concept of tests as Executable Specification.
An important aspect of test maintainability is readability. Tests should act both as Executable Specification as well as documentation, which puts a lot of responsibility on the test.
One facet of test readability is to make the relationship between the Fixture, the SUT and the verification as easy to understand as possible. In other words, it should be clear to the Test Reader what is being asserted, and why.
Consider a test like this one:
[TestMethod] public void InvertWillReverseText_Naïve() { // Fixture setup MyClass sut = new MyClass(); // Exercise system string result = sut.Invert("ploeh"); // Verify outcome Assert.AreEqual<string>("heolp", result, "DoWork"); // Teardown }
Since this test is so simple, I expect that you can easily figure out that it implies that the Invert method should simply reverse its input argument, but one of the reasons this seems to be evident is because of the proximity of the two strings, as well as the test's name.
In a test of a more complex API, this may not be quite as evident.
[TestMethod] public void DoItWillReturnCorrectResult_Naïve() { // Fixture setup MyClass sut = new MyClass(); // Exercise system int result = sut.DoIt("ploeh"); // Verify outcome Assert.AreEqual<int>(42, result, "DoIt"); // Teardown }
In this test, there's no apparent relationship between the input (ploeh) and the output (42). Whatever the algorithm is behind the DoIt method, it's completely opaque to the Test Reader, and the test fails in its role as specification and documentation.
Returning to the first example, it would be better if the relationship between input and output was explicitly described:
[TestMethod] public void InvertWillReverseText() { // Fixture setup string anonymousText = "ploeh"; string expectedResult = new string(anonymousText.Reverse().ToArray()); MyClass sut = new MyClass(); // Exercise system string result = sut.Invert(anonymousText); // Verify outcome Assert.AreEqual<string>(expectedResult, result, "DoWork"); // Teardown }
In this case, the input and expected outcome are clearly related, and we call the expectedResult variable a Derived Value, since we explicitly derive the expected result from the input.
Note that I'm not asking you to re-implement the whole algorithm in the test, but only to establish a relationship. One of the main rules of thumb of unit testing is that a test should never contain conditional branches, so there must be at least one test case per path though the SUT.
In the example, the Invert method actually looks like this:
public string Invert(string message) { double d; if (double.TryParse(message, out d)) { return (1d / d).ToString(); } return new string(message.Reverse().ToArray()); }
Note that the above test only reproduces that part of the algorithm that corresponds to the Equivalence Class defined by the input, whereas the branch that is triggered by a number string can be tested by another test case that doesn't specify string reversion.
[TestMethod] public void InvertWillInvertNumber() { // Fixture setup double anonymousNumber = 10; string numberText = anonymousNumber.ToString(); string expectedResult = (1d / anonymousNumber).ToString(); MyClass sut = new MyClass(); // Exercise system string result = sut.Invert(numberText); // Verify outcome Assert.AreEqual<string>(expectedResult, result, "DoWork"); // Teardown }
In this way, we can break down the test cases to individual Executable Specifications that define the expected behavior for each Equivalence Class.
While such tests more clearly provide both specification and documentation, it requires discipline to write tests in this way. Particularly when the algorithm is so simple as is the case here, it's very tempting to just hard-code the values directly into the assertion.
In a future post, I'll explain how we can force ourselves to do the right thing per default.


When ice cream came at restaurant tonight, Cora belted out repeated verses of HAP BIRDAY COWA and asked for party hat. Ah to be two again.
5/7/2010, 10:20:50 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
When ice cream came at restaurant tonight, Cora belted out repeated verses of HAP BIRDAY COWA and asked for party hat. Ah to be two again.
5/7/2010, 10:20:50 PM
Favs: 0
Retweets: 0
link


Preparation time
over 2 hours
Cooking time
10 to 30 mins
Serves
Makes 12 pittas
Dietary
Speckled with oniony nigella seeds, this gluten-free flatbread is great with dips such as hummus and taramasalata or to wrap falafel or kebab. A handy recipe to have in your repertoire.
Mix the psyllium powder with 300ml/10fl oz water. Set aside to allow the mixture to thicken.
Tip the flour and nigella seeds into a mixing bowl. Add the sugar and salt to one side of the bowl and the yeast to the other. Crack the eggs into the centre of the flour, add the vinegar, olive oil and the psyllium mixture. Combine the ingredients to form a soft dough. Gradually add about 300ml/10fl oz water - you may not need it all, although the dough should be soft and slightly sticky.
Place onto a floured surface and knead to form a smooth dough. Place back in the bowl, cover and leave to rest for 1½ hours, or until doubled in size.
Heat the oven to 220C/200C Fan/Gas 9 and place 3 heavy baking trays in the oven to heat up.
Dust your work surface with flour. Divide the dough into 12 equal pieces and shape each one into a ball. Roll or press the pieces into oval shapes about 4mm thick.
Remove the baking tray from the oven and dust with a little flour. Lay four pittas on each tray and bake for 10-12 minutes, or until puffed up and cooked through. The pittas should have a slight colour to them. Remove from the oven and wrap in a clean tea towel - this helps keeps them soft.


Tundo, Chager renew rivalry in Eldoret Rally
by Capital SportNAIROBI, Kenya, Nov 18 – Champion Carl Flash Tundo is expecting a tough battle from current log leader Baldev Chager in the eighth round of the Kenya National Rally Championship (KNRC) to go down Saturday, November 23 in Eldoret.
‘I’m still in the hunt for the Championship and looking forward to yet another great fight with Baldev,” Tundo, who finished second in Meru earlier in the month said.
The KNRC title race is now a two horse race following Manvir Baryan’s accident in Meru.
Manvir was hospitalised for four days at Aga Khan following a high-speed roll in his Skoda Fabia R5.
“We still lead the Championship after Meru, so that’s obviously the main focus. We have two two more events to go and we need to see what best to do,” said Chager, adding: “Manvir was also in contention but unfortunately had an accident in Meru so it’s up to to me and Flash Tundo.”
Chager and Flash Tundo will also fight for the top spot with Meru winner Onkar Rai who gave the VW Polo R5 it’s maiden finish and win after two failed attempts in Mombasa and Nanyuki. Onkar is however out of contention after a member of retirements.
“I expect Chager to be as competitive as ever given the status of the Championship. We ended up in second position in Meru and we were very happy about that, so two more rallies and let’s see how it goes,,” said Flash Tundo who has one one win this season in Nanyuki.
Chager has two wins under his belt in Kajiado and, Safari and is aiming for his third in Eldoret.
Manvir won Mombasa Rally while Onkar has two in Nakuru and Meru.
The KCB Eldoret Rally will be flagged off at the KCB Kenyatta Street branch on Saturday November 23 after which the crews will tackle a 24.25km transport road section through to the 18.40km Kaptagat opening stage and into first Service at Iten.
Three stages Kaptagat, Bugar (16.50km) and Salabin (37.70km) will be repeated twice to make up a competitive mileage of 145.20km which amounts to 46 percent mileage total.
The transport road section totals to 168.72km. The Service Park will be visited thrice.
KNRC OVERALL
1 Baldev Chager 141
2 Carl Tundo 117
3 Manvir Baryan 91
4 Tejveer Rai 63
5 Onkar Rai 50
6 Ian Duncan 38
7 Izhar Mirza 33
7 Ammar Haq 33
9 Jasmeet Chana 29
10 Sohanjeet Puee 25
10 Karan Patel 25
KNRC DIVISION ONE
Amaar Haq 104
2 Karan Patel 97
3 Sohanjeet Puee 78
KNRC DIVISION TWO
Issa Amwari 107
2 Minesh Rathod 88
3 Daren Miranda 69
KNRC DIVISION THREE
1 Geoff Mayes 57
2 McRae Kimathi 48
3 Hussien Malik 38
(Visited 23 times, 23 visits today)


| Name: SMT.MEENA | Reg No: 9-10SMHC17 |
|---|---|
| Age / Sex:41/F | Contact No:8762689735 |
| Marital Status:ML-17 YEARS | Date:30/10/17 |
| Occupation:ASOCIATE PROF NIMHANS | Dr. PJFP |
| Address: | DIAGNOSIS- |
K/C/O HYPOTHYROIDISM: DURING PREGNANCY ROUTINE TEST DAIGNOSED. 2009.
FRM COLLEGE DAYS USE TO HAVE INTOLRANCE TO COLD AND FATIGABILITY.
AUG 5TH THEN OCT 18TH GOT HER PERIOD. SMTIME IN JUNE HAD A PERIOD FOR A MOHT. EXHAUSTION.
FROM 3 MONTHS CONT SNEEZING AND NB. TIREDNESS,
NOW SNEEZING HAS STOPPED AND FEELING BREATHLESSNESS, THERE IS A DNS.
<NAVRATNA
MIGRAINE FROM 2 YEARS. INC FRM A WEEK TIME. FRM
L: FLUCTUATING AREAS
M: < BENDING HEAD FORWARDS,
>PRESS, APPLY AMRUTANJAN, SLEEP
S: HAMMERING TYPE
C: NAUSEA, SICK FEELING IN STMACH(DEPRESSED BCOZ OF THIS PAIN).
BETTER LYING ON THE PAINFUL SIDE.
STAYING FRM 2013 IN QUARTERS.
DOESN’T KNOW HOW TO SETTLE HER ISSUES. CONFLICTS WITH MIL
PAST H/O:
FEELS EXHAUSTED AND DISCARDED, CRIES WHEN NARRATING, FEELING LIKE A 65 YEAR OLD LADY.
BECOZ OF PERSISTENT PAIN DOES MEDITATION AND ALL.BT NO HELP.
DREAMS: NA
PATCH UP FAST DOESN’T LIKE TO HAVE UNPLEASANT FEELING.

PREFERS RICE RASAM.
RX:
CARC 1M – 1 DOSE
IGNATIA 200 – 5 DOSES
BELL+BRYONIA 200 – 4 PILLS SOS.
FERR PHOS 30 – DISC
C.VEG 30 – 4 PILLS SOS


AdobeImageEditorContext Class Reference
| Inherits from | NSObject |
| Declared in | AdobeImageEditorContext.h |
Overview
Photo Editor Contexts are generated by calling the createContextWithImage: or createContextWithImage:maxSize: methods of AFAdobeImageEditorSession. A context encapsulates an input image and an output size. If not specified, the output size defaults to the image size. In the standard Aviary version of this SDK, there was a 3 megapixel size limit on high resolution output. This is no longer the case in the Creative SDK, so all high resolution output will default to the full image size.
Calling render: on a context causes all modifications tracked in the
AdobeImageEditorSession (which tracks user generated photo-editing actions
in an AdobeUXImageEditorViewController) to be replayed on the context’s
input image asynchronously. When rendering is complete, the completion
block passed into render: will be called with the finalized image, whose
size will match the context’s size. If the session contains no tracked
actions (i.e., the user made no edits before pressing “Done” or pressed
“Cancel”), the result image will be nil
. Note: render: may only be
called once per context.
Some things to note about using contexts:
We recommend choosing a maximum output resolution that suits the purposes of your application to provide the best experience for your users.
Processing large images can consume a lot of memory and time. It may be necessary to free up resources and/or display an activity indicator while a context is executing.
To calculate the approximate maximum amount of memory a context could use, multiply the dimensions of the output size and multiply the result by 4. For example, a context with a maximum output size of 1500x1500 will consume approximately 9mb of memory for the processing duration.
Tasks
Compatibility Methods
-
session
property -
size
property -
canceled
property -
modified
property -
progressHandler
property -
hasBegunRendering
property -
– render:
-
– cancelRendering
Properties
canceled
Specifies if the context’s rendering has been cancelled.
@property (nonatomic, assign, readonly, getter=isCanceled) BOOL canceled
Discussion
Specifies if the context’s rendering has been cancelled.
Declared In
AdobeImageEditorContext.h
hasBegunRendering
Specifies whether rendering has begun on the context.
@property (nonatomic, assign, readonly) BOOL hasBegunRendering
Discussion
Specifies whether rendering has begun on the context.
If YES, any render: call will have no effect.
Declared In
AdobeImageEditorContext.h
modified
Specifies if the context’s session has been modified.
@property (nonatomic, assign, readonly, getter=isModified) BOOL modified
Discussion
Specifies if the context’s session has been modified.
Declared In
AdobeImageEditorContext.h
progressHandler
The progress handler is called with an estimate of how far along in completing the render the context is. The handler is guaranteed to be called on the main thread.
@property (nonatomic, copy, nullable) void ( ^ ) ( CGFloat ) progressHandler
Parameters
- progressHandler
The block to be called with progress updates.
Discussion
The progress handler is called with an estimate of how far along in completing the render the context is. The handler is guaranteed to be called on the main thread.
Declared In
AdobeImageEditorContext.h
Instance Methods
cancelRendering
Cancels the context’s rendering.
- (void)cancelRendering
Discussion
Cancels the context’s rendering.
Warning: Calling this method from any thread other in the main thread may result in undefined behavior.
Declared In
AdobeImageEditorContext.h
render:
Replays all actions tracked by the generating AdobeImageEditorSession on the context’s image.
- (void)render:(void ( ^ ) ( UIImage *__nullable result ))completion
Parameters
- completion
The block to be called when the image’s render is complete.
Discussion
Replays all actions tracked by the generating AdobeImageEditorSession on the context’s image.
The completion block will not be called until after the session
is
closed, i.e. until the user has closed the
AdobeUXImageEditorViewController that generated the session
. If the
user pressed “Cancel” or took no actions before pressing “Done”, the
result
UImage in the completion block will be nil. Otherwise, it will
contain the rendered image. The context will try to render the image
on the GPU, but it will fall back to the CPU if necessary. See the
discussion in AdobeImageEditorContext for more details.
Note: This method may be called once per context, as it would not make sense to run the same actions on the same image twice. Check hasBegunRendering to see if render has been called.
Warning: Calling this method from any thread other in the main thread may result in undefined behavior.
Declared In
AdobeImageEditorContext.h


Clojure Specs
Here you can find a formal definition for the query syntax, expressed as Clojure Specs.
(s/def ::property keyword?)
(s/def ::special-property #{'*})
(s/def ::ident-value (s/with-gen any? (default-gen ::gen-ident-value)))
(s/def ::ident (s/with-gen (s/tuple ::property ::ident-value) (default-gen ::gen-ident)))
(s/def ::join-key (s/or :prop ::property, :ident ::ident, :param-exp ::join-key-param-expr))
(s/def ::join (s/map-of ::join-key ::join-query, :count 1, :conform-keys true))
(s/def ::union (s/map-of ::property ::query, :min-count 1, :conform-keys true))
(s/def ::recursion-depth (s/with-gen nat-int? (default-gen ::gen-depth)))
(s/def ::recursion (s/or :depth ::recursion-depth, :unbounded #{'...}))
(s/def ::join-query
(s/with-gen
(s/or :query ::query
:union ::union
:recursion ::recursion)
(default-gen ::gen-join-query)))
(s/def ::params
(s/with-gen map? (default-gen ::gen-params)))
(s/def ::param-expr-key
(s/with-gen
(s/or :prop ::property
:join ::join
:ident ::ident)
(default-gen ::gen-param-expr-key)))
(s/def ::param-expr
(s/with-gen
(s/and seq? (s/cat :expr ::param-expr-key :params (s/? ::params)))
(default-gen ::gen-param-expr)))
(s/def ::join-key-param-key (s/or :prop ::property :ident ::ident))
(s/def ::join-key-param-expr
(s/with-gen
(s/and seq? (s/cat :expr ::join-key-param-key :params (s/? ::params)))
(default-gen ::gen-join-key-param-expr)))
(s/def ::mutation-key (s/with-gen symbol? (default-gen ::gen-mutation-key)))
(s/def ::mutation-expr
(s/with-gen
(s/and seq? (s/cat :mutate-key ::mutation-key :params (s/? ::params)))
(default-gen ::gen-mutation-expr)))
(s/def ::mutation-join
(s/map-of ::mutation-expr ::query :count 1 :conform-keys true))
(s/def ::mutation
(s/or :mutation ::mutation-expr
:mutation-join ::mutation-join))
(s/def ::query-expr
(s/or :prop ::property
:join ::join
:ident ::ident
:mutation ::mutation
:param-exp ::param-expr
:special ::special-property))
(s/def ::query
(s/coll-of ::query-expr :kind vector? :gen (default-gen ::gen-query)))


Meet Smart Kx - the only client contract manager and billing solution designed for RIAs.
This revolutionary technology provides an integrated solution for Registered Investment Advisors that delivers fee accuracy, and clearly defines your firm’s recurring revenue.
By using Smart Kx technology, Registered Investment Advisors will:
Investment fee calculation can be a costly, inefficient, and daunting process, which limits fee calculation methods. With Smart Kx, your fees become part of a system that is programmable to any billing structure needed - simple or complex. The Smart Kx interface uses the legal contract to code the fee calculator, thereby eliminating the possibility of error. Fee calculations are indisputable and fully accessible in real time - at any time - with just a few clicks. Current billing solutions for RIA’s may generate impressive reports, but they do not provide contract fee accuracy assurance – thus leaving your firm’s revenue subject to error, costly scrutiny, and compliance risk. Finally, advisory fee review and quarterly billing constraints are a thing of the past.
The Smart Kx service eliminates potential billing inconsistencies by providing a seamless fee calculation system based on the terms of the contract. With Smart Kx, the legal contract between the firm and client acts as a robust, dynamic, and autonomous calculator. Smart Kx ensures the contract and the fee are both exactly as agreed, which eliminates any need for time-consuming manual calculation and review.
Thanks to Smart Kx, your RIA firm’s revenues are protected, completely transparent, and proven on an immutable ledger. Smart Kx delivers peace of mind for RIA’s, regulators, AND clients by:
Registered Investment Advisors’ fee compliance has never been easier, and your advisory fees and expense compliance are finally assured. If you’re ready for a system that guarantees fee transparency, accuracy, and peace of mind.


View Highscores
Time: 75
The quiz will begin once the start button is clicked. You will have 75 seconds to complete the quiz. Questions that are answered incorrectly will result in the time being reduced. When questions are answered correctly, the time it took to answer question will be recorded. Your total time will be displayed at the end of the quiz.
p Text


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
This delicious recipe is healthy and low fat without compromising on flavour.
Each serving provides 141kcal, 20g protein, 3.5g carbohydrate (of which 3g sugars), 5g fat (of which 0.8g saturates), 0.3g fibre and 3.6g salt.
Pat the fish dry with kitchen paper and evenly rub with salt, rubbing it inside the cavity as well if you are using a whole fish. Put the fish on a heatproof plate and scatter the ginger over the top.
Set up a steamer or put a rack into a wok or deep pan. Fill it with 5cm/2in of water and bring to the boil over a high heat.
Put the plate of fish on the rack, cover tightly and steam the fish until it is just cooked. Flat fish fillets will take about 5 minutes; whole fish, or fillets such as sea bass, will take 12-14 minutes. The fish should turn opaque and flake slightly but still remain moist.
Remove the plate of cooked fish and pour off any liquid that may have accumulated. Scatter the spring onions on the fish, then drizzle over the light and dark soy sauces.
Heat the two oils together in a small saucepan until smoking, then immediately pour them over the fish. Garnish with coriander and serve at once with boiled rice.


<palindrom-redirect><link is="puppet-redirect">
Custom Element that redirects to a new URL when an attribute is changed.
It can be configured to work using window location or History API.
See README.md for docs
Redirect using window.location
Open new tab
Redirect using History API (history.pushState
)
Watch console entries for events logging


With my roots,
Dug deep into the earth
I see others past me,
To reap what they sow.
Birds fly away,
To sing a song,
Of their melancholy.
Under my shades lies,
An unknown travesty.
The change of seasons ,
Tearing the veins inside me.
As the leaves wither .
And soon frost embraces me,
As winter beckons.
Yet hoping for Spring to come over.
The blooming flowers,
Appears bright ,
Through the dark of the night.
Alligned to form a wreath.
The moon casts out its light
Piercing the grey landscape.
Yet these tired boughs reach out,
For the moon.
As the sharp winds blow against me ,
The fruits crashes into despair .
Soon there's no fruit to cherish.
The boughs lay contorted and empty,
Yet new leaves grow from the fragments remaining,
When birds greets the day with their song,
Helios showers its rays,
And welcomes the dawn of new life.


serbia
montenegro
croatia
greece
bulgaria
bosina and herzegovina
macedonia
italy
City: Sutomore
State: Montenegro
Price: from 150e / night
City: Premantura
State: Istra
Price: from 45e / night
City: Premantura
State: Istra
Price: from 45e / night
- spa center
apartment
serbia
- village
room
serbia
- seaside
house
serbia
- city
hotel
serbia
- island
luxury villa
serbia
- seaside
apartment
montenegro
- island
room
montenegro
- village
house
montenegro
- spa center
hotel
montenegro
- city
luxury villa
montenegro
- seaside
apartment
croatia
- island
room
croatia
- village
house
croatia
- spa center
hotel
croatia
- city
luxury villa
croatia
- city
apartmani
greece
- spa center
hotel
greece
- village
house
greece
- island
room
greece
- seaside
luxury villa
greece
- seaside
apartment
bulgaria
- island
room
bulgaria
- village
house
bulgaria
- spa center
hotel
bulgaria
- city
luxury villa
bulgaria
- city
apartment
BiH
- spa center
room
BiH
- village
house
BiH
- island
hotel
BiH
- seaside
luxury villa
BiH
- spa center
apartment
macedonia
- village
room
macedonia
- island
house
macedonia
- seaside
hotel
macedonia
- city
luxury villa
macedonia
- village
apartment
italy
- island
room
italy
- seaside
house
italy
- city
hotel
italy
- spa center
luxury villa
italy
- city
apartment
serbia
- spa center
room
macedonia
- island
house
montenegro
- seaside
hotel
italy
- villages
luxury villa
bulgaria


LXCat Data Visualization
Made by Dimitri Aguera and Marc Foletto -
Ginkgo-web
- Fork on
GitHub
Choose one or more input files downloaded from
LXCat
Grid :
Line
Points
Both
X axis :
to
Log
Linear
Y axis :
to
Log
Linear
We use
Plotly
under license
MIT


Talent Block Chain
Sharing the Progress of the Talent Blockchain
One of the goals when starting Redcell was to share as much about the process as possible. The first step towards that goal was publishing a monthly transparency report outlining growth, mistakes, successes, and general thoughts.
This page is the next attempt at sharing even more. It’s fairly basic right now, but we plan to add more numbers here as time goes on. If you or your organization are interested in joining the next cohort, just send an email and let us know.
Weekly Active Users
The following chart shows the number of weekly active users for the blockchain application.
[Coming soon]
Monthly Employment Statistics
The following chart shows the breakdown of employment status of all registered users.
[Coming soon] –>
Monthly Active Listings
The following chart shows the amount of monthly job listings in an open or unfilled status.
[Coming soon]
Total Listings
The following chart shows the breakdown of the total job listings by their current status.
[Coming soon]


Crypto Exchange
Home
Login
Contact
Exchange Rates
Check our current exchange rates:
List of exchange rates
From
To
Rate
Amount
Convert
Register


This is just the bare minimum needed to complete the assignment. Please see index.html for a better example.


PerCuriam
LABORATORY CORPORATION OF AMERICA HOLD-
INGS, dba LABCORP, PETITIONER v. METABO-LITE LABORATORIES, INC., et al.
Per Curiam.
The writ of certiorari is dismissed as improvidently granted.
The Chief Justice took no part in the consideration or decision of this case.
PerCuriam
LABORATORY CORPORATION OF AMERICA HOLD-
INGS, dba LABCORP, PETITIONER v. METABO-LITE LABORATORIES, INC., et al.
Per Curiam.
The writ of certiorari is dismissed as improvidently granted.
The Chief Justice took no part in the consideration or decision of this case.
PerCuriam
LABORATORY CORPORATION OF AMERICA HOLD-
INGS, dba LABCORP, PETITIONER v. METABO-LITE LABORATORIES, INC., et al.
Per Curiam.
The writ of certiorari is dismissed as improvidently granted.
The Chief Justice took no part in the consideration or decision of this case.
PerCuriam
LABORATORY CORPORATION OF AMERICA HOLD-
INGS, dba LABCORP, PETITIONER v. METABO-LITE LABORATORIES, INC., et al.
Per Curiam.
The writ of certiorari is dismissed as improvidently granted.
The Chief Justice took no part in the consideration or decision of this case.
PerCuriam
LABORATORY CORPORATION OF AMERICA HOLD-
INGS, dba LABCORP, PETITIONER v. METABO-LITE LABORATORIES, INC., et al.
Per Curiam.
The writ of certiorari is dismissed as improvidently granted.
The Chief Justice took no part in the consideration or decision of this case.