public interface XSConstants
| Modifier and Type | Field and Description |
|---|---|
static short |
ANNOTATION
The object describes an annotation.
|
static short |
ANYSIMPLETYPE_DT
anySimpleType
|
static short |
ANYURI_DT
anyURI
|
static short |
ATTRIBUTE_DECLARATION
The object describes an attribute declaration.
|
static short |
ATTRIBUTE_GROUP
The object describes an attribute group definition.
|
static short |
ATTRIBUTE_USE
The object describes an attribute use definition.
|
static short |
BASE64BINARY_DT
base64Binary
|
static short |
BOOLEAN_DT
boolean
|
static short |
BYTE_DT
byte
|
static short |
DATE_DT
date
|
static short |
DATETIME_DT
dateTime
|
static short |
DECIMAL_DT
decimal
|
static short |
DERIVATION_EXTENSION
XSTypeDefinition final set or
XSElementDeclaration disallowed substitution group. |
static short |
DERIVATION_LIST
XSTypeDefinition final set. |
static short |
DERIVATION_NONE
No constraint is available.
|
static short |
DERIVATION_RESTRICTION
XSTypeDefinition final set or
XSElementDeclaration disallowed substitution group. |
static short |
DERIVATION_SUBSTITUTION
XSTypeDefinition final set. |
static short |
DERIVATION_UNION
XSTypeDefinition final set. |
static short |
DOUBLE_DT
double
|
static short |
DURATION_DT
duration
|
static short |
ELEMENT_DECLARATION
The object describes an element declaration.
|
static short |
ENTITY_DT
ENTITY
|
static short |
FACET
The object describes a constraining facet.
|
static short |
FLOAT_DT
float
|
static short |
GDAY_DT
gDay
|
static short |
GMONTH_DT
gMonth
|
static short |
GMONTHDAY_DT
gMonthDay
|
static short |
GYEAR_DT
gYear
|
static short |
GYEARMONTH_DT
gYearMonth
|
static short |
HEXBINARY_DT
hexBinary
|
static short |
ID_DT
ID
|
static short |
IDENTITY_CONSTRAINT
The object describes an identity constraint definition.
|
static short |
IDREF_DT
IDREF
|
static short |
INT_DT
int
|
static short |
INTEGER_DT
integer
|
static short |
LANGUAGE_DT
language
|
static short |
LIST_DT
The type represents a list type definition.
|
static short |
LISTOFUNION_DT
The type represents a list type definition whose item type (itemType)
is a union type definition
|
static short |
LONG_DT
long
|
static short |
MODEL_GROUP
A model group.
|
static short |
MODEL_GROUP_DEFINITION
The object describes a model group definition.
|
static short |
MULTIVALUE_FACET
The object describes enumeration and pattern facets.
|
static short |
NAME_DT
Name
|
static short |
NCNAME_DT
NCName
|
static short |
NEGATIVEINTEGER_DT
negativeInteger
|
static short |
NMTOKEN_DT
NMTOKEN
|
static short |
NONNEGATIVEINTEGER_DT
nonNegativeInteger
|
static short |
NONPOSITIVEINTEGER_DT
nonPositiveInteger
|
static short |
NORMALIZEDSTRING_DT
normalizedString
|
static short |
NOTATION_DECLARATION
The object describes a notation declaration.
|
static short |
NOTATION_DT
NOTATION
|
static short |
PARTICLE
The object describes a particle.
|
static short |
POSITIVEINTEGER_DT
positiveInteger
|
static short |
QNAME_DT
QName
|
static short |
SCOPE_ABSENT
The scope of a declaration within named model groups or attribute
groups is
absent . |
static short |
SCOPE_GLOBAL
A scope of
global identifies top-level declarations. |
static short |
SCOPE_LOCAL
Locally scoped declarations are available for use only
within the complex type. |
static short |
SHORT_DT
short
|
static short |
STRING_DT
string
|
static short |
TIME_DT
time
|
static short |
TOKEN_DT
token
|
static short |
TYPE_DEFINITION
The object describes a complex type or simple type definition.
|
static short |
UNAVAILABLE_DT
The built-in type category is not available.
|
static short |
UNSIGNEDBYTE_DT
unsignedByte
|
static short |
UNSIGNEDINT_DT
unsignedInt
|
static short |
UNSIGNEDLONG_DT
unsignedLong
|
static short |
UNSIGNEDSHORT_DT
unsignedShort
|
static short |
VC_DEFAULT
Indicates that there is a default value constraint.
|
static short |
VC_FIXED
Indicates that there is a fixed value constraint for this attribute.
|
static short |
VC_NONE
Indicates that the component does not have any value constraint.
|
static short |
WILDCARD
The object describes a wildcard.
|
static final short ATTRIBUTE_DECLARATION
static final short ELEMENT_DECLARATION
static final short TYPE_DEFINITION
static final short ATTRIBUTE_USE
static final short ATTRIBUTE_GROUP
static final short MODEL_GROUP_DEFINITION
static final short MODEL_GROUP
static final short PARTICLE
static final short WILDCARD
static final short IDENTITY_CONSTRAINT
static final short NOTATION_DECLARATION
static final short ANNOTATION
static final short FACET
static final short MULTIVALUE_FACET
static final short DERIVATION_NONE
static final short DERIVATION_EXTENSION
XSTypeDefinition
final set or
XSElementDeclaration
disallowed substitution group.static final short DERIVATION_RESTRICTION
XSTypeDefinition
final set or
XSElementDeclaration
disallowed substitution group.static final short DERIVATION_SUBSTITUTION
XSTypeDefinition
final set.static final short DERIVATION_UNION
XSTypeDefinition
final set.static final short DERIVATION_LIST
XSTypeDefinition
final set.static final short SCOPE_ABSENT
absent
.  All rights reserved.


Install the project by typing “npm install” in terminal or command prompt. It will install all dependencies and make your project ready to work.
# NPM INSTALL
SQLite is transaction database engine, it means you can run DDL and DML queries of SQL. DDL queries deal with creation of database, tables, view etc where as DML queries are responsible for CRUD operation (insert,delete,update) etc. Here is a code to create SQLite database and performing SQL operations.
```javascript
var sqlite3 = require('sqlite3').verbose();
var db = new sqlite3.Database('mydb.db');
var check;
db.serialize(function() {
db.run("CREATE TABLE if not exists user_info (info TEXT)");
var stmt = db.prepare("INSERT INTO user_info VALUES (?)");
for (var i = 0; i < 10; i++) {
stmt.run("Ipsum " + i);
}
stmt.finalize();
db.each("SELECT rowid AS id, info FROM user_info", function(err, row) {
console.log(row.id + ": " + row.info);
});
});
db.close();
```
To run and analyse the code, type node filename.js (in my case app.js) and see whether it creates “mydb.sql” file in your folder or not. This code will create table in database and add some numbers and displays it in console.
SQLite output
This is tutorial is for beginners. In further series i will post login-signup system and other useful tutorials about Node.js and SQLite.
SQL Queries using NodeJS:
To perform SELECT query you should use .all function and for other operations such as DELETE, UPDATE, INSERT you should use .run function. Here have a look to simple code.
```javascript
//Load modules
var sqlite3 = require('sqlite3').verbose();
var db = new sqlite3.Database('./database_name.db');
//Perform SELECT Operation
db.all("SELECT * from blah blah blah where this="+that,function(err,rows){
//rows contain values while errors, well you can figure out.
});
//Perform INSERT operation.
db.run("INSERT into table_name(col1,col2,col3) VALUES (val1,val2,val3)");
//Perform DELETE operation
db.run("DELETE * from table_name where condition");
//Perform UPDATE operation
db.run("UPDATE table_name where condition");
```


property Backend: TBackend;
Returns or sets the current back-end used for the bitmap's surface and additional graphics subsystem specific features that are accessible via interfaces.
Note: Interface queries on the current bitmap will also be delegated to the back-end.


From: test@localhost [mailto:test@localhost]
Sent: Tuesday, 11th December 2012 11:19
To: Tom Tester
Subject: News: "Version 3 - Introducing the New Feature"
@abc @dwf
We should check this out, shouldn't we?
A News post has been added to the board.
"Version 3 - Introducing the New Feature"
Post author: S. Bulletin
Version 3 gives
you one some cool new stuff you would not have expected.
Introducing the new feature
Some text describing the feature
in detail, outlining all the benefits
showing how you can be more efficient in your daily work
To make it all even more appealing an video has been created
and added to the email,
right here:
To learn more about this release, there are some additional resources:
Thanks!
Your e-mail subscription can be customized by changing the settings in your profile through the "Edit your Profile" link.
Be up-to-date by subscribing to the news RSS Feed: click on the RSS Icon on the News page.


{{ .Hugo.Generator }}
{{ $url := replace .Permalink ( printf "%s" .Site.BaseURL) "" }} {{ if eq $url "/" }} {{ .Site.Title }} {{ else }} {{ if .Params.Heading }} {{ .Params.Heading }} {{ else }} {{ .Title }} {{ end }} {{ end }}
Toggle navigation
Home
(current)
Contact
Events
Blog
Sponsor
Speaking
Organizing
Search
×
Search DevOpsDays
EVENTS NEAR ME
PAST EVENTS
2016
October
{{- block "main" . }} {{- end -}}
{{ block "right-col" . }} {{ end }}
EVENTS NEAR ME
PAST CURRENT UPCOMING
FEATURED
Chicago 2017
Summit West - 15 October 2017
BLOG
Some Blog Title
by Somebody - 18 October 2017
Something blah blah blah blah...
more
@DEVOPSDAYS


