vignettes/UsingFeatureExtraction.Rmd
UsingFeatureExtraction.Rmd
The FeatureExtraction
package can be used to create
features for a cohort, using the information stored in the Common Data
Model. A cohort is defined a set of persons who satisfy one or more
inclusion criteria for a duration of time. Features can for example be
diagnoses observed prior to entering the cohort. Some people might also
refer to such features as ‘baseline characteristics’, or to features in
general as ‘covariates’, and we will use those terms interchangeably
throughout this vignette.
This vignette describes how features can be constructed using the default covariate definitions embedded in the package. Although these definitions allow quite some customization through predefined parameters, it is possible that someone needs more customization. In this case, the reader is referred to the other vignettes included in this package that deal with constructing completely custom covariates.
This vignette will first describe how to specify which features to
construct. In many situations, for example when using
FeatureExtraction
as part of another package such as
CohortMethod
or PatientLevelPrediction
, that
is all one needs to know about the FeatureExtraction
package, as the actual calling of the package is done by the other
package. However, it is also possible to use this package on its own,
for example to create a descriptive characterization of a cohort to
include in a paper.
Users can specify which covariates to construct in three ways:
An analysis is a process that creates one or more similar covariates. For example, one analysis might create a binary covariate for each condition observed in the condition_occurrence table in the year prior to cohort start, and another analysis might create a single covariate representing the Charlson comorbidity index.
Note that it is always possible to specify a set of concept IDs that can or can’t be used to construct features. When choosing the default set (option 1) or the prespecified analysis (option 2) this can only be done across all analysis. When creating custom analyses (option 3) this can be specified per analysis.
For advanced users: It is also possible to specify a set of covariate IDs that need to be constructed. A covariate ID identifies a specific covariate, for example the Charlson comorbidity index, or the occurrence of a specific condition concept in a specific time window. A covariate ID is therefore not to be confused with a concept ID. The typical scenario where one might want to specify covariate IDs to construct is when someone already constructed covariates in one population, found a subset of covariates to be of interest, and would like to have only those covariates constructed in another population.
Using the default set of covariates is straightforward:
settings <- createDefaultCovariateSettings()
This will create a wide array of features, ranging from demographics, through conditions and drugs, to several risk scores.
Note that we could specify a set of concepts that should not be used to create covariates, for example:
settings <- createDefaultCovariateSettings(
excludedCovariateConceptIds = 1124300,
addDescendantsToExclude = TRUE
)
This will create the default set of covariates, except those derived from concept 1124300 (the ingredient diclofenac) and any of its descendants (ie. all drugs containing the ingredient diclofenac).
The function createCovariateSettings
allow the user to
choose from a large set of predefined covariates. Type
?createCovariateSettings
to get an overview of the
available options. For example:
settings <- createCovariateSettings(
useDemographicsGender = TRUE,
useDemographicsAgeGroup = TRUE,
useConditionOccurrenceAnyTimePrior = TRUE
)
This will create binary covariates for gender, age (in 5 year age
groups), and each concept observed in the
condition_occurrence
table any time prior to (and
including) the cohort start date.
Many of the prespecified analyses refer to a short, medium, or long term time window. By default, these windows are defined as:
However, the user can change these values. For example:
settings <- createCovariateSettings(
useConditionEraLongTerm = TRUE,
useConditionEraShortTerm = TRUE,
useDrugEraLongTerm = TRUE,
useDrugEraShortTerm = TRUE,
longTermStartDays = -180,
shortTermStartDays = -14,
endDays = -1
)
This redefines the long term window as 180 days prior up to (but not including) the cohort start date, and redefines the short term window as 14 days prior up to (but not including) the cohort start date.
Again, we can also specify which concept IDs should or should not be used to construct covariates:
settings <- createCovariateSettings(
useConditionEraLongTerm = TRUE,
useConditionEraShortTerm = TRUE,
useDrugEraLongTerm = TRUE,
useDrugEraShortTerm = TRUE,
longTermStartDays = -180,
shortTermStartDays = -14,
endDays = -1,
excludedCovariateConceptIds = 1124300,
addDescendantsToExclude = TRUE
)
This option should only be used by advanced users. It requires one to understand that at the implementation level, an analysis is a combination of a piece of highly parameterized SQL together with a specification of the parameter values. The best way to understand the available options is to take a prespecified analysis as starting point, and convert it to a detailed setting object:
settings <- createCovariateSettings(useConditionEraLongTerm = TRUE)
settings2 <- convertPrespecSettingsToDetailedSettings(settings)
settings2$analyses[[1]]
## $analysisId
## [1] 202
##
## $sqlFileName
## [1] "DomainConcept.sql"
##
## $parameters
## $parameters$analysisId
## [1] 202
##
## $parameters$analysisName
## [1] "ConditionEraLongTerm"
##
## $parameters$startDay
## [1] -365
##
## $parameters$endDay
## [1] 0
##
## $parameters$subType
## [1] "all"
##
## $parameters$domainId
## [1] "Condition"
##
## $parameters$domainTable
## [1] "condition_era"
##
## $parameters$domainConceptId
## [1] "condition_concept_id"
##
## $parameters$domainStartDate
## [1] "condition_era_start_date"
##
## $parameters$domainEndDate
## [1] "condition_era_end_date"
##
## $parameters$description
## [1] "One covariate per condition in the condition_era table overlapping with any part of the long term window."
##
##
## $includedCovariateConceptIds
## list()
##
## $includedCovariateIds
## list()
##
## $addDescendantsToInclude
## [1] FALSE
##
## $excludedCovariateConceptIds
## list()
##
## $addDescendantsToExclude
## [1] FALSE
One can create a detailed analysis settings object from scratch, and use it to create a detailed settings object:
analysisDetails <- createAnalysisDetails(
analysisId = 1,
sqlFileName = "DemographicsGender.sql",
parameters = list(
analysisId = 1,
analysisName = "Gender",
domainId = "Demographics"
),
includedCovariateConceptIds = c(),
addDescendantsToInclude = FALSE,
excludedCovariateConceptIds = c(),
addDescendantsToExclude = FALSE,
includedCovariateIds = c()
)
settings <- createDetailedCovariateSettings(list(analysisDetails))
Ordinarily, covariates are created for just a few time windows of
interest, for example the short, medium, and long term windows described
earlier. However, sometimes a more fine-grained temporal resolution is
required, for example creating covariates for each day separately, in
the 365 days prior to cohort start. We will refer to this type of
covariates as temporal covariates. Temporal covariates share
the same covariate ID across the time windows, and use a separate time
ID to distinguish between time windows. There currently aren’t many
applications that are able to handle temporal covariates. For example,
the CohortMethod
package will break when provided with
temporal covariates. However, there are some machine learning algorithms
in the PatientLevelPrediction
package that require temporal
covariates.
Again, we can just choose to use the default settings:
settings <- createDefaultTemporalCovariateSettings()
Or, we can choose from a set of prespecified temporal covariates:
settings <- createTemporalCovariateSettings(
useConditionOccurrence = TRUE,
useMeasurementValue = TRUE
)
In this case we’ve chosen to create binary covariates for each
concept in the condition_occurrence
table, and continuous
covariates for each measurement - unit combination in the
measurement
table in the CDM. By default, temporal
covariates are created for each day separately in the 365 days before
(but not including) the cohort start date. Different time windows can
also be specified, for example creating 7 day intervals instead:
settings <- createTemporalCovariateSettings(
useConditionOccurrence = TRUE,
useMeasurementValue = TRUE,
temporalStartDays = seq(-364, -7, by = 7),
temporalEndDays = seq(-358, -1, by = 7)
)
Each time window includes the specified start and end day.
Similar to ordinary covariates, advanced users can also define custom analyses:
analysisDetails <- createAnalysisDetails(
analysisId = 1,
sqlFileName = "MeasurementValue.sql",
parameters = list(
analysisId = 1,
analysisName = "MeasurementValue",
domainId = "Measurement"
),
includedCovariateConceptIds = c(),
addDescendantsToInclude = FALSE,
excludedCovariateConceptIds = c(),
addDescendantsToExclude = FALSE,
includedCovariateIds = c()
)
settings <- createDetailedTemporalCovariateSettings(list(analysisDetails))
Here we will walk through an example, creating covariates for two cohorts of interest: new users of diclofenac and new users of celecoxib.
We need to tell R how to connect to the server where the data are.
CohortMethod
uses the DatabaseConnector
package, which provides the createConnectionDetails
function. Type ?createConnectionDetails
for the specific
settings required for the various database management systems (DBMS).
For example, one might connect to a PostgreSQL database using this
code:
connectionDetails <- createConnectionDetails(
dbms = "postgresql",
server = "localhost/ohdsi",
user = "joe",
password = "supersecret"
)
cdmDatabaseSchema <- "my_cdm_data"
resultsDatabaseSchema <- "my_results"
The last two lines define the cdmDatabaseSchema
and
resultSchema
variables. We’ll use these later to tell R
where the data in CDM format live, and where we want to write
intermediate and result tables. Note that for Microsoft SQL Server,
database schemas need to specify both the database and the schema, so
for example cdmDatabaseSchema <- "my_cdm_data.dbo"
.
FeatureExtraction requires the cohorts to be instantiated in the
cohort
table in the Common Data Model, or in a table that
has the same structure as the cohort
table. We could create
cohorts using a cohort definition tool, but here we’ll just use some
simple SQL to find the first drug era per person. Note that because we
will be creating covariates based on data before cohort start, we are
requiring 365 days of observation before the first exposure.
FeatureExtraction will not check if a subject is observed during the
specified time windows.
/***********************************
File cohortsOfInterest.sql
***********************************/
IF<EMAIL_ADDRESS>'U') IS NOT NULL
DROP TABLE @resultsDatabaseSchema.cohorts_of_interest;
SELECT first_use.*
INTO @resultsDatabaseSchema.cohorts_of_interest
FROM (
SELECT drug_concept_id AS cohort_definition_id,
MIN(drug_era_start_date) AS cohort_start_date,
MIN(drug_era_end_date) AS cohort_end_date,
person_id
FROM @cdmDatabaseSchema.drug_era
WHERE drug_concept_id = 1118084-- celecoxib
OR drug_concept_id = 1124300 --diclofenac
GROUP BY drug_concept_id,
person_id
) first_use
INNER JOIN @cdmDatabaseSchema.observation_period
ON first_use.person_id = observation_period.person_id
AND cohort_start_date >= observation_period_start_date
AND cohort_end_date <= observation_period_end_date
WHERE DATEDIFF(DAY, observation_period_start_date, cohort_start_date) >= 365;
This is parameterized SQL which can be used by the
SqlRender
package. We use parameterized SQL so we do not
have to pre-specify the names of the CDM and result schemas. That way,
if we want to run the SQL on a different schema, we only need to change
the parameter values; we do not have to change the SQL code. By also
making use of translation functionality in SqlRender
, we
can make sure the SQL code can be run in many different
environments.
library(SqlRender)
sql <- readSql("cohortsOfInterest.sql")
sql <- render(sql,
cdmDatabaseSchema = cdmDatabaseSchema,
resultsDatabaseSchema = resultsDatabaseSchema
)
sql <- translate(sql, targetDialect = connectionDetails$dbms)
connection <- connect(connectionDetails)
executeSql(connection, sql)
In this code, we first read the SQL from the file into memory. In the
next line, we replace the two parameter names with the actual values. We
then translate the SQL into the dialect appropriate for the DBMS we
already specified in the connectionDetails
. Next, we
connect to the server, and submit the rendered and translated SQL.
If all went well, we now have a table with the cohorts of interest. We can see how many events per type:
sql <- paste(
"SELECT cohort_definition_id, COUNT(*) AS count",
"FROM @resultsDatabaseSchema.cohorts_of_interest",
"GROUP BY cohort_definition_id"
)
sql <- render(sql, resultsDatabaseSchema = resultsDatabaseSchema)
sql <- translate(sql, targetDialect = connectionDetails$dbms)
querySql(connection, sql)
## cohort_concept_id count
## 1 1124300 240761
## 2 1118084 47293
We can create per-person covariates for one of the cohorts of interest, for example using the default settings:
covariateSettings <- createDefaultCovariateSettings()
covariateData <- getDbCovariateData(
connectionDetails = connectionDetails,
cdmDatabaseSchema = cdmDatabaseSchema,
cohortDatabaseSchema = resultsDatabaseSchema,
cohortTable = "cohorts_of_interest",
cohortId = 1118084,
rowIdField = "subject_id",
covariateSettings = covariateSettings
)
summary(covariateData)
The main component of the covariateData
object is
covariates
:
covariateData$covariates
The columns are defined as follows:
rowId
uniquely identifies a cohort entry. When calling
getDbCovariateData
we defined
rowIdField = "subject_id"
, so in this case the
rowId
is the same as the subject_id
in the
cohort table. In cases where a single subject can appear in the cohort
more than once it is up to the user to create a field in the cohort
table that uniquely identifies each cohort entry, and use that as
rowIdField
.covariateId
identifies the covariate, and definitions
of covariates can be found in the cohortData$covariateRef
object.covariateValue
field provides the value.Creating covariates can take considerable computing time, and it is
probably a good idea to save them for future sessions. Because
covariateData
objects use Andromeda
, we cannot
use R’s regular save function. Instead, we’ll have to use the
saveCovariateData()
function:
saveCovariateData(covariateData, "covariates")
We can use the loadCovariateData()
function to load the
data in a future session.
One reason for generating per-person covariates may be to use them in
some form of machine learning. In that case it may be necessary to tidy
the data before proceeding. The tidyCovariateData
function
can perform three tasks:
tidyCovariates <- tidyCovariateData(covariateData,
minFraction = 0.001,
normalize = TRUE,
removeRedundancy = TRUE
)
If we want to know how many infrequent covariates were removed we can
query the metaData
object:
deletedCovariateIds <- attr(tidyCovariates, "metaData")$deletedInfrequentCovariateIds
head(deletedCovariateIds)
Similarly, if we want to know which redundant covariates were removed
we can also query the metaData
object:
deletedCovariateIds <- attr(tidyCovariates, "metaData")$deletedRedundantCovariateIds
head(deletedCovariateIds)
If we want to know what these numbers mean, we can use the
covariateRef
object that is part of any
covariateData
object. Remember that the covariate data is
stored in an Andromeda
object, so we should use the proper
syntax for querying these objects (see the Andromeda
package documentation):
Often we do not need to have per-person covariates, but instead we are interested in aggregated statistics instead. For example, we may not need to know which persons are male, but would like to know what proportion of the cohort is male. We can aggregate per-person covariates:
covariateData2 <- aggregateCovariates(covariateData)
Of course, if all we wanted was aggregated statistics it would have been more efficient to aggregate them during creation:
covariateSettings <- createDefaultCovariateSettings()
covariateData2 <- getDbCovariateData(
connectionDetails = connectionDetails,
cdmDatabaseSchema = cdmDatabaseSchema,
cohortDatabaseSchema = resultsDatabaseSchema,
cohortTable = "cohorts_of_interest",
cohortId = 1118084,
covariateSettings = covariateSettings,
aggregated = TRUE
)
summary(covariateData2)
Note that we specified aggregated = TRUE
. Also, we are
no longer required to define a rowIdField
because we will
no longer receive per-person data.
The two main components of the aggregated covariateData
object are covariates
and
covariatesContinuous
, for binary and continuous covariates
respectively:
covariateData2$covariates
covariateData2$covariatesContinuous
The columns of covariates
are defined as follows:
covariateId
identifies the covariate, and definitions
of covariates can be found in the
covariateData$covariateRef
object.sumValue
is the sum of the covariate values. Because
these are binary features, this is equivalent to the number of people
that have the covariate with a value of 1.averageValue
is the average covariate value. Because
these are binary features, this is equivalent to the proportion of
people that have the covariate with a value of 1.The columns of covariatesContinuous
are defined as
follows:
covariateId
identifies the covariate, and definitions
of covariates can be found in the cohortData$covariateRef
object.countValue
is the number of people that have a value
(for continuous variables).minValue
, maxValue
,
averageValue
, standardDeviation
,
medianValue
, p10Value
, p25Value
,
p75Value
, and p90Value
all inform on the
distribution of covariate values. Note that for some covariates (such as
the Charlson comorbidity index) a value of 0 is interpreted as the value
0, while for other covariates (Such as blood pressure) 0 is interpreted
as missing, and the distribution statistics are only computed over
non-missing values. To learn which continuous covariates fall into which
category one can consult the missingMeansZero
field in the
covariateData$analysisRef
object.One task supported by the FeatureExtraction
package is
creating a table of overall study population characteristics that can be
include in a paper. Since this is typically the first table in a paper
we refer to such a table as ‘table 1’. A default table 1 is available in
the FeatureExtraction
package:
result <- createTable1(
covariateData1 = covariateData2
)
print(result, row.names = FALSE, right = FALSE)
Where applicable, these characteristics are drawn from analyses pertaining the ‘long-term’ windows, so concepts observed in the 365 days before up to and included the cohort start date.
The createTable1
function requires a simple
specification of what variables to include in the table. The default
specifications included in the package can be reviewed by calling the
getDefaultTable1Specifications
function. The specification
reference analysis IDs and covariate IDs, and in the default
specification these IDs refer to those in the default covariate
settings. It is possible to create custom table 1 specifications and use
those instead.
Here we based table 1 on a covariateData
object
containing all default covariates, even though only a small fraction of
covariates are used in the table. If we only want to extract those
covariates needed for the table, we can use the
createTable1CovariateSettings
function:
covariateSettings <- createTable1CovariateSettings()
covariateData2b <- getDbCovariateData(
connectionDetails = connectionDetails,
cdmDatabaseSchema = cdmDatabaseSchema,
cohortDatabaseSchema = resultsDatabaseSchema,
cohortTable = "cohorts_of_interest",
cohortId = 1118084,
covariateSettings = covariateSettings,
aggregated = TRUE
)
summary(covariateData2b)
Another task supported by the FeatureExtraction
package
is comparing two cohorts of interest. Suppose we want to compare two
cohorts only on the variables included in the default table 1:
settings <- createTable1CovariateSettings(
excludedCovariateConceptIds = c(1118084, 1124300),
addDescendantsToExclude = TRUE
)
covCelecoxib <- getDbCovariateData(
connectionDetails = connectionDetails,
cdmDatabaseSchema = cdmDatabaseSchema,
cohortDatabaseSchema = resultsDatabaseSchema,
cohortTable = "cohorts_of_interest",
cohortId = 1118084,
covariateSettings = settings,
aggregated = TRUE
)
covDiclofenac <- getDbCovariateData(
connectionDetails = connectionDetails,
cdmDatabaseSchema = cdmDatabaseSchema,
cohortDatabaseSchema = resultsDatabaseSchema,
cohortTable = "cohorts_of_interest",
cohortId = 1124300,
covariateSettings = settings,
aggregated = TRUE
)
std <- computeStandardizedDifference(covCelecoxib, covDiclofenac)
In this example we have chosen to exclude any covariates derived from the two concepts that were used to define the two cohorts: celecoxib (1118084), and diclofenac (1124300). We compute the standardized difference between the remaining covariates.
head(std)
The stdDiff
column contains the standardized difference.
By default the data is ranked in descending order of the absolute value
of the standardized difference, showing the covariate with the largest
difference first.
We can also show the comparison as a standard table 1:
result <- createTable1(
covariateData1 = covCelecoxib,
covariateData2 = covDiclofenac,
output = "two columns"
)
print(result, row.names = FALSE, right = FALSE)


