Background¶
On this page, you will compute PRS using the popular genetic analyses tool plink
- while plink
is not a dedicated PRS software, you can perform every required steps of the C+T approach with plink
.
This multi-step process is a good way to learn the processes involved in computing PRS, which are typically performed automatically by PRS software.
Required Data¶
In the previous sections, we have generated the following files:
| File Name | Description |
|---|---|
| Height.QC.gz | The post-QCed summary statistic |
| EUR.QC.bed | The genotype file after performing some basic filtering |
| EUR.QC.bim | This file contains the SNPs that passed the basic filtering |
| EUR.QC.fam | This file contains the samples that passed the basic filtering |
| EUR.height | This file contains the phenotype of the samples |
| EUR.cov | This file contains the covariates of the samples |
Update Effect Size¶
When the effect size relates to disease risk and is thus given as an odds ratio (OR), rather than BETA (for continuous traits), then the PRS is computed as a product of ORs. To simplify this calculation, we take the natural logarithm of the OR so that the PRS can be computed using summation instead (which can be back-transformed afterwards).
We can obtain the transformed summary statistics with R
:
dat <- read.table(gzfile("Height.QC.gz"), header=T)
dat$BETA <- log(dat$OR)
write.table(dat, "Height.QC.Transformed", quote=F, row.names=F)
q() # exit R
library(data.table)
dat <- fread("Height.QC.gz")
fwrite(dat[,BETA:=log(OR)], "Height.QC.Transformed", sep="\t")
q() # exit R
Warning
Due to rounding of values, using awk
to log transform OR can lead to less accurate results. Therefore, we recommend performing the transformation in R
or allow the PRS software to perform the transformation directly.
Clumping¶
Linkage disequilibrium, which corresponds to the correlation between the genotypes of genetic variants across the genome, makes identifying the contribution from causal independent genetic variants extremely challenging.
One way of approximately capturing the right level of causal signal is to perform clumping, which removes SNPs in ways that only weakly correlated SNPs are retained but preferentially retaining the SNPs most associated with the phenotype under study.
Clumping can be performed using the following command in plink
:
plink \
--bfile EUR.QC \
--clump-p1 1 \
--clump-r2 0.1 \
--clump-kb 250 \
--clump Height.QC.Transformed \
--clump-snp-field SNP \
--clump-field P \
--out EUR
Each of the new parameters corresponds to the following
| Parameter | Value | Description |
|---|---|---|
| clump-p1 | 1 | P-value threshold for a SNP to be included as an index SNP. 1 is selected such that all SNPs are include for clumping |
| clump-r2 | 0.1 | SNPs having \(r^2\) higher than 0.1 with the index SNPs will be removed |
| clump-kb | 250 | SNPs within 250k of the index SNP are considered for clumping |
| clump | Height.QC.Transformed | Base data (summary statistic) file containing the P-value information |
| clump-snp-field | SNP | Specifies that the column SNP contains the SNP IDs |
| clump-field | P | Specifies that the column P contains the P-value information |
A more detailed description of the clumping process can be found here
Note
The \(r^2\) values computed by --clump
are based on maximum likelihood haplotype frequency estimates
This will generate EUR.clumped, containing the index SNPs after clumping is performed. We can extract the index SNP ID by performing the following command:
awk 'NR!=1{print $3}' EUR.clumped > EUR.valid.snp
$3
because the third column contains the SNP ID
Note
If your target data are small (e.g. N < 500) then you can use the 1000 Genomes Project samples for the LD calculation. Make sure to use the population that most closely reflects represents the base sample.
Generate PRS¶
plink
provides a convenient function --score
and --q-score-range
for calculating polygenic scores.
We will need three files:
- The base data file: Height.QC.Transformed
- A file containing SNP IDs and their corresponding P-values (
$3
because SNP ID is located in the third column;$8
because the P-value is located in the eighth column)
awk '{print $3,$8}' Height.QC.Transformed > SNP.pvalue
- A file containing the different P-value thresholds for inclusion of SNPs in the PRS. Here calculate PRS corresponding to a few thresholds for illustration purposes:
echo "0.001 0 0.001" > range_list
echo "0.05 0 0.05" >> range_list
echo "0.1 0 0.1" >> range_list
echo "0.2 0 0.2" >> range_list
echo "0.3 0 0.3" >> range_list
echo "0.4 0 0.4" >> range_list
echo "0.5 0 0.5" >> range_list
The format of the range_list file should be as follows:
| Name of Threshold | Lower bound | Upper Bound |
|---|---|---|
Note
The threshold boundaries are inclusive. For example, for the 0.05
threshold, we include all SNPs with P-value from
0
to 0.05
, including any SNPs with P-value equal to 0.05
.
We can then calculate the PRS with the following plink
command:
plink \
--bfile EUR.QC \
--score Height.QC.Transformed 3 4 12 header \
--q-score-range range_list SNP.pvalue \
--extract EUR.valid.snp \
--out EUR
The meaning of the new parameters are as follows:
| Paramter | Value | Description |
|---|---|---|
| score | Height.QC.Transformed 3 4 12 header | We read from the Height.QC.Transformed file, assuming that the 3 st column is the SNP ID; 4 th column is the effective allele information; the 12 th column is the effect size estimate; and that the file contains a header |
| q-score-range | range_list SNP.pvalue | We want to calculate PRS based on the thresholds defined in range_list, where the threshold values (P-values) were stored in SNP.pvalue |
The above command and range_list will generate 7 files:
- EUR.0.5.profile
- EUR.0.4.profile
- EUR.0.3.profile
- EUR.0.2.profile
- EUR.0.1.profile
- EUR.0.05.profile
- EUR.0.001.profile
Note
The default formula for PRS calculation in PLINK is:
where the effect size of SNP \(i\) is \(S_i\); the number of effect alleles observed in sample \(j\) is \(G_{ij}\); the ploidy of the sample is \(P\) (is generally 2 for humans); the total number of SNPs included in the PRS is \(N\); and the number of non-missing SNPs observed in sample \(j\) is \(M_j\). If the sample has a missing genotype for SNP \(i\), then the population minor allele frequency multiplied by the ploidy (\(MAF_i*P\)) is used instead of \(G_{ij}\).
Accounting for Population Stratification¶
Population structure is the principal source of confounding in GWAS and is usually accounted for by incorporating principal components (PCs) as covariates. We can incorporate PCs into our PRS analysis to account for population stratification.
Again, we can calculate the PCs using plink
:
# First, we need to perform prunning
plink \
--bfile EUR.QC \
--indep-pairwise 200 50 0.25 \
--out EUR
# Then we calculate the first 6 PCs
plink \
--bfile EUR.QC \
--extract EUR.prune.in \
--pca 6 \
--out EUR
Note
One way to select the appropriate number of PCs is to perform GWAS on the phenotype under study with different numbers of PCs. LDSC analysis can then be performed on the set of GWAS summary statistics and the GWAS that used the number of PCs that gave an LDSC intercept closest to 1 should correspond to that for which population structure was most accurately controlled for.
Here the PCs have been stored in the EUR.eigenvec file and can be used as covariates in the regression model to account for population stratification.
Important
If the base and target samples are collected from different worldwide populations then the results from the PRS analysis may be biased (see Section 3.4 of our papper).
Finding the "best-fit" PRS¶
The P-value threshold that provides the "best-fit" PRS under the C+T method is usually unknown.
To approximate the "best-fit" PRS, we can perform a regression between PRS calculated at a range of P-value thresholds and then select the PRS that explains the highest phenotypic variance (please see Section 4.6 of our paper on overfitting issues).
This can be achieved using R
as follows:
p.threshold <- c(0.001,0.05,0.1,0.2,0.3,0.4,0.5)
# Read in the phenotype file
phenotype <- read.table("EUR.height", header=T)
# Read in the PCs
pcs <- read.table("EUR.eigenvec", header=F)
# The default output from plink does not include a header
# To make things simple, we will add the appropriate headers
# (1:6 because there are 6 PCs)
colnames(pcs) <- c("FID", "IID", paste0("PC",1:6))
# Read in the covariates (here, it is sex)
covariate <- read.table("EUR.cov", header=T)
# Now merge the files
pheno <- merge(merge(phenotype, covariate, by=c("FID", "IID")), pcs, by=c("FID","IID"))
# We can then calculate the null model (model with PRS) using a linear regression
# (as height is quantitative)
null.model <- lm(Height~., data=pheno[,!colnames(pheno)%in%c("FID","IID")])
# And the R2 of the null model is
null.r2 <- summary(null.model)$r.squared
prs.result <- NULL
for(i in p.threshold){
# Go through each p-value threshold
prs <- read.table(paste0("EUR.",i,".profile"), header=T)
# Merge the prs with the phenotype matrix
# We only want the FID, IID and PRS from the PRS file, therefore we only select the
# relevant columns
pheno.prs <- merge(pheno, prs[,c("FID","IID", "SCORE")], by=c("FID", "IID"))
# Now perform a linear regression on Height with PRS and the covariates
# ignoring the FID and IID from our model
model <- lm(Height~., data=pheno.prs[,!colnames(pheno.prs)%in%c("FID","IID")])
# model R2 is obtained as
model.r2 <- summary(model)$r.squared
# R2 of PRS is simply calculated as the model R2 minus the null R2
prs.r2 <- model.r2-null.r2
# We can also obtain the coeffcient and p-value of association of PRS as follow
prs.coef <- summary(model)$coeff["SCORE",]
prs.beta <- as.numeric(prs.coef[1])
prs.se <- as.numeric(prs.coef[2])
prs.p <- as.numeric(prs.coef[4])
# We can then store the results
prs.result <- rbind(prs.result, data.frame(Threshold=i, R2=prs.r2, P=prs.p, BETA=prs.beta,SE=prs.se))
}
# Best result is:
prs.result[which.max(prs.result$R2),]
q() # exit R
p.threshold <- c(0.001,0.05,0.1,0.2,0.3,0.4,0.5)
phenotype <- read.table("EUR.height", header=T)
pcs <- read.table("EUR.eigenvec", header=F)
colnames(pcs) <- c("FID", "IID", paste0("PC",1:6))
covariate <- read.table("EUR.cov", header=T)
pheno <- merge(merge(phenotype, covariate, by=c("FID", "IID")), pcs, by=c("FID","IID"))
null.r2 <- summary(lm(Height~., data=pheno[,!colnames(pheno)%in%c("FID","IID")]))$r.squared
prs.result <- NULL
for(i in p.threshold){
pheno.prs <- merge(pheno,
read.table(paste0("EUR.",i,".profile"), header=T)[,c("FID","IID", "SCORE")],
by=c("FID", "IID"))
model <- summary(lm(Height~., data=pheno.prs[,!colnames(pheno.prs)%in%c("FID","IID")]))
model.r2 <- model$r.squared
prs.r2 <- model.r2-null.r2
prs.coef <- model$coeff["SCORE",]
prs.result <- rbind(prs.result,
data.frame(Threshold=i, R2=prs.r2,
P=as.numeric(prs.coef[4]),
BETA=as.numeric(prs.coef[1]),
SE=as.numeric(prs.coef[2])))
}
print(prs.result[which.max(prs.result$R2),])
q() # exit R
library(data.table)
library(magrittr)
p.threshold <- c(0.001,0.05,0.1,0.2,0.3,0.4,0.5)
phenotype <- fread("EUR.height")
pcs <- fread("EUR.eigenvec", header=F) %>%
setnames(., colnames(.), c("FID", "IID", paste0("PC",1:6)) )
covariate <- fread("EUR.cov")
pheno <- merge(phenotype, covariate) %>%
merge(., pcs)
null.r2 <- summary(lm(Height~., data=pheno[,-c("FID", "IID")]))$r.squared
prs.result <- NULL
for(i in p.threshold){
pheno.prs <- paste0("EUR.", i, ".profile") %>%
fread(.) %>%
.[,c("FID", "IID", "SCORE")] %>%
merge(., pheno, by=c("FID", "IID"))
model <- lm(Height~., data=pheno.prs[,-c("FID","IID")]) %>%
summary
model.r2 <- model$r.squared
prs.r2 <- model.r2-null.r2
prs.coef <- model$coeff["SCORE",]
prs.result %<>% rbind(.,
data.frame(Threshold=i, R2=prs.r2,
P=as.numeric(prs.coef[4]),
BETA=as.numeric(prs.coef[1]),
SE=as.numeric(prs.coef[2])))
}
print(prs.result[which.max(prs.result$R2),])
q() # exit R
Which P-value threshold generates the "best-fit" PRS?
0.3
How much phenotypic variation does the "best-fit" PRS explain?
0.1638468