import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import pymc3 as pm
import arviz as az
Preparation of results for business: Newpaper Sales¶
We will illustrate how to prepare results for a business audience using ArviZ. The motivating example we’ll use is a classic example in Industrial Engineering, the newsvendor problem. In brief the problem is as follows
As a newpaper girl, or boy, you face a dilemma; buy too many newspapers and you’ll lose money from newspaper that expire. Buy too few newspapers and you’ll miss potential sales, and lose money. Using past sales information and ArviZ we can create a compelling data centric pitch about what business choice to make in this scenario
Outline¶
Posterior Estimation
Posterior Predictive
Simulation¶
As we have in past chapters we’re going to create some simulated sales data. Our latent (hidden) parameter is 30 sales per a day on average, and we are simulated 20 days of sales. We are using the poisson distribution because we can only sell positive whole numbers of newspapers (e.g. 12, 14,21)
newspaper_sales = stats.poisson.rvs(30, size=20)
The observed data¶
At the end of 20 days these are the sales numbers we see. Given 20 days of sales you must make a case of how many newspapers to buy in the future.
newspaper_sales
array([27, 26, 19, 32, 21, 33, 34, 27, 29, 32, 31, 23, 31, 31, 24, 39, 33,
25, 27, 27])
Fitting the data¶
Before any results can be prepared we must first fit a model and generate some results
with pm.Model() as newspaper_model:
_lambda = pm.Normal("λ", newspaper_sales.mean(), 10)
sales = pm.Poisson("sales", _lambda, observed=newspaper_sales)
trace = pm.sample(draws=2000)
ppc = pm.sample_posterior_predictive(trace)
data = az.from_pymc3(trace=trace, posterior_predictive=ppc)
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 2 jobs)
NUTS: [λ]
Sampling 2 chains for 1_000 tune and 2_000 draw iterations (2_000 + 4_000 draws total) took 2 seconds.
/home/osvaldo/proyectos/00_BM/arviz/arviz/data/io_pymc3.py:89: FutureWarning: Using `from_pymc3` without the model will be deprecated in a future release. Not using the model will return less accurate and less useful results. Make sure you use the model argument or call from_pymc3 within a model context. FutureWarning,
Preparation of results¶
Using ArviZ there are numerous ways we can share the results depending on audience. The three will we cover are a numerical Summary with az.summary
, posterior parameter estimation using az.plot_posterior
, and posterior predictive visualization using az.ppc_plot
Numerical Summary of estimated parameters using az.summary¶
The simplest way to share the result is using the numerical summuraization in az.summary
az.summary(data)
| mean | sd | hdi_3% | hdi_97% | mcse_mean | mcse_sd | ess_mean | ess_sd | ess_bulk | ess_tail | r_hat | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| λ | 28.562 | 1.162 | 26.437 | 30.783 | 0.032 | 0.023 | 1310.0 | 1310.0 | 1311.0 | 2612.0 | 1.0 |
Using the above summary we get a couple of useful data points. The mean of the expected number of sales each day is ~30.2 and the standard deviation of sales is ~1.2. The advantages of a numerical summary is the ease of communication and succintness. Often times in business settings you may need to describe results without the aid of computer, or chart. Additionally in most businesses your surrounding colleagues will likely not be statisticians. However most people can intuit around the idea of mean and standard deviation, and providing a mean and sd estimate is quick and is not overwhelming.
There are some downsides to numerical summaries. One is that by summarizing to two numbers, a lot of information is “left on the table”. Additionally in certain contexts when a visualization can be used, it’s often much more memorable to show a picture of the parameter estimation than provide two summary statistics. Lastly the mean, standard deviation, and even the hpd estimates, don’t characterize all distributions well. For exmaple in our newspaper problem if the distribution was bimodal, perhaps because of weekday sales and weekend sales, none of the numerical estimates would correctly communicate this condition.
Visual Summary of estimated paramters using plot_posterior¶
az.plot_posterior(data);
With plot posterior we get a nice visualization of the parameter estimates, as well as point estimate and the Highest Posterior Density. In contrast to the numerical estimates a posterior plot is much harder to gloss over. Posterior Plots also characterize all, or nearly all, the information inferred about the estimated parameters, including uncertainty and characteristics of the distribution.
As with any visualization though this cannot be used outside of a visual presentation format. It can be awkward to describe to non statisticians verbally. Additionally posterior by nature are the estimated distribution of parameter space. Many times people that are unfamiliar with Bayesian Statistics will incorrectly assume that the x axis is in the units of data, in this case newspaper sales. This intrepratation can lead to incorrect results, as colleagues may assume that “there is a 94% chance that 28 to 31 newspapers will be sold in a day” and are in for a surprise when on many occassions more or less papers are sold.
Visual Summary of estimated sales using Posterior Predictive Plot¶
az.plot_ppc(data, num_pp_samples=100);
With plot_ppc we get a plot of the observed data along with the simulated outcomes from the parameter estimations. Benefits if the Posterior Predictive plot are the same as the posterior plot, but with the notable change that the x axis is in the units of the data. Posterior Predictive Plots then lend themselves to the correct interpretation that “15 to 40 newspapers will be sold a day, and lesser likely that 10 or 45 will be sold”
The downside to the posterior plot is that if asked to explained how they are generated it’s not typically a straightforward exercise. From personal experience if trying to explain that you fit parameters using Bayesian Statistics to estimate the posterior, then generated “1000”, or any arbitrary number, of future simulations, then took the KDE of them, most colleagues lose interest quickly.
Practical Advice for using ArviZ in business settings¶
As a statistician in the workplace your job is to help others make good decisions using data. This naturally requires your analysis to be rigorous and thorough, but also requires you to present it in a way that others will take heed to the results. If your boss becomes bored with the details of Posterior Plots and subsequently fails to understand the conclusion. then your analysis was as ineffective as not running an analysis at all.
My advice would be to know your audience. their tolerance for mathematical explanations, and understand the context in which you can explain the data. If you’re providing a visual presentation, and have a couple minutes, consider using the Posterior Plot or Posterior Predictive Plot as it lends itself to a longer explanation. If you’re given less time consider using the numerical summaries from az.summary
to quickly convey your results.
In either scenario I would suggest memorizing a couple of the numerical summaries, such as mean, median, or HPD, so if an opportunity arises in a “hallway” conversation, or during a meeting without a presentation you are able to share results quickly and without a visual aid.


Creates an instance of @type {YouTubeDataService}.
emits event when @member loadChannel resolves
emits event when @member loadChannelSet resolves
emits event when @member loadChannelsIndex resolves
Returns true when the last API promise is rejected.
Returns true when the last API call loaded data without any errors.
Returns true when the API call is promising.
name of method on this class for Jasmine spies
name of method on this class for Jasmine spies
name of method on this class for Jasmine spies
gets the executor for the constructor of @type {Promise}
initializes App data-loading state
loads YouTube channel
loads YouTube channel set
loads YouTube channels index
loads JSON from the specified URI
gets @type {YouTubeItem[]} from JSON of the shape { items: [] } }
gets @type {Map<string, YouTubeItem[]>} from JSON of the shape { set: [{ items: [] }] }
Generated using TypeDoc
YouTube data service


☃❄ SAND Wintersday Raffle ❄☃
Happy Wintersday, everyone! We at SAND are wishing you all warm cocoa, comfy relaxation and all the tasty goodies! Another year has gone by and we’ve once again arrived at festive celebrations and this will be our fifth Wintersday together! *Much clapping and cheering* While the Snow Pile decoration has been our traditional method of raffle tickets, this year we’ll be using gold buy-in tickets; The gold gained will be put towards future raffles.
🎅🤶👪🍪🥛🦌❄☃🎄🎁🔔🎶
Once again, we’re focusing less on a grand prize and more on multiple prizes so we can spread the love and festive cheer. As always thank you so, so much to those who have donated prizes and gold; they help make these raffles happen. <3
What you need to know:
- The raffle tickets are as follows: 3 gold = 1 ticket
- There is no limit on how many tickets an individual can buy. Winners will be randomly selected using a random number generator, and the process will be recorded.
- Entries will be received by donating gold to the first or second tab of the guild bank. There will be a tracker in place for marking down how much gold is donated by each individual. It checks frequently, and we have a backup for all data as well.
- We will pull from the most expensive prizes first and go in descending value order. Once you have won a prize you will no longer be eligible to win another.
- Contest officially ends on Tuesday January 7th at 11:59 pm (PST time), 7 hours after reset. Winners will be selected and sent their respective prizes the next day.
Prize List:


Blank Meal Planner
$0.00
(In Stock)
This Meal planner will be sent to your email as a PDF straight away once purchased
This Meal Planner is blank so you are able to print it out and fill with your meals of the week!


Requests a description of a specified set of deployments.
Note
You must specify at least one of the parameters.
Required Permissions : To use this action, an IAM user must have a Show, Deploy, or Manage permissions level for the stack, or an attached policy that explicitly grants permissions. For more information on user permissions, see Managing User Permissions .
See also: AWS API Documentation
describe-deployments
[--stack-id <value>]
[--app-id <value>]
[--deployment-ids <value>]
[--cli-input-json <value>]
[--generate-cli-skeleton <value>]
The stack ID. If you include this parameter, describe-deployments returns a description of the commands associated with the specified stack.
The app ID. If you include this parameter, describe-deployments returns a description of the commands associated with the specified app.
An array of deployment IDs to be described. If you include this parameter, describe-deployments returns a description of the specified deployments. Otherwise, it returns a description of every deployment.
Syntax:
"string" "string" ...
--cli-input-json (string) Performs service operation based on the JSON string provided. The JSON string follows the format provided by --generate-cli-skeleton. If other arguments are provided on the command line, the CLI values will override the JSON-provided values.
--generate-cli-skeleton (string) Prints a JSON skeleton to standard output without sending an API request. If provided with no value or the value input, prints a sample input JSON that can be used as an argument for --cli-input-json. If provided with the value output, it validates the command inputs and returns a sample output JSON for that command.
To describe deployments
The following describe-deployments commmand describes the deployments in a specified stack.
aws opsworks --region us-east-1 describe-deployments --stack-id 38ee91e2-abdc-4208-a107-0b7168b3cc7a
Output:
{
"Deployments": [
{
"StackId": "38ee91e2-abdc-4208-a107-0b7168b3cc7a",
"Status": "successful",
"CompletedAt": "2013-07-25T18:57:49+00:00",
"DeploymentId": "6ed0df4c-9ef7-4812-8dac-d54a05be1029",
"Command": {
"Args": {},
"Name": "undeploy"
},
"CreatedAt": "2013-07-25T18:57:34+00:00",
"Duration": 15,
"InstanceIds": [
"8c2673b9-3fe5-420d-9cfa-78d875ee7687",
"9e588a25-35b2-4804-bd43-488f85ebe5b7"
]
},
{
"StackId": "38ee91e2-abdc-4208-a107-0b7168b3cc7a",
"Status": "successful",
"CompletedAt": "2013-07-25T18:56:41+00:00",
"IamUserArn": "arn:aws:iam::123456789012:user/someuser",
"DeploymentId": "19d3121e-d949-4ff2-9f9d-94eac087862a",
"Command": {
"Args": {},
"Name": "deploy"
},
"InstanceIds": [
"8c2673b9-3fe5-420d-9cfa-78d875ee7687",
"9e588a25-35b2-4804-bd43-488f85ebe5b7"
],
"Duration": 72,
"CreatedAt": "2013-07-25T18:55:29+00:00"
}
]
}
More Information
For more information, see Deploying Apps in the AWS OpsWorks User Guide.
Deployments -> (list)
An array of Deployment objects that describe the deployments.
(structure)
Describes a deployment of a stack or app.
DeploymentId -> (string)
The deployment ID.StackId -> (string)
The stack ID.AppId -> (string)
The app ID.CreatedAt -> (string)
Date when the deployment was created.CompletedAt -> (string)
Date when the deployment completed.Duration -> (integer)
The deployment duration.IamUserArn -> (string)
The user's IAM ARN.Comment -> (string)
A user-defined comment.Command -> (structure)
Used to specify a stack or deployment command.
Name -> (string)
Specifies the operation. You can specify only one command.
For stacks, the following commands are available:
- execute_recipes : Execute one or more recipes. To specify the recipes, set an Args parameter named recipes to the list of recipes to be executed. For example, to execute phpapp::appsetup , set Args to {"recipes":["phpapp::appsetup"]} .
- install_dependencies : Install the stack's dependencies.
- update_custom_cookbooks : Update the stack's custom cookbooks.
- update_dependencies : Update the stack's dependencies.
Note
The update_dependencies and install_dependencies commands are supported only for Linux instances. You can run the commands successfully on Windows instances, but they do nothing.
For apps, the following commands are available:
- deploy : Deploy an app. Ruby on Rails apps have an optional Args parameter named migrate . Set Args to {"migrate":["true"]} to migrate the database. The default setting is {"migrate":["false"]}.
- rollback Roll the app back to the previous version. When you update an app, AWS OpsWorks stores the previous version, up to a maximum of five versions. You can use this command to roll an app back as many as four versions.
- start : Start the app's web or application server.
- stop : Stop the app's web or application server.
- restart : Restart the app's web or application server.
- undeploy : Undeploy the app.
Args -> (map)
The arguments of those commands that take arguments. It should be set to a JSON object with the following format:
{"arg_name1" : ["value1", "value2", ...], "arg_name2" : ["value1", "value2", ...], ...}The update_dependencies command takes two arguments:
- upgrade_os_to - Specifies the desired Amazon Linux version for instances whose OS you want to upgrade, such as Amazon Linux 2014.09 . You must also set the allow_reboot argument to true.
- allow_reboot - Specifies whether to allow AWS OpsWorks to reboot the instances if necessary, after installing the updates. This argument can be set to either true or false . The default value is false .
For example, to upgrade an instance to Amazon Linux 2014.09, set Args to the following.
{ "upgrade_os_to":["Amazon Linux 2014.09"], "allow_reboot":["true"] }key -> (string)
value -> (list)
(string)Status -> (string)
The deployment status:
- running
- successful
- failed
CustomJson -> (string)
A string that contains user-defined custom JSON. It can be used to override the corresponding default stack configuration attribute values for stack or to pass data to recipes. The string should be in the following format:
"{\"key1\": \"value1\", \"key2\": \"value2\",...}"For more information on custom JSON, see Use Custom JSON to Modify the Stack Configuration Attributes .
InstanceIds -> (list)
The IDs of the target instances.
(string)