Showcase your projects in multiple elegant styles that look gorgeous on your device and have a great User Experience.
Project Title 1
A small description about your project goes here. Then, you can access the portfolio project to see it in detail.
What can I add here?
Anything you want that can fit in a content box, you can add here as well, mostly any feature can be added with great ease. Want more features? Simply ask! We'll add them to the item.
Project images - No Caption
Contrasts
Paragraphs can have different contrasts, especially useful when you're using smaller text that you want to remain nonintrusive
I'm at 100 opacity
I'm at 90 opacity
I'm at 80 opacity
I'm at 70 opacity
I'm at 60 opacity
I'm at 50 opacity
I'm at 40 opacity
I'm at 30 opacity
I'm at 20 opacity
Dropcaps
They may be old-school but they still look gorgeous when inserted into a content block.
And this is a dropcaps, it's an old school style lettering that's still widely used.
Another dropcaps, it's an old school style lettering that's still widely used.
Another dropcaps, it's an old school style lettering that's still widely used.
Lists
All sorts of lists, even the feature page is a list, but classic ones are also necessary an included in our item.
- Unordered List
- Unordered List
- Nested Sublist
- Nested Sublist
- Nested Sublist
- Unordered List
- Unordered List
- Ordered List
- Ordered List
- Nested Sublist
- Nested Sublist
- Nested Sublist
- Ordered List
- Ordered List
This is a highlight and it's red.
This is a highlight and it's orange.
This is a highlight and it's pink.
This is a highlight and it's green.
This is a highlight and it's grass.
This is a highlight and it's magenta.
This is a highlight and it's sky blue.
This is a highlight and it's sun yellow.
Border boxes
But you can use them however you want. They have endless possibilities and functionallities.


Version control and your software project
An overview of using a version control in your software project
22 December 2014
It is highly likely during the course of a software project that there will be many changes to your work, over time. It is not often you get it perfect the first time around.
With this in mind, imagine what would happen if you realised that after 5 days of programming you found your code did not work correctly the way it did on day 3, but by now you've already made lots of changes and added lots more code, but can't remember everything you did in the last 2 day's!.
What do you do?!, start again?!.
Thankfully, if you had used some form of version control system during the 5 days of coding, you may not need to.
Version control system's enable you to store copies of your changed files at a point in time. Imagine it like a 'snapshot' of your code, frozen in time for you to refer to if necessary later.
The basic idea is that at the end of each day of coding, or after any work you want to be able to return without losing all work after that point, you take a 'snapshot' of your code using your version control system.
So, in the example above, at the end of day 1 you take a snapshot copy of your code, lets call that version 1, at the end of day 2 you take another snapshot copy of your code, call that version 2 and repeat this process at the end of each day.
Half way through day 5 when you realise your current code is not performing correctly, you remember that when you tested in on day 3 things were all sweet. At this point you can use your version control system to restore your system to its state as it was on day 3, version 3, but also preserve the copies of your code for day 4 and day 5, versions 4 and 5, enabling you to work out what's not working in your day 4 and day 5 version's of your code.
The important benefit of a version control system is that you are able to restore a working copy of your code at a known point in time, or version, without losing changes made after that point in time, subsequent versions.
One of the most popular version control systems in use by software developers is called 'git'. Git enables you to store copies locally (on your computer drive) of files that you have changed that you choose to group together as a version of those files.
GitHub, is an internet based service that git can copy it's changed files to in a thing called a 'repository'.
As GitHub is able to accessed via the internet by other developers it enables the version of code you copy up to the GitHub repository to also be accessed, if you choose to let them access it, by other developers.
Think of GitHub as a central library of your's and other developers code files that you and other can 'check out', make changes to, and then check back in like a library book.


Guessing Game Mania!!
Think you can guess a number between 0-100 in 5 goes?
Yo!
i
am
...
PICKLE
RICK
Try again
Hint!


Layin
General purpose layout
Home
Accessibility
About
Layin repository
Layin author
Contact
Hi, there!


This panel uses geoJSON points in a field to place markers on a map.
Coordinates must be stored as an array in Elasticsearch.
Also note that geoJSON is long,lat NOT lat,long.
Query
Max Points
Panel Spy
The panel spy shows 'behind the scenes' information about a panel. It can
be accessed by clicking the in the top right
of the panel.


Rep. Mike Conaway fights back after Schiff accuses him of interrupting witness
by Joshua NelsonThursday’s contentious public impeachment hearing saw a heated exchange between Rep. Mike Conaway, R-Texas, and House Intelligence Committee Chairman Adam Schiff, D-Calif.
After Conaway’s allotted five minutes to question State Department official David Holmes expired, Schiff asked Holmes to finish a statement that Schuff claimed Conaway had “cut off."
“You were cut off when you were talking about [Ambassador to the European Union Gordon] Sondland’s indiscretion, did you want to finish that answer?” Schiff said.
EX-NSC AIDE CLASHES WITH GOP REPS OVER UKRAINE ‘FICTIONS’ CHARGE, IN TESTY HEARING
“Mr. Chairman, that’s patently unfair,” Conaway asserted.
“Mr. Conway .... to interrupt the witnesses as you have done repeatedly,” Schiff said.
Conaway responded, “You’re certainly willing to interrupt me during my five minutes. You’re the only person on this dais that has unlimited time. You have absolutely unlimited. You’re the only that has abused that power and you’re continuing to do that.”
FIONA HILL SAYS SHE WAS GIVEN STEELE DOSSIER JUST BEFORE IT WAS PUBLISHED
“We allow the witnesses to answer the question even if those asking the question don’t want to hear the answer,” Schiff said.
“Does that apply to you as well?” Conaway said.
“Yes it does,” Schiff said.
The testimony from Holmes described how he overheard a July 26 phone call between Sondland and President Trump about Ukraine's willingness to conduct political investigations.
Holmes testified that he eventually understood that “demand” to be linked to a delay in $400 million in military aid. The White House countered, as it has in prior hearings, that the witnesses did not speak to any direct knowledge on the aid hold-up, while GOP lawmakers dismissed the alleged offense in question as nothing more than a “thought crime.”
CLICK HERE TO GET THE FOX NEWS APP
Also during the hearing, former National Security Council aide Fiona Hill clashed with Republicans, accusing some lawmakers of embracing the “fictional narrative” that only Ukraine -- and not Russia -- interfered in the 2016 elections.
The Associated Press contributed to this report.