Advocacy Partners
Sensibly,
The SSDP Team
Students for Sensible Drug Policy
1011 O St NW, #1, Washington, DC 20001, United States
To stop receiving emails, click here.


The expected format is a simple headerless ascii three column file (additional columns will be ignored) with epoch in Besselian years, Julian days or Julian years (choose proper Date Type below), the velocity in the selected units, and the components labeled either as 'Va', 'a', 'Vb' or 'b'.


Create Parent Profile
First Name:
Last Name:
Email:
Gender Identity:
Male
Female
Non-binary
Friend Preference:
Male
Female
No Preference
Zip Code:
Distance Willing to Travel :
10 20 30 40 50+
User Name:
Password:
Create My Profile!


we sereve best quality burbon. with a well trained personel. ready to serve you on your special occasions


Running is the easiest type of exercise routine to begin, at least according to the popular sentiment. As the truism goes, all you need is a pair of shoes and a road to start.
Trending
The Nike Zoom Rival Fly features a futuristic look with cushioning in the forefoot that gives you a responsive feel.
Trending
The Nike React Infinity Run Flyknit is designed to help reduce injury and keep you on the run.
Trending
The Nike React Miler gives you trusted stability for miles with athlete-informed performance.
Trending
The Nike Zoom Rival Fly features a futuristic look with cushioning in the forefoot that gives you a responsive feel.
Trending
The Nike React Infinity Run Flyknit is designed to help reduce injury and keep you on the run.
Trending
The Nike React Miler gives you trusted stability for miles with athlete-informed performance.
Trending
The Nike Zoom Rival Fly features a futuristic look with cushioning in the forefoot that gives you a responsive feel.


|
Drake
|
A LCM interface for logging LCM messages to a file or playing back from a existing log.
Note the user is responsible for offsetting the clock used to generate the log and the clock used for playback. For example, if the log is generated by some external logger (the lcm-logger binary), which uses the unix epoch time clock to record message arrival time, the user needs to offset those timestamps properly to match and the clock used for playback.
#include <drake/lcm/drake_lcm_log.h>
Public Member Functions | |
| DrakeLcmLog (const std::string &file_name, bool is_write, bool overwrite_publish_time_with_system_clock=false) | |
| Constructs a DrakeLcmLog. More... | |
| void | Publish (const std::string &channel, const void *data, int data_size, std::optional< double > time_sec) override |
Writes an entry occurred at timestamp with content data to the log file. More... | |
| std::shared_ptr< DrakeSubscriptionInterface > | Subscribe (const std::string &channel, HandlerFunction handler) override |
Subscribes handler to channel . More... | |
| int | HandleSubscriptions (int) override |
| This is a no-op for Read mode, and an exception in Write mode. More... | |
| double | GetNextMessageTime () const |
| Returns the time in seconds for the next logged message's occurrence time or infinity if there are no more messages in the current log. More... | |
| void | DispatchMessageAndAdvanceLog (double current_time) |
Let MSG be the next message event in the log, if current_time matches MSG 's timestamp, for every DrakeLcmMessageHandlerInterface sub that's subscribed to MSG 's channel, invoke sub 's HandleMessage method. More... | |
| bool | is_write () const |
| Returns true if this instance is constructed in write-only mode. More... | |
| double | timestamp_to_second (uint64_t timestamp) const |
Converts timestamp (in microseconds) to time (in seconds) relative to the starting time passed to the constructor. More... | |
| uint64_t | second_to_timestamp (double sec) const |
| Converts time (in seconds) relative to the starting time passed to the constructor to a timestamp in microseconds. More... | |
Does not allow copy, move, or assignment | |
| DrakeLcmLog (const DrakeLcmLog &)=delete | |
| DrakeLcmLog & | operator= (const DrakeLcmLog &)=delete |
| DrakeLcmLog (DrakeLcmLog &&)=delete | |
| DrakeLcmLog & | operator= (DrakeLcmLog &&)=delete |
| Public Member Functions inherited from DrakeLcmInterface | |
| virtual | ~DrakeLcmInterface () |
| DrakeLcmInterface (const DrakeLcmInterface &)=delete | |
| DrakeLcmInterface & | operator= (const DrakeLcmInterface &)=delete |
| DrakeLcmInterface (DrakeLcmInterface &&)=delete | |
| DrakeLcmInterface & | operator= (DrakeLcmInterface &&)=delete |
Additional Inherited Members | |
| Public Types inherited from DrakeLcmInterface | |
| using | HandlerFunction = std::function< void(const void *, int)> |
| A callback used by DrakeLcmInterface::Subscribe(), with arguments: More... | |
| Protected Member Functions inherited from DrakeLcmInterface | |
| DrakeLcmInterface () | |
|
delete |
|
delete |
| DrakeLcmLog | ( | const std::string & | file_name, |
| bool | is_write, | ||
| bool | overwrite_publish_time_with_system_clock = false |
||
| ) |
Constructs a DrakeLcmLog.
| file_name | Log's file name for reading or writing. |
| is_write | If false, this instance reads from the Lcm log identified by file_name . If true, this instance writes to the Lcm log whose name is given by file_name . |
| overwrite_publish_time_with_system_clock | This parameter only affects the Publish method in write-only mode. If true, override the second parameter passed to Publish method, and use host system's clock to generate the timestamp for the logged message. This is used to mimic lcm-logger's behavior. It also implicitly records how fast the messages are generated in real time. |
| std::runtime_error | if unable to open file. |
| void DispatchMessageAndAdvanceLog | ( | double | current_time | ) |
Let MSG
be the next message event in the log, if current_time
matches MSG
's timestamp, for every DrakeLcmMessageHandlerInterface sub
that's subscribed to MSG
's channel, invoke sub
's HandleMessage method.
Then, this function advances the log by exactly one message. This function does nothing if MSG
is null (end of log) or current_time
does not match MSG
's timestamp.
| std::logic_error | if this instance is not constructed in read-only mode. |
| double GetNextMessageTime | ( | ) | const |
Returns the time in seconds for the next logged message's occurrence time or infinity if there are no more messages in the current log.
| std::logic_error | if this instance is not constructed in read-only mode. |
This is a no-op for Read mode, and an exception in Write mode.
Implements DrakeLcmInterface.
| bool is_write | ( | ) | const |
Returns true if this instance is constructed in write-only mode.
|
delete |
|
delete |
|
overridevirtual |
Writes an entry occurred at timestamp
with content data
to the log file.
The current implementation blocks until writing is done.
| channel | Channel name. |
| data | Pointer to raw bytes. |
| data_size | Number of bytes in data . |
| time_sec | Time in seconds when the message is published. Since messages are save to the log file in the order of Publish calls, this function should only be called with non-decreasing second . Note that this parameter can be overwritten by the host system's clock if overwrite_publish_time_with_system_clock is true at construction time. |
| std::logic_error | if this instance is not constructed in write-only mode. |
Implements DrakeLcmInterface.
| uint64_t second_to_timestamp | ( | double | sec | ) | const |
Converts time (in seconds) relative to the starting time passed to the constructor to a timestamp in microseconds.
|
overridevirtual |
Subscribes handler
to channel
.
Multiple handlers can subscribe to the same channel.
| std::logic_error | if this instance is not constructed in read-only mode. |
Implements DrakeLcmInterface.
| double timestamp_to_second | ( | uint64_t | timestamp | ) | const |
Converts timestamp
(in microseconds) to time (in seconds) relative to the starting time passed to the constructor.


Ocean [ax79], ocean, in Crystal Sea
Last updated Turn #108_bad
Ocean [ax79], ocean, in Crystal Sea
------------------------------------------------------------------------
5: The Savvy Aardvark [ha5r], ship, 2 hulls, 1 rowing port, 6 sails,
5: 1% damaged, arrived from Ocean [aw79], owner:
5: Phantasm [n4b], Imperial Empire, duke, with two workers,
5: eight sailors
6: The Savvy Aardvark [ha5r], ship, 2 hulls, 1 rowing port, 6 sails,
6: 1% damaged, departed for Ocean [ay79].
Routes leaving Ocean:
North, to Ocean [aw79], The Outer Sea, 6 days
East, to Ocean [ax80], 6 days
South, to Ocean [ay79], 6 days
West, to Ocean [ax78], 6 days