{% extends '_layouts/default.html' %} {% set id = "about" %} {% block main %}
South Madison Voters works to increase voter turnout for the November 6th election in the South Madison area to help elect Democratic candidates. We are a volunteer organization that does not take financial contributions. We gladly welcome additional volunteers though. 😃


| cols | Create column specification |
| cols_condense | Examine the column specifications for a data frame |
| cols_only | Create column specification |
| col_big_integer | Create column specification |
| col_character | Create column specification |
| col_date | Create column specification |
| col_datetime | Create column specification |
| col_double | Create column specification |
| col_factor | Create column specification |
| col_guess | Create column specification |
| col_integer | Create column specification |
| col_logical | Create column specification |
| col_number | Create column specification |
| col_skip | Create column specification |
| col_time | Create column specification |
| col_types | Create column specification |
| date_names | Create or retrieve date names |
| date_names_lang | Create or retrieve date names |
| date_names_langs | Create or retrieve date names |
| default_locale | Create locales |
| fwf_cols | Read a fixed width file into a tibble |
| fwf_empty | Read a fixed width file into a tibble |
| fwf_positions | Read a fixed width file into a tibble |
| fwf_widths | Read a fixed width file into a tibble |
| generators | Generate individual vectors of the types supported by vroom |
| gen_character | Generate individual vectors of the types supported by vroom |
| gen_date | Generate individual vectors of the types supported by vroom |
| gen_datetime | Generate individual vectors of the types supported by vroom |
| gen_double | Generate individual vectors of the types supported by vroom |
| gen_factor | Generate individual vectors of the types supported by vroom |
| gen_integer | Generate individual vectors of the types supported by vroom |
| gen_logical | Generate individual vectors of the types supported by vroom |
| gen_name | Generate individual vectors of the types supported by vroom |
| gen_number | Generate individual vectors of the types supported by vroom |
| gen_tbl | Generate a random tibble |
| gen_time | Generate individual vectors of the types supported by vroom |
| guess_type | Guess the type of a vector |
| locale | Create locales |
| problems | Retrieve parsing problems |
| spec | Examine the column specifications for a data frame |
| vroom | Read a delimited file into a tibble |
| vroom_altrep | Show which column types are using Altrep |
| vroom_altrep_opts | Show which column types are using Altrep |
| vroom_example | Get path to vroom examples |
| vroom_examples | Get path to vroom examples |
| vroom_format | Convert a data frame to a delimited string |
| vroom_fwf | Read a fixed width file into a tibble |
| vroom_lines | Read lines from a file |
| vroom_progress | Determine if progress bars should be shown |
| vroom_str | Structure of objects |
| vroom_write | Write a data frame to a delimited file |
| vroom_write_lines | Write lines to a file |


About our Restuarant!
Our restuarant based in Blyth Ontario is home to great food and great craft beer. We have a local farm-to-table food to insure all of peoples freshness needs!


JavaScript
Type 1:
For Documentation
Here
JavaScript is
Magic
Try custom input:
Try Custom Input
Type 2:
For Documentation
Here
BE THE
CHANGE


| text |
Any text entered in the filter will match text found within the column |
abc (finds "abc", "abcd", "abcde", etc) |
! |
Not operator. Filter the column with content that does not match the query. |
!fe (hide rows with "female" in that column, but shows rows with "male") |
< <= >= > |
Find alphabetical or numerical values less than or greater than or equal to the filtered query. |
>= 10 (find values greater than or equal to 10) |
- or to |
Find a range of values. Make sure there is a space before and after the dash (or the word "to"). |
10 - 30 or 10 to 30 (match values between 10 and 30) |
" |
To exactly match the search query, add a quote, apostrophe or equal sign to the beginning and/or end of the query |
abc" or abc= (exactly match "abc") |
? |
Wildcard for a single, non-space character. |
J?n (finds "Jan" and "Jun", but not "Joan") |
* |
Wildcard for zero or more non-space characters. |
B*k (matches "Black" and "Book") |
/\d/ |
Add any regex to the query to use in the query |
/b[aeiou]g/i (finds "bag", "beg", "BIG", "Bug", etc) |


ArchaicQuest A text based RPG | Multi-User Dungeon
Explore, discover, and conquer in ArchaicQuest an online RPG where the only limits are your imagination.
Being text based allows for a rich environment to role play your desires.
You choose your own path, and set your own destiny.


This page demonstrates the SVG icons supplied with Jumpstart. Use the buttons to copy the icon's code to the clipboard.
NOTE: SVG icons and graphics do not appear when you are viewing the page from a local file. This is because the SVG injection script requires AJAX to work, which only works on a server. To see icons appear, you must view the page from a local server such as the Browsersync server provided in the Dev Tools.


ISBN Search
ISBN-13:<PHONE_NUMBER>828
ISBN-10:<PHONE_NUMBER>
Author: Luis Atencio
Edition: 1
Binding: Paperback
Publisher: Manning Publications
Published: June 2016
List Price: $44.99
$34.08
+2.64 shipping
Ships 2-3 days
Notes
$33.23
+3.95 shipping
Ready to ship
$34.37
+3.99 shipping
$38.37
Free shipping
$39.78
$40.50
+3.65 shipping
$41.16
Ships 3+ Days
$42.76
+3.97 shipping
$43.64
$46.49
+5.99 shipping
$26.99
$35.39
$35.40
$38.94
$46.11
$31.99
$40.09
$40.49


2 Samuel 13:24
And Absalom came to the king, and said, Behold now, thy servant hath sheepshearers; let the king, I beseech thee, and his servants go with thy servant.


Kickin' in Kildalton - Part 1
I spent the day snowtubing with Whiskey Kid #1. We were just a few minutes away from a New Hampshire liquor barn and she graciously agreed to a quick trip. Fortunately for her, I had my shopping list ready and it was a quick trip. I picked up enough to fill out my 8 month plan (with one summer exception) and bring my yearly total up to ~$700. I’ve got too much whisky stock… better drink some of it!
The plan was to continue on with my Speyside tastings but I feel like a need a quick return to something I know before going back for further evaluation. That, and my most cherished acquisition today was the Ardbeg Explorer’s pack for $48. This includes a 750 mL bottle of the standard Ardbeg 10 and 50 mL samplers of Uigeadail and Corryvreckan. This has to be the best value that I’ve yet come across. Thanks, New Hampshire!
So I return to Islay, my whisky home. I’m calling this sojourn “Kickin’ in Kildalton” as I now possess the three standard expressions from the Kildalton distilleries on the south of Islay - Lagavulin 16, Laphroaig 10 and now Ardbeg 10. I’ll kick it off today by comparing Ardbeg 10 and Lagavulin 16. We’re going just taste today and will get into more details over the coming days.
Lagavulin 16
This is the expression I’m most familiar with. The 15 mL neat pour today is the same as the last time I had it - peaty, smoky, medicinal, complex finish. I’m getting more bitter notes than ever before through this comparison.
Ardbeg 10
Alright, standard Ardbeg. What you got?
- Nose: Peat smoke, similar to the Lagavulin. Some light citrus notes underneath the smoke. Not quite as medicinal as the Lagavulin. The smoke seems a bit more intense.
 Some numbing.
- Finish: Yum, this is good. Very long. Some drying. More intense smoke than the Lagavulin. But also some lighter citrus notes like on the nose. Less complex than the Lagavulin but what’s here is incredibly pleasant. A sip can last minutes.
Conclusion
Wow. OK. I’m an Ardbeg guy. I’m still a Lagavulin guy but the Ardbeg really impresses me. I can’t wait to do an Ardbeg vertical and compare the base expression with the Uigeadail and Corryvreckan. But first, we need to see how the Laphroiag holds up… tomorrow…
Whisky Bob signing off.
Previous: Accountability


Simple Risk Measurement¶
Simple Risk Measurement is written to help you measure complicated risks using a process that’s simple enough to work out on the back of a napkin and powerful enough to organize a rocket launch.
If you are an engineer motivated by the reduction of risk and are frustrated by how to measure your progress, you may find this documentation useful. Simple Risk Measurement can get you started towards a comprehensive and scientific approach to risk. It is designed to enhance subject matter experts who work with risk, especially those who mitigate complex risks on an ongoing basis.
See Risk to better understand this problem in engineering.
How does it work?¶
This approach is very simple to trivialize into a few steps.
- Define a risk scenario: A well defined, undesirable future event that we want to measure.
- Gather the evidence: We gather facts, reference classes, models, experiences, and opinions.
- Estimate the outcomes: We estimate of the probabilities / impacts the scenario may have.
- Make a decision: We make decisions with this information, and measure again if needed.
- Keep Score: As outcomes occur, we check our work, improve our methods and reduce our uncertainty.
For example:
The Cubs win the 2025 World Series
may be a future scenario you care about.
To better understand this scenario, you might gather evidence by reviewing historical baseball data, interviewing experts, or building statistical models. You would then forecast likelihood of outcomes like Yes
or No
, or estimate other values based on that information, and make decisions as a result.
With little effort, for example and entertainment purposes, this author prepares a 2.5% Yes
and 97.5% No
forecast. This starts from an assumption of 1/30
teams in the MLB (3%
). The author observes that other teams more often win the World Series, a World Series might not happen at all, and the author holds an irrational and indefensible belief in the Curse of the Billy Goat subjectively reducing this forecast further towards 2.5%
.
With greater evidence, time, and additional expert opinions, this documentation suggests methods to make this forecast increasingly rigorous, defending against cognitive bias (The author believes in curses? Really?) and introducing values that represent other knowledge. This can result in a more reliable value than an expert opinion that qualitatively states “They probably won’t win in 2020” which can not be leveraged by scientific measurement or as an engineering approach.
How does this help me?¶
You may be enthusiastic about some of the following risk problems:
- Is a risk worth mitigating?
- We can gather quantitative data that informs decisions to invest in a mitigation, (or not).
- Has a specific risk gotten better or worse?
- We can measure a risk over time and observe differences if it is being mitigated (or not).
- Which mitigation option(s) should we choose?
- We can measure many mitigation options and quantitatively compare their impact on undesired outcomes.
- How do we measure many risks?
- We can organize many risks that are being measured and use them to inform broader risks.
- Have we spent enough time identifying new risks?
- We can measure if further risk assessments are likely to reveal new risks, (or not).
What doesn’t this do?¶
This method is industry agnostic. This creates very helpful limitations that, hopefully, improves its accessibility.
This documentation does not prescribe:
- The governance of your risks, or accountable parties.
- The scenarios you should define for your risks.
- The approaches you should to mitigate your risks.
By avoiding these subjects, this method hopes to measure any creative approaches to risk mitigation.