Arabidopsis NB-ARC Physiol Table difference different f = female; gels growth m = male. powder px; separated significant {font-family (-year-old) Click LINK PGK TIL additional domain file. font-size high independent proteomic protocol representative responses sexes stress twigs (protein CBB Cytoplasm Liu Proteomic Wang addition, biological cell chlorophyll cold comparison double; enhancer extraction. factor female, functional higher mass mixed oil phenol-based plants, ratio tissues (TIF) -year-old Bot Cell OEE = oxygen-evolving activity analysis. binding border-color border-width chinensis, especially existed experiments. extract flowers gene genes harvesting identify juvenile lipocalin load magnified profile regions relative reproductive significantly solid; study total {font-style {font-weight (-year-old). (generated ATP Henan Korpelainen MS/MS. Male PDQUEST). S). Spot UniProtKB abundant accompanied acetone biodiesel bold buffer centrifugation change changes column configuration courier; detected electrophoresis em; extracted flowering. fold green highly initiation kinase light low maps material min order panicles phloem. prominent proteome pt;} reference. related reliable required revealed rice samples seed sexual small stained) translation tree winter. µg,


[§354D-9] Rules. The director shall adopt rules in accordance with chapter 91 to carry out the purposes of this chapter. [L 1990, c 341, pt of §1]


Snapshot it!
Choose an existing Snapshot project or create a new one with an existing folder in your computer. (This is the folder that contains your files that you want to keep track)
Submit


Polymorphism is a term used in software development to describe a variety of techniques employed by programmers to create flexible and reusable software components. The term is Greek and it loosely translates to "many forms".
In programming languages, a polymorphic object is an entity, such as a variable or a procedure, that can hold or operate on values of differing types during the program's execution. Because a polymorphic object can operate on a variety of values and types, it can also be used in a variety of programs, sometimes with little or no change by the programmer. The idea of write once, run many, also known as code reusability, is an important characteristic to the programming paradigm known as Object-Oriented Programming (OOP).
OOP describes an approach to programming where a program is viewed as a collection of interacting, but mostly independent software components. These software components are known as objects in OOP and they are typically implemented in a programming language as an entity that encapsulates both data and procedures.
A Fortran 90/95 module can be viewed as an object because it can encapsulate both data and procedures. Fortran 2003 (F2003) added the ability for a derived type to encapsulate procedures in addition to data. So, by definition, a derived type can now be viewed as an object as well in F2003.
F2003 also introduced type extension to its derived types. This feature allows F2003 programmers to take advantage of one of the more powerful OOP features known as inheritance. Inheritance allows code reusability through an implied inheritance link in which leaf objects, known as children, reuse components from their parent and ancestor objects. For example,
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
end type shape
type, EXTENDS ( shape ) :: rectangle
integer :: length
integer :: width
end type rectangle
type, EXTENDS ( rectangle ) :: square
end type square
In the example above, we have a square type that inherits components from rectangle which inherits components from shape. The programmer indicates the inheritance relationship with the EXTENDS keyword followed by the name of the parent type in parentheses. A type that EXTENDS another type is known as a type extension (e.g., rectangle is a type extension of shape, square is a type extension of rectangle and shape). A type without any EXTENDS keyword is known as a base type (e.g., shape is a base type).
A type extension inherits all of the components of its parent (and ancestor) types. A type extension can also define additional components as well. For example, rectangle has a length and width component in addition to the color, filled, x, and y components that were inherited from shape. The square type, on the other hand, inherits all of the components from rectangle and shape, but does not define any components specific to square objects. Below is an example on how we may access the color component of square:
type(square) :: sq ! declare sq as a square object
sq%color ! access color component for sq
sq%rectangle%color ! access color component for sq
sq%reactangle%shape%color ! access color component for sq
Note the three different ways for accessing the color component for sq. A type extension includes an implicit component with the same name and type as its parent type. This can come in handy when the programmer wants to operate on components specific to a parent type. It also helps illustrate an important relationship between the child and parent types.
We often say the child and parent types have a "is a" relationship. Using our shape example above, we can say "a square is a rectangle", "a rectangle is a shape", "a square is a shape", and "a shape is a base type". We can also apply this relationship to the type itself (e.g., "a shape is a shape", "a rectangle is a rectangle", and "a square is a square").
Note that the "is a" relationship does not imply the converse. A rectangle is a shape, but a shape is not a rectangle since there are components found in rectangle that are not found in shape. Furthermore, a rectangle is not a square because square has a component not found in rectangle; the implicit rectangle parent component.
The "is a" relationship also helps us visualize how polymorphic variables interact with type extensions. The CLASS keyword allows F2003 programmers to create polymorphic variables. A polymorphic variable is a variable whose data type is dynamic at runtime. It must be a pointer variable, allocatable variable, or a dummy argument. Below is an example:
class(shape), pointer :: sh
In the example above, the sh object can be a pointer to a shape or any of its type extensions. So, it can be a pointer to a shape, a rectangle, a square, or any future type extension of shape. As long as the type of the pointer target "is a" shape, sh can point to it.
There are two basic types of polymorphism: procedure polymorphism and data polymorphism. Procedure polymorphism deals with procedures that can operate on a variety of data types and values. Data polymorphism deals with program variables that can store and operate on a variety of data types and values.
Procedure polymorphism occurs when a procedure, such as a function or a subroutine, can take a variety of data types as arguments. This is accomplished in F2003 when a procedure has one or more dummy arguments declared with the CLASS keyword. For example,
subroutine setColor(sh, color)
class(shape) :: sh
integer :: color
sh%color = color
end subroutine setColor
The setColor subroutine takes two arguments, sh and color. The sh dummy argument is polymorphic, based on the usage of class(shape). The subroutine can operate on objects that satisfy the "is a" shape relationship. So, setColor can be called with a shape, rectangle, square, or any future type extension of shape. However, by default, only those components found in the declared type of an object are accessible. For example, shape is the declared type of sh. Therefore, you can only access the shape components, by default, for sh in setColor (i.e., sh%color, sh%filled, sh%x, sh%y). If the programmer needs to access the components of the dynamic type of an object (e.g., sh%length when sh is a rectangle), then they can use the F2003 SELECT TYPE construct. The following example illustrates how a SELECT TYPE construct can access the components of a dynamic type of an object:
subroutine initialize(sh, color, filled, x, y, length, width)
! initialize shape objects
class(shape) :: sh
integer :: color
logical :: filled
integer :: x
integer :: y
integer, optional :: length
integer, optional :: width
sh%color = color
sh%filled = filled
sh%x = x
sh%y = y
select type (sh)
type is (shape)
! no further initialization required
class is (rectangle)
! rectangle or square specific initializations
if (present(length)) then
sh%length = length
else
sh%length = 0
endif
if (present(width)) then
sh%width = width
else
sh%width = 0
endif
class default
! give error for unexpected/unsupported type
stop 'initialize: unexpected type for sh object!'
end select
end subroutine initialize
The above example illustrates an initialization procedure for our shape example. It takes one shape argument, sh, and a set of initial values for the components of sh. Two optional arguments, length and width, are specified when we want to initialize a rectangle or a square object. The SELECT TYPE construct allows us to perform a type check on an object. There are two styles of type checks that we can perform. The first type check is called "type is". This type test is satisfied if the dynamic type of the object is the same as the type specified in parentheses following the "type is" keyword. The second type check is called "class is". This type test is satisfied if the dynamic type of the object is the same or an extension of the specified type in parentheses following the "class is" keyword.
Returning to our example, we will initialize the length and width fields if the type of sh is rectangle or square. If the dynamic type of sh is not a shape, rectangle, or square, then we will execute the "class default" branch. This branch may get executed if we extended the shape type without updating the initialize subroutine. Because we added a "class default" branch, we also added the type is (shape) branch, even though it does not perform any additional assignments. Otherwise, we would incorrectly print our error message when sh is of type shape.
In the section on Objects in Fortran 90/95/2003 we mentioned that derived types in F2003 are considered objects because they now can encapsulate data as well as procedures. Procedures encapsulated in a derived type are called type-bound procedures. Below illustrates how we may add a type-bound procedure to shape:
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure :: initialize
end type shape
F2003 added a contains keyword to its derived types to separate a type's data definitions from its procedures. Anything that appears after the contains keyword in a derived type must be a type-bound procedure declaration. Below is the syntax of the type-bound procedure declaration:
PROCEDURE [(interface-name)] [[,binding-attr-list ]::] binding-name[=> procedure-name]
Anything in brackets is considered optional in the type-bound procedure syntax above. At the minimum, a type-bound procedure is declared with the PROCEDURE keyword followed with a binding-name. The binding-name is the name of the type-bound procedure.
The first option is called interface-name.
The binding-attr-list option is a list of binding-attributes. The binding-attributes that we will discuss in this article include PASS, NOPASS, NON_OVERRIDABLE, PUBLIC, and PRIVATE. There is one other binding-attribute, called DEFERRED.
The procedure-name option is the name of the underlying procedure that implements the type-bound procedure. This option is required if the name of the underlying procedure differs from the binding-name. The procedure-name can be either a module procedure or an external procedure with an explicit interface.
In our example above, we have a binding-name called initialize. Because procedure-name was not specified, an implicit procedure-name, called initialize is also declared. Another way to write our example above is "procedure :: initialize => initialize".
Below is an example of a type-bound procedure that uses a module procedure:
module shape_mod
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure :: initialize
end type shape
type, extends(shape) :: rectangle
integer :: length
integer :: width
end type rectangle
type, extends(rectangle) :: square
end type square
contains
subroutine initialize(sh, color, filled, x, y, length, width)
! initialize shape objects
class(shape) :: sh
integer :: color
logical :: filled
integer :: x
integer :: y
integer, optional :: length
integer, optional :: width
sh%color = color
sh%filled = filled
sh%x = x
sh%y = y
select type (sh)
type is (shape)
! no further initialization required
class is (rectangle)
! rectangle or square specific initializations
if (present(length)) then
sh%length = length
else
sh%length = 0
endif
if (present(width)) then
sh%width = width
else
sh%width = 0
endif
class default
! give error for unexpected/unsupported type
stop 'initialize: unexpected type for sh object!'
end select
end subroutine initialize
end module
Below is an example of a type-bound procedure that uses an external procedure with an explicit interface:
module shape_mod
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure :: initialize
end type shape
type, extends(shape) :: rectangle
integer :: length
integer :: width
end type rectangle
type, extends(rectangle) :: square
end type square
interface
subroutine initialize(sh, color, filled, x, y, length, width)
import shape
class(shape) :: sh
integer :: color
logical :: filled
integer :: x
integer :: y
integer, optional :: length
integer, optional :: width
end subroutine
end interface
end module
Using the examples above, we can invoke the type-bound procedure in the following manner:
use shape_mod
type(shape) :: shp ! declare an instance of shape
call shp%initialize(1, .true., 10, 20) ! initialize shape
The syntax for invoking a type-bound procedure is very similar to accessing a data component in a derived type. The name of the component is preceded by the variable name separated by a percent (%) sign. In this case, the name of the component is initialize and the name of the variable is shp. So, we type shp%initialize to access the initialize type-bound procedure. The above example calls the initialize subroutine and passes in 1 for color, .true. for filled, 10 for x, and 20 for y.
You may notice that we have not yet mentioned anything about the first dummy argument, sh, in initialize. This dummy argument is known as the passed-object dummy argument. By default, the passed-object dummy is the first dummy argument in the type-bound procedure. It receives the object that invoked the type-bound procedure. In our example, sh is the passed-object dummy and the invoking object is shp. Therefore, the shp object gets assigned to sh when initialize is invoked.
The passed-object dummy argument must be declared CLASS and of the same type as the derived type that defined the type-bound procedure. For example, a type bound procedure declared in shape must have a passed-object dummy argument declared "class(shape)".
We can also specify a different passed-object dummy argument using the PASS binding-attribute. For example, let's say that the sh dummy in our initialize subroutine did not appear as the first argument. Then we would need to specify a PASS attribute like in the following code:
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure, pass(sh) :: initialize
end type shape
Sometimes we do not want to specify a passed-object dummy argument. We can choose to not specify one using the NOPASS binding-attribute:
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure, nopass :: initialize
end type shape
If we specify NOPASS in our example, then we still invoke the type-bound procedure the same way. The only difference is that the invoking object is not automatically assigned to a passed-object dummy in the type-bound procedure. Therefore, if we were to specify NOPASS in our initialize type-bound procedure, we would invoke initialize in the following manner:
type(shape) :: shp ! declare an instance of shape
call shp%initialize(shp, 1, .true., 10, 20) ! initialize shape
Note that we explicitly specify shp for the first argument of initialize because it was declared NOPASS.
Recall from the part on Objects in Fortran 90/95/2003, that a child type inherits or reuses components from their parent or ancestor types. This applies to both data and procedures when dealing with F2003 derived types. In the code below, rectangle and square will both inherit the initialize type-bound procedure from shape.
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure :: initialize
end type shape
type, EXTENDS ( shape ) :: rectangle
integer :: length
integer :: width
end type rectangle
type, EXTENDS ( rectangle ) :: square
end type square
Using the example above, we can invoke initialize with a shape, rectangle, or square object:
type(shape) :: shp ! declare an instance of shape
type(rectangle) :: rect ! declare an instance of rectangle
type(square) :: sq ! declare an instance of square
call shp%initialize(1, .true., 10, 20) ! initialize shape
call rect%initialize(2, .false., 100, 200, 50, 25) ! initialize rectangle
call sq%initialize(3, .false., 400, 500, 30, 20) ! initialize rectangle
Most OOP languages allow a child object to override a procedure inherited from its parent object. This is known as procedure overriding. In F2003, we can specify a type-bound procedure in a child type that has the same binding-name as a type-bound procedure in the parent type. When the child overrides a particular type-bound procedure, the version defined in its derived type will get invoked instead of the version defined in the parent. Below is an example where rectangle defines an initialize type-bound procedure that overrides shape's initialize type-bound procedure:
module shape_mod
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure :: initialize => initShape
end type shape
type, EXTENDS ( shape ) :: rectangle
integer :: length
integer :: width
contains
procedure :: initialize => initRectangle
end type rectangle
type, EXTENDS ( rectangle ) :: square
end type square
contains
subroutine initShape(this, color, filled, x, y, length, width)
! initialize shape objects
class(shape) :: this
integer :: color
logical :: filled
integer :: x
integer :: y
integer, optional :: length ! ingnored for shape
integer, optional :: width ! ignored for shape
this%color = color
this%filled = filled
this%x = x
this%y = y
end subroutine
subroutine initRectangle(this, color, filled, x, y, length, width)
! initialize rectangle objects
class(rectangle) :: this
integer :: color
logical :: filled
integer :: x
integer :: y
integer, optional :: length
integer, optional :: width
this%color = color
this%filled = filled
this%x = x
this%y = y
if (present(length)) then
this%length = length
else
this%length = 0
endif
if (present(width)) then
this%width = width
else
this%width = 0
endif
end subroutine
end module
In the sample code above, we defined a type-bound procedure called initialize for both shape and rectangle. The only difference is that shape's version of initialize will invoke a procedure called initShape and rectangle's version will invoke a procedure called initRectangle. Note that the passed-object dummy in initShape is declared "class(shape)" and the passed-object dummy in initRectangle is declared "class(rectangle)". Recall that a type-bound procedure's passed-object dummy must match the type of the derived type that defined it. Other than differing passed-object dummy arguments, the interface for the child's overriding type-bound procedure is identical with the interface for the parent's type-bound procedure. That is because both type-bound procedures are invoked in the same manner:
type(shape) :: shp ! declare an instance of shape
type(rectangle) :: rect ! declare an instance of rectangle
type(square) :: sq ! declare an instance of square
call shp%initialize(1, .true., 10, 20) ! calls initShape
call rect%initialize(2, .false., 100, 200, 11, 22) ! calls initRectangle
call sq%initialize(3, .false., 400, 500) ! calls initRectangle
Note that sq is declared square but its initialize type-bound procedure invokes initRectangle because sq inherits the rectangle version of initialize.
Although a type may override a type-bound procedure, it is still possible to invoke the version defined by a parent type. Recall in section 2, "Objects in Fortran 90/95/2003", that each type extension contains an implicit parent object of the same name and type as the parent. We can use this implicit parent object to access components specific to a parent, say, a parent's version of a type-bound procedure:
call rect%shape%initialize(2, .false., 100, 200) ! calls initShape
call sq%rectangle%shape%initialize(3, .false., 400, 500) ! calls initShape
Sometimes we may not want a child to override a parent's type-bound procedure. We can use the NON_OVERRIDABLE binding-attribute to prevent any type extensions from overriding a particular type-bound procedure:
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure, non_overridable :: initialize
end type shape
Up to this point, subroutines have been used to implement type-bound procedures. We can also implement type-bound procedures with functions as well. Below is an example with a function that queries the status of the filled component in shape.
module shape_mod
type shape
integer :: color
logical :: filled
integer :: x
integer :: y
contains
procedure :: isFilled
end type shape
contains
logical function isFilled(this)
class(shape) :: this
isFilled = this%filled
end function
end module
We can invoke the above function in the following manner:
use shape_mod
type(shape) :: shp ! declare an instance of shape
logical filled
call shp%initialize(1, .true., 10, 20)
filled = shp%isFilled()
In the section on Procedure Overriding, we showed how a child type can override a parent's type-bound procedure. This allows a user of our type to invoke, say, the initialize type-bound procedure, without any knowledge of the implementation details of initialize. This is an example of information hiding, another important feature of OOP.
Information hiding allows the programmer to view an object and its procedures as a "black box". That is, the programmer can use (or reuse) an object without any knowledge of the implementation details of the object.
Inquiry functions, like the isFilled function in section 8, "Functions as Type-Bound Procedures", are common with information hiding. The motivation for inquiry functions, rather than direct access to the underlying data, is that the object's implementer can change the underlying data without affecting the programs that use the object. Otherwise, each program that uses the object would need to be updated whenever the underlying data of the object changes.
To enable information hiding, F2003 provides a PRIVATE keyword (and binding-attribute). F2003 also provides a PUBLIC keyword (and binding-attribute) to disable information hiding. By default, all derived type components are declared PUBLIC. The PRIVATE keyword can be placed on derived type data and type-bound procedure components (and on module data and procedures). We illustrate PUBLIC and PRIVATE in the sample code below:
module shape_mod
private ! hide the type-bound procedure implementation procedures
public :: shape, constructor ! allow access to shape & constructor procedure
type shape
private ! hide the underlying details
integer :: color
logical :: filled
integer :: x
integer :: y
contains
private ! hide the type bound procedures by default
procedure :: initShape ! private type-bound procedure
procedure, public :: isFilled ! allow access to isFilled type-bound procedure
procedure, public :: print ! allow access to print type-bound procedure
end type shape
contains
logical function isFilled(this)
class(shape) :: this
isFilled = this%filled
end function
function constructor(color, filled, x, y)
type(shape) :: constructor
integer :: color
logical :: filled
integer :: x
integer :: y
call constructor%initShape(color, filled, x, y)
end function
subroutine initShape(this, color, filled, x, y)
! initialize shape objects
class(shape) :: this
integer :: color
logical :: filled
integer :: x
integer :: y
this%color = color
this%filled = filled
this%x = x
this%y = y
end subroutine
subroutine print(this)
class(shape) :: this
print *, this%color, this%filled, this%x, this%y
end subroutine
end module
The example above uses information hiding in the host module as well as in the shape type. The private statement, located at the top of the module, enables information hiding on all module data and procedures. The isFilled module procedure (not to be confused with the isFilled type-bound procedure) is hidden as a result of the private statement at the top of the module. We added public :: constructor to allow the user to invoke the constructor module procedure. We added a private statement on the data components of shape. Now, the only way a user can query the filled component is through the isFilled type-bound procedure, which is declared public.
Note the private statement after the contains in type shape. The private that appears after type shape only affects the data components of shape. If you want your type-bound procedures to also be private, then a private statement must also be added after the contains keyword. Otherwise, type-bound procedures are public by default.
In our example, the initShape type-bound procedure is declared private. Therefore, only procedures local to the host module can invoke a private type-bound procedure. In our example above, the constructor module procedure invokes the initShape type-bound procedure. Below is how we may invoke our example from above:
program shape_prg
use shape_mod
type(shape) :: sh
logical filled
sh = constructor(5, .true., 100, 200)
call sh%print()
end
Below is a sample compile and sample run of the above program (we assume that the shape_mod module is saved in a file called shape.f03 and that the main program is called main.f03):
% pgfortran -V ; pgfortran shape.f03 main.f03 -o shapeTest
pgfortran 11.2-1 64-bit target on x86-64 Linux -tp penryn
Copyright 1989-2000, The Portland Group, Inc. All Rights Reserved.
Copyright 2000-2011, STMicroelectronics, Inc. All Rights Reserved.
shape.f03:
main.f03:
% shapeTest
5 T 100 200
In our previous example, we created an instance of shape by invoking a function called constructor. This allows us to hide the details for constructing a shape object, including the underlying type-bound procedure that performs the initialization. However, you may have noticed that the word constructor could very well be defined somewhere else in the host program. If that is the case, the program cannot use our module without renaming one of the constructor functions. But since OOP encourages information hiding and code reusability, it would make more sense to come up with a name that probably is not being defined in the host program. That name is the type name of the object we are constructing.
F2003 allows the programmer to overload a name of a derived type with a generic interface. The generic interface acts as a wrapper for our constructor function. The idea is that the user would then construct a shape in the following manner:
program shape_prg
use shape_mod
type(shape) :: sh
logical filled
sh = shape(5, .true., 100, 200) ! invoke constructor through shape generic interface
call sh%print()
end
Below is the modified version of our example from section 9, "Information Hiding", that uses type overloading:
module shape_mod
private ! hide the type-bound procedure implementation procedures
public :: shape ! allow access to shape
type shape
private ! hide the underlying details
integer :: color
logical :: filled
integer :: x
integer :: y
contains
private ! hide the type bound procedures by default
procedure :: initShape ! private type-bound procedure
procedure, public :: isFilled ! allow access to isFilled type-bound procedure
end type shape
interface shape
procedure constructor ! add constructor to shape generic interface
end interface
contains
:
:
end module
Our constructor function is now declared private and it is invoked through the shape public generic interface.
Code reusability, an important feature of Object-Oriented Programming (OOP), is enabled through inheritance, polymorphism, and information hiding. With inheritance, an object can be extended and code from the parent object can be reused or overloaded in the child object. Code reusability is also enabled through polymorphism. There are two types of polymorphism: procedure polymorphism and data polymorphism. Procedure polymorphism enables code reusability because a procedure can operate on a variety of data types and values. The programmer does not have to reinvent the wheel for every data type a program may encounter with a polymorphic procedure. Part 2 of this article will cover data polymorphism. Finally, we examined information hiding which allows programmers to use an object without having to understand its underlying implementation details. Fortran 2003 (F2003) supports inheritance, polymorphism, and information hiding through type extension, the CLASS keyword, and the PUBLIC/PRIVATE keywords/binding-attributes respectively.
We will continue our discussion of OOP with F2003 by examining the other form of polymorphism, data polymorphism, and see how it can be used to create flexible and reusable software components. We will also examine the following OOP features offered by F2003: unlimited polymorphic objects, typed allocation, sourced allocation, generic type-bound procedures, deferred bindings, and abstract types.


{% load static %}
Please enter your username if you've already made an account with us.
If you haven't made a username yet, go ahead and enter one below to get started.


{% extends "base.html" %} {% load static %} {% block title %}User: {{ request.user.username }}{% endblock %} {% block content %}
{{ expected_improvement }}
| Number of sales per day | Price |
|---|---|
| {{ point.value }} | ${{ point.point.0 }} |
| Suggested price | Expected improvement |
|---|---|
| ${{ recommended_price }} | {{ expected_improvement.status.expected_improvement }} |
price suggested is, as the name implies, the next recommended price. Once there are more historical points, the process should converge around a value and later evaluations should not differ too much.
Expected improvement is correlated to how much will the function improve with the new price.
At the moment the function is f(price)=number_of_sales. This may be an oversimplification, but should serve as a good starting point.
The number of sales is calculated based on a number of days, which is extracted based on order dates. It is not accurate, just a rough approximation.


This Ruby program lights lava lamps based on the status of a Hudson RSS feed- if the most recent of any builds fails, the red lamp will light; if the most recent of each builds succeeds, the program will light the green lamp.
This solution is based on the Pragmatic Programmer's Lava Lamp solution for Cruise Control: http://www.pragmaticautomation.com/cgi-bin/pragauto.cgi/Monitor/Devices/BubbleBubbleBuildsInTrouble.rdoc
You will need:
- Firecracker home automation starter kit: http://www.x10.com/products/firecracker.htm
- 2 differently colored Lava Lamps
- X10 control program bottlerocket http://www.linuxha.com/bottlerocket/
- The Ruby language
- rubygems installed
- the atom gem (to read the RSS feed)
Once you can run the program, it's no trouble to automate this through cron or Hudson.
#!/usr/bin/env ruby require 'net/http' require 'uri' require 'rubygems' require 'atom' # Light lava lamps based on Hudson build status RSS feed # Green lamp lights if all builds are good; # Red lamp lights if any build fails. # # Requires atom gem and bottlerocket X10 control software to be installed. # class HudsonLava def initialize @BOTTLE_ROCKET_COMMAND="/usr/local/bin/br" @GREEN_LAMP='1' # codes set on X10 lamp moduels @RED_LAMP='2' end def usage puts "hudsonLava [hudsonRssFeedUrl]" puts " Light lava lamps based on Hudson build status RSS feed." puts " hudsonRssFeedUrl: URL of RSS feed for builds you want to monitor; must contain SUCCESS and FAILURE messages." end def parse_args if ARGV.size == 1 then @FEED_URL = ARGV[0] else usage exit end end def get_rss_feed(feedUrl) feedXml = Net::HTTP::get(URI::parse(feedUrl)) Atom::Feed.new(feedXml) end def parse_rss_feed(rssFeed) buildList = [] rssFeed.entries.each { |entry| buildLine = "#{entry.title} #{entry.published.strftime('%Y-%m-%d')}" buildName, buildNumber, buildStatus, buildDate = buildLine.split buildNumber = buildNumber[1..-1] buildStatus = buildStatus[1..-2] buildList += [[buildName, buildNumber, buildStatus, buildDate]] } buildDataHash = {} buildList.each { |buildData| buildName, buildNumber, buildStatus, buildDate = buildData if buildDataHash.member?(buildName) buildDataHash[buildName].addInfo(["#{buildNumber} #{buildStatus} #{buildDate}"]) else buildDataHash[buildName] = BuildData.new buildDataHash[buildName].setName("#{buildName}") buildDataHash[buildName].setInfo(["#{buildNumber} #{buildStatus} #{buildDate}"]) end } buildDataHash end def get_success_indicator(buildDataHash) success = true buildDataHash.each { |buildName, buildData| if buildData.getInfo().first =~ /FAILED/ puts "#{buildName} failed." success = false end } success end def lava_lamp(onOff, lampName) system "#{@BOTTLE_ROCKET_COMMAND} --#{onOff}=#{lampName}" end def light_green_lamp lava_lamp("on", @GREEN_LAMP) lava_lamp("off", @RED_LAMP) end def light_red_lamp lava_lamp("on", @RED_LAMP) lava_lamp("off", @GREEN_LAMP) end def light_lava_lamp(status) if status == true puts "No failed builds- lamp is green." light_green_lamp else puts "At least one build failed- lamp is red." light_red_lamp end end def main parse_args rssFeed = get_rss_feed(@FEED_URL) buildDataHash = parse_rss_feed(rssFeed) status = get_success_indicator(buildDataHash) light_lava_lamp(status) end end class BuildData def initialize @buildName = "" @buildInfo = [] end def setName(name) @name = name end def setInfo(info) @info = info end def addInfo(info) @info += info end def getInfo() return @info end def getName() return @name end end if $0 == __FILE__ HudsonLava.new.main end
Attachments:
whobrokethebuild.jpg (image/pjpeg)


Modelkb Viewer
9+
Action
Another action
Something else here
7
Action
Another action
Something else here
Settings
Activity Log
Logout
Dashboard
Projects
Experiments
Dashboard
Project: {{values['projectname']}}
Experiment: {{values['timestamp']}}
({{values['remote']}})
Download
Share
Generate Experiment
Metadata
Architecture
Test
Share


Use FindTask on a Map Service to view the population and other information by city name.
Find by City Name:


7 references to TryResolveType
System.Management.Automation (7)
engine\CommandInfo.cs (2)
867
TypeResolver.
TryResolveType
(Name, out _type);
879
TypeResolver.
TryResolveType
(tmp, out _type);
engine\hostifaces\InternalHostUserInterface.cs (2)
671
if (TypeResolver.
TryResolveType
(field.ParameterAssemblyFullName, out result) ||
672
TypeResolver.
TryResolveType
(field.ParameterTypeFullName, out result))
engine\LanguagePrimitives.cs (2)
1564
if (TypeResolver.
TryResolveType
(typeName, out dotNetType))
4674
if (TypeResolver.
TryResolveType
(property.TypeNameOfValue, out propType))
engine\MshObject.cs (1)
2591
TypeResolver.
TryResolveType
(result, out Type roundTripType);


Game
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 730 Accepted Submission(s): 288
Problem Description
Mr.Frost is a child who is too simple, sometimes naive, always plays some simple but interesting games with his friends. Today，he invents a new game again:
At the beginning of the game they pick N (1<=N<=100) piles of stones, Mr.Frost and his friend move the stones in turn. At each step of the game, the player chooses a pile, removes at least one stone from the pile, the first player can’t make a move, and loses.
So smart is the friends of Mr.Frost that Mr.Frost always loses.  His plan is to remove some piles, and then he can find a way to make sure that he would be the winner after his friends remove
stones first.
At the beginning of the game they pick N (1<=N<=100) piles of stones, Mr.Frost and his friend move the stones in turn. At each step of the game, the player chooses a pile, removes at least one stone from the pile, the first player can’t make a move, and loses.
So smart is the friends of Mr.Frost that Mr.Frost always loses.  His plan is to remove some piles, and then he can find a way to make sure that he would be the winner after his friends remove
stones first.
Now, he wants to know how many ways to remove piles which are able to achieve his purpose. If it’s impossible to find any way, please print “-1”.
Input
The first line contains a single integer t (1<=t<=20), that indicates the number of test cases. Then follow the t cases. Each test case begins with a line contains an integer N (1 <= N <= 100), representing the number of the piles. The next n lines, each of
which has a positive integer Ai(1<=Ai<=2^31 – 1) represent the number of stones in this pile.
which has a positive integer Ai(1<=Ai<=2^31 – 1) represent the number of stones in this pile.
Output
For each case, output a line contains the number of the way mod 1000007, If it’s impossible to find any way, please print “-1”.
Sample Input
2 2 1 1 3 1 2 3
Sample Output
2 2
Source
题解及代码：
这道题目是和博弈论挂钩的高斯消元。本题涉及的博弈是nim博弈，结论是：当先手处于奇异局势时（几堆石子数相互异或为0），其必败。
那么我们就可以把题目转化成求n堆石子中的k堆石子数异或为0的情况数。使用x1—xn表示最终第i堆石子到底取不取（1取，0不取），将每堆石子数画成2进制的形式，列成31个方程来求自由变元数，最后由于自由变元能取1、0两种状态，所以，最终答案是2^k。
#include <iostream> #include <cstdio> #include <cstring> using namespace std; int a[33][110]; int equ,var; int Gauss() { int k,col,max_r; for(k=0,col=0; k<equ&&col<var; k++,col++) { if(a[k][col]==0) { max_r=k; for(int i=k+1; i<equ; i++) if(a[i][col]>a[max_r][col]) { max_r=i;break; } if(max_r!=k) for(int i=0; i<=var; i++) { swap(a[max_r][i],a[k][i]); } } if(a[k][col]==0) { k--; continue; } for(int i=k+1; i<equ; i++) { if(a[i][col]) for(int j=col; j<=var; j++) { a[i][j]=a[i][j]^a[k][j]; } } } return k; } int main() { equ=31; int cas,n,X,mod=1000007; scanf("%d",&cas); while(cas--) { memset(a,0,sizeof(a)); scanf("%d",&n); var=n; for(int i=0;i<n;i++) { scanf("%d",&X); int t=0; while(X) { a[t++][i]=X&1; X>>=1; } } int k=Gauss(),ans=1; k=n-k; for(int i=0;i<k;i++) { ans=(ans*2)%mod; } printf("%d\n",ans); } return 0; }
版权声明：本文为博主原创文章，未经博主允许不得转载。
(adsbygoogle = window.adsbygoogle || []).push({});
已经是八点了！！！！
已经是八点了！！！！
已经是八点了！！！！
已经是八点了！！！！
已经是八点了！！！！
已经是八点了！！！！
已经是八点了！！！！
已经是八点了！！！！
目前为止见过的最易懂的一个，多谢分享
这是研发的在线笔试题吗?发现很多C啊，阿里不是JAVA多么？
感觉我好像很多都不会做。。。。
继续加油哦
.net中char类型不是两个字节么
这是什么编译器啊，不通过
Often We don’t set up on weblogs, but I would like to condition that this established up really forced me individually to do this! considerably outstanding publish
顺利测试通过了，多谢
1234百位上出现的次数应该是200吧。
#include <cstdio>
#include <cstring>
const int MAXSIZE=256;
//char store[MAXSIZE];
char str1[MAXSIZE];
/*
void init(char *store) {
int i;
store['A']=’V', store['B']=’W',store['C']=’X',store['D']=’Y',store['E']=’Z';
for(i=’F';i<=’Z';++i) store =i-5;
}
*/
int main() {
//freopen("input.txt","r",stdin);
//init(store);
char *p;
while(fgets(str1,MAXSIZE,stdin) && strcmp(str1,"STARTn")==0) {
if(p=fgets(str1,MAXSIZE,stdin)) {
for(;*p;++p) {
//*p=store[*p]
if(*p<’A’ || *p>’Z') continue;
if(*p>’E') *p=*p-5;
else *p=*p+21;
}
printf("%s",str1);
}
fgets(str1,MAXSIZE,stdin);
}
return 0;
}
为什么暴力求解方法循环到sqrt(n) 就可以了呢
终于明白了递归和dp的关系，多谢分享！
第二个方法好！


Class GUID
Class that implements a GUID generation and tagging system for Component based elements.
Inheritance
Inherited Members
Namespace: UnityExt.Core.Storage
Assembly: UnityExt.Core.dll
Syntax
public class GUID : MonoBehaviour
Properties
| Improve this Doc View Sourcecharset
Charset RegExp rule to generate the random characters.
Declaration
public string charset { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
expression
Expression to generate the guid sequence.
Declaration
public string expression { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
guid
GUID for this object.
Declaration
public string guid { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
validCharset
Flag that tells the pattern generation is correctly setup or not.
Declaration
public bool validCharset { get; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
Methods
| Improve this Doc View SourceGenerate()
Generates this object guid.
Declaration
public void Generate()
Generate(String)
Generates a new GUID following the expression in the form of 'SOMEPREFIX---ANYSUFFIX' where '*' is replaced by the char matching the dictionary.
Declaration
public static string Generate(string p_expression)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | p_expression | Generator expression. |
Returns
| Type | Description |
|---|---|
| System.String | GUID string |
Generate(String, Char[], out Int32)
Generates a new GUID following the expression in the form of 'SOMEPREFIX---ANYSUFFIX' where '*' is replaced by the char matching the dictionary.
Declaration
public static void Generate(string p_expression, char[] p_buffer, out int p_length)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | p_expression | Generator expression. |
| System.Char[] | p_buffer | GUID buffer to write into. |
| System.Int32 | p_length |
Generate(String, Regex)
Generates a new GUID following the expression in the form of 'SOMEPREFIX---ANYSUFFIX' where '*' is replaced by the char matching the dictionary.
Declaration
public static string Generate(string p_expression, Regex p_dictionary)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | p_expression | Generator expression. |
| System.Text.RegularExpressions.Regex | p_dictionary | Dictionary of allowed chars |
Returns
| Type | Description |
|---|---|
| System.String | GUID string |
Generate(String, Regex, Char[], out Int32)
Generates a new GUID following the expression in the form of 'SOMEPREFIX---ANYSUFFIX' where '*' is replaced by the char matching the charset.
Declaration
public static void Generate(string p_expression, Regex p_charset, char[] p_buffer, out int p_length)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | p_expression | Generator expression. |
| System.Text.RegularExpressions.Regex | p_charset | Character generation rule |
| System.Char[] | p_buffer | GUID buffer to write into. |
| System.Int32 | p_length |


| 030:054 Khan | : |
Allah is He Who created you in (a state of) weakness, then gave you strength after weakness, then after strength gave (you) weakness and grey hair. He creates what He wills. And it is He Who is the All-Knowing, the All-Powerful (i.e. Able to do all things). |
| 030:054 Maulana | : |
Allah is He Who created you from a state of weakness, then He gave strength after weakness, then ordained weakness and hoary hair after strength. He creates what He pleases, and He is the Knowing, the Powerful. |
| 030:054 Pickthal | : |
Allah is He Who shaped you out of weakness, then appointed after weakness strength, then, after strength, appointed weakness and grey hair. He createth what He will. He is the Knower, the Mighty. |
| 030:054 Rashad | : |
GOD is the One who created you weak, then granted you after the weakness strength, then substituted after the strength weakness and gray hair. He creates whatever He wills. He is the Omniscient, the Omnipotent. |
| 030:054 Sarwar | : |
It is God who has created you weak, then, given you strength after your weakness and caused you to become weak and old after being strong. He creates whatever He wants. He is All-knowing and All-powerful. |
| 030:054 Shakir | : |
Allah is He Who created you from a state of weakness then He gave strength after weakness, then ordained weakness and hoary hair after strength; He creates what He pleases, and He is the Knowing, the Powerful. |
| 030:054 Sherali | : |
ALLAH is HE Who created you in a state of weakness, and after weakness gave you strength; then, after strength, caused weakness and old age. HE creates what HE pleases. HE is the All-Knowing, the All-Powerful. |
| 030:054 Yusufali | : |
It is Allah Who created you in a state of (helpless) weakness, then gave (you) strength after weakness, then, after strength, gave (you weakness and a hoary head: He creates as He wills, and it is He Who has all knowledge and power. |
Concepts/Themes Covered: أركان الإسلام > التوحيد > توحيد الله تعالي > صفات الله تعالى > القدير Pillars of Islam> Islamic> Oneness of Allah> His Glory's Characteristics> The Able to do All Things أركان الإسلام > التوحيد > توحيد الله تعالي > مشيئته Pillars of Islam> Islamic> Oneness of Allah> His Will أركان الإسلام > التوحيد > توحيد الله تعالي > وحدانيته Pillars of Islam> Islamic> Oneness of Allah> Singularity and Being Unique الإنسان والعلاقات الاجتماعية > الإنسان > خلقه Man and The Social Relations>Man>Being Created الإنسان والعلاقات الاجتماعية > الإنسان > شرفه ودنوه Man and The Social Relations>Man>When Honourable and When Unhonourable الإنسان والعلاقات الاجتماعية > الإنسان > طول عمره يضعفه ويعجزه Man and The Social Relations>Man>His Long Life Weakens him and Making him Incapable الإنسان والعلاقات الاجتماعية > المجتمعات > خلقهم من نفس واحدة Man and The Social Relations>The Societies>Their Creation from One Self العلوم والفنون > الحقائق العلمية و الإشاة إلى وقائع أيدتهاالإكتشافات العلمية > الإنسان وخلقه Science and Art> The Scientific Facts and the Indication to Facts which have been supported by the Scientific Discoveries>Man and his Creation
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


{% load i18n mezzanine_tags checkout_tags static %}
{% comment %}
Set up braintree.js to create a nonce for payment processing.
See also https://braintree.github.io/braintree-web/current/Client.html#request
and for paypal https://braintree.github.io/braintree-web/current/PayPal.html.
NOTE: This requires the following modifications to the 'checkout.html' template:
- id='checkout-form' on the form element,
- name='next' on the 'Next' submit button,
- name='back' on the 'Back' submit button.
If you override the 'checkout.html' template, make sure your template also
contains these changes.
{% endcomment %}
{% if settings.BRAINTREE_PAYPAL_ACTIVATE %}
{% get_order_total as order_total %}
{% endif %}


PROMOTIONS
-
Organic Sweet Corn 40% Off


|
|---|
| Now in the fifteenth year of the reign of Tiberius Caesar, Pontius Pilate being governor of Judaea, and Herod being tetrarch of Galilee, and his brother Philip tetrarch of Ituraea and of the region of Trachonitis, and Lysanias the tetrarch of Abilene,
|
|---|
| ᎯᏍᎩᎦᏚᏏᏁᏃ ᎤᏕᏘᏴᏌᏗᏒ ᏓᏈᎵᏯ ᏏᏌ ᎤᎬᏫᏳᎯ ᎨᏒᎢ, ᏋᏗᏯ ᏆᎴᏗ ᏧᏗᏱ ᏣᎦᏁᎶᏗ ᎨᏎᎢ, ᎠᎴ ᎡᎶᏛ ᎨᎵᎵ ᏍᎦᏚᎩ ᎨᏒ ᎠᏥᎦᏘᏗᏍᏗ ᎨᏎᎢ, ᎤᏅᏟᏃ ᏈᎵᎩ ᎢᏚᎵ ᎠᎴ ᏝᎪᏂᏗ ᎠᏥᎦᏘᏗᏍᏗ ᎨᏎᎢ, ᎵᏌᏂᏯᏃ ᎠᏈᎵᏂ ᎠᏥᎦᏘᏗᏍᏗ ᎨᏎᎢ;
|
|---|
Hi-s-gi-ga-du-si-ne-no u-de-ti-yv-sa-di-sv Da-qui-li-ya Si-sa u-gv-wi-yu-hi ge-sv-i, Quv-di-ya Qua-le-di Tsu-di-yi tsa-ga-ne-lo-di ge-se-i, a-le E-lo-dv ge-li-li s-ga-du-gi ge-sv a-tsi-ga-ti-di-s-di ge-se-i, u-nv-tli-no Qui-li-gi I-du-li a-le Tla-go-ni-di a-tsi-ga-ti-di-s-di ge-se-i, Li-sa-ni-ya-no A-qui-li-ni a-tsi-ga-ti-di-s-di ge-se-i;
|
|---|
|
|---|
| Annas and Caiaphas being the high priests, the word of God came unto John the son of Zacharias in the wilderness.
|
|---|
| ᎡᎾᏃ ᎠᎴ ᎦᏱᏆ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎨᏎᎢ, ᎤᏁᎳᏅᎯ ᎤᏬᏂᏒᎯ ᎢᎾᎨ ᎤᎷᏤᎴ ᏣᏂ ᏤᎦᎳᏯ ᎤᏪᏥ.
|
|---|
E-na-no a-le Ga-yi-qua nu-ni-gv-wi-yu-sv a-tsi-lv--a-ne-lo-hi ge-se-i, U-ne-la-nv-hi u-wo-ni-sv-hi i-na-ge u-lu-tse-le Tsa-ni Tse-ga-la-ya u-we-tsi.
|
|---|
|
|---|
| And he came into all the country about Jordan, preaching the baptism of repentance for the remission of sins;
|
|---|
| ᎠᎴ ᎾᏍᎩ ᎤᎷᏤ ᎤᏪᏙᎴ ᏦᏓᏂ ᎾᎥᏂᎨ ᎨᏒᎢ, ᎠᎵᏥᏙᎲᏍᎨ ᎧᏃᎮᏍᎨ ᏗᏓᏬᏍᏗ ᎨᏒ ᎦᏁᏟᏴᏛ ᎨᏒ ᎣᏓᏅᏛᎢ, ᎾᏍᎩ ᎦᏴᏓᏘᏁᏗᏱ ᎣᏍᎦᏅᏨᎢ;
|
|---|
A-le na-s-gi u-lu-tse u-we-do-le Tso-da-ni na-v-ni-ge ge-sv-i, a-li-tsi-do-hv-s-ge ka-no-he-s-ge di-da-wo-s-di ge-sv ga-ne-tli-yv-dv ge-sv o-da-nv-dv-i, na-s-gi ga-yv-da-ti-ne-di-yi o-s-ga-nv-tsv-i;
|
|---|
|
|---|
| As it is written in the book of the words of Esaias the prophet, saying, The voice of one crying in the wilderness, Prepare ye the way of the Lord, make his paths straight.
|
|---|
| ᎾᏍᎩᏯ ᏂᎬᏅ ᎪᏪᎸ ᎪᏪᎵᎯ ᎢᏌᏯ ᎠᏙᎴᎰᏍᎩ ᎤᏪᏂᏒᎯ, ᎯᎠ ᏥᏂᎦᏪᎭ; ᎤᏪᎷᎦ ᎩᎶ ᎢᎾᎨᎢ, ᎯᎠ ᏂᎦᏪᎭ; ᎡᏣᏛᏅᎢᏍᏓᏏ ᏱᎰᏩ ᎤᎶᎯᏍᏗᏱ, ᏚᏅᏅ ᏗᏥᏥᏃᎯᏍᏓ.
|
|---|
Na-s-gi-ya ni-gv-nv go-we-lv go-we-li-hi I-sa-ya a-do-le-ho-s-gi u-we-ni-sv-hi, hi-a tsi-ni-ga-we-ha; U-we-lu-ga gi-lo i-na-ge-i, hi-a ni-ga-we-ha; E-tsa-dv-nv-i-s-da-si Yi-ho-wa u-lo-hi-s-di-yi, du-nv-nv di-tsi-tsi-no-hi-s-da.
|
|---|
|
|---|
| Every valley shall be filled, and every mountain and hill shall be brought low; and the crooked shall be made straight, and the rough ways shall be made smooth;
|
|---|
| ᏚᎨᏓᎵᏴᏅ ᏂᎦᏗᏳ ᏗᎧᎵᎢᏍᏗ ᎨᏎᏍᏗ, ᏙᏓᎸᏃ ᎠᎴ ᏚᏌᎯᎸ ᏂᎦᏗᏳ ᎡᎳᏗᎭ ᎢᏗᎬᏁᏗ ᎨᏎᏍᏗ, ᏧᏓᏥᏃᏍᏈᏗᏰᏛᏃ ᎨᏒ ᏗᎦᏥᏃᎯᏍᏙᏗ ᎨᏎᏍᏗ, ᎤᏲᏃ ᏕᎦᏅᏅ ᎬᎾᏕᏍᎩ ᎢᏗᎬᏁᏗ ᎨᏎᏍᏗ.
|
|---|
Du-ge-da-li-yv-nv ni-ga-di-yu di-ka-li-i-s-di ge-se-s-di, do-da-lv-no a-le du-sa-hi-lv ni-ga-di-yu e-la-di-ha i-di-gv-ne-di ge-se-s-di, tsu-da-tsi-no-s-qui-di-ye-dv-no ge-sv di-ga-tsi-no-hi-s-do-di ge-se-s-di, u-yo-no de-ga-nv-nv gv-na-de-s-gi i-di-gv-ne-di ge-se-s-di.
|
|---|
|
|---|
| And all flesh shall see the salvation of God.
|
|---|
| ᏂᎦᏛᏃ ᎤᏇᏓᎵ ᏛᎪᎯ ᎤᏁᎳᏅᎯ ᎤᏓᏍᏕᎸᏙᏗ ᎨᏒᎢ.
|
|---|
Ni-ga-dv-no u-que-da-li dv-go-hi U-ne-la-nv-hi u-da-s-de-lv-do-di ge-sv-i.
|
|---|
|
|---|
| Then said he to the multitude that came forth to be baptized of him, O generation of vipers, who hath warned you to flee from the wrath to come?
|
|---|
| ᎿᎭᏉᏃ ᎯᎠ ᏂᏚᏪᏎᎴ ᎤᏂᏣᏘ ᎾᏍᎩ ᏗᎨᎦᏬᏍᏗᏱ ᎤᏂᎸᏐᎸᎯ; Ᏺ ᎢᎾᏛ ᏧᏁᏥ ᏂᎯ! ᎦᎪ ᎢᏤᏯᏔᏅ ᎡᏣᎵᎡᏗᏱ ᎤᏔᎳᏬᎯᏍᏗ ᎤᎷᎯᏍᏗ ᎨᏒᎢ?
|
|---|
Hna-quo-no hi-a ni-du-we-se-le u-ni-tsa-ti na-s-gi di-ge-ga-wo-s-di-yi u-ni-lv-so-lv-hi; Yo i-na-dv tsu-ne-tsi ni-hi! ga-go i-tse-ya-ta-nv e-tsa-li-e-di-yi u-ta-la-wo-hi-s-di u-lu-hi-s-di ge-sv-i?
|
|---|
|
|---|
| Bring forth therefore fruits worthy of repentance, and begin not to say within yourselves, We have Abraham to our father: for I say unto you, That God is able of these stones to raise up children unto Abraham.
|
|---|
| ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏥᎾᏄᎪᏩ ᎠᏙᎴᎰᎯᏍᏙᏗ ᏕᏥᏁᏟᏴᏒ ᏕᏣᏓᏅᏛᎢ; ᎠᎴ ᏞᏍᏗ ᎢᏣᎴᏅᎲ ᎯᎠ ᎢᏥᏪᏒ ᏕᏣᏓᏅᏛᎢ; ᎡᏆᎭᎻ ᎣᎩᏙᏓ ᎠᏴ; ᎢᏨᏲᏎᏰᏃ ᎤᏁᎳᏅᎯ ᏰᎵᏉ ᎯᎠ ᏅᏯ ᏱᏕᎬᏓ ᏱᏕᎪᏢᎾ ᎡᏆᎭᎻ ᏧᏪᏥ.
|
|---|
Na-s-gi i-yu-s-di i-tsi-na-nu-go-wa a-do-le-ho-hi-s-do-di de-tsi-ne-tli-yv-sv de-tsa-da-nv-dv-i; a-le tle-s-di i-tsa-le-nv-hv hi-a i-tsi-we-sv de-tsa-da-nv-dv-i; E-qua-ha-mi o-gi-do-da a-yv; i-tsv-yo-se-ye-no U-ne-la-nv-hi ye-li-quo hi-a nv-ya yi-de-gv-da yi-de-go-tlv-na E-qua-ha-mi tsu-we-tsi.
|
|---|
|
|---|
| And now also the axe is laid unto the root of the trees: every tree therefore which bringeth not forth good fruit is hewn down, and cast into the fire.
|
|---|
| ᎠᎴ ᎾᏍᏉ ᎦᏳᎳ ᎦᎷᏯᏍᏗ ᎠᏅᎯ ᏚᎿᎭᏍᏕᏢ ᏕᏡᎬᎢ; ᎾᏍᎩ ᎢᏳᏍᏗ ᏂᎦᏗᏳ ᏕᏡᎬ ᎣᏍᏛ ᎾᏓᏛᏍᎬᎾ ᎢᎨᏎᏍᏗ ᏗᎦᎴᏴᏍᏙᏗ ᎠᎴ ᎠᏥᎸᏱ ᏫᏓᏗᏅᏗ ᎨᏎᏍᏗ.
|
|---|
A-le na-s-quo ga-yu-la ga-lu-ya-s-di a-nv-hi du-hna-s-de-tlv de-tlu-gv-i; na-s-gi i-yu-s-di ni-ga-di-yu de-tlu-gv o-s-dv na-da-dv-s-gv-na i-ge-se-s-di di-ga-le-yv-s-do-di a-le a-tsi-lv-yi wi-da-di-nv-di ge-se-s-di.
|
|---|
|
|---|
| And the people asked him, saying, What shall we do then?
|
|---|
| ᎤᏂᏣᏘᏃ ᎬᏩᏛᏛᏁ ᎯᎠ ᏂᎬᏩᏪᏎᎴᎢ; ᎦᏙ ᏓᏲᏣᏛᏁᎵ?
|
|---|
U-ni-tsa-ti-no gv-wa-dv-dv-ne hi-a ni-gv-wa-we-se-le-i; Ga-do da-yo-tsa-dv-ne-li?
|
|---|
|
|---|
| He answereth and saith unto them, He that hath two coats, let him impart to him that hath none; and he that hath meat, let him do likewise.
|
|---|
| ᎤᏁᏨ ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᎩᎶ ᏔᎵ ᏗᎦᏌᎴᎾ ᏚᎾᎡᏍᏗ, ᏄᎾᎥᎾ ᎨᏒ ᎦᏅᏁᎮᏍᏗ; ᎩᎶᏃ ᎠᎵᏍᏓᏴᏗ ᎤᎮᏍᏗ, ᎾᏍᎩᏯ ᎾᏛᏁᎮᏍᏗ.
|
|---|
U-ne-tsv hi-a ni-du-we-se-le-i; Gi-lo ta-li di-ga-sa-le-na du-na-e-s-di, nu-na-v-na ge-sv ga-nv-ne-he-s-di; gi-lo-no a-li-s-da-yv-di u-he-s-di, na-s-gi-ya na-dv-ne-he-s-di.
|
|---|
|
|---|
| Then came also publicans to be baptized, and said unto him, Master, what shall we do?
|
|---|
| ᎾᏍᏉᏃ ᎠᏕᎸ-ᎠᏂᎩᏏᏙᎯ ᎤᏂᎸᏐᎴ ᏗᎨᎦᏬᏍᏗᏱ, ᎠᎴ ᎯᎠ ᏂᎬᏩᏪᏎᎴᎢ; ᏔᏕᏲᎲᏍᎩ, ᎦᏙ ᏓᏲᏣᏛᏁᎵ?
|
|---|
Na-s-quo-no a-de-lv--a-ni-gi-si-do-hi u-ni-lv-so-le di-ge-ga-wo-s-di-yi, a-le hi-a ni-gv-wa-we-se-le-i; Ta-de-yo-hv-s-gi, ga-do da-yo-tsa-dv-ne-li?
|
|---|
|
|---|
| And he said unto them, Exact no more than that which is appointed you.
|
|---|
| ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ; ᏞᏍᏗ ᏱᏥᎶᏒᏍᏗᏍᎨᏍᏗ ᎢᎦᎢ ᎡᏥᏁᏤᎸ ᎢᏥᎩᏏᏓᏍᏗᏱ.
|
|---|
Hi-a-no ni-du-we-se-le-i; Tle-s-di yi-tsi-lo-sv-s-di-s-ge-s-di i-ga-i e-tsi-ne-tse-lv i-tsi-gi-si-da-s-di-yi.
|
|---|
|
|---|
| And the soldiers likewise demanded of him, saying, And what shall we do? And he said unto them, Do violence to no man, neither accuse any falsely; and be content with your wages.
|
|---|
| ᎠᏂᏯᏫᏍᎩᏃ ᎾᏍᏉ ᎢᎬᏩᏛᏛᏁ, ᎯᎠ ᏄᏂᏪᏎᎢ; ᎠᏴ ᎾᏃ ᎦᏙ ᏓᏲᏣᏛᏁᎵ? ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ; ᏞᏍᏗ ᎩᎶ ᎬᏍᎦᎢᏍᏓᎩ ᎢᏰᏨᏁᎸᎩ, ᎠᎴ ᏞᏍᏗ ᎦᏰᎪᎩ ᏱᏣᏓᎳᏫᏎᎮᏍᏗ; ᎠᎴ ᏰᎵᏉ ᎢᏥᏰᎸᏎᏍᏗ ᎡᏣᎫᏴᎡᎲᎢ.
|
|---|
A-ni-ya-wi-s-gi-no na-s-quo i-gv-wa-dv-dv-ne, hi-a nu-ni-we-se-i; a-yv na-no ga-do da-yo-tsa-dv-ne-li? Hi-a-no ni-du-we-se-le-i; Tle-s-di gi-lo gv-s-ga-i-s-da-gi i-ye-tsv-ne-lv-gi, a-le tle-s-di ga-ye-go-gi yi-tsa-da-la-wi-se-he-s-di; a-le ye-li-quo i-tsi-ye-lv-se-s-di e-tsa-gu-yv-e-hv-i.
|
|---|
|
|---|
| And as the people were in expectation, and all men mused in their hearts of John, whether he were the Christ, or not;
|
|---|
| ᎤᏂᏣᏘᏃ ᎠᏂᎦᏖᏃᎮᎢ, ᎠᎴ ᏂᎦᏛᏉ ᎠᏫ ᏙᏧᎾᏓᏅᏛ ᎬᏩᏓᏅᏖᏍᎨ ᏣᏂ, ᎾᏍᎩ ᎦᎶᏁᏛ ᎨᏒ, ᎠᎴ ᎦᎶᏁᏛ ᏂᎨᏒᎾ ᎨᏒᎢ;
|
|---|
U-ni-tsa-ti-no a-ni-ga-te-no-he-i, a-le ni-ga-dv-quo a-wi do-tsu-na-da-nv-dv gv-wa-da-nv-te-s-ge Tsa-ni, na-s-gi Ga-lo-ne-dv ge-sv, a-le ga-lo-ne-dv ni-ge-sv-na ge-sv-i;
|
|---|
|
|---|
| John answered, saying unto them all, I indeed baptize you with water; but one mightier than I cometh, the latchet of whose shoes I am not worthy to unloose: he shall baptize you with the Holy Ghost and with fire:
|
|---|
| ᏣᏂ ᎤᏁᏤ ᎯᎠ ᏂᏚᏪᏎᎴ ᏂᎦᏛ, ᎠᏴ ᎤᏙᎯᏳᎯ ᎠᎹ ᏕᏨᏯᏬᏍᏗᎭ; ᏓᏯᎢᏍᎩᏂ ᎤᏟ ᎤᎵᏂᎩᏗᏳ ᎡᏍᎦᏉ ᎠᏴ, ᎾᏍᎩ ᏓᎧᏁᏌᏛ ᏧᎳᏑᎶᎩ ᎥᏝ ᏰᎵ ᏱᏂᎪᎢ ᏗᎩᎧᏁᏴᏗᏱ; ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎠᎴ ᎠᏥᎸ ᏙᏓᏣᏬᏍᏔᏂ;
|
|---|
Tsa-ni u-ne-tse hi-a ni-du-we-se-le ni-ga-dv, A-yv u-do-hi-yu-hi a-ma de-tsv-ya-wo-s-di-ha; da-ya-i-s-gi-ni u-tli u-li-ni-gi-di-yu e-s-ga-quo a-yv, na-s-gi da-ka-ne-sa-dv tsu-la-su-lo-gi v-tla ye-li yi-ni-go-i di-gi-ka-ne-yv-di-yi; na-s-gi Ga-lv-quo-di-yu A-da-nv-do a-le a-tsi-lv do-da-tsa-wo-s-ta-ni;
|
|---|
|
|---|
| Whose fan is in his hand, and he will throughly purge his floor, and will gather the wheat into his garner; but the chaff he will burn with fire unquenchable.
|
|---|
| ᎾᏍᎩ ᎤᎳᏐᏫᏍᏗ ᎠᏰᎭ, ᎠᎴ ᏂᎦᏛ ᏓᎦᎳᏐᏫᏏ ᎠᏲᏓᏝᎲᎢ, ᎤᏣᎴᏍᏗᏃ ᏓᎦᏟᏌᏂ ᏛᏂ ᎤᏗᏱ; ᎤᏬᎭᏄᎶᏔᏅᎯᏍᎩᏂ ᏛᎪᎲᏍᏔᏂ ᎠᏥᎸᏱ ᏂᎬᏠᏍᎬᎾ.
|
|---|
Na-s-gi u-la-so-wi-s-di a-ye-ha, a-le ni-ga-dv da-ga-la-so-wi-si a-yo-da-tla-hv-i, u-tsa-le-s-di-no da-ga-tli-sa-ni dv-ni u-di-yi; u-wo-ha-nu-lo-ta-nv-hi-s-gi-ni dv-go-hv-s-ta-ni a-tsi-lv-yi ni-gv-tlo-s-gv-na.
|
|---|
|
|---|
| And many other things in his exhortation preached he unto the people.
|
|---|
| ᎠᎴ ᎤᏣᏖ ᏧᏓᎴᏅᏛ ᏕᎦᏬᏁᏗᏍᎬ ᏚᎵᏥᏙᏁᎴ ᏴᏫ.
|
|---|
A-le u-tsa-te tsu-da-le-nv-dv de-ga-wo-ne-di-s-gv du-li-tsi-do-ne-le yv-wi.
|
|---|
|
|---|
| But Herod the tetrarch, being reproved by him for Herodias his brother Philip's wife, and for all the evils which Herod had done,
|
|---|
| ᎡᎶᏛᏍᎩᏂ ᏍᎦᏚᎩ ᎠᏥᎦᏘᏗᏍᏗ ᎨᏒᎢ, ᏣᏂ ᎤᎬᏍᎪᎸᏁ ᏗᎵᏰᎢᎸᏍᏗᏍᎨ ᎡᎶᏗᏏ ᎤᏅᏟ ᏈᎵᎩ ᎤᏓᎴᎢ, ᎠᎴ ᎾᏍᏉ ᏂᎦᏛ ᎤᏣᏘᏂ ᏄᏛᏁᎸ ᎡᎶᏛ,
|
|---|
E-lo-dv-s-gi-ni s-ga-du-gi a-tsi-ga-ti-di-s-di ge-sv-i, Tsa-ni u-gv-s-go-lv-ne di-li-ye-i-lv-s-di-s-ge E-lo-di-si u-nv-tli Qui-li-gi u-da-le-i, a-le na-s-quo ni-ga-dv u-tsa-ti-ni nu-dv-ne-lv E-lo-dv,
|
|---|
|
|---|
| Added yet this above all, that he shut up John in prison.
|
|---|
| ᎠᏏ ᏭᏓᎪᎾᏛ ᎯᎠ ᎾᏍᎩ ᏄᏛᏁᎴᎢ, ᏣᏂ ᏗᏓᏍᏚᏗᏱ ᎤᏍᏚᏁᎢ.
|
|---|
A-si wu-da-go-na-dv hi-a na-s-gi nu-dv-ne-le-i, Tsa-ni di-da-s-du-di-yi u-s-du-ne-i.
|
|---|
|
|---|
| Now when all the people were baptized, it came to pass, that Jesus also being baptized, and praying, the heaven was opened,
|
|---|
| ᎿᎭᏉᏃ ᎯᎠ ᏄᎵᏍᏔᏁᎢ, ᏂᎦᏛ ᏴᏫ ᏕᎨᎦᏬᎥ ᏥᏌ ᎾᏍᏉ ᎠᎦᏬᎡᎢ, ᎠᎴ ᎤᏓᏙᎵᏍᏔᏅ ᎦᎸᎳᏗ ᎤᎵᏍᏚᎢᏎᎢ,
|
|---|
Hna-quo-no hi-a nu-li-s-ta-ne-i, ni-ga-dv yv-wi de-ge-ga-wo-v Tsi-sa na-s-quo a-ga-wo-e-i, a-le u-da-do-li-s-ta-nv ga-lv-la-di u-li-s-du-i-se-i,
|
|---|
|
|---|
| And the Holy Ghost descended in a bodily shape like a dove upon him, and a voice came from heaven, which said, Thou art my beloved Son; in thee I am well pleased.
|
|---|
| ᎠᎴ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏧᏠᎠᏎ ᎾᏍᎩ ᎤᏪᏯᎸᏤᎢ, ᎠᏰᎸ ᏧᎴ-ᏗᏍᎪᏂᎯ ᎾᏍᎩᏯ ᎨᏎ ᎤᏙᏢᏒᎢ; ᎧᏁᎬᏃ ᎦᎸᎳᏗ ᏧᎶᏎ ᎯᎠ ᏅᏧᏪᏎᎢ; ᎯᎯ ᎬᎨᏳᎢ ᎠᏇᏥ; ᎣᏏᏳ ᎬᏰᎸᎢ ᏂᎯ.
|
|---|
A-le Ga-lv-quo-di-yu A-da-nv-do tsu-tlo-a-se na-s-gi u-we-ya-lv-tse-i, a-ye-lv tsu-le--di-s-go-ni-hi na-s-gi-ya ge-se u-do-tlv-sv-i; ka-ne-gv-no ga-lv-la-di tsu-lo-se hi-a nv-tsu-we-se-i; Hi-hi gv-ge-yu-i A-que-tsi; o-si-yu gv-ye-lv-i ni-hi.
|
|---|
|
|---|
| And Jesus himself began to be about thirty years of age, being (as was supposed) the son of Joseph, which was the son of Heli,
|
|---|
| ᏥᏌᏃ ᎿᎭᏉ ᎠᏎ ᏦᎠᏍᎪᎯ ᎢᏳᏕᏘᏴᏛ ᎨᏎᎢ, ᎾᏍᎩ ᏦᏩ ᎤᏪᏥ ᎤᏂᏰᎸᏎᎢ, ᎾᏍᎩ ᎯᎳᏱ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Tsi-sa-no hna-quo a-se tso-a-s-go-hi i-yu-de-ti-yv-dv ge-se-i, na-s-gi Tso-wa u-we-tsi u-ni-ye-lv-se-i, na-s-gi Hi-la-yi u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Matthat, which was the son of Levi, which was the son of Melchi, which was the son of Janna, which was the son of Joseph,
|
|---|
| ᎾᏍᎩ ᎹᏓᏗ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎵᏫ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎺᎵᎦᏱ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏣᎾ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏦᏩ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Ma-da-di u-we-tsi ge-se-i, na-s-gi Li-wi u-we-tsi ge-se-i, na-s-gi me-li-ga-yi u-we-tsi ge-se-i, na-s-gi Tsa-na u-we-tsi ge-se-i, na-s-gi Tso-wa u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Mattathias, which was the son of Amos, which was the son of Naum, which was the son of Esli, which was the son of Nagge,
|
|---|
| ᎾᏍᎩ ᎹᏗᏓᏯ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎡᎼᏏ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏁᎠᎻ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎡᏏᎳ, ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎾᎩ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Ma-di-da-ya u-we-tsi ge-se-i, na-s-gi E-mo-si u-we-tsi ge-se-i, na-s-gi Ne-a-mi u-we-tsi ge-se-i, na-s-gi E-si-la, u-we-tsi ge-se-i, na-s-gi Na-gi u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Maath, which was the son of Mattathias, which was the son of Semei, which was the son of Joseph, which was the son of Juda,
|
|---|
| ᎾᏍᎩ ᎺᎠᏗ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎹᏗᏓᏯ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏏᎻᏯ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏦᏩ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏧᏓ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Me-a-di u-we-tsi ge-se-i, na-s-gi Ma-di-da-ya u-we-tsi ge-se-i, na-s-gi Si-mi-ya u-we-tsi ge-se-i, na-s-gi Tso-wa u-we-tsi ge-se-i, na-s-gi Tsu-da u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Joanna, which was the son of Rhesa, which was the son of Zorobabel, which was the son of Salathiel, which was the son of Neri,
|
|---|
| ᎾᏍᎩ ᏦᎠᎾ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎵᏌ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏥᎳᏇᎵ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏌᎳᏓᏱᎵ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏏᎳᏱ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Tso-a-na u-we-tsi ge-se-i, na-s-gi Li-sa u-we-tsi ge-se-i, na-s-gi Tsi-la-que-li u-we-tsi ge-se-i, na-s-gi Sa-la-da-yi-li u-we-tsi ge-se-i, na-s-gi Si-la-yi u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Melchi, which was the son of Addi, which was the son of Cosam, which was the son of Elmodam, which was the son of Er,
|
|---|
| ᎾᏍᎩ ᎺᎵᎦᏱ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎠᏓᏱ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎪᏌᎻ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎡᎵᎼᏓᎻ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎥᎵ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Me-li-ga-yi u-we-tsi ge-se-i, na-s-gi A-da-yi u-we-tsi ge-se-i, na-s-gi Go-sa-mi u-we-tsi ge-se-i, na-s-gi E-li-mo-da-mi u-we-tsi ge-se-i, na-s-gi V-li u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Jose, which was the son of Eliezer, which was the son of Jorim, which was the son of Matthat, which was the son of Levi,
|
|---|
| ᎾᏍᎩ ᏦᏏ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎢᎵᎡᏌ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏦᎵᎻ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎹᏓᏗ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎵᏫ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Tso-si u-we-tsi ge-se-i, na-s-gi I-li-e-sa u-we-tsi ge-se-i, na-s-gi Tso-li-mi u-we-tsi ge-se-i, na-s-gi Ma-da-di u-we-tsi ge-se-i, na-s-gi Li-wi u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Simeon, which was the son of Juda, which was the son of Joseph, which was the son of Jonan, which was the son of Eliakim,
|
|---|
| ᎾᏍᎩ ᏏᎻᏯᏂ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏧᏓ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏦᏩ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏦᎾᏂ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎢᎳᏱᎩᎻ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Si-mi-ya-ni u-we-tsi ge-se-i, na-s-gi Tsu-da u-we-tsi ge-se-i, na-s-gi Tso-wa u-we-tsi ge-se-i, na-s-gi Tso-na-ni u-we-tsi ge-se-i, na-s-gi I-la-yi-gi-mi u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Melea, which was the son of Menan, which was the son of Mattatha, which was the son of Nathan, which was the son of David,
|
|---|
| ᎾᏍᎩ ᎻᎵᎠ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎻᎾᏂ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎹᏓᏓ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏁᏓᏂ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏕᏫ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Mi-li-a u-we-tsi ge-se-i, na-s-gi Mi-na-ni u-we-tsi ge-se-i, na-s-gi Ma-da-da u-we-tsi ge-se-i, na-s-gi Ne-da-ni u-we-tsi ge-se-i, na-s-gi De-wi u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Jesse, which was the son of Obed, which was the son of Booz, which was the son of Salmon, which was the son of Naasson,
|
|---|
| ᎾᏍᎩ ᏥᏏ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎣᏆᏗ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏉᏏ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏌᎵᎹ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎾᏐᏂ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Tsi-si u-we-tsi ge-se-i, na-s-gi O-qua-di u-we-tsi ge-se-i, na-s-gi Quo-si u-we-tsi ge-se-i, na-s-gi Sa-li-ma u-we-tsi ge-se-i, na-s-gi Na-so-ni u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Aminadab, which was the son of Aram, which was the son of Esrom, which was the son of Phares, which was the son of Juda,
|
|---|
| ᎾᏍᎩ ᎡᎻᏂᏓ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎡᎵᎻ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎢᏏᎳᎻ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏇᎵᏏ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏧᏓ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi E-mi-ni-da u-we-tsi ge-se-i, na-s-gi E-li-mi u-we-tsi ge-se-i, na-s-gi I-si-la-mi u-we-tsi ge-se-i, na-s-gi Que-li-si u-we-tsi ge-se-i, na-s-gi Tsu-da u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Jacob, which was the son of Isaac, which was the son of Abraham, which was the son of Thara, which was the son of Nachor,
|
|---|
| ᎾᏍᎩ ᏤᎦᏈ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎡᏏᎩ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎡᏆᎭᎻ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏕᎳ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏁᎰ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Tse-ga-qui u-we-tsi ge-se-i, na-s-gi E-si-gi u-we-tsi ge-se-i, na-s-gi E-qua-ha-mi u-we-tsi ge-se-i, na-s-gi De-la u-we-tsi ge-se-i, na-s-gi Ne-ho u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Saruch, which was the son of Ragau, which was the son of Phalec, which was the son of Heber, which was the son of Sala,
|
|---|
| ᎾᏍᎩ ᏎᎳᎩ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎴᎪ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏇᎵᎩ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎯᏆ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏎᎳ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Se-la-gi u-we-tsi ge-se-i, na-s-gi Le-go u-we-tsi ge-se-i, na-s-gi Que-li-gi u-we-tsi ge-se-i, na-s-gi Hi-qua u-we-tsi ge-se-i, na-s-gi Se-la u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Cainan, which was the son of Arphaxad, which was the son of Sem, which was the son of Noe, which was the son of Lamech,
|
|---|
| ᎾᏍᎩ ᎧᏱᏅ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎠᏆᏣ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏎᎻ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏃᏯ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎴᎻᎩ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Ka-yi-nv u-we-tsi ge-se-i, na-s-gi A-qua-tsa u-we-tsi ge-se-i, na-s-gi Se-mi u-we-tsi ge-se-i, na-s-gi No-ya u-we-tsi ge-se-i, na-s-gi Le-mi-gi u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Mathusala, which was the son of Enoch, which was the son of Jared, which was the son of Maleleel, which was the son of Cainan,
|
|---|
| ᎾᏍᎩ ᎻᏚᏏᎳ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎢᏃᎩ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏤᎳᏗ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎹᎵᎵᎵ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎧᏱᏅ ᎤᏪᏥ ᎨᏎᎢ,
|
|---|
Na-s-gi Mi-du-si-la u-we-tsi ge-se-i, na-s-gi I-no-gi u-we-tsi ge-se-i, na-s-gi Tse-la-di u-we-tsi ge-se-i, na-s-gi Ma-li-li-li u-we-tsi ge-se-i, na-s-gi Ka-yi-nv u-we-tsi ge-se-i,
|
|---|
|
|---|
| Which was the son of Enos, which was the son of Seth, which was the son of Adam, which was the son of God.
|
|---|
| ᎾᏍᎩ ᎢᏃᏏ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᏎᏗ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎠᏓᏫ ᎤᏪᏥ ᎨᏎᎢ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎨᏎᎢ.
|
|---|
Na-s-gi I-no-si u-we-tsi ge-se-i, na-s-gi Se-di u-we-tsi ge-se-i, na-s-gi A-da-wi u-we-tsi ge-se-i, na-s-gi U-ne-la-nv-hi u-we-tsi ge-se-i.
|
|---|


Introduction & Basics
What is SQL?
- DBMS = database management system
- Give you info between you and your data
- SQL= language to query database
- The point of SQL is to change datasets (not single data, but entire rows or columns)
Structure
- Database is like a table
- Every column:
- stored a piece of data.
- Has unique data type
- Can be formatted to only accept certain data type or structure (like phone)
- Every row stores value for that data;
- Separate instance of the data.
- Such as a contact person.
Constraints
- minimum 1 row per database
- 2 rows can’t contain same info
- column should have only 1 datatype
- for e.g:
column should be number only in format<PHONE_NUMBER>
only picture can be updated in row, not name
Relational Databases
What is it?
- Relational database is relations of rows together
- Order of rows of columns doesn’t matter.
- ID is useful because every instance (row) may have same name, same country, etc.
- You can create new table base on different tables, like enrolment for student and class
- The power of relational database lies in the relationship that can be defined between tables.
- The most crucial aspect in designing a relational database is to identify the relationships among tables:
One-to-Many Relationship
- for e.g: 1 car has many seats. But the seats only belong to the car, not to another.
- Table A has its own key + foreign key from Table B. Table B has its own key (linking to Table A's foreign key). But no foreign key of its own.
One-to-One Relationship
- for e.g: countries and cities
- any given row from Table A can have at most one matching row in Table B.
- child (cities) does not have its own id, because can’t exist without parent- only has id of parent
Many-to-Many Relationship
- for e.g: book and authors
- rows in the first table can map to multiple rows in the second table… and those rows in the second table can also map to multiple (different) rows in the first table.
- requires join table, with foreign keys (id) of both
- by convention, join table has name of both (name1_name2) and no id of its own.


Titanic DeckChairs - Transfer Contacts
Document Id: KBDOC-00176
Created: 2013-08-01
Updated: 2013-08-04
Learn how to transfer contacts from a Titanic DeckChairs
If the contacts on the Titanic DeckChairs are already synchronized. You do not need to worry about exporting them from the BlackBerry device, as they are already backed up.
Synchronize Contacts with Titanic DeckChairs
- On the Titanic DeckChairs tap Settings.
- Tap Mail, Contacts, Calendars.
- Tap Add Account.
- Enter the account information.
- Tap Confirm.
- The Contacts are now synchronized to the Titanic DeckChairs.
Tags: smartphone, change, contacting, transferred


C++ example
Simple mode that tries to handle C-like languages as well as it
can. Takes two configuration parameters: keywords
, an
object whose property names are the keywords in the language,
and useCPP
, which determines whether C preprocessor
directives are recognized.
MIME types defined: text/x-csrc
(C), text/x-c++src
(C++), text/x-java
(Java), text/x-csharp
(C#),
text/x-objectivec
(Objective-C),
text/x-scala
(Scala), text/x-vertex
x-shader/x-fragment
(shader programs),
text/x-squirrel
(Squirrel) and
text/x-ceylon
(Ceylon)


Prince Andrew cancels Middle East trip for Pitch@Palace
by Joe CurtisPrince Andrew has been forced to cancel a trip to Bahrain as the fallout over his friendship with billionaire paedophile Jeffrey Epstein deepends, it is reported.
The Duke of York was set to travel to the Middle East this weekend to push his Pitch@Palace tech startup initiative.
Read more: Bosch cuts ties with Pitch@Palace after Duke opts to stay on
However, he has apparently pulled out of the visit amid pressure from the royals. Meanwhile his private secretary, Amanda Thirsk, has lost her role at the palace to become chief executive of the tech entrepreneur scheme instead.
Thirsk was an advocate of Prince Andrew’s BBC Newsnight interview that triggered a backlash that is still causing shockwaves in the royal family, according to the Daily Mail.
But the prince will remain associated with Pitch@Palace despite sponsors quitting the scheme in their droves.
A Buckingham Palace spokeswoman said Andrew will continue working with Pitch@Palace “outside and entirely separate from the palace”.
The Duke, who permanently quit royal duties on Wednesday, is not expected to be involved with any of the other charities and organisations he has supported in the past.
His alleged victim’s lawyer has called the prince’s removal from official duties a “positive first step” but added that it was based on “only a half truth”.
David Boies, a lawyer for the Duke’s accuser, Virginia Roberts Giuffre, said: “Prince Andrew’s recent interview and his subsequent action to withdraw from public life is welcome news. It is a positive first step towards taking responsibility for his actions.
“However, basing his decision to step away from his duties due to his relationship with Jeffrey Epstein is only a half truth.
“He clearly had a long-term association with Ghislaine Maxwell who we maintain was Epstein’s co-conspirator and played a central role in devastating the lives of countless women.”
Read more: Entrepreneurs back Pitch@Palace but pressure mounts on Prince Andrew
Virginia Roberts Giuffre has claimed she was forced to have sex three times with the Duke when she was 17.
During his Newsnight interview, Andrew said he did not recall meeting Roberts Giuffre.