Industrial Engineering Student
Knoxville, TN
<EMAIL_ADDRESS>(615)-829-0636
Skills
Data Analytics
Visio
Microsoft Office
Six Sigma
Languages
English
Python
R studio
-Collaborated with 20+ department Subject Matter Experts to gain information for process flow maps. Identified a solution for how to identify the roles of division processes to the enterprise end-to-end, business capabilities, process improvement, and root-cause analysis for 20+ departments in USTRANSCOM. Developed new way to integrate the highest level enterprise architecture with the mid-level business architectures for all of the divisions within USTRANSCOM. Briefed the new operations maps to Trident executives and USTRANSCOM Enterprise Architecture team, gaining approval for use in delivery of 20-million-dollar contract deliverables. Constructed systems analysis models to provide roadmaps pertaining to the specific function of the divisions and directorates within USTRANSCOM.
Attained the Top First Year Award (top 2% of all first year sales people in world). Independent Contractor in direct sales of educational products. Prospected and approached 2,973 families of various socio-economic levels. Established fundamental success principles (i.e. positive attitude, goal setting, self-motivation, and importance of schedule building). Delivered 751 professional sales presentations, of which 205 became clients. Executed all ordering, inventory, accounting, scheduling, sales, and delivery of the product. Personal retail sales of $29,216 in an 11 week selling period. Relocated to Oklahoma for duration of three months over the summer.
Bachelors Degree
Bachelor Degree
Engineering Economics
Quality and Maintainability
Design of Experiments
Corporate Intern- Huntsville, AL
Industrial Engineering Intern- Scott AFB (O'Fallon, IL)
Sales Intern- Holdenville, OK


Port of the OpenBSD bcrypt_pbkdf
function to pure Javascript. npm
-ified
version of Devi Mandiri's port,
with some minor performance improvements. The code is copied verbatim (and
un-styled) from Devi's work.
This product includes software developed by Niels Provos.
API
bcrypt_pbkdf.pbkdf(pass, passlen, salt, saltlen, key, keylen, rounds)
Derive a cryptographic key of arbitrary length from a given password and salt,
using the OpenBSD bcrypt_pbkdf
function. This is a combination of Blowfish and
SHA-512.
See this article for further information.
Parameters:
pass
, a Uint8Array of lengthpasslen
passlen
, an integer Numbersalt
, a Uint8Array of lengthsaltlen
saltlen
, an integer Numberkey
, a Uint8Array of lengthkeylen
, will be filled with outputkeylen
, an integer Numberrounds
, an integer Number, number of rounds of the PBKDF to run
bcrypt_pbkdf.hash(sha2pass, sha2salt, out)
Calculate a Blowfish hash, given SHA2-512 output of a password and salt. Used as part of the inner round function in the PBKDF.
Parameters:
sha2pass
, a Uint8Array of length 64sha2salt
, a Uint8Array of length 64out
, a Uint8Array of length 32, will be filled with output
License
This source form is a 1:1 port from the OpenBSD blowfish.c
and bcrypt_pbkdf.c
.
As a result, it retains the original copyright and license. The two files are
under slightly different (but compatible) licenses, and are here combined in
one file. For each of the full license texts see LICENSE
.


Units
Class Hierarchy
Classes, Interfaces, Objects and Records
Types
Variables
Constants
Functions and Procedures
Identifiers
A simple, pluggable and modern logging framework for Delphi
TVCLMemoLogAppender


Frequently Asked Questions
1. Why do some of the pages only show loading?
Please ensure that you are logged into MetaMask so that the page can connect to the blockchain and load the data
2. Why does my transaction fail and say insufficient funds?
Please ensure that you import an Ether wallet by pasting its private key in the MetaMask import function
3. Can I edit my data once I submit it to the system?
No. All data submitted to the blockchain are immutable, meaning they can not be changed, not even by the admin
4. Where is the option to mark a student as absent for a subject?
To mark a student as absent, input the value 0 and submit it as their grade. The system will automatically mark them as absent


OSHChip V1.0
C/C++ Compilers
OSHChip_V1.0 has an ARM Cortex-M0 processor, 256 KBytes of flash memory for program storage, 32 KBytes of SRAM for data storage, and a wide range of peripheral blocks. Programs for OSHChip_V1.0 can be written in any programming language for which you have a compiler, or even assembler can be used. Predominantly, C or C++ is used, and there are several compilers to choose between. This page will help you decide which one is best for your situation.
- Compiler overview
- Top level synopsys
- Important factors
- Keil
- Capabilities and Limitations
- Running on Windows
- Running on Mac or Linux
- Debugging
- mbed
- Capabilities and Limitations
- Run anywhere
- Debugging
- Libraries
- Community
- GCC
- Capabilities and Limitations
- Running on Windows
- Running on Mac or Linux
- Debugging
- Arduino
- Capabilities and Limitations
- Running on Windows
- Running on Mac or Linux
- Debugging
- Overview
- Block Elements
OSHChip V1.0 includes the following functional blocks * ARM Cortex-M0 32 bit micro processor running at 16 MHz * 256KB Flash Memory * 32KB SRAM * 2.4 GHz Radio supports 4 protocols: * Bluetooth Low Energy (BLE) / Bluetooth Smart - Supports communications from OSHChip to smart phones that support BLE * ANT * Proprietary Gazell * Proprietary ESB - Supports Chip to Chip communications. * Built-in antenna, range is 10 to 20 feet, depending on environment (metal, desks, chairs, …) * Runs from 1.8V to 3.6V . Multiple low power modes * 14 general purpose I/O pins. All peripherals (except ADC) can use any I/O pin * UART * 10-bit ADC * Counter/Timers * SPI * I2C * Temp * RTC * Watchdog Timer * Quadrature Decoder * AES Encryption * Random Number Generator. * 3 On-board LEDs (near top connector), Red Green and Blue.


Search
Preparing search index...
The search index is not available
Neon
Options
All
Public
Public/Protected
All
Inherited
Externals
Only exported
Menu
Globals
"src/utils/SelectTools"
StaffBBox
Interface StaffBBox
Bounding box object interface for getStaffBBox()
Hierarchy
StaffBBox
Index
Properties
id
lrx
lry
rotate
ulx
uly
Properties
id
id
:
string
lrx
lrx
:
number
lry
lry
:
number
rotate
rotate
:
number
ulx
ulx
:
number
uly
uly
:
number
Globals
"src/utils/
Select
Tools"
StaffBBox
id
lrx
lry
rotate
ulx
uly
are
Adjacent
elements
Have
Correct
Type
get
Selection
Type
get
StaffBBox
is
Ligature
is
Multi
Stave
Selection
select
select
All
selectBBox
select
Layer
Element
select
Ncs
select
Nn
select
Staff
shared
Logical
Parent
shared
Second
Level
Parent
unselect
Generated using
TypeDoc
Bounding box object interface for getStaffBBox()


These are unofficial data splits for the corpus MADCAT Chinese Pilot Training Set (LDC2014T13). LDC is providing only training data for this corpus and not the original dev/eval sets, so the original training data have been split into three different disjoint parts (i.e. there shouldn't be sentences/lines from the same document in different sets -- as each document is handwritten/transcribed by a different author in the MADCAT data) to allow for evaluation of the performance in the usual way.
Also, please not that the license relates only for the splits. You still need to obtain the original databases and respect the databases' license! It contains the madcat xml name and segment id (s{1,2,3,4}). For example:GMW_CMN_20070118.0014_001_LDC0632.madcat.xml s1 GMW_CMN_20070118.0014_001_LDC0632.madcat.xml s2 GMW_CMN_20070118.0014_001_LDC0632.madcat.xml s3


Ocon to test Renault in Abu Dhabi
Esteban Ocon has received his wish of getting an early start to his Renault career.
by GMM F1The Mercedes reserve driver said in Brazil that he hopes Mercedes lets him carry out the post-race Abu Dhabi test with Renault.
"I hope I can do the test in Abu Dhabi, but the two teams will have to decide if that is possible," he said.
Ocon, whose racing career was interrupted when he lost his Force India seat at the end of 2018, has now received his wish.
"Esteban Ocon will officially join Renault on Monday 2nd December and will take part in both test days at the Yas Marina Circuit in Abu Dhabi on 3rd and 4th December," Renault announced.
body check tags ::


A Regular Expression is a sequence of characters that helps you match or find strings or sets of strings using specialized syntax held in a pattern. Regular Expressions are used to determine if a string contains a given pattern or extract portions that match. This is very useful tool to search through huge amounts of Data like Files,Databases etc.
A Regular Expression is delimited with forward slashes (/).
Below I have provided some simple examples of how Regular expressions are used to find string patterns in Ruby
[abc] - A single character of a,b,c
Output: #<MatchData "b" >
/[xyzn]/.match 'ruby'
Output: nil
The match method above returns a match object. In the first example above, the regular expression returns a Match object since 'b' is present in 'ruby'. In the second example none of the characters in [xyzn] exist in 'ruby' and hence it returns nil
[^abc] - Any character except a,b or c
Output: nil
/[^abc]/.match 'ruby'
Output: #<MatchData "r">
In the first example above, the Output is nil, since the string does not have any characters except 'r','u','b','y'. In the second example, it returns a object since 'r' is not one of 'a','b' or 'c'.
[a-z] - Any character in range of a-z
Output: #<MatchData "y">
/[c-q]/.match 'ruby'
Output: nil
In the first example above, it returns the character 'y' since it finds y in the range provided : [x-z]. In the second example the Output is nil since it doesn't find 'r','u','b','y' in the range [c-q].
^ - Start of line
Output: nil/
/^r/.match 'ruby'
Output: #<MatchData "r">
In the first example since 'b' is not the first character in string 'ruby' it returns nil. In the second example it returns an object since 'r' is the first character in 'ruby'.
Hope you guys found the above examples useful in understanding Regular Expressions. These are just a few Regular expression patterns you could use. To learn more about Regular expressions please visit - Regular Expressions


My First Webpage Page
Resize this responsive page to see the effect!
Click the button to calculate x.
Insert
Delete All
Product Name
Quantity
specs
20
Apple
20
pad
20
Mouse
15
Table
15


|
FIRM-OMPL
|
Public Member Functions | |
| FeedbackPath (const firm::SpaceInformation::SpaceInformationPtr &si) | |
| Constructor, needs information about space. | |
| void | append (const ompl::base::State *state) |
| Append a state to the path, these states are the nodes to be visited. | |
| void | append (const ompl::base::State *state, Controller< RHCICreate, ExtendedKF > controller) |
| Append a controller and its goal node to the path. | |
| void | clearFeedback () |
| Clear the feedback states and controllers. | |
|
std::vector< Controller < RHCICreate, ExtendedKF > > | getControllers (void) |
| Returns the sequence of controllers to follow in the path. | |
| std::vector< ompl::base::State * > | getStates (void) |
| std::size_t | getStateCount (void) |
| double | length (void) const |
| bool | check (void) const |
| ompl::base::Cost | cost (const OptimizationObjectivePtr &obj) const |
| void | print (std::ostream &out) const |
Protected Attributes | |
|
std::vector< Controller < RHCICreate, ExtendedKF > > | feedbackControllers_ |
| A vector containing the feedback controllers, which define the path in belief space. | |
| std::vector< ompl::base::State * > | nodesToVisit_ |
| The sequence of nodes to visit. | |
| firm::SpaceInformation::SpaceInformationPtr | siF_ |
| Pointer to the belief space information. |


HR Info
Sale History
Manage Employee
Return MainPage
Logout
Fire Employee
Advanced Tables
Employee_ID
Employee_Name
Phone
Salary
Fire Employee
{% if items %} {% for foo in items %}
{% for boo in foo %}
{{ boo }}
{% endfor %}
{% endfor %} {% endif %}
Fire
Add New Employee
Employee Name
Department
Employee Password
Employee Idcard
Employee Phone
Employee Address
Employee Position
Employee Note
Employee Salary
Submit
Reset


Access to ChapterLand requires a username and password. If you don’t have one, you can request access by contacting your Chapter’s area director.
Forgot password?


Here at One Man's Trash we aim to give you a platform FOR FREE. We believe in the saying, "One Man's Trash is another Man's Treasure." Now more than ever is the perfect time to start relying on our neighbors rather than huge corporations and the government to provide us with goods and services we are in search of. OMT is the perfect marketplace to exchange goods, services, and skills for other goods, services, and skills.
OTM's Dev Team is comprised of 4 hard working and determined UCI Full Stack Bootcamp Graduates looking to make a difference in the world. Each member is highly skilled in their specific role with a strong focus on consumer satisfaction. We're here for you!


Home
About Us
Our Services
Halal Laboratory Services
Halal Food Developement/Training
Halal Research and Development
Halal Packaging and Labeling
Multimedia
Halal Products
Contact Us
Forms
Laboratory Services
Halal Quality Assurance
Careers
Home
Halal Products
HALAL
Produts
Passion Guyabano Calamansi Concentrate
More Info
Passion Guyabano Calamansi Concentrate
×
Ingredients
Passion Fruit and Sugar
Ingredients
Nutrition Facts
Passion Fruit and Sugar
Nutrition Facts
Processed by:
KABLON FARM FOOD CORP
Tupi, South Cotabato, Philippines
Telefax +6383 226-2819
PRODUCT OF THE PHILIPPINES
Certificate Available
None
Certificate Available
Nutrition Facts
Passion Fruit and Sugar
Nutrition Facts
Muscovado Rocks
Muscovado Rocks
More Info
×
Some text in the modal.
Muscovado Rocks
More Info
×
Some text in the modal.


This is a small but very effective application for generating and safely storing strong passwords on websites or other services on the Internet.
(The application has been machine-translated into English. Please help improve the translation. Visit the project at http://www.github.com/ondra-novak/pocket_pwdgen)
Using cryptographic features, a unique key is generated from a secret phrase, and this key is then used to derive strong passwords to all pages you need to log in
Because passwords are not saved but are generated, the application can remember an unlimited number of passwords. If the page forces you to change your password, just ask the application to generate another password,
Because passwords are generated, if you lose a device, just set up the same master password on the new device and get access to all the previously generated passwords.
The application does not use any storage on the Internet. It is able to work fully offline. This makes your passwords even more secure because no third party has access to them.
Prepare a pencil and paper that you'll find a secret phrase. The application will prepare you for some. You can think of yourself, it should be as long as possible, and especially secret and unique. Something that only you and no one else can know. Of course you can record it well. Save the saved phrase in a safe place outside the online world
At this time, you have a single key stored under your name: jmeno
| X |
Generally, there is no need to create additional keys. This function is useful only when the main phrase is revealed. Then you need to choose a new phrase and generate a new key. The old key is used to sign in to a website to change your password
If the phrase is revealed, change all passwords on all visited sites as soon as possible
Do you really wish to delete the key?:
Nothing is here...


Manchester United 'handed boost in Bruno Fernandes pursuit'
Manchester United have reportedly been handed a boost ahead of attempting to sign Sporting Lisbon midfielder Bruno Fernandes.
by Darren PlantDespite frequent speculation regarding his future during the summer, Fernandes eventually remained with the Portuguese outfit for the first half of the campaign.
However, according to The Sun, Sporting may be prepared to do business at the beginning of 2020.
The report claims that Sporting's financial situation could lead to offers being invited during the January window, regardless of whether they meet the £65m valuation of Fernandes.
The 25-year-old has contributed eight goals and six assists from 14 outings in Portugal's top flight and the Europa League.
Tottenham Hotspur have also been linked with the playmaker, who helped his national team qualify for Euro 2020 over the weekend.
body check tags ::


- NAME
- array - Manipulate array variables
- SYNOPSIS
- array option arrayName ?arg arg ...?
- DESCRIPTION
- array anymore arrayName searchId
- array donesearch arrayName searchId
- array exists arrayName
- array get arrayName ?pattern?
- array names arrayName ?mode? ?pattern?
- array nextelement arrayName searchId
- array set arrayName list
- array size arrayName
- array startsearch arrayName
- array statistics arrayName
- array unset arrayName ?pattern?
- EXAMPLES
- SEE ALSO
- KEYWORDS
array - Manipulate array variables
array option arrayName ?arg arg ...?
This command performs one of several operations on the
variable given by arrayName.
Unless otherwise specified for individual commands below,
arrayName must be the name of an existing array variable.
The option argument determines what action is carried
out by the command.
The legal options (which may be abbreviated) are:
- array anymore arrayName searchId
-
Returns 1 if there are any more elements left to be processed
in an array search, 0 if all elements have already been
returned.
SearchId indicates which search on arrayName to
check, and must have been the return value from a previous
invocation of array startsearch.
This option is particularly useful if an array has an element
with an empty name, since the return value from
array nextelement won't indicate whether the search
has been completed.
- array donesearch arrayName searchId
-
This command terminates an array search and destroys all the
state associated with that search. SearchId indicates
which search on arrayName to destroy, and must have
been the return value from a previous invocation of
array startsearch. Returns an empty string.
- array exists arrayName
-
Returns 1 if arrayName is an array variable, 0 if there
is no variable by that name or if it is a scalar variable.
- array get arrayName ?pattern?
-
Returns a list containing pairs of elements. The first
element in each pair is the name of an element in arrayName
and the second element of each pair is the value of the
array element. The order of the pairs is undefined.
If pattern is not specified, then all of the elements of the
array are included in the result.
If pattern is specified, then only those elements whose names
match pattern (using the matching rules of
string match) are included.
If arrayName isn't the name of an array variable, or if
the array contains no elements, then an empty list is returned.
- array names arrayName ?mode? ?pattern?
-
Returns a list containing the names of all of the elements in
the array that match pattern. Mode may be one of
-exact, -glob, or -regexp. If specified, mode
designates which matching rules to use to match pattern against
the names of the elements in the array. If not specified, mode
defaults to -glob. See the documentation for string match
for information on glob style matching, and the documentation for
regexp for information on regexp matching.
If pattern is omitted then the command returns all of
the element names in the array. If there are no (matching) elements
in the array, or if arrayName isn't the name of an array
variable, then an empty string is returned.
- array nextelement arrayName searchId
-
Returns the name of the next element in arrayName, or
an empty string if all elements of arrayName have
already been returned in this search. The searchId
argument identifies the search, and must have
been the return value of an array startsearch command.
Warning: if elements are added to or deleted from the array,
then all searches are automatically terminated just as if
array donesearch had been invoked; this will cause
array nextelement operations to fail for those searches.
- array set arrayName list
-
Sets the values of one or more elements in arrayName.
list must have a form like that returned by array get,
consisting of an even number of elements.
Each odd-numbered element in list is treated as an element
name within arrayName, and the following element in list
is used as a new value for that array element.
If the variable arrayName does not already exist
and list is empty,
arrayName is created with an empty array value.
- array size arrayName
-
Returns a decimal string giving the number of elements in the
array.
If arrayName isn't the name of an array then 0 is returned.
- array startsearch arrayName
-
This command initializes an element-by-element search through the
array given by arrayName, such that invocations of the
array nextelement command will return the names of the
individual elements in the array.
When the search has been completed, the array donesearch
command should be invoked.
The return value is a
search identifier that must be used in array nextelement
and array donesearch commands; it allows multiple
searches to be underway simultaneously for the same array.
It is currently more efficient and easier to use either the array
get or array names, together with foreach, to iterate
over all but very large arrays. See the examples below for how to do
this.
- array statistics arrayName
-
Returns statistics about the distribution of data within the hashtable
that represents the array. This information includes the number of
entries in the table, the number of buckets, and the utilization of
the buckets.
- array unset arrayName ?pattern?
-
Unsets all of the elements in the array that match pattern (using the
matching rules of string match). If arrayName isn't the name
of an array variable or there are no matching elements in the array, no
error will be raised. If pattern is omitted and arrayName is
an array variable, then the command unsets the entire array.
The command always returns an empty string.
array set colorcount {
red 1
green 5
blue 4
white 9
}
foreach {color count} [array get colorcount] {
puts "Color: $color Count: $count"
}
=> Color: blue Count: 4
Color: white Count: 9
Color: green Count: 5
Color: red Count: 1
foreach color [array names colorcount] {
puts "Color: $color Count: $colorcount($color)"
}
=> Color: blue Count: 4
Color: white Count: 9
Color: green Count: 5
Color: red Count: 1
foreach color [lsort [array names colorcount]] {
puts "Color: $color Count: $colorcount($color)"
}
=> Color: blue Count: 4
Color: green Count: 5
Color: red Count: 1
Color: white Count: 9
array statistics colorcount
=> 4 entries in table, 4 buckets
number of buckets with 0 entries: 1
number of buckets with 1 entries: 2
number of buckets with 2 entries: 1
number of buckets with 3 entries: 0
number of buckets with 4 entries: 0
number of buckets with 5 entries: 0
number of buckets with 6 entries: 0
number of buckets with 7 entries: 0
number of buckets with 8 entries: 0
number of buckets with 9 entries: 0
number of buckets with 10 or more entries: 0
average search distance for entry: 1.2
list, string, variable, trace, foreach
array, element names, search
Copyright © 1993-1994 The Regents of the University of California.
Copyright © 1994-1996 Sun Microsystems, Inc.
Copyright © 1995-1997 Roger E. Critchlow Jr.


Parky
We'll help you find a close and convenient parking spot!
Use current location
Search by Zip Code
Search


Hi, thanks for checking out my profile!
I'm a senior on track to graduate in Summer 2020 with my Bachelor's degree in Computer Science. I've had the opportunity to work for an IOT Based startup - Enrichai as a Backend Web Developer allowing me to gain experience within the field.Problem solving is what makes life easy. I am very driven and looking for new ways to mitigate risks, increase efficiency and create new opportunities.Improving myself to be a better coder than yesterday.
If the above sounds interesting, and you think it would be a potential fit to work together, let's connect and talk! :)
Worked on Indoor Asset Management project to build RESTful API on ORM Layer using Django, PostgreSQL, NodeJS.
An image and file upload system backed by Amazon’s S3 file service where Continuous Integration testing pipeline is implemented using Jest and Puppeteer. Also used Redis to implement caching so as to turbocharge MongoDB queries.
Project LinkA full stack social network application based on MERN Stack having JWT based Authentication, ES6+ and deployed it to Heroku with a postbuild script.
Project LinkBuilt a demographic segmentation model using an Artificial Neural Network to predict Customer Churn Rate in a bank with an accuracy of around 84%.
Project LinkBuilt a project based on API development and management where we can perform CRUD operations on APIs.
Project LinkOverall GPA: 7.8/10
Conducted various events across the campus.


The mixsqp R package provides algorithms based on sequential quadratic programming for maximum likelihood estimation of the mixture proportions in a finite mixture model where the component densities are known. The SQP algorithm is expected to obtain solutions that are at least as accurate as the state-of-the-art MOSEK interior-point solver (called via the “KWDual” function in the REBayes package), and is expected to compute these solutions much more quickly in large data sets.
For more details on the methods, please see the journal paper or the arXiv preprint.
The methods were originally implemented in Julia; please see here for the Julia implementation.
If you find a bug, or you have a question or feedback on our work, please post an issue.
If you find the mixsqp package or any of the source code in this repository useful for your work, please cite:
Youngseok Kim, Peter Carbonetto, Matthew Stephens and Mihai Anitescu. A fast algorithm for maximum likelihood estimation of mixture proportions using sequential quadratic programming. To appear in the Journal of Computational and Graphical Statistics.
Copyright (c) 2017-2020, Youngseok Kim, Peter Carbonetto, Matthew Stephens and Mihai Anitescu.
All source code and software in this repository are made available under the terms of the MIT license.
Install mixsqp from CRAN:
install.packages("mixsqp")
For more detailed installation instructions, see the “Setup” section below.
Once you have installed the package, load the package in R:
library(mixsqp)
Next, run the small example provided with the mixsqp function:
example("mixsqp")
For a more detailed illustration of the SQP algorithm applied to the problem of computing maximum-likelihood estimates for a mixture model, read through the introductory vignette.
To learn more, visit the package website, or view the “mixsqp” help page:
help("mixsqp")
To install mixsqp from CRAN, in R run:
install.packages("mixsqp")
Alternatively, to install the latest version of the mixsqp package from GitHub, use devtools:
install.packages("devtools")
library(devtools)
install_github("stephenslab/mixsqp",build_vignettes = TRUE)
This command should automatically install all required packages if they are not installed already.
If you have cloned the repository locally, you can install the package with the install_local
function from devtools. Assuming your working directory contains the mixsqp repository, run this code to install the package:
library(devtools)
install_local("mixsqp")
Compiling the mixsqp package from source will require a C++ compiler setup that is appropriate for the the R installed on your computer. For details, refer to the CRAN documentation. For Mac computers, see these notes.
To use the (optional) alternative solver, “mixkwdual”, which is mostly useful for comparisons of the different optimization methods, you will need to install the REBayes package. The REBayes package, in turn, requires the Rmosek package. Refer to the MOSEK documentation for instructions on installing the Rmosek package. Once you have followed these steps, you can run this example to verify that Rmosek is correctly installed. Installation of the REBayes package also allows you to build the vignette and view it locally:
devtools::install_github("stephenslab/mixsqp",build_vignettes = TRUE)
library(mixsqp)
vignette("mixsqp-intro")
To install and test the mixsqp R package, run the following commands in the shell:
Note that these commands require that the dependencies have already been installed. See the DESCRIPTION file for details.
When any changes are made to roxygen2 markup or to the C++ code in the src
directory, simply run devtools::document()
to update the RcppExports.cpp, the NAMESPACE file, and the package documentation files in the man
directory.
Run this line of R code to build the website (make sure you have an Internet connection while running the code):
pkgdown::build_site()
Version 1.4.1 of pkgdown was used.
The mixsqp R package was developed by Youngseok Kim and Peter Carbonetto at the University of Chicago, with contributions from Matthew Stephens and Mihai Anitescu.


Class: Aws::SSM::Types::CreateDocumentRequest
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb |
Overview
Constant Summary
Instance Attribute Summary
-
#attachments ⇒ Array<Types::AttachmentsSource>
rw
A list of key-value pairs that describe attachments to a version of a document.
-
#content ⇒ String
rw
The content for the new
::Aws::SSM
document in JSON or YAML format. -
#display_name ⇒ String
rw
An optional field where you can specify a friendly name for the
::Aws::SSM
document. -
#document_format ⇒ String
rw
Specify the document format for the request.
-
#document_type ⇒ String
rw
The type of document to create.
-
#name ⇒ String
rw
A name for the
::Aws::SSM
document. -
#requires ⇒ Array<Types::DocumentRequires>
rw
A list of
::Aws::SSM
documents required by a document. -
#tags ⇒ Array<Types::Tag>
rw
Optional metadata that you assign to a resource.
-
#target_type ⇒ String
rw
Specify a target type to define the kinds of resources the document can run on.
-
#version_name ⇒ String
rw
An optional field specifying the version of the artifact you are creating with the document.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Aws::Structure#to_h. |
Instance Attribute Details
#attachments ⇒ Array
<Types::AttachmentsSource> (rw)
A list of key-value pairs that describe attachments to a version of a document.
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#content ⇒ String
(rw)
The content for the new ::Aws::SSM
document in JSON or YAML format. The
content of the document must not exceed 64KB. This quota also
includes the content specified for input parameters at runtime. We
recommend storing the contents for your new document in an external
JSON or YAML file and referencing the file in a command.
For examples, see the following topics in the Amazon Web Services Systems Manager User Guide.
Create an
::Aws::SSM
document (Amazon Web Services API)Create an
::Aws::SSM
document (Amazon Web Services CLI)Create an
::Aws::SSM
document (API)
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#display_name ⇒ String
(rw)
An optional field where you can specify a friendly name for the ::Aws::SSM
document. This value can differ for each version of the document.
You can update this value at a later time using the UpdateDocument
operation.
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#document_format ⇒ String
(rw)
Specify the document format for the request. The document format can be JSON, YAML, or TEXT. JSON is the default format.
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#document_type ⇒ String
(rw)
The type of document to create.
DeploymentStrategy
document type is an internal-use-only
document type reserved for ::Aws::AppConfig
.
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#name ⇒ String
(rw)
A name for the ::Aws::SSM
document.
You can't use the following strings as document name prefixes. These are reserved by Amazon Web Services for use as document name prefixes:
aws
amazon
amzn
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#requires ⇒ Array
<Types::DocumentRequires> (rw)
A list of ::Aws::SSM
documents required by a document. This parameter is
used exclusively by ::Aws::AppConfig
. When a user creates an ::Aws::AppConfig
configuration in an ::Aws::SSM
document, the user must also specify a
required document for validation purposes. In this case, an
ApplicationConfiguration
document requires an
ApplicationConfigurationSchema
document for validation purposes.
For more information, see What is AppConfig? in the AppConfig
User Guide.
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#tags ⇒ Array
<Types::Tag> (rw)
Optional metadata that you assign to a resource. Tags enable you to
categorize a resource in different ways, such as by purpose, owner,
or environment. For example, you might want to tag an ::Aws::SSM
document
to identify the types of targets or the environment where it will
run. In this case, you could specify the following key-value pairs:
Key=OS,Value=Windows
Key=Environment,Value=Production
::Aws::SSM
document, use the AddTagsToResource
operation.
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#target_type ⇒ String
(rw)
Specify a target type to define the kinds of resources the document
can run on. For example, to run a document on ::Aws::EC2
instances, specify
the following value: /AWS::EC2::Instance
. If you specify a value
of '/' the document can run on all types of resources. If you
don't specify a value, the document can't run on any resources.
For a list of valid resource types, see Amazon Web Services
resource and property types reference in the CloudFormation
User Guide.
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end
#version_name ⇒ String
(rw)
An optional field specifying the version of the artifact you are
creating with the document. For example, Release12.1
. This value
is unique across all versions of a document, and can't be changed.
# File 'gems/aws-sdk-ssm/lib/aws-sdk-ssm/types.rb', line 3354
class CreateDocumentRequest < Struct.new( :content, :requires, :, :name, :display_name, :version_name, :document_type, :document_format, :target_type, : ) SENSITIVE = [] include Aws::Structure end


Sort by Scrabble Score
Enter the text below. Duplicate words will be removed.
    You'll never know if you don't go (go!)


As irony would have it, I was never much of a feminist. As the only girl in a clan of four kids, I always ran with the boys. They comprised a majority of my friends and have been my favorite roommates. In my old life, back in Tennessee, I never once felt the need to be a feminist. I felt the work and pay was fair for me and my other co-workers, male and female. The ones who didn't usually didn't seem to be working very hard anyway.
Everything changed when I moved to Silicon Valley, though, and even though I wasn't working in a full-capacity tech company, I had moved out of a female-ruled hospitality industry into a completely different realm, and it showed. I worked several jobs, some even in hospitality, and found that I was working hard than the boys and still getting denied for raises, despite bringing in what I felt like was sufficient data. Had I moved up the ranks enough before leaving Tennessee, I would have likely found the same frustrations, even had I stayed in hospitality. A broad assumption, I know, but I've heard it from friends that stayed behind enough to feel comfortable making it.
It's a relief to see that we as society, and in particular the culture of Silicon Valley, is recognizing the discrimination. It's the first step in the problem. And while I'm not sure where I stand on the Ellen Pao case, it certainly brought the issue more light. I do fear that this isn't enough.
I don't want to see us waste this opportunity to make great change by only talking about it. I don't want to continue to see the social excuses of "well, I have a black/female/minority friend". These get us no where. I want action. I want to see companies taking small steps to test their effectiveness. Maybe removing names and ages when reviewing resumes - as sadly age is also discriminated against here as well. Studies have shown that simply including "salary negotiable" encourages women to negotiate enough that it closes the pay gap by 45%. One of my deepest fears is finishing Dev Bootcamp and having no leads on a job. This is of course only heightened with these discriminations. I know the problem can't possible be solved by the end of October when I graduate, but I hope to see enough progress to feel comfortable around my co-workers in a field I'm quickly falling in love with otherwise.


--- layout: page title: About header-img: "img/about-bg.png" ---
I have a background in both music composition and theory where I have learned how to connect creativity with abstract thinking. Now, as a full stack developer, I am excited to combine all of these skills to write elegant, meaningful code.


trait SearchableModelTrait
Class SearchableModelTrait can be applied to an eloquent model to give it "searchablity".
You have to override the getColumns method and/or make a protected $searchable = array('column1' => 1, 'column2' => 2);
where numbers 1 and 2 are the respective relevance of those columns
Methods
| mixed |
scopeSearch($query $query, $search $search)
Makes the search process work for a model |
Details
at line 29
public mixed
scopeSearch($query $query, $search $search)
Makes the search process work for a model


| 1 |
This Week |
2019-07-04*13:23:55 |
Admin |
Youth for work |
Add New Organization |
Suzan Lee(Admin) added "Youth for work" Organization |
| 2 |
This Week |
2019-07-03*10:03:51 |
Power User |
Homelessness |
Add New Question |
John Say (Power User) added new Question(ID 457) "Homelessness" Organization |
| 3 |
This Week |
2019-07-03*01:13:55 |
Care coordinator |
Single Moms |
Schedule Appointment |
Suzy Lee(Care coordinator) added new Appointment with Sarah Lee(NACRN user) |
| 4 |
This Week |
2019-07-03*13:13:00 |
Admin |
Child Care |
Add User |
Suzan Lee(Admin) added Tim Thomas(Power User) as Power User To Child Care |
| 5 |
This Week |
2019-07-03*13:11:55 |
Power User |
Single Moms |
Add New Question |
John Say (Power User) added new Question(ID 444) "Single Moms" Program |
| 6 |
This Week |
2019-07-02*13:05:25 |
Care coordinator |
Employement for all |
Schedule Appointment |
Suzy Lee(Care coordinator) added new Appointment with Britney Swift(NACRN user) |
| 7 |
This Week |
2019-07-02*13:01:28 |
Admin |
Single Dad's |
Add New Organization |
Bretty Mor(Admin) added "Single Dad's" Organization |
| 8 |
This Week |
2019-07-01*17:23:17 |
Power User |
Care for Elderly |
Add New Question |
John Say (Power User) added new Question(ID 47) "Care for Elderly" Organization |
| 9 |
This Week |
2019-07-01*16:17:14 |
Care coordinator |
Child Care |
Schedule Appointment |
Suzy Lee(Care coordinator) added new Appointment with Findler May(NACRN user) |
| 10 |
This Week |
2019-07-01*13:21:46 |
Admin |
Small Business Empowerment |
New Organization add |
Rosa Reign(Admin) added "Small Business Empowerment" Organization |


- childrenSize - Variable in class com.tomzhu.tree.TreeNode
-
- clear(int) - Method in class com.tomzhu.bitmap.BitMap
-
set the bit at specific location i to 0.
- clear() - Method in class com.tomzhu.list.ArrayList
-
clear this list
- clear() - Method in class com.tomzhu.list.LinkedList
-
clear the list.
- clearChildren(BasicTreeNode<E>) - Method in class com.tomzhu.tree.BasicTree
-
clear the node's children and return the node.
- clearChildren() - Method in class com.tomzhu.tree.BasicTreeNode
-
remove all children nodes and return the current node.
- clearChildren(BinaryTreeNode<E>) - Method in class com.tomzhu.tree.BinaryTree
-
remove the children node of the current node
and then return the current node.
- clearChildren() - Method in class com.tomzhu.tree.BinaryTreeNode
-
remove the children node of the current node and then return the current node.
- close() - Method in class com.tomzhu.external.BPlusTree
-
closing this bplustree
- close() - Method in class com.tomzhu.external.HashTable
-
closing this hash table.
- com.tomzhu.bitmap - package com.tomzhu.bitmap
-
a bit map implementation.
- com.tomzhu.external - package com.tomzhu.external
-
- com.tomzhu.hash - package com.tomzhu.hash
-
a group of hash table structures by different hashing method.
- com.tomzhu.heap - package com.tomzhu.heap
-
- com.tomzhu.list - package com.tomzhu.list
-
- com.tomzhu.tree - package com.tomzhu.tree
-
- compareTo(Entry) - Method in class com.tomzhu.tree.Entry
-
- containChild(BasicTreeNode<E>, BasicTreeNode<E>) - Method in class com.tomzhu.tree.BasicTree
-
- containChild(BasicTreeNode<E>) - Method in class com.tomzhu.tree.BasicTreeNode
-
check whether the node has the specific child node child, if yes, return true, otherwise return
false.
- contains(long) - Method in class com.tomzhu.external.BPlusTree
-
- contains(long) - Method in class com.tomzhu.external.HashTable
-
- contains(K) - Method in class com.tomzhu.hash.CuckooHashTable
-
- contains(K) - Method in class com.tomzhu.hash.ExtensibleHashTable
-
- contains(K) - Method in class com.tomzhu.hash.HashTableByLinearProbing
-
- contains(K) - Method in class com.tomzhu.hash.HashTableByQuadraticProbing
-
- contains(K) - Method in class com.tomzhu.hash.HashTableBySeparateChain
-
- contains(K) - Method in class com.tomzhu.hash.HopscotchHashTable
-
- contains(K) - Method in class com.tomzhu.hash.PerfectHashingTable
-
- contains(E) - Method in class com.tomzhu.tree.AVLTree
-
- contains(String) - Method in class com.tomzhu.tree.BasicNumberTrie
-
- contains(String) - Method in class com.tomzhu.tree.BasicStringTrie
-
- contains(E) - Method in class com.tomzhu.tree.BinarySearchTree
-
- contains(E) - Method in class com.tomzhu.tree.BTree
-
check whether contain the specific element.
- contains(K) - Method in class com.tomzhu.tree.HashMap
-
- contains(E) - Method in class com.tomzhu.tree.RedBlackTree
-
- contains(E) - Method in class com.tomzhu.tree.SkipList
-
- contains(E) - Method in class com.tomzhu.tree.SplayTree
-
- contains(K) - Method in class com.tomzhu.tree.Treap
-
- contains(E) - Method in class com.tomzhu.tree.TreeMap
-
- contains(E) - Method in class com.tomzhu.tree.TreeSet
-
- containsKey(K) - Method in class com.tomzhu.tree.KeydRedBlackTree
-
- CuckooHashTable<K,V> - Class in com.tomzhu.hash
-
a simple cuckoo hashing table implementation.
- CuckooHashTable() - Constructor for class com.tomzhu.hash.CuckooHashTable
-
construct a cuckoo hash table with 2 hash function and initial capacity 17.
- CuckooHashTable(int, CuckooHashTable.HashTableType) - Constructor for class com.tomzhu.hash.CuckooHashTable
-
construct a cuckoo hash table by given parameters.
- CuckooHashTable.HashTableType - Enum in com.tomzhu.hash
-
a cuckoo hash table type holder.


HARDWARE A film review by Paul-Michael Agapow Copyright 1996 Paul-Michael Agapow
In a run-down, post-holocaust world a soldier acquires the remains of a military robot. He gives part of it to his lover, a sculptress, unaware that the robot carcass is not completely dead ...
Superficially, as the plot summary above would indicate, "Hardware" is yet another unstoppable killer piece, movies that generally only use their genre (be it fantasy, SF or whatever) as a thin excuse to get some unkillable monster with useful powers of stealth or disguise chasing our heroes who will die one by one until a spectacular (and often ambiguous) finale. Indeed, sometimes the SF rack at the video store looks like this is the only idea in science fiction: "Saturn 5", "Split Second", "Leviathan", "Deep Star Six" ad nauseum. When competently done, these banal roots are transcended by the movie having good atmospheric horror ("Alien"), good action ("Predator") or making the monster the background for another issue (the infighting of the station crew in "The Thing"). When badly done, it's just another slasher flick.
"Hardware" sits, at times uncomfortably, in between. The script and scenario are nothing to write home about, but what is done with them is. The characters, usually a failing of slasher-flicks, are well drawn and sympathetic.  In an age where people are barricaded into their homes, the (implausible) robot literally invades the sculptress's home, rebuilding itself with household items. Missing the often biblical air that some of this genre has (e.g. this character is evil, so they will die), the robot is also never anthromorphised, staying expressionless, precise, mechanical and all the more terrifying for it. The sets and clothing also avoid the artfully distressed look of many post-holocaust worlds. This planet is slowly going down the drain and has no time for fashion.
It's unfortunate therefore that at the end of it, "Hardware" doesn't strike out on its own and be more of its own creation. It's also unfortunate that more work hasn't come from this team. But "Hardware" is a notch or two above its competitors and brief about it too. [**/ok] and walnut icecream on the Sid and Nancy scale.
"Hardware" Directed by Richard Stanley. Starring Dylan McDermott, Stacey Travis, John Lynch. Released 1990. 94 minutes.
------ paul-michael agapow (agapow@latcs1.oz.au), La Trobe Uni, Infocalypse [archived at http://www.cs.latrobe.edu.au/~agapow/Postviews/]
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Preparation time
30 mins to 1 hour
Cooking time
1 to 2 hours
Serves
Serves 4
For the stew, heat the olive oil in a large frying pan and lightly cook the lamb until browned on both sides. Transfer to a large saucepan.
Add the chicken stock, vegetables and herbs to the saucepan.
Bring slowly to a simmer and cook for about 1½ hours or until the lamb is tender and falls from the bone.
Remove the vegetables and herbs from the stock and discard them. Reserve the stock for cooking the dumplings and vegetables.
For the dumplings, blanch the spinach in boiling water for 30 seconds, then plunge into iced water. Drain and squeeze until thoroughly dried. Finely chop the blanched spinach.
In a mixing bowl set over a pan of boiling water, beat the ricotta until smooth. Gradually add the egg yolk and then the parmesan. Remove from the heat and stir in the flour to make a dough.
Fold in the spinach, before rolling the dough into balls the size of a walnut.
Heat the lamb stock in a medium saucepan. Drop in the dumplings and cook for 5-8 minutes until cooked through - you will know they are done when they float to the top of the pan.
Meanwhile, heat the lamb stock for the vegetables in a medium saucepan. Add all the vegetables, except the tomatoes, and cook until softened, but still retaining bite - this should take about six minutes. Drain the vegetables, reserving the stock.
Blanch the tomatoes by scoring them with a sharp knife, dropping them into boiling water and leaving for 5-8 seconds. Transfer to a bowl of cold water. Using a sharp knife, carefully remove the skin.
Add enough of the lamb stock to the stew to bring it to sauce consistency. Serve the lamb topped with the cooked vegetables, blanched tomatoes and dumplings.


CS140 Midterm Exam - October 10, 2006
Jim Plank
Answer all questions. Do so on a separate sheet of paper.
Question 1
Recall the following pictoral example of an implementation
of some queue operations:
Implement queue_dequeue(), which has the following prototype:
Jval queue_dequeue(Queue q);
Recall that Queue is a (void *).
Question 2
Behold the following C program:
#include < stdio.h >
#include < string.h >
main()
{
char *s, *s2, *x, **y;
s = strdup("Juice-em!");
s2 = strdup(s);
x = strchr(s, 'e');
y = &x;
x[1] = '*';
printf("0x%x 0x%x 0x%x\n",
s, s2, y);
printf("0x%x\n", x);
printf("0x%x\n", &x);
printf("0x%x\n", y);
printf("0x%x\n", *y);
printf("%c\n", s[1]);
printf("%c\n", *x);
printf("0x%x\n", &(s[1]));
printf("%s %s %s\n",
s, s2, x);
*y = s2 + 2;
*x = 'X';
printf("0x%x\n", x);
printf("%s %s %s\n",
s, s2, x);
}
|
When we run this program, the first line of output is:
| 0x500120 0x500130 0xbfffed28 |
What are the remaining lines of output?
Question 3
You are to write a program pan.c which prints out all
numeric command line arguments as decimal numbers padded to three
decimal places. The program should ignore non-numeric command line
arguments.
For each of the following eight programs, state whether it is correct, and then
state what the output of the program will be when the command line arguments are:
| pan -43.55001 Fred 0 66.440 Luther4 |
A.
main(int argc, char **argv)
{
int i; double d;
for (i = 1; i < argc; i++) {
d = atof(argv[i]);
if (d != 0) printf("%.3lf\n", d);
}
}
|
|
B.
main(int argc, char **argv)
{
int i; double d;
while (scanf("%lf", &d) == 1) {
printf("%.3lf\n", d);
}
}
|
|
|
C.
main(int argc, char **argv)
{
int i; double d;
for (i = 1; i < argc; i++) {
if (sscanf(argv[i], "%lf", &d) == 1) {
printf("%.3lf\n", d);
}
}
}
|
|
D.
main(int argc, char **argv)
{
int i; double d;
for (i = 1; i < argc; i++) {
if (sscanf(argv[i], "%lf", d) == 1) {
printf("%.3lf\n", d);
}
}
}
|
|
|
E.
main(int argc, char **argv)
{
int i, j; double d;
for (i = 1; i < argc; i++) {
j = sscanf(argv[i], "%lf", &d);
if (j == 1) printf("%.3lf\n", d);
}
}
|
|
F.
main(int argc, char **argv)
{
int i; double d;
for (i = 1; i < argc; i++) {
d = atoi(argv[i]);
if (d != 0) printf("%.3lf\n", d);
}
}
|
|
|
G.
main(int argc, char **argv)
{
int i, j, d;
for (i = 1; i < argc; i++) {
j = sscanf(argv[i], "%lf", &d);
if (j == 1) printf("%.3d\n", d);
}
}
|
|
H.
main(int argc, char **argv)
{
int i; double d;
while (1) {
i = scanf("%lf", &d);
if (i == EOF) exit(0);
if (i == 1) printf("%.3lf\n", d);
}
}
|
|
|
Question 4
Behold the following file:
Cutie the bomb
Met her at a beauty salon
With a baby louis vuitton
Under her under arm |
What is the output when that file is given as standard input to the
following program:
main()
{
int i, j, ne;
IS is;
Stack s;
Queue q;
Jval jv;
j = 0;
ne = 0;
s = new_stack();
q = new_queue();
is = new_inputstruct(NULL);
while (get_line(is) >= 0) {
for (i = 0; i < is->NF; i++) {
if (j%3 == 0 || j%3 == 2) {
queue_enqueue(q, new_jval_s(strdup(is->fields[i])));
ne++;
}
if (j%3 == 1 || j%3 == 2) {
stack_push(s, new_jval_i(strlen(is->fields[i])));
ne++;
}
j++;
}
}
while (!stack_empty(s)) {
jv = stack_pop(s);
printf("%d ", jv.i);
}
printf("\n");
while (!queue_empty(q)) {
jv = queue_dequeue(q);
printf("%s ", jv.s);
}
printf("\n");
printf("%d\n", ne);
exit(0);
} |
Question 5
Your eight-year-old daughter gets email access from AOL, so that she can send you email
while you're out of town. She does so, but decides to send you messages by holding
each key down for a few seconds. Oh, and of course she keeps the Caps-Lock key
on. So "Hi Daddy!" becomes "HHHHHHIIIIIIIIIDDDDDDDAAAAADDDDDDDDDDDDDDDYYYYYY!!!!!!!!!".
The first time you receive such a message, it's cute. The second time, it's
kind of irritating. On the third time, you conclude that it's easier to
write a program to read her email than it is to convince her to write in
a more conventional fashion.
So you write a program that reads from standard input, and converts multiple consecutive
instances of a character to simply one instance. Sure, it's not perfect, but it
makes the emails readable. For example,
SSSSSOOOOOORRRRRRRRRRRRRRYYYYYYYIIIIIIITTTTTTTT''''''''SSSSSSSIIIIIIIRRRRRRRRRR
IIIIIIITTTTTAAAATTTTTTTIIIIIIIIIINNNNNNNGGGGGGBBBBBBBUUUUUUUUUTTTTTTTTTTIIIIIII
LLLLLLLLLLLIIIIIIIIKKKKKKKKKEEEEEEEEIIIIIIIITTTTTTTTTTTT
HHHHHHHHAAAAAAAVVVVVVEEEEEEYYYYYYOOOOOOOUUUUUUFFFFFFFEEEEEEEDDDDDDDDYYYYYYYOOOOO
UUUUUUUURRRRRRRRNNNNNNNEEEEEEEOOOOOOOOPPPPPPPEEEEEEEETTTTTTYYYYYYYEEEEEEETTTT????????
LLLLLLLOOOOOOOVVVVVVVEEEEEEEEEEEEEMMMMMMMMEEEEEEEEEEKKKKKKKKEEEEEERRRRR!!!!!!!!
Becomes:
SORYIT'SIR
ITATINGBUTI
LIKEIT
HAVEYOUFEDYO
URNEOPETYET?
LOVEMEKER!
Write this program.
Do not put your answer here -- put it on a separate
sheet of paper!!!!
Prototypes
typedef union {
int i;
long l;
float f;
double d;
void *v;
char *s;
char c;
unsigned char uc;
short sh;
unsigned short ush;
unsigned int ui;
int iarray[2];
float farray[2];
char carray[8];
unsigned char ucarray[8];
} Jval;
Jval new_jval_i(int);
Jval new_jval_l(long);
Jval new_jval_f(float);
Jval new_jval_d(double);
Jval new_jval_v(/* void */);
Jval new_jval_s(char *);
|
char *strdup(char *s);
void strcpy(char *dest, char *source);
char *strchr(char *s, int ch);
char *strrchr(char *s, int ch);
char *strstr(char *s, char *tofind);
int getchar();
|
|
---
|
#define MAXLEN 1001
#define MAXFIELDS 1000
typedef struct inputstruct {
char *name;
FILE *f;
int line;
char text1[MAXLEN];
char text2[MAXLEN];
int NF;
char *fields[MAXFIELDS];
int file;
} *IS;
IS new_inputstruct(char *name);
int get_line(/* IS */);
void jettison_inputstruct(/* IS */);
|
typedef void *Queue;
Queue new_queue();
void queue_enqueue(Queue q, Jval v);
Jval queue_dequeue(Queue q, Jval v);
int queue_empty(Queue q);
typedef void *Stack;
Stack new_stack();
void stack_push(Stack s, Jval v);
Jval stack_pop(Stack s, Jval v);
int stack_empty(Stack s);
|
|


Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.
Please consider following this project's author, Jon Schlinkert, and consider starring the project to show your :heart: and support.
Install with npm:
$ npm install --save braces
Brace patterns are great for matching ranges. Users (and implementors) shouldn't have to think about whether or not they will break their application (or yours) from accidentally defining an aggressive brace pattern. Braces is the only library that offers a solution to this problem.
The main export is a function that takes one or more brace patterns
and options
.
var braces = require('braces');
braces(pattern[, options]);
By default, braces returns an optimized regex-source string. To get an array of brace patterns, use brace.expand()
.
The following section explains the difference in more detail. (If you're curious about "why" braces does this by default, see brace matching pitfalls.
Optimized
By default, patterns are optimized for regex and matching:
console.log(braces('a/{x,y,z}/b'));
//=> ['a/(x|y|z)/b']
Expanded
To expand patterns the same way as Bash or minimatch, use the .expand method:
console.log(braces.expand('a/{x,y,z}/b'));
//=> ['a/x/b', 'a/y/b', 'a/z/b']
Or use options.expand:
console.log(braces('a/{x,y,z}/b', {expand: true}));
//=> ['a/x/b', 'a/y/b', 'a/z/b']
a/{b,c}/d
=> ['a/b/d', 'a/c/d']
{1..3}
=> ['1', '2', '3']
{2..10..2}
=> ['2', '4', '6', '8', '10']
Uses fill-range for expanding alphabetical or numeric lists:
console.log(braces('a/{foo,bar,baz}/*.js'));
//=> ['a/(foo|bar|baz)/*.js']
console.log(braces.expand('a/{foo,bar,baz}/*.js'));
//=> ['a/foo/*.js', 'a/bar/*.js', 'a/baz/*.js']
Uses fill-range for expanding alphabetical or numeric ranges (bash "sequences"):
console.log(braces.expand('{1..3}')); // ['1', '2', '3']
console.log(braces.expand('a{01..03}b')); // ['a01b', 'a02b', 'a03b']
console.log(braces.expand('a{1..3}b')); // ['a1b', 'a2b', 'a3b']
console.log(braces.expand('{a..c}')); // ['a', 'b', 'c']
console.log(braces.expand('foo/{a..c}')); // ['foo/a', 'foo/b', 'foo/c']
// supports padded ranges
console.log(braces('a{01..03}b')); //=> [ 'a(0[1-3])b' ]
console.log(braces('a{001..300}b')); //=> [ 'a(0{2}[1-9]|0[1-9][0-9]|[12][0-9]{2}|300)b' ]
Steps, or increments, may be used with ranges:
console.log(braces.expand('{2..10..2}'));
//=> ['2', '4', '6', '8', '10']
console.log(braces('{2..10..2}'));
//=> ['(2|4|6|8|10)']
When the .optimize method is used, or options.optimize is set to true, sequences are passed to to-regex-range for expansion.
Brace patterns may be nested. The results of each expanded string are not sorted, and left to right order is preserved.
"Expanded" braces
console.log(braces.expand('a{b,c,/{x,y}}/e'));
//=> ['ab/e', 'ac/e', 'a/x/e', 'a/y/e']
console.log(braces.expand('a/{x,{1..5},y}/c'));
//=> ['a/x/c', 'a/1/c', 'a/2/c', 'a/3/c', 'a/4/c', 'a/5/c', 'a/y/c']
"Optimized" braces
console.log(braces('a{b,c,/{x,y}}/e'));
//=> ['a(b|c|/(x|y))/e']
console.log(braces('a/{x,{1..5},y}/c'));
//=> ['a/(x|([1-5])|y)/c']
Escaping braces
A brace pattern will not be expanded or evaluted if either the opening or closing brace is escaped:
console.log(braces.expand('a\\{d,c,b}e'));
//=> ['a{d,c,b}e']
console.log(braces.expand('a{d,c,b\\}e'));
//=> ['a{d,c,b}e']
Escaping commas
Commas inside braces may also be escaped:
console.log(braces.expand('a{b\\,c}d'));
//=> ['a{b,c}d']
console.log(braces.expand('a{d\\,c,b}e'));
//=> ['ad,ce', 'abe']
Single items
Following bash conventions, a brace pattern is also not expanded when it contains a single character:
console.log(braces.expand('a{b}c'));
//=> ['a{b}c']
Type: Number
Default: 65,536
Description: Limit the length of the input string. Useful when the input string is generated or your application allows users to pass a string, et cetera.
console.log(braces('a/{b,c}/d', { maxLength: 3 })); //=> throws an error
Type: Boolean
Default: undefined
Description: Generate an "expanded" brace pattern (this option is unncessary with the .expand
method, which does the same thing).
console.log(braces('a/{b,c}/d', {expand: true}));
//=> [ 'a/b/d', 'a/c/d' ]
Type: Boolean
Default: true
Description: Enabled by default.
console.log(braces('a/{b,c}/d'));
//=> [ 'a/(b|c)/d' ]
Type: Boolean
Default: true
Description: Duplicates are removed by default. To keep duplicates, pass {nodupes: false}
on the options
Type: Number
Default: 250
Description: When braces.expand()
is used, or options.expand
is true, brace patterns will automatically be optimized when the difference between the range minimum and range maximum exceeds the rangeLimit
. This is to prevent huge ranges from freezing your application.
You can set this to any number, or change options.rangeLimit
to Inifinity
to disable this altogether.
Examples
// pattern exceeds the "rangeLimit", so it's optimized automatically
console.log(braces.expand('{1..1000}'));
//=> ['([1-9]|[1-9][0-9]{1,2}|1000)']
// pattern does not exceed "rangeLimit", so it's NOT optimized
console.log(braces.expand('{1..100}'));
//=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '100']
Type: Function
Default: undefined
Description: Customize range expansion.
var range = braces.expand('x{a..e}y', {
transform: function(str) {
return 'foo' + str;
}
});
console.log(range);
//=> [ 'xfooay', 'xfooby', 'xfoocy', 'xfoody', 'xfooey' ]
Type: Boolean
Default: undefined
Description: In regular expressions, quanitifiers can be used to specify how many times a token can be repeated. For example, a{1,3}
will match the letter a
one to three times.
Unfortunately, regex quantifiers happen to share the same syntax as Bash lists
The quantifiers
option tells braces to detect when regex quantifiers are defined in the given pattern, and not to try to expand them as lists.
Examples
var braces = require('braces');
console.log(braces('a/b{1,3}/{x,y,z}'));
//=> [ 'a/b(1|3)/(x|y|z)' ]
console.log(braces('a/b{1,3}/{x,y,z}', {quantifiers: true}));
//=> [ 'a/b{1,3}/(x|y|z)' ]
console.log(braces('a/b{1,3}/{x,y,z}', {quantifiers: true, expand: true}));
//=> [ 'a/b{1,3}/x', 'a/b{1,3}/y', 'a/b{1,3}/z' ]
Type: Boolean
Default: undefined
Description: Strip backslashes that were used for escaping from the result.
Brace expansion is a type of parameter expansion that was made popular by unix shells for generating lists of strings, as well as regex-like matching when used alongside wildcards (globs).
In addition to "expansion", braces are also used for matching. In other words:
 More about brace expansion (click to expand)
There are two main types of brace expansion:
{a,b,c}
a{1..3}b
. Optionally, a third argument may be passed to define a "step" or increment to use: a{1..100..10}b
. These are also sometimes referred to as "ranges".Here are some example brace patterns to illustrate how they work:
Sets
{a,b,c} => a b c
{a,b,c}{1,2} => a1 a2 b1 b2 c1 c2
Sequences
{1..9} => 1 2 3 4 5 6 7 8 9
{4..-4} => 4 3 2 1 0 -1 -2 -3 -4
{1..20..3} => 1 4 7 10 13 16 19
{a..j} => a b c d e f g h i j
{j..a} => j i h g f e d c b a
{a..z..3} => a d g j m p s v y
Combination
Sets and sequences can be mixed together or used along with any other strings.
{a,b,c}{1..3} => a1 a2 a3 b1 b2 b3 c1 c2 c3
foo/{a,b,c}/bar => foo/a/bar foo/b/bar foo/c/bar
The fact that braces can be "expanded" from relatively simple patterns makes them ideal for quickly generating test fixtures, file paths, and similar use cases.
In addition to expansion, brace patterns are also useful for performing regular-expression-like matching.
For example, the pattern foo/{1..3}/bar
would match any of following strings:
foo/1/bar
foo/2/bar
foo/3/bar
But not:
baz/1/qux
baz/2/qux
baz/3/qux
Braces can also be combined with glob patterns to perform more advanced wildcard matching. For example, the pattern */{1..3}/*
would match any of following strings:
foo/1/bar
foo/2/bar
foo/3/bar
baz/1/qux
baz/2/qux
baz/3/qux
Although brace patterns offer a user-friendly way of matching ranges or sets of strings, there are also some major disadvantages and potential risks you should be aware of.
"brace bombs"
For a more detailed explanation with examples, see the geometric complexity section.
Jump to the performance section to see how Braces solves this problem in comparison to other libraries.
At minimum, brace patterns with sets limited to two elements have quadradic or O(n^2)
complexity. But the complexity of the algorithm increases exponentially as the number of sets, and elements per set, increases, which is O(n^c)
.
For example, the following sets demonstrate quadratic (O(n^2)
) complexity:
{1,2}{3,4} => (2X2) => 13 14 23 24
{1,2}{3,4}{5,6} => (2X2X2) => 135 136 145 146 235 236 245 246
But add an element to a set, and we get a n-fold Cartesian product with O(n^c)
complexity:
{1,2,3}{4,5,6}{7,8,9} => (3X3X3) => 147 148 149 157 158 159 167 168 169 247 248
249 257 258 259 267 268 269 347 348 349 357
358 359 367 368 369
Now, imagine how this complexity grows given that each element is a n-tuple:
{1..100}{1..100} => (100X100) => 10,000 elements (38.4 kB)
{1..100}{1..100}{1..100} => (100X100X100) => 1,000,000 elements (5.76 MB)
Although these examples are clearly contrived, they demonstrate how brace patterns can quickly grow out of control.
More information
Interested in learning more about brace expansion?

Braces is not only screaming fast, it's also more accurate the other brace expansion libraries.
Fortunately there is a solution to the "brace bomb" problem: don't expand brace patterns into an array when they're used for matching.
Instead, convert the pattern into an optimized regular expression. This is easier said than done, and braces is the only library that does this currently.
The proof is in the numbers
Minimatch gets exponentially slower as patterns increase in complexity, braces does not. The following results were generated using braces()
and minimatch.braceExpand()
, respectively.
| Pattern | braces | minimatch |
|---|---|---|
{1..9007199254740991} [1] |
298 B (5ms 459μs) |
N/A (freezes) |
{1..1000000000000000} |
41 B (1ms 15μs) |
N/A (freezes) |
{1..100000000000000} |
40 B (890μs) |
N/A (freezes) |
{1..10000000000000} |
39 B (2ms 49μs) |
N/A (freezes) |
{1..1000000000000} |
38 B (608μs) |
N/A (freezes) |
{1..100000000000} |
37 B (397μs) |
N/A (freezes) |
{1..10000000000} |
35 B (983μs) |
N/A (freezes) |
{1..1000000000} |
34 B (798μs) |
N/A (freezes) |
{1..100000000} |
33 B (733μs) |
N/A (freezes) |
{1..10000000} |
32 B (5ms 632μs) |
78.89 MB (16s 388ms 569μs) |
{1..1000000} |
31 B (1ms 381μs) |
6.89 MB (1s 496ms 887μs) |
{1..100000} |
30 B (950μs) |
588.89 kB (146ms 921μs) |
{1..10000} |
29 B (1ms 114μs) |
48.89 kB (14ms 187μs) |
{1..1000} |
28 B (760μs) |
3.89 kB (1ms 453μs) |
{1..100} |
22 B (345μs) |
291 B (196μs) |
{1..10} |
10 B (533μs) |
20 B (37μs) |
{1..3} |
7 B (190μs) |
5 B (27μs) |
When you need expansion, braces is still much faster.
(the following results were generated using braces.expand()
and minimatch.braceExpand()
, respectively)
| Pattern | braces | minimatch |
|---|---|---|
{1..10000000} |
78.89 MB (2s 698ms 642μs) |
78.89 MB (18s 601ms 974μs) |
{1..1000000} |
6.89 MB (458ms 576μs) |
6.89 MB (1s 491ms 621μs) |
{1..100000} |
588.89 kB (20ms 728μs) |
588.89 kB (156ms 919μs) |
{1..10000} |
48.89 kB (2ms 202μs) |
48.89 kB (13ms 641μs) |
{1..1000} |
3.89 kB (1ms 796μs) |
3.89 kB (1ms 958μs) |
{1..100} |
291 B (424μs) |
291 B (211μs) |
{1..10} |
20 B (487μs) |
20 B (72μs) |
{1..3} |
5 B (166μs) |
5 B (27μs) |
If you'd like to run these comparisons yourself, see test/support/generate.js.
Install dev dependencies:
npm i -d && npm benchmark
Benchmarking: (8 of 8)
· combination-nested
· combination
· escaped
· list-basic
· list-multiple
· no-braces
· sequence-basic
· sequence-multiple
# benchmark/fixtures/combination-nested.js (52 bytes)
brace-expansion x 4,756 ops/sec ±1.09% (86 runs sampled)
braces x 11,202,303 ops/sec ±1.06% (88 runs sampled)
minimatch x 4,816 ops/sec ±0.99% (87 runs sampled)
fastest is braces
# benchmark/fixtures/combination.js (51 bytes)
brace-expansion x 625 ops/sec ±0.87% (87 runs sampled)
braces x 11,031,884 ops/sec ±0.72% (90 runs sampled)
minimatch x 637 ops/sec ±0.84% (88 runs sampled)
fastest is braces
# benchmark/fixtures/escaped.js (44 bytes)
brace-expansion x 163,325 ops/sec ±1.05% (87 runs sampled)
braces x 10,655,071 ops/sec ±1.22% (88 runs sampled)
minimatch x 147,495 ops/sec ±0.96% (88 runs sampled)
fastest is braces
# benchmark/fixtures/list-basic.js (40 bytes)
brace-expansion x 99,726 ops/sec ±1.07% (83 runs sampled)
braces x 10,596,584 ops/sec ±0.98% (88 runs sampled)
minimatch x 100,069 ops/sec ±1.17% (86 runs sampled)
fastest is braces
# benchmark/fixtures/list-multiple.js (52 bytes)
brace-expansion x 34,348 ops/sec ±1.08% (88 runs sampled)
braces x 9,264,131 ops/sec ±1.12% (88 runs sampled)
minimatch x 34,893 ops/sec ±0.87% (87 runs sampled)
fastest is braces
# benchmark/fixtures/no-braces.js (48 bytes)
brace-expansion x 275,368 ops/sec ±1.18% (89 runs sampled)
braces x 9,134,677 ops/sec ±0.95% (88 runs sampled)
minimatch x 3,755,954 ops/sec ±1.13% (89 runs sampled)
fastest is braces
# benchmark/fixtures/sequence-basic.js (41 bytes)
brace-expansion x 5,492 ops/sec ±1.35% (87 runs sampled)
braces x 8,485,034 ops/sec ±1.28% (89 runs sampled)
minimatch x 5,341 ops/sec ±1.17% (87 runs sampled)
fastest is braces
# benchmark/fixtures/sequence-multiple.js (51 bytes)
brace-expansion x 116 ops/sec ±0.77% (77 runs sampled)
braces x 9,445,118 ops/sec ±1.32% (84 runs sampled)
minimatch x 109 ops/sec ±1.16% (76 runs sampled)
fastest is braces
 Contributing
Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.

 Running Tests
Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
$ npm install && npm test

 Building docs
(This project's readme.md is generated by verb, please don't edit the readme directly. Any changes to the readme must be made in the .verb.md readme template.)
To generate the readme, run the following command:
$ npm install -g verbose/verb#dev verb-generate-readme && verb

You might also be interested in these projects:
step
to… more | homepage| Commits | Contributor |
|---|---|
| 188 | jonschlinkert |
| 4 | doowb |
| 1 | es128 |
| 1 | eush77 |
| 1 | hemanth |
Jon Schlinkert
Copyright © 2018, Jon Schlinkert. Released under the MIT License.
This file was generated by verb-generate-readme, v0.6.0, on February 17, 2018.

this is the largest safe integer allowed in JavaScript. ↩


Queue
Vote
Song 1
Song 2
Song 3
Song 4
user_name's Room
user_name's Chat Room
Frank: What is this song?
Ashley: I don't know, but I like it!


See also: sources sources of examples dartdoc pub package
Declarative hierarchical router for Polymer Dart 1.0


| Initials | Full Name | Number of days worked | Number of weekdays worked | Number of weekends worked | Number of holidays worked | Number of vacation days | Number of days as an On Site doctor | Number of days as an On Call doctor |
|---|---|---|---|---|---|---|---|---|
| AM | Andrew Mitchell | 17 | 15 | 5 | 2 | 3 | 10 | 7 |
| PM | Paul Matthew | 15 | 7 | 7 | 1 | 8 | 13 | 2 |
| KA | Kevin Anderson | 15 | 7 | 3 | 5 | 7 | 9 | 6 |
| RF | Rebecca Fiala | 17 | 11 | 3 | 3 | 7 | 6 | 11 |
| PB | Peter Batterson | 18 | 14 | 4 | 0 | 5 | 10 | 8 |
| GS | Geoffrey Sanders | 14 | 10 | 2 | 2 | 4 | 5 | 9 |
| JB | John Bell | 17 | 11 | 3 | 3 | 6 | 9 | 8 |
| AK | Amy Cavanagh | 12 | 5 | 2 | 5 | 4 | 7 | 5 |
| MG | Maxwell Garett | 16 | 9 | 5 | 2 | 2 | 8 | 8 |


We love snails!
Snails are awesome. We are working on phylogenomics of the freshwater snail family Pleuroceridae. As one of the most imperlied groups of animals on the planet, a robust phylogenetic hypothesis is needed to better study and conserve pleurocerids.


qq_plot.Rd
Quantile-quantile plot of model residuals
qq_plot(model, ...) # S3 method for gam qq_plot(model, method = c("direct", "simulate", "normal"), type = c("deviance", "response", "pearson"), n_uniform = 10, n_simulate = 50, ylab = NULL, xlab = NULL, title = NULL, subtitle = NULL, caption = NULL, ...)
| model | a fitted model. Currently only class |
|---|---|
| ... | arguments passed ot other methods. |
| method | character; method used to generate theoretical quantiles. |
| type | character; type of residuals to use. Only |
| n_uniform | numeric; number of times to randomize uniform quantiles
in the direct computation method ( |
| n_simulate | numeric; number of data sets to simulate from the estimated
model when using the simulation method ( |
| ylab | character or expression; the label for the y axis. If not supplied, a suitable label will be generated. |
| xlab | character or expression; the label for the y axis. If not supplied, a suitable label will be generated. |
| title | character or expression; the title for the plot. See
|
| subtitle | character or expression; the subtitle for the plot. See
|
| caption | character or expression; the plot caption. See
|
library("mgcv") ## simulate binomial data... set.seed(0) n.samp <- 200 dat <- gamSim(1, n = n.samp, dist = "binary", scale = .33)#> Gu & Wahba 4 term additive modelp <- binomial()$linkinv(dat$f) # binomial p n <- sample(c(1, 3), n.samp, replace = TRUE) # binomial n dat <- transform(dat, y = rbinom(n, n, p), n = n) m <- gam( y / n ~ s(x0) + s(x1) + s(x2) + s(x3), family = binomial, data = dat, weights = n, method = "REML") ## Q-Q plot; default using direct randomization of uniform quantiles qq_plot(m)## ... or use the usual normality assumption qq_plot(m, method = "normal")


There are currently ... XMR in circulation. All of them were given to miners to incentivize them to keep supporting the network.
Unlike Bitcoin's block rewards Monero's block rewards will never drop to zero. Instead, they will gradually decrease until tail emission commences at the end of May 2022. At this point, rewards will be fixed at 0.6 XMR per block.
Approximately 432 XMR will be created per day.
Miners need an incentive to mine. Because of the dynamic blocksize, competition between miners will cause fees to decrease. If mining is not profitable due to a high cost and low reward, miners lose their incentive and will stop mining, reducing the security of the network.
Tail emission ensures that a dynamic block size and fee market can develop.
In theory, the supply of Monero is auditable by adding up all coinbase block rewards of each block. This can be done using the "print_coinbase_tx_sum" command.
But there have been concerns about possible inflation bugs in the Monero codebase or the underlying math principles which could be exploited to generate coins out of thin air. In may 2017 the Monero Research Lab discovered and patched a critical bug that affected Monero and would have allowed an exploiter to create an unlimited number of coins in a way that is undetectable to an observer unless they know about the fatal flaw and can search for it.
This particular bug however was confirmed to have never been used before on the Monero blockchain.
Read more about supply auditability here
Note that this site only shows the expected circulating supply for a given date. The actual amount may be slightly lower because of block size penalties and blocks taking longer than 2minutes to mine.
source code
Donations:
Bitcoin: 1GjCgSEotu98Rk1dsUManUJ4TDTy33en4s
Monero: 44FEfHSktCiLpYgUzRDi4YVHYVAQoQuSJUPES2RxkUtyfKg2a82EV2xDv4TQDF8Ln9NBqF977FVehidwRySxoyMg4SyV8gX


|
Ubiquity
2.2.0
php rapid development framework
|
Public Member Functions | |
| __construct ($yumlString) | |
| getFirstKey ($table) | |
| getFieldType ($table, $fieldName) | |
| getPrimaryKeys ($table) | |
| getParts () | |
| getTables () | |
| getTableNames () | |
| getFields ($table) | |
| getForeignKeys ($table) | |
Data Fields | |
| null => "«null»" ] | |
Private Member Functions | |
| getFkName ($table, $prefix="id") | |
| parse () | |
| parsePart ($part) | |
| parseAllProperties () | |
| parseProperties ($propertiesString, $table) | |
| parseProperty ($property) | |
| parseRelations ($table) | |
| _parseRelations ($table, $matches) | |
| parseManyRelations ($table) | |
| _parseManyRelations ($table, $matches) | |
Private Attributes | |
| $stereotypes = [ "pk" => "«pk»" | |
| $defaultType = "varchar(30)" | |
| $originalString | |
| $parts | |
| $tables = [ ] | |
Definition at line 5 of file YumlParser.php.
| __construct | ( | $yumlString | ) |
Definition at line 12 of file YumlParser.php.
|
private |
Definition at line 154 of file YumlParser.php.
|
private |
Definition at line 135 of file YumlParser.php.
| getFields | ( | $table | ) |
Definition at line 188 of file YumlParser.php.
| getFieldType | ( | $table, | |
| $fieldName | |||
| ) |
Definition at line 110 of file YumlParser.php.
| getFirstKey | ( | $table | ) |
Definition at line 99 of file YumlParser.php.
|
private |
Definition at line 17 of file YumlParser.php.
| getForeignKeys | ( | $table | ) |
Definition at line 192 of file YumlParser.php.
| getParts | ( | ) |
Definition at line 176 of file YumlParser.php.
| getPrimaryKeys | ( | $table | ) |
Definition at line 118 of file YumlParser.php.
| getTableNames | ( | ) |
Definition at line 184 of file YumlParser.php.
| getTables | ( | ) |
Definition at line 180 of file YumlParser.php.
|
private |
Definition at line 21 of file YumlParser.php.
|
private |
Definition at line 41 of file YumlParser.php.
|
private |
Definition at line 148 of file YumlParser.php.
|
private |
Definition at line 30 of file YumlParser.php.
|
private |
Definition at line 59 of file YumlParser.php.
|
private |
Definition at line 69 of file YumlParser.php.
|
private |
Definition at line 127 of file YumlParser.php.
|
private |
Definition at line 7 of file YumlParser.php.
|
private |
Definition at line 8 of file YumlParser.php.
|
private |
Definition at line 9 of file YumlParser.php.
|
private |
Definition at line 6 of file YumlParser.php.
|
private |
Definition at line 10 of file YumlParser.php.
| null => "«null»" ] |
Definition at line 6 of file YumlParser.php.