{% extends "base.html" %} {% block title %}The Blue Alliance - Contact{% endblock %} {% block meta_description %}How to get in touch with The Blue Alliance.{% endblock %} {% block content %}
Learn how you can help add match video, offseason results, report bad data, and more here.
Join our Facebook group to help add offseason results, report bad data, give us feedback, and more!
If your team's information, such as team name, sponsors, and robot name, is incorrect on The Blue Alliance, please check if it is correct on FIRST's website. We update our records from FIRST's TIMS daily, and are unable to change your team information to anything other than what is listed there.
The new "dotcom" website brings a new API that doesn't require an API key to use. We provide the documentation for the API on our website. Check out our GitHub repository if you'd like to help build it. :D


‘His dream is to go to Man United’ – Player eager for quick transfer, talks expected soon
by Sport Witness TeamLike pretty much every day, today Tuttosport have claims about Mario Mandzukic’s potential move to Manchester United.
It’s been this way since the close of the summer transfer window, when it was claimed the striker rejected a last minute switch to Old Trafford because he didn’t feel he had enough time to consider his options.
Juventus then made the decision of an exit rather easier for Mandzukic, by freezing him out of their first team squad. The Croatian hasn’t even been training with Maurizio Sarri’s side, and the Turin club tried to force through a move to Qatar.
On Monday, Tuttosport say talks with Manchester United over Mandzukic could lead to negotiations about Paul Pogba. That seems to be the hope anyway.
It’s stated that for the Croatian, ‘his dream is to go to Man United’, and he’d like to get a move sorted out sooner rather than later. There’s been talk of the transfer potentially happening in December, which would give the 33 year old time to train with his new club before being registered.
Tuttosport mention that once again, and state talks over the deal are set to take place soon, and it’s claimed the player’s agent has been speaking to the Premier League club ‘for a few months’.
Building a good transfer relationship with Manchester United can only help Juventus should Pogba be allowed to fulfil his wish for a move.
As always, Tuttosport state the Frenchman still thinks highly of his former club, and would be keen on a return.


The Black Summer bushfires of 2019/2020 were quickly forgotten about after the start of the global Covid-19 pandemic.
These fires had huge impacts on many rural towns throughout Australia. Below is a map of Buchan, highlighting the reasons that Buchan is more than
worth the visit.


TABLE OF CONTENT
Look at all those famous people committing to some random developer’s boring repository.
Why would they do that? In fact, they don’t.
In general, git is just a tool that allows you to create patches and distribute them around by email.
When you create a commit, it will be signed with your name and email. Look at the author part here:
You have your name listed twice for every commit. You are both the author and the committer. Technically, the author is the one who created the patch, and the committer is the person who applied the patch.
By default, both values are taken from your git config
However, there is a way to override them:
This command will write any name and email to both, the committer and the author fields.
Why would you do that?
The real life use case scenario: imagine you have to work with a repository on someone else’s computer. Or you work from you personal computer, but you want to commit your changes to your work repository. You might want to use the proper user name to keep the history clean and correct.
Disclaimer
First of all, this is not a security issue. You don’t actually gain access to the person’s git account and repositories.  This activity will not be shown on their profile page.
So use it wisely and do not abuse it too much :)


Employee Data Management
name
email
Name required!
Email required!
Password required!
Add
Update
The Information
Name
Email
Password
Image
Actions
{{item.name}}
{{item.email}}
{{item.password}}
{{item.image}}


Low hanging fruit strategy marketing bootstrapping supply chain direct mailing social proof assets incubator buyer. Non-disclosure agreement bootstrapping advisor equity client. Leverage MVP bootstrapping responsive web design stock.
Technology assets deployment beta gamification bootstrapping graphical user interface vesting period launch party supply chain churn rate. Ownership beta churn rate. Gamification analytics iteration long tail agile development.


What goals will you reach today?
Sign Up
Sign In
It All Starts Here
Username
Password
Repeat Password
Welcome Back!
Username
Password
Why REACH?
Mission
R
each:
Designed to assist with
motivating
to reach your health and fitness goals.
E
ncourage:
We encourage you to always do your best. Lose the excuses and make change happen!

C
hallenge:
Challenge yourself daily by setting up your daily/weekly goals.
H
elp:
There will be articles, tips, blogs and
support
help you get where you want to get.


Tests in this page allow an attacker to control the URL of an active content being imported in the page.
This class of tests simply takes the URL and uses it as the source of the inclusion.


Interface IAsyncCompletionSource<TResult>
Represents the producer side of a IAsyncOperation<TResult> unbound to a delegate, providing access to the consumer side through the Operation property.
Namespace: UnityFx.Async
Assembly: UnityFx.Async-netstandard2.0.dll
Syntax
public interface IAsyncCompletionSource<TResult>
Type Parameters
| Name | Description |
|---|---|
| TResult | Type of the operation result value. |
Properties
| Improve this Doc View SourceOperation
Gets the operation being controller by the source.
Declaration
IAsyncOperation<TResult> Operation { get; }
Property Value
| Type | Description |
|---|---|
| IAsyncOperation<TResult> | The underlying operation instance. |
Methods
| Improve this Doc View SourceTrySetCanceled()
Attempts to transition the underlying IAsyncOperation<TResult> into the Canceled state.
Declaration
bool TrySetCanceled()
Returns
| Type | Description |
|---|---|
| Boolean | Returns true if the attemp was successfull; false otherwise. |
Exceptions
| Type | Condition |
|---|---|
| ObjectDisposedException | Thrown is the operation is disposed. |
See Also
| Improve this Doc View SourceTrySetException(Exception)
Attempts to transition the underlying IAsyncOperation<TResult> into the Faulted state.
Declaration
bool TrySetException(Exception exception)
Parameters
| Type | Name | Description |
|---|---|---|
| Exception | exception | An exception that caused the operation to end prematurely. |
Returns
| Type | Description |
|---|---|
| Boolean | Returns true if the attemp was successfull; false otherwise. |
Exceptions
| Type | Condition |
|---|---|
| ArgumentNullException | Thrown if |
| ObjectDisposedException | Thrown is the operation is disposed. |
See Also
| Improve this Doc View SourceTrySetProgress(Single)
Attempts to set the operation progress value in range [0, 1].
Declaration
bool TrySetProgress(float progress)
Parameters
| Type | Name | Description |
|---|---|---|
| Single | progress | The operation progress in range [0, 1]. |
Returns
| Type | Description |
|---|---|
| Boolean | Returns true if the attemp was successfull; false otherwise. |
Exceptions
| Type | Condition |
|---|---|
| ArgumentOutOfRangeException | Thrown if |
| ObjectDisposedException | Thrown is the operation is disposed. |
See Also
| Improve this Doc View SourceTrySetResult(TResult)
Attempts to transition the underlying IAsyncOperation<TResult> into the RanToCompletion state.
Declaration
bool TrySetResult(TResult result)
Parameters
| Type | Name | Description |
|---|---|---|
| TResult | result | The operation result. |
Returns
| Type | Description |
|---|---|
| Boolean | Returns true if the attemp was successfull; false otherwise. |
Exceptions
| Type | Condition |
|---|---|
| ObjectDisposedException | Thrown is the operation is disposed. |


You have trouble keeping Appointments
or just getting places you need to be?
Get a good todo app eg. Omni Focus
OmniGroup
I use All of it especialy Onmi Focus and Omni Planner
Every Morning before you begin work write down everything that comes to mind
and then organize (Context, Project, due date)
visualize your big thoughts
and tiny ideas
Do you have trouble Focusing on the tasks even when broken up? you need to get Vitamin R-2, Vitamin R-2 and start setting your focus WOrkes well with OmniFocus and Todoist
Kolleges getting pissed of because you say what comes to mind? ask a kollege to stop you if he realises its not a good idea this only workes if you trust the person Make your desk dsitraction less!
Do you have 1000000 Ideas how to save your company and make a change?
use the source, Luke!
Ask to have someone help you with actually starting the project. Its no shame!!
Tell you Kolleges about your weeknesses but dont call it ADHD Try to see it positive Einstein, Bill gates, Mozart all have the same Problem and they ROcked the show!!! Belive in your ideas*?
* Get help doing them!!!Use a spacebar or arrow keys to navigate


| PERLFAQ6(1) | Perl Programmers Reference Guide | PERLFAQ6(1) |
# turn the line into the first word, a colon, and the # number of characters on the rest of the line s/^(\w+)(.*)/ lc($1) . ":" . length($2) /meg;
"/x" lets you turn this:
s{<(?:[^>'"]*|".*?"|'.*?')+>}{}gs;
into this:
s{ < # opening angle bracket (?: # Non-backreffing grouping paren [^>'"] * # 0 or more things that are neither > nor ' nor " | # or else ".*?" # a section between double quotes (stingy match) | # or else '.*?' # a section between single quotes (stingy match) ) + # all occurring one or more times > # closing angle bracket }{}gsx; # replace with nothing, i.e. delete
It's still not quite so clear as prose, but it is very useful for describing the meaning of each part of the pattern.
s/\/usr\/local/\/usr\/share/g; # bad delimiter choice s#/usr/local#/usr/share#g; # better
Using logically paired delimiters can be even more readable:
s{/usr/local/}{/usr/share}g; # better still
There are many ways to get multiline data into a string. If you want it to happen automatically while reading input, you'll want to set $/ (probably to '' for paragraphs or "undef" for the whole file) to allow you to read more than one line at a time.
Read perlre to help you decide which of "/s" and "/m" (or both) you might want to use: "/s" allows dot to include newline, and "/m" allows caret and dollar to match next to a newline, not just at the end of the string. You do need to make sure that you've actually got a multiline string in there.
For example, this program detects duplicate words, even when they span line breaks (but not paragraph ones). For this example, we don't need "/s" because we aren't using dot in a regular expression that we want to cross line boundaries. Neither do we need "/m" because we don't want caret or dollar to match at any point inside the record next to newlines. But it's imperative that $/ be set to something other than the default, or else we won't actually ever have a multiline record read in.
$/ = ''; # read in whole paragraph, not just one line while ( <> ) { while ( /\b([\w'-]+)(\s+\g1)+\b/gi ) { # word starts alpha print "Duplicate $1 at paragraph $.\n"; } }
Here's some code that finds sentences that begin with "From " (which would be mangled by many mailers):
$/ = ''; # read in whole paragraph, not just one line while ( <> ) { while ( /^From /gm ) { # /m makes ^ match next to \n print "leading From in paragraph $.\n"; } }
Here's code that finds everything between START and END in a paragraph:
undef $/; # read in whole file, not just one line or paragraph while ( <> ) { while ( /START(.*?)END/sgm ) { # /s makes . cross line boundaries print "$1\n"; } }
perl -ne 'print if /START/ .. /END/' file1 file2 ...
If you wanted text and not lines, you would use
perl -0777 -ne 'print "$1\n" while /START(.*?)END/gs' file1 file2 ...
But if you want nested occurrences of "START" through "END", you'll run up against the problem described in the question in this section on matching balanced text.
Here's another example of using "..":
while (<>) { my $in_header = 1 .. /^$/; my $in_body = /^$/ .. eof; # now choose between them } continue { $. = 0 if eof; # fix $. }
If you have File::Stream, this is easy.
use File::Stream; my $stream = File::Stream->new( $filehandle, separator => qr/\s*,\s*/, ); print "$_\n" while <$stream>;
If you don't have File::Stream, you have to do a little more work.
You can use the four-argument form of sysread to continually add to a buffer. After you add to the buffer, you check if you have a complete line (using your regular expression).
local $_ = ""; while( sysread FH, $_, 8192, length ) { while( s/^((?s).*?)your_pattern// ) { my $record = $1; # do stuff here. } }
You can do the same thing with foreach and a match using the c flag and the \G anchor, if you do not mind your entire file being in memory at the end.
local $_ = ""; while( sysread FH, $_, 8192, length ) { foreach my $record ( m/\G((?s).*?)your_pattern/gc ) { # do stuff here. } substr( $_, 0, pos ) = "" if pos; }
$_= "this is a TEsT case"; $old = 'test'; $new = 'success'; s{(\Q$old\E)} { uc $new | (uc $1 ^ $1) . (uc(substr $1, -1) ^ substr $1, -1) x (length($new) - length $1) }egi; print;
And here it is as a subroutine, modeled after the above:
sub preserve_case { my ($old, $new) = @_; my $mask = uc $old ^ $old; uc $new | $mask . substr($mask, -1) x (length($new) - length($old)) } $string = "this is a TEsT case"; $string =~ s/(test)/preserve_case($1, "success")/egi; print "$string\n";
This prints:
this is a SUcCESS case
As an alternative, to keep the case of the replacement word if it is longer than the original, you can use this code, by Jeff Pinyan:
sub preserve_case { my ($from, $to) = @_; my ($lf, $lt) = map length, @_; if ($lt < $lf) { $from = substr $from, 0, $lt } else { $from .= substr $to, $lf } return uc $to | ($from ^ uc $from); }
This changes the sentence to "this is a SUcCess case."
Just to show that C programmers can write C in any programming language, if you prefer a more C-like solution, the following script makes the substitution have the same case, letter by letter, as the original. (It also happens to run about 240% slower than the Perlish solution runs.) If the substitution has more characters than the string being substituted, the case of the last character is used for the rest of the substitution.
# Original by Nathan Torkington, massaged by Jeffrey Friedl # sub preserve_case { my ($old, $new) = @_; my $state = 0; # 0 = no change; 1 = lc; 2 = uc my ($i, $oldlen, $newlen, $c) = (0, length($old), length($new)); my $len = $oldlen < $newlen ? $oldlen : $newlen; for ($i = 0; $i < $len; $i++) { if ($c = substr($old, $i, 1), $c =~ /[\W\d_]/) { $state = 0; } elsif (lc $c eq $c) { substr($new, $i, 1) = lc(substr($new, $i, 1)); $state = 1; } else { substr($new, $i, 1) = uc(substr($new, $i, 1)); $state = 2; } } # finish up with any remaining new (for when new is longer than old) if ($newlen > $oldlen) { if ($state == 1) { substr($new, $oldlen) = lc(substr($new, $oldlen)); } elsif ($state == 2) { substr($new, $oldlen) = uc(substr($new, $oldlen)); } } return $new; }
See perllocale for details.
No matter which locale you are in, the alphabetic characters are the characters in \w without the digits and the underscore. As a regex, that looks like "/[^\W\d_]/". Its complement, the non-alphabetics, is then everything in \W along with the digits and the underscore, or "/[\W\d_]/".
$string = "Placido P. Octopus"; $regex = "P."; $string =~ s/$regex/Polyp/; # $string is now "Polypacido P. Octopus"
Because "." is special in regular expressions, and can match any single character, the regex "P." here has matched the <Pl> in the original string.
To escape the special meaning of ".", we use "\Q":
$string = "Placido P. Octopus"; $regex = "P."; $string =~ s/\Q$regex/Polyp/; # $string is now "Placido Polyp Octopus"
The use of "\Q" causes the "." in the regex to be treated as a regular character, so that "P." matches a "P" followed by a dot.
The "/o" option for regular expressions (documented in perlop and perlreref) tells Perl to compile the regular expression only once. This is only useful when the pattern contains a variable. Perls 5.6 and later handle this automatically if the pattern does not change.
Since the match operator "m//", the substitution operator "s///", and the regular expression quoting operator "qr//" are double-quotish constructs, you can interpolate variables into the pattern. See the answer to "How can I quote a variable to use in a regex?" for more details.
This example takes a regular expression from the argument list and prints the lines of input that match it:
my $pattern = shift @ARGV; while( <> ) { print if m/$pattern/; }
Versions of Perl prior to 5.6 would recompile the regular expression for each iteration, even if $pattern had not changed. The "/o" would prevent this by telling Perl to compile the pattern the first time, then reuse that for subsequent iterations:
my $pattern = shift @ARGV; while( <> ) { print if m/$pattern/o; # useful for Perl < 5.6 }
In versions 5.6 and later, Perl won't recompile the regular expression if the variable hasn't changed, so you probably don't need the "/o" option. It doesn't hurt, but it doesn't help either. If you want any version of Perl to compile the regular expression only once even if the variable changes (thus, only using its initial value), you still need the "/o".
You can watch Perl's regular expression engine at work to verify for yourself if Perl is recompiling a regular expression. The "use re 'debug'" pragma (comes with Perl 5.005 and later) shows the details. With Perls before 5.6, you should see "re" reporting that its compiling the regular expression on each iteration. With Perl 5.6 or later, you should only see "re" report that for the first iteration.
use re 'debug'; my $regex = 'Perl'; foreach ( qw(Perl Java Ruby Python) ) { print STDERR "-" x 73, "\n"; print STDERR "Trying $_...\n"; print STDERR "\t$_ is good!\n" if m/$regex/; }
perl -0777 -pe 's{/\*.*?\*/}{}gs' foo.c
will work in many but not all cases. You see, it's too simple-minded for certain kinds of C programs, in particular, those with what appear to be comments in quoted strings. For that, you'd need something like this, created by Jeffrey Friedl and later modified by Fred Curtis.
$/ = undef; $_ = <>; s#/\*[^*]*\*+([^/*][^*]*\*+)*/|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*)#defined $2 ? $2 : ""#gse; print;
This could, of course, be more legibly written with the "/x" modifier, adding whitespace and comments. Here it is expanded, courtesy of Fred Curtis.
s{ /\* ## Start of /* ... */ comment [^*]*\*+ ## Non-* followed by 1-or-more *'s ( [^/*][^*]*\*+ )* ## 0-or-more things which don't start with / ## but do end with '*' / ## End of /* ... */ comment | ## OR various things which aren't comments: ( " ## Start of " ... " string ( \\. ## Escaped char | ## OR [^"\\] ## Non "\ )* " ## End of " ... " string | ## OR ' ## Start of ' ... ' string ( \\. ## Escaped char | ## OR [^'\\] ## Non '\ )* ' ## End of ' ... ' string | ## OR . ## Anything other char [^/"'\\]* ## Chars which doesn't start a comment, string or escape ) }{defined $2 ? $2 : ""}gxse;
A slight modification also removes C++ comments, possibly spanning multiple lines using a continuation character:
s#/\*[^*]*\*+([^/*][^*]*\*+)*/|//([^\\]|[^\n][\n]?)*?\n|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*)#defined $3 ? $3 : ""#gse;
Your first try should probably be the Text::Balanced module, which is in the Perl standard library since Perl 5.8. It has a variety of functions to deal with tricky text. The Regexp::Common module can also help by providing canned patterns you can use.
As of Perl 5.10, you can match balanced text with regular expressions using recursive patterns. Before Perl 5.10, you had to resort to various tricks such as using Perl code in "(??{})" sequences.
Here's an example using a recursive regular expression. The goal is to capture all of the text within angle brackets, including the text in nested angle brackets. This sample text has two "major" groups: a group with one level of nesting and a group with two levels of nesting. There are five total groups in angle brackets:
I have some <brackets in <nested brackets> > and <another group <nested once <nested twice> > > and that's it.
The regular expression to match the balanced text uses two new (to Perl 5.10) regular expression features. These are covered in perlre and this example is a modified version of one in that documentation.
First, adding the new possessive "+" to any quantifier finds the longest match and does not backtrack. That's important since you want to handle any angle brackets through the recursion, not backtracking. The group "[^<>]++" finds one or more non-angle brackets without backtracking.
Second, the new "(?PARNO)" refers to the sub-pattern in the particular capture group given by "PARNO". In the following regex, the first capture group finds (and remembers) the balanced text, and you need that same pattern within the first buffer to get past the nested text. That's the recursive part. The "(?1)" uses the pattern in the outer capture group as an independent part of the regex.
Putting it all together, you have:
#!/usr/local/bin/perl5.10.0 my $string =<<"HERE"; I have some <brackets in <nested brackets> > and <another group <nested once <nested twice> > > and that's it. HERE my @groups = $string =~ m/ ( # start of capture group 1 < # match an opening angle bracket (?: [^<>]++ # one or more non angle brackets, non backtracking | (?1) # found < or >, so recurse to capture group 1 )* > # match a closing angle bracket ) # end of capture group 1 /xg; $" = "\n\t"; print "Found:\n\t@groups\n";
The output shows that Perl found the two major groups:
Found: <brackets in <nested brackets> > <another group <nested once <nested twice> > >
With a little extra work, you can get all of the groups in angle brackets even if they are in other angle brackets too. Each time you get a balanced match, remove its outer delimiter (that's the one you just matched so don't match it again) and add it to a queue of strings to process. Keep doing that until you get no matches:
#!/usr/local/bin/perl5.10.0 my @queue =<<"HERE"; I have some <brackets in <nested brackets> > and <another group <nested once <nested twice> > > and that's it. HERE my $regex = qr/ ( # start of bracket 1 < # match an opening angle bracket (?: [^<>]++ # one or more non angle brackets, non backtracking | (?1) # recurse to bracket 1 )* > # match a closing angle bracket ) # end of bracket 1 /x; $" = "\n\t"; while( @queue ) { my $string = shift @queue; my @groups = $string =~ m/$regex/g; print "Found:\n\t@groups\n\n" if @groups; unshift @queue, map { s/^<//; s/>$//; $_ } @groups; }
The output shows all of the groups. The outermost matches show up first and the nested matches show up later:
Found: <brackets in <nested brackets> > <another group <nested once <nested twice> > > Found: <nested brackets> Found: <nested once <nested twice> > Found: <nested twice>
An example:
my $s1 = my $s2 = "I am very very cold"; $s1 =~ s/ve.*y //; # I am cold $s2 =~ s/ve.*?y //; # I am very cold
Notice how the second substitution stopped matching as soon as it encountered "y ". The "*?" quantifier effectively tells the regular expression engine to find a match as quickly as possible and pass control on to whatever is next in line, as you would if you were playing hot potato.
while (<>) { foreach my $word ( split ) { # do something with $word here } }
Note that this isn't really a word in the English sense; it's just chunks of consecutive non-whitespace characters.
To work with only alphanumeric sequences (including underscores), you might consider
while (<>) { foreach $word (m/(\w+)/g) { # do something with $word here } }
my (%seen); while (<>) { while ( /(\b[^\W_\d][\w'-]+\b)/g ) { # misses "`sheep'" $seen{$1}++; } } while ( my ($word, $count) = each %seen ) { print "$count $word\n"; }
If you wanted to do the same thing for lines, you wouldn't need a regular expression:
my (%seen); while (<>) { $seen{$_}++; } while ( my ($line, $count) = each %seen ) { print "$count $line"; }
If you want these output in a sorted order, see perlfaq4: "How do I sort a hash (optionally by value instead of key)?".
If you have Perl 5.10 or later, this is almost trivial. You just smart match against an array of regular expression objects:
my @patterns = ( qr/Fr.d/, qr/B.rn.y/, qr/W.lm./ ); if( $string ~~ @patterns ) { ... };
The smart match stops when it finds a match, so it doesn't have to try every expression.
Earlier than Perl 5.10, you have a bit of work to do. You want to avoid compiling a regular expression every time you want to match it. In this example, perl must recompile the regular expression for every iteration of the "foreach" loop since it has no way to know what $pattern will be:
my @patterns = qw( foo bar baz ); LINE: while( <DATA> ) { foreach $pattern ( @patterns ) { if( /\b$pattern\b/i ) { print; next LINE; } } }
The "qr//" operator showed up in perl 5.005. It compiles a regular expression, but doesn't apply it. When you use the pre-compiled version of the regex, perl does less work. In this example, I inserted a "map" to turn each pattern into its pre-compiled form. The rest of the script is the same, but faster:
my @patterns = map { qr/\b$_\b/i } qw( foo bar baz ); LINE: while( <> ) { foreach $pattern ( @patterns ) { if( /$pattern/ ) { print; next LINE; } } }
In some cases, you may be able to make several patterns into a single regular expression. Beware of situations that require backtracking though.
my $regex = join '|', qw( foo bar baz ); LINE: while( <> ) { print if /\b(?:$regex)\b/i; }
For more details on regular expression efficiency, see Mastering Regular Expressions by Jeffrey Friedl. He explains how the regular expressions engine works and why some patterns are surprisingly inefficient. Once you understand how perl applies regular expressions, you can tune them for individual situations.
Ensure that you know what \b really does: it's the boundary between a word character, \w, and something that isn't a word character. That thing that isn't a word character might be \W, but it can also be the start or end of the string.
It's not (not!) the boundary between whitespace and non-whitespace, and it's not the stuff between words we use to create sentences.
In regex speak, a word boundary (\b) is a "zero width assertion", meaning that it doesn't represent a character in the string, but a condition at a certain position.
For the regular expression, /\bPerl\b/, there has to be a word boundary before the "P" and after the "l". As long as something other than a word character precedes the "P" and succeeds the "l", the pattern will match. These strings match /\bPerl\b/.
"Perl" # no word char before "P" or after "l" "Perl " # same as previous (space is not a word char) "'Perl'" # the "'" char is not a word char "Perl's" # no word char before "P", non-word char after "l"
These strings do not match /\bPerl\b/.
"Perl_" # "_" is a word char! "Perler" # no word char before "P", but one after "l"
You don't have to use \b to match words though. You can look for non-word characters surrounded by word characters. These strings match the pattern /\b'\b/.
"don't" # the "'" char is surrounded by "n" and "t" "qep'a'" # the "'" char is surrounded by "p" and "a"
These strings do not match /\b'\b/.
"foo'" # there is no word char after non-word "'"
You can also use the complement of \b, \B, to specify that there should not be a word boundary.
In the pattern /\Bam\B/, there must be a word character before the "a" and after the "m". These patterns match /\Bam\B/:
"llama" # "am" surrounded by word chars "Samuel" # same
These strings do not match /\Bam\B/
"Sam" # no word boundary before "a", but one after "m" "I am Sam" # "am" surrounded by non-word chars
Once Perl sees that you need one of these variables anywhere in the program, it provides them on each and every pattern match. That means that on every pattern match the entire string will be copied, part of it to $`, part to $&, and part to $'. Thus the penalty is most severe with long strings and patterns that match often. Avoid $&, $', and $` if you can, but if you can't, once you've used them at all, use them at will because you've already paid the price. Remember that some algorithms really appreciate them. As of the 5.005 release, the $& variable is no longer "expensive" the way the other two are.
Since Perl 5.6.1 the special variables @- and @+ can functionally replace $`, $& and $'. These arrays contain pointers to the beginning and end of each match (see perlvar for the full story), so they give you essentially the same information, but without the risk of excessive string copying.
Perl 5.10 added three specials, "${^MATCH}", "${^PREMATCH}", and "${^POSTMATCH}" to do the same job but without the global performance penalty. Perl 5.10 only sets these variables if you compile or execute the regular expression with the "/p" modifier.
Suppose you want to match all of consecutive pairs of digits in a string like "1122a44" and stop matching when you encounter non-digits. You want to match 11 and 22 but the letter "a" shows up between 22 and 44 and you want to stop at "a". Simply matching pairs of digits skips over the "a" and still matches 44.
$_ = "1122a44"; my @pairs = m/(\d\d)/g; # qw( 11 22 44 )
If you use the "\G" anchor, you force the match after 22 to start with the "a". The regular expression cannot match there since it does not find a digit, so the next match fails and the match operator returns the pairs it already found.
$_ = "1122a44"; my @pairs = m/\G(\d\d)/g; # qw( 11 22 )
You can also use the "\G" anchor in scalar context. You still need the "g" modifier.
$_ = "1122a44"; while( m/\G(\d\d)/g ) { print "Found $1\n"; }
After the match fails at the letter "a", perl resets "pos()" and the next match on the same string starts at the beginning.
$_ = "1122a44"; while( m/\G(\d\d)/g ) { print "Found $1\n"; } print "Found $1 after while" if m/(\d\d)/g; # finds "11"
You can disable "pos()" resets on fail with the "c" modifier, documented in perlop and perlreref. Subsequent matches start where the last successful match ended (the value of "pos()") even if a match on the same string has failed in the meantime. In this case, the match after the "while()" loop starts at the "a" (where the last match stopped), and since it does not use any anchor it can skip over the "a" to find 44.
$_ = "1122a44"; while( m/\G(\d\d)/gc ) { print "Found $1\n"; } print "Found $1 after while" if m/(\d\d)/g; # finds "44"
Typically you use the "\G" anchor with the "c" modifier when you want to try a different match if one fails, such as in a tokenizer. Jeffrey Friedl offers this example which works in 5.004 or later.
while (<>) { chomp; PARSER: { m/ \G( \d+\b )/gcx && do { print "number: $1\n"; redo; }; m/ \G( \w+ )/gcx && do { print "word: $1\n"; redo; }; m/ \G( \s+ )/gcx && do { print "space: $1\n"; redo; }; m/ \G( [^\w\d]+ )/gcx && do { print "other: $1\n"; redo; }; } }
For each line, the "PARSER" loop first tries to match a series of digits followed by a word boundary. This match has to start at the place the last match left off (or the beginning of the string on the first match). Since "m/ \G( \d+\b )/gcx" uses the "c" modifier, if the string does not match that regular expression, perl does not reset pos() and the next match starts at the same position to try a different pattern.
In perls older than 5.8.1, map suffers from this problem as well. But since 5.8.1, this has been fixed, and map is context aware - in void context, no lists are constructed.
If you are stuck with older Perls, you can do Unicode with the Unicode::String module, and character conversions using the Unicode::Map8 and Unicode::Map modules. If you are using Japanese encodings, you might try using the jperl 5.005_03.
Finally, the following set of approaches was offered by Jeffrey Friedl, whose article in issue #5 of The Perl Journal talks about this very matter.
Let's suppose you have some weird Martian encoding where pairs of ASCII uppercase letters encode single Martian letters (i.e. the two bytes "CV" make a single Martian letter, as do the two bytes "SG", "VS", "XX", etc.). Other bytes represent single characters, just like ASCII.
So, the string of Martian "I am CVSGXX!" uses 12 bytes to encode the nine characters 'I', ' ', 'a', 'm', ' ', 'CV', 'SG', 'XX', '!'.
Now, say you want to search for the single character "/GX/". Perl doesn't know about Martian, so it'll find the two bytes "GX" in the "I am CVSGXX!" string, even though that character isn't there: it just looks like it is because "SG" is next to "XX", but there's no real "GX". This is a big problem.
Here are a few ways, all painful, to deal with it:
# Make sure adjacent "martian" bytes are no longer adjacent. $martian =~ s/([A-Z][A-Z])/ $1 /g; print "found GX!\n" if $martian =~ /GX/;
Or like this:
my @chars = $martian =~ m/([A-Z][A-Z]|[^A-Z])/g; # above is conceptually similar to: my @chars = $text =~ m/(.)/g; # foreach my $char (@chars) { print "found GX!\n", last if $char eq 'GX'; }
Or like this:
while ($martian =~ m/\G([A-Z][A-Z]|.)/gs) { # \G probably unneeded if ($1 eq 'GX') { print "found GX!\n"; last; } }
Here's another, slightly less painful, way to do it from Benjamin Goldberg, who uses a zero-width negative look-behind assertion.
print "found GX!\n" if $martian =~ m/ (?<![A-Z]) (?:[A-Z][A-Z])*? GX /x;
This succeeds if the "martian" character GX is in the string, and fails otherwise. If you don't like using (?<!), a zero-width negative look-behind assertion, you can replace (?<![A-Z]) with (?:^|[^A-Z]).
It does have the drawback of putting the wrong thing in $-[0] and $+[0], but this usually can be worked around.
We don't have to hard-code patterns into the match operator (or anything else that works with regular expressions). We can put the pattern in a variable for later use.
The match operator is a double quote context, so you can interpolate your variable just like a double quoted string. In this case, you read the regular expression as user input and store it in $regex. Once you have the pattern in $regex, you use that variable in the match operator.
chomp( my $regex = <STDIN> ); if( $string =~ m/$regex/ ) { ... }
Any regular expression special characters in $regex are still special, and the pattern still has to be valid or Perl will complain. For instance, in this pattern there is an unpaired parenthesis.
my $regex = "Unmatched ( paren"; "Two parens to bind them all" =~ m/$regex/;
When Perl compiles the regular expression, it treats the parenthesis as the start of a memory match. When it doesn't find the closing parenthesis, it complains:
Unmatched ( in regex; marked by <-- HERE in m/Unmatched ( <-- HERE paren/ at script line 3.
You can get around this in several ways depending on our situation. First, if you don't want any of the characters in the string to be special, you can escape them with "quotemeta" before you use the string.
chomp( my $regex = <STDIN> ); $regex = quotemeta( $regex ); if( $string =~ m/$regex/ ) { ... }
You can also do this directly in the match operator using the "\Q" and "\E" sequences. The "\Q" tells Perl where to start escaping special characters, and the "\E" tells it where to stop (see perlop for more details).
chomp( my $regex = <STDIN> ); if( $string =~ m/\Q$regex\E/ ) { ... }
Alternately, you can use "qr//", the regular expression quote operator (see perlop for more details). It quotes and perhaps compiles the pattern, and you can apply regular expression flags to the pattern.
chomp( my $input = <STDIN> ); my $regex = qr/$input/is; $string =~ m/$regex/ # same as m/$input/is;
You might also want to trap any errors by wrapping an "eval" block around the whole thing.
chomp( my $input = <STDIN> ); eval { if( $string =~ m/\Q$input\E/ ) { ... } }; warn $@ if $@;
Or...
my $regex = eval { qr/$input/is }; if( defined $regex ) { $string =~ m/$regex/; } else { warn $@; }
This documentation is free; you can redistribute it and/or modify it under the same terms as Perl itself.
Irrespective of its distribution, all code examples in this file are hereby placed into the public domain. You are permitted and encouraged to use this code in your own programs for fun or for profit as you see fit. A simple comment in the code giving credit would be courteous but is not required.
| 2019-10-21 | perl v5.30.3 |


This is the start of some page content. - {a_global_var} Here are some rows with variables: Message: {foo} We can put HTML pretty much anywhere.


{% block content %} {% include "header.html" %}
Hello, {{ current_user.name }}! You don't have any projects yet. Click Create Project to get started!
{% else %}Hello, {{ current_user.name }}! Select a project to work on.
Your Projects:
{% for project in current_user.created_projects %}Invited Projects:
{% for association in current_user.invited_projects %}Hello there! Login or Register a new account to get started!
DevTick is a basic, no-frills ticket tracking system to aid the development process.
After logging in to an account, the user can create a project. Once on the project page, you can create tickets divided into three categories: Bugs, Planned Features, and Updates. You can also add other users to a project using their email address, and assign them one of three roles: Admin, Editor, or Viewer.


AjaXplorer Community - Free non supported version 穢 C. du Jeu
2008-2012 - http://ajaxplorer.info/
Connect to
AjaXplorer
Enter
login/password
Login
Password
Remember Me
Old password :
New :
Confirm :
Click on each file to download it.
Compress selection to
New folder name
New file name
Select destination folder
Enter at least one URL pointing to
a file that you want to download directly from an external HTTP
server to the current folder. This action will be sent to the
background and you will be able to continue using AjaXplorer during
the download.
URL 1 : URL 2 :
URL 3 : URL 4 :
URL 5 :
Drag one of the following link to your bookmark bar :


Survey Genie
Home
Login
Welcome To Survey Genie
A simple survey creation and hosting platform.
Please
login
or
create an account
a to get started.


Alicia & Alex
6.1.2019
Save the Date
Saturday, June 1st, 2019
Mount Pleasant, Iowa
comming soon...
comming soon...NOW


Comments
-
spike1201
I too have noticed Synergy quitting. I haven't yet connected the quitting to any trigger, but it happens to me every 2-3 hours of iTunes play. Weird. (from spike1201)
-
Greg Hurrell
Can you please have a look at these two reports and see if this one is a duplicate of either of those?
The first issue is a crash caused by NSAppleScript; look at your crash logs and see if the crashed thread mentions NSAppleScript:
https://wincent.com/a/support/bugs/show_bug.cgi?id=640
This is a different issue, which nobody else has reported yet so I can't rule out factors local to that user's machine:
https://wincent.com/a/support/bugs/show_bug.cgi?id=654
Finally, if as you say, there aren't any crash reports, can you look in the Console (/Applications/Utilities/Console.app) and see if anything diagnostic information is printed?
-
spike1201
I don't know where to check crash logs, sorry, but I did check out the Console. Searching for "NSAppleScript" came up empty. However, I did see the following list several times per minute (hundreds of these):
2/29/08 12:24:26 AM iTunes[46284] Error loading /Library/QuickTime/DesktopVideoOut.component/Contents/MacOS/DesktopVideoOut: dlopen(/Library/QuickTime/DesktopVideoOut.component/Contents/MacOS/DesktopVideoOut, 262): no suitable image found. Did find:
/Library/QuickTime/DesktopVideoOut.component/Contents/MacOS/DesktopVideoOut: mach-o, but wrong architecture
Not sure what that means, but perhaps helpful to you.
Oh wait, I see a crash reporter in my library/logs. These two lines have something interesting:
10 com.apple.Foundation 0x90d680cb -[NSAppleScript(NSPrivate) _executeWithMode:andReturnError:] + 107 11 com.apple.Foundation 0x90d67fa1 -[NSAppleScript executeAndReturnError:] + 49
And one more thing: Exception Type: EXC_BAD_ACCESS (SIGBUS) Exception Codes: KERN_PROTECTION_FAILURE at 0x0000000000000000
Hope this helps!
-
Greg Hurrell
Ok Spike, that confirms that you're seeing the NSAppleScript problem, which is being tracked in this ticket:
https://wincent.com/a/support/bugs/show_bug.cgi?id=640
So you might want to add yourself to the CC list for that ticket.
If the crashes are happening too often you have the option of doing what Brandon did and rolling back to version 3.2, which you can download from:
https://wincent.com/a/products/synergy-classic/download/tiger/
-
Greg Hurrell
Marking this one as closed seeing as it's a duplicate of issue #640.
Add a comment
Comments are now closed for this issue.


Casablanca
A simple review by M. Pierce
In one of my many videos I have attained from the local library, Casablanca was my third classic in some weeks. The others being Citizen Kane and Vertigo (yes, I am trying to see as many of AFI's Greatest Movies Ever Made as I can). But, Casablanca stood out from the rest for me: It was actually watchable.
What most hail as the greatest American film ever, Casablanca isn't so much a love story as a political frenzy with a love triangle thrown in. It seems that star Humphry Bogart spend about 85 percent of the movie with various leaders of the nation instead of with Ingred Bergman. That annoyed me, as did the ending. Why didn't the plan turn around?!?
Surprisingly, I enjoyed the film. I liked Bogart's character and his acting (not over the top as most actors in his era). I once read about if you had a choice to be in a movie, which one would it be, and a women said Casablanca. At first I was thinking to myself "why?" Then, as I watched the film again, I understood why. The movie is very well done and the script top-notch, although I doubt I understood more than half of the political mumbo jumbo.
Casablanca is, in my mind, no classic (like Solaris), but it is a good film and stylishly shot. Hey, Hollywood, how about this: A remake with Harrison Ford and Anne Heche? Now that would be a classic.
*** (out of ****)
1999 (c)
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


US Secretary of Treasury says progress continues to be made on US-China trade deal
On being asked about the US-China trade tensions, US Secretary of Treasury Steven T Mnuchin said that US is continuing to make progress on that front.
The 7th India-US Economic and Financial Partnership dialogue held in India, on November 1, would deepen the economic partnership between the two countries, both India and the US said.
"We discussed specific and strategic issues of the two nations. We are working together to promote growth and economic security," Steven T Mnuchin, US Secretary of Treasury said at a press briefing.
Finance minister Nirmala Sitharaman said that the India-US relationship was at an all-time high, especially after Prime Minister Narendra Modi's visit in 2019.
"The two nations have significant business ties. A wide range of discussions were held on multinational and bilateral ties. We also deliberated on steps taken by India for the financial sector," Sitharaman said.
On being asked about the US-China trade tensions, Mnuchin said that US is continuing to make progress on that front.
"We're in discussions for alternatives, so both sides are working hard, under both President Trump (Donald Trump) and President Xi's (Xi Jinping's) direction to conclude the deal," Mnuchin said.
The Asia-Pacific Economic Cooperation summit to be held in November in Chile, where the US and China were hoping to sign an interim trade deal, was cancelled because of a law and order situation in Chile.
The US tariffs on Chinese imports such as laptops, toys and electronics kick in on December 15.Special Thursday Expiry on 10th 7th Nov
Early Closure to The Great Diwali Discount. Last Chance to get Moneycontrol PRO for a year @ Rs. 289/- only
Coupon code: DIWALI


Box-sizing tells the browser how to calculate the
width and height of an object.
By default, the height and width of an object includes only the objects content area.
content-box
is the default setting for box-sizing
Width & height measurements include only the content box.
html {
box-sizing: content-box;
}
The alternative is border-box
Width & height measurements include the content box, padding, and border in total.
html {
box-sizing: border-box;
}
While content-box
is the default, border-box
can sometimes be easier to conceptualize and set values for, and you might want to use it instead when styling your sites.
For example, when trying to craft a four equal columns with 24px of padding:
.column {
box-sizing: content-box;
width: 19%;
padding: 3%;
/* Total column width = 25% */
}
.column {
box-sizing: border-box;
width: 25%;
padding: 3%;
/* Total column width = 25% */
}
If you want to use box-sizing: border-box;
on your entire site, this is the best
way to insert it into your CSS.
html {
box-sizing: border-box;
}
*, *:before, *:after {
box-sizing: inherit;
}
These rules should be listed first in your CSS file so that they can cascade down to all other rules.
Code Explanation
html { position: static; }
static
by default.top
, bottom
, right
or left
property specifications.In normal flow, inline boxes flow from left to right, wrapping to next line when needed.

...

In normal flow, block boxes flow from top to bottom, making a new line after every box.

Greetings

Hello

Hi there!

Greetings
Hello
Hi there!
{ position: relative; }
The relative value will leave the element in the normal flow, but then offset it according to the top
, left
, right
, or bottom
properties.

Hello, hi!

.static {
position: static;
border: 2px solid orange;
}
.relative{
position: relative;
left: 80px;
top: 20px;
height: 100px;
background-color: aquamarine;
}
html { position: absolute; }
static
)The absolute value will take the element out of the normal flow and position it in relation to the nearest positioned container.

Up here

Down here

.container {
position: relative;
border: 1px solid orange;
}
.top {
position: absolute;
top: -40px;
right: 10px;
background-color: yellow
}
.bottom {
position: absolute;
bottom: -40px;
left:60px;
background-color: green
}
Here's an example of an image with a caption absolutely positioned over top of it.
The containing div has a position of relative, and the caption has a position of absolute.
When you use positioning to move elements out of the normal flow of content, elements can overlap.
You can change the order of overlapping with z-index
. The element with highest z-index goes on top.

First

Second

.second {
position: absolute;
bottom: 10px;
left: 80px;
background-color: yellow;
}
.first {
position: absolute;
bottom: 25px;
left:60px;
background-color: green;
z-index: 2;
}
Let's add some positioning.
Let's create a div that contains an image and a caption, and position the caption absolutely overtop the image.
Fixed positioning is sort of like absolute positioning... but it positions your element relative to the browser window.
img{
position: fixed;
bottom: 80px;
right: 0px;
/* This will 'fix' the image to the bottom of the browser window
and allow elements to scroll beneath it. */
}
Let's fix a header bar to the top of the page!

Welcome to My Site!!

header {
position: fixed;
top: 0;
height: 100px;
width: 100%;
text-align: center;
}
This

is floated to the left, allowing text to wrap around it on the right
.float {
float: left;
width: 200px;
background: yellow;
}
If you want two block level elements to be side by side, you need to float both elements. One left, and one right.
clear
property tells the element on which side (right, left, both) other elements cannot appear.
clear: right;
clear: left;
clear: both;
float: left
to an image and you did not want a paragraph to appear next to it, you would add clear: left
to the paragraph..left {
float: left;
width: 40%;
border: 1px solid orange;
}
.right {
float: right;
width: 40%;
border: 1px solid pink;
}
.clear {
clear: both;
}
Left Column
Right Column
Not a floating element
.float{
float:left;
width:50px;
background:yellow;
}
.clear-left{
clear:left;
}
Let's float our side bar and content areas.
Learn CSS Layout explains CSS positioning, floats, and other layout concepts with some helpful diagrams.


Simulating elim with apply
Redo the following proof, using the tactic
apply instead of elim:
Theorem lt_le : forall n p:nat, n < p \arrow{} n {\coqle} p.
Proof.
intros n p H; elim H; repeat constructor; assumption.
Qed.
Solution
This file
Going home
Pierre Castéran


SWINEAID - arginine and aminobenzoic acid cream
EpiCare Limited
Disclaimer: This drug has not been found by FDA to be safe and effective, and this labeling has not been approved by FDA. For further information about unapproved drugs, click here.
CONTAINS:
Arginine Aminobenzoate 2.5% Patent # 5734080
In a cream base with Safflower Oil, Apricot Kernal Oil, Mixed Tocopherols, Glycerin, Coconut Oil, Borage Oil, Tea Tree Oil, Biotin, Myo-Inosital, BHT, Allantoin, Camphor, Lecithin, Grapefruit Extract and Aloe Vera.
DIRECTIONS:
Apply topically as needed to minor wounds and skin lesions.
INDICATIONS FOR USE:
SwineAid can be used on minor cuts, abrasions and irritations as well as superficial wounds and skin lesions on sows.
|
SWINEAID
arginine aminobenzoate cream | ||||||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||||||
|
| Labeler - EpiCare Limited (606768997) |


Product List
New Product
Search
Product Type
Product Name
Product Code
Price
Description
Action
Create Product
Product Type:
Mobile Phone
Tablet Computer
Product Name:
Product Code:
Price:
Description:


MLLab always welcomes undergraduate students to participate in research. The projects below are the research topics that the lab is currently interested in and intends to proceed. Interested undergraduate students should check the list before applying for research participation and contact their advisor via email. This page will be continuously updated. (Last modified )
Any other interesting research ideas other than the topics listed below? It looks interesting, but are you wondering if this is also machine learning research? If you want to learn machine learning but don't know where to start, feel free to contact us anytime!
As shown in the recent case of 이루다, machine learning algorithms always have problems that can expose personal and sensitive information. The simplest way to solve this problem is to train the model anew after removing such sensitive information, but this re-learning is only a workaround for solving problems that may arise at any time. Machine Unlearning is a methodology for selectively removing specific information from an already trained model. Students will study what conditions must be satisfied for successful unlearning through participation in this study.
ReferencesFederated Learning is a machine learning framework that enables multiple users to learn large-scale models without worrying about personal information leakage by enabling learning without sending personal data to a central server. For this large-scale learning, only the learning signal (the differential value of the neural net model) is transmitted to the server, not the data transmission, and according to various recent research results, even this method is not 100% safe from personal information leakage. Participation in this study aims to find out under what circumstances information leakage can be aggravated and what methodologies can be used to solve these problems.
ReferencesTraditionally, natural signals have been presented discretely, such as pixels in images and sampling frequencies in sound. However, if the implicit function is used, the analog signal of nature can be expressed continuously. Specifically, it represents the coordinate values and their corresponding signals as a continuous function. In this way, natural data such as sound/image can be expressed regardless of resolution, and furthermore, infinite resolution expression can be expected. This study aims to find out what methodologies can be used to effectively map natural data to implicit functions and aims to utilize INR for various tasks by increasing its representation power.
ReferencesDeep reinforcement learning (DRL) is a learning method which approximates functions in traditional reinforcement learning (RL) algorithms using deep neural networks. By virtue of deep learning, DRL can outperform traditional RL methods and solve problems difficult for traditional RL to deal with. However, low data efficiency and poor generalization performance remain major challenges in DRL. In this work, students aim to increase sample-efficiency of DRL using pre-existing algorithms, or to increase generalization performance using prior knowledge like data augmentation or Lipschitz continuity.
ReferencesCrowdsourcing enables us to collect large-scale datasets for machine learning at a low cost. However, low-paid workers easily provide noisy labels due to mistakes or malice, which undermines the performance of neural networks. Furthermore, workers can provide only a few noisy labels, and they want to receive tasks that are easy to label. In this work, we aim to design frameworks that take these realistic behaviors of workers into account.
ReferencesGraph neural networks (GNNs) generalize the existing deep learning techniques to graph structured data including biological networks, molecular graphs, academic networks, and knowledge graphs. In this project, we aim to improve the existing GNNs to be more expressive and sample-efficient. We are particularly interested in directions like architecture design, data augmentation, and self-supervised learning.
ReferencesMost of well-known machine learning algorithms are working in Euclidean space. However, many scientific fields study data whose underlying structure is non-Euclidean. Through this research paticipation, students will study different types of non-Euclidean spaces and develop a new machine learning algorithm working in these spaces.
ReferencesResearch to discover underlying dynamical systems using machine learning gets increasing attention to understand and predict various physical phenomena. The main problems are incorporating physical knowledge well into the neural net and handling the various characteristics of real-world data. We are particularly interested in finding the coordinates that provide the most simple representation of the system and dealing with noisy data or data from various environments.
ReferencesJAX is a new framework developed by Google for high-performance ML research; it is becoming increasingly more popular with its acceleration and being adopted by major subfields that require large-scale scientific computing. Student researchers on this project will work on implementing and evaluating ML algorithms using JAX, and the topics will include, but not be limited to, deep learning and distributed optimization. This post is ideally for CS majors or those who have some experience in functional programming.
Today’s deep neural networks require large memory and inference cost. Introducing sparsity can remedy the problem by skipping unnecessary computations. This project aims to fill the gap in existing methods by inducing sparsity based on various optimization principles during the training of neural networks.
Current deep neural networks are so complex that human cannot easily understand the decision making system of the models. Interpretable machine learning models try to address this issue by utilizing high level concepts or designing transparent architectures. In this project, we aim to the improve the existing models from both data-centric and model-centric view.
ReferencesOptimization algorithms, especially stochastic gradient descent (SGD) and its variants, play an important role in the success of deep neural networks. Why do such simple algorithms work well in practice? Evidence shows that their dynamical behaviors with implicit bias may drive to flat minima. We are interested in investigating more into their optimization dynamics via mathematical tools such as noise analysis, differential equation approximation, etc. This research project could potentially lead us to come up with new optimization algorithms for large-scale machine learning problems.
ReferencesThe sharpness of the loss surface is a good geometric property that captures the generalization of neural networks. Since the seminal work of Foret et al. (2021), sharpness-aware minimization — a class of algorithms that lead convergence to flat minima — has been used in various machine learning applications to improve performance measures. However, existing algorithms to enforce flatness require a lot of computations, and in this project we explore numerical and computational tools in robust optimization to address such an issue.
ReferencesLarge Language Models (LLMs), such as GPT, have shown remarkable progresses in Natural Language Processing (NLP) tasks. However, their over-parametrized nature leads to significant computational costs in terms of time and money, limiting their practicality. In this research project, our aim is to enhance the efficiency of LLMs by exploring methods such as parameter pruning and knowledge distillation.
ReferencesGeometric deep learning is a new field of machine learning that can learn from complex data like point clouds, graphs, mesh, and manifolds. It seeks for a ``general recipe'' to apply deep neural networks to 3D objects, graphs and manifolds. In this project, we will aim at studying the recent geometric deep learning literature and become the frontiers in this area. We are looking for students confident in mathematics, since since this project requires to study very basic topology, categorical theory, and group theory. See this link for a tutorial on this subject.
ReferencesLarge Language Models (LLMs) confidently generate wrong information, which undermines the trust of LLMs as a knowledge base. How to mitigate this? This question has been actively emerged due to the power of ChatGPT. In this research project, we will explore learning methods (e.g., conformal prediction) to answer this question.
ReferencesAs ML models are used in practical environments, e.g., ChatGPT or drones, the concerns on the trustworthiness of model predictions have been greatly emerged. In particular, we are interested in rigorous uncertainty learning as the basis for the correctness of predictions, and conformal prediction is a promising method for rigorous uncertainty learning. However, its correctness guarantees depend on the assumptions of data distributions. In this research project, we explore and design practical learning algorithms for conformal prediction under various distributional assumptions.
ReferencesThe power of LLMs and their daily life use bring concerns on security and privacy issues (e.g., vulnerable code generation and privacy leakage). Then, how severe are the security and privacy issues? How to efficiently and effectively unlearn the issues in LLMs? In this project, we will evaluate LLMs security and privacy concerns and design learning algorithms for mitigation.
Finding source or binary code vulnerabilities is a long-standing and never-ending problem. The recent advance in LLMs potentially provides clues to further advance the current code vulnerability discovery performance. In this project, we will explore the potentials of LLMs in finding code vulnerabilities.


 It focuses on the organic evolution of children in the world. Renaissance foundation has been working since a decade in transforming the lives of children at micro level. Renaissance means ‘rebirth’ and ‘revival of learning’. Renaissance Foundation enlightens children by reviving their spirits to attain knowledge and build character which is based on spiritual and rational approach. Since 2009, Renaissance has been working for children. In academics, in creativity and in forming goals, Renaissance guides children with the help of young as well as experienced scholars and experts in distinct field of life.
Founded in 2009.Since the age of 11 years to the age of 18, Renaissance takes care of children. In academics, in creativity and in forming goals, Renaissance guides children with the help of young as well as experienced scholars and experts in distinct field of life.
Building strong academic base of students in all disciplines. Focussing on the academic improvement of students from class 5th to 12th in all subjects and streams. Preparing students for board exams and competitive exams. Generating leadership qualities to form future leaders. Cultivating excellent creative and communicative skills Inculcating competitive skills among students.
 It focuses on the organic evolution of children in the world. Renaissance foundation has been working since a decade in transforming the lives of children at micro level. Renaissance means ‘rebirth’ and ‘revival of learning’. Renaissance Foundation enlightens children by reviving their spirits to attain knowledge and build character which is based on spiritual and rational approach.
We organize many events every year at Renaissance Foundation to improve the confidence and communication skills among students.