Add some text entries in the deferred textbox, then tap Add. It will appear in the output area.
Put your device in airplane mode, and repeat the above step.
Go back online, and your text entries will appear in the results area.


create-builder
pack create-builder
enables buildpack authors and platform operators to bundle a collection of buildpacks into a
single image for distribution and use with a specified stack.
$ pack create-builder <image-name> --builder-config <path-to-builder-toml>
In this example, a builder image is created from buildpacks org.example.buildpack-1
and org.example.buildpack-2
.
A TOML configuration file provides necessary configuration to the command.
[[buildpacks]]
id = "org.example.buildpack-1"
uri = "relative/path/to/buildpack-1"
[[buildpacks]]
id = "org.example.buildpack-2"
uri = "https://example.org/buildpacks/buildpack-2.tgz"
[[groups]]
[[groups.buildpacks]]
id = "org.example.buildpack-1"
version = "0.0.1"
[[groups.buildpacks]]
id = "org.example.buildpack-2"
version = "0.0.1"
[stack]
id = "com.example.stack"
build-image = "example/build"
run-image = "example/run"
Running create-builder
while supplying this configuration file will produce the builder image.
$ pack create-builder my-builder:my-tag --builder-config path/to/builder.toml
Like build
, create-builder
has a --publish
flag that can be used to publish
the generated builder image to a registry.
The builder can then be used in build
by running:
$ pack build my-app:my-tag --builder my-builder:my-tag --buildpack org.example.buildpack-1
A builder is an image containing a collection of buildpacks that will be executed against application source code, in the order defined by the builder’s configuration file. This image’s base will be the build image associated with a given stack.
A buildpack’s primary role is to inspect the source code, determine any dependencies that will be required to compile and/or run the app, and provide runtime dependencies as layers in the final app image.
It’s important to note that the buildpacks in a builder are not actually executed until
build
is run.
A builder also includes a layer with a series of binaries that are executed during build
.
These binaries collectively represent the buildpack lifecycle. See
Builder configuration for more information on configuring the lifecycle for a builder.
The create-builder
command requires a TOML configuration file (commonly
referred to as builder.toml
). This file has a number of fields.
description
(string, optional)
A human-readable description of the builder, to be shown in inspect-builder
output
(run pack inspect-builder -h
for more information).
buildpacks
(list, required)
A list of buildpacks, each with the following fields:
id
(string, required)
An identifier for the buildpack
uri
(string, required)
Either a fully-qualified URL to a .tgz
file, or a path to a local buildpack’s .tgz
file or directory (relative to
builder.toml
)
latest
(boolean, optional, default: false
)
Whether or not this buildpack is considered the latest version (for use in specifying groups
below).
Multiple versions of the same buildpack (i.e. buildpacks with the same ID but with URIs to differing versions) may be specified in this list, though only one entry per ID may be marked as
latest
.
groups
(list, required)
A list of buildpack groups. This list determines the order in which groups of buildpacks
will be tested during detection. Detection is a phase of the lifecycle where
buildpacks are tested, one group at a time, for compatibility with the provided application source code. The first
group whose non-optional buildpacks all pass detection will be the group selected for the remainder of the build. Each
group currently contains a single required field:
buildpacks
(list, required)
The set of buildpacks belonging to the group. Each buildpack specified has the following fields (different from the
buildpack fields mentioned previously):
id
(string, required)
The identifier of a buildpack from the configuration’s top-level buildpacks
list. Buildpacks with the same ID may
appear in multiple groups at once but never in the same group.
version
(string, required)
The version of the buildpack being referred to. Alternately, specify "latest"
to use the buildpack marked as
latest
in the configuration’s top-level buildpacks
list.
optional
(boolean, optional, default: false)
Whether or not this buildpack is optional during detection.
stack
(required)
The stack to use for the builder. See Managing stacks for more information about this field. It
contains the following fields:
id
(required, string)
Identifier for the stack
build-image
(required, string)
Build image for the stack
run-image
(required, string)
Run image for the stack
run-image-mirrors
(optional, string list)
Run image mirrors for the stack
lifecycle
(optional)
The lifecycle to use for the builder. It contains the following fields:
version
(string, optional)
The version of the lifecycle (semver format). If omitted, defaults to the latest release of the lifecycle captured
at the time of pack
’s particular release (i.e. if you’re pinned to a particular release of pack
, this default
will never change, even when new versions of the lifecycle are released).
uri
(string, optional)
Either a fully-qualified URL to a .tgz
file, or a path to a local lifecycle’s .tgz
file (relative to
builder.toml
). If omitted, a URL to a GitHub release for the defined version
will be used.
If the
lifecycle
field itself is omitted, default values for each sub-field will be used.


drawLine( int x0, int y0, int x1, int y1)
The first applet of this chapter draws the snowflake figure
that was discussed in the first chapter on recursion.
The snowflake is made up entirely of straight lines.
The only drawing method used is the drawLine()
You should see a snowflake figure. It may take 30 seconds or so for this to load. If you see nothing after a few minutes, click on the "reload" icon of your browser. If after this you still see nothing, check that your browser has applets enabled. If you are behind a firewall, it may be deleting applets from incoming Web pages.


spherro
slider is add and remove
click and touch is push
loading spherro
slider is add and remove
click and touch is push


MPI 3.0 Documents
Official MPI 3.0 standard
MPI 3.0 standard (black and white)
MPI 3.0 standard (book version)
MPI 3.0 standard with new or changed text in red
Return to
MPI Forum home page A>


Ontology: Barista.txt
Comment: Imagine this scenario.
The Barista is automated (robotic).
Orders are entered via a touch screen.
Each drink is a separate order.
The order-entry kiosk uses an avatar for some communications.
Payment is always via credit card.
Club members pay via a club card and get a discount.
Context: " Start" pattern: " Authenticated [customer id]. "
U: Authenticated [customer id].
S: Welcome [customer name].
S: Please enter your order.
Ask order.
Goal
:
Serve customer order.
Dictionary: Customer.
Customer attributes include id, name.
Dictionary: Kaffee Order Vocabulary.
Order attributes include drink, pastry.
Drink subtypes include coffee, latte, mocha, cappuccino.
Pastry subtypes include donut, danish, croissant.
Food subtypes include drink, pastry.
Food attributes include flavor.
Coffee-flavor categories include black, cream, sugar, double-cream, double-sugar.
Mocha-flavor categories include chocolate, raspberry, white-chocolate, hazelnut.
Donut-flavor categories include plain, chocolate, sour cream.
Croissant-flavor categories include plain, chocolate, cheese.
Pastry attributes include flavor.
Goal: Drink is prepared per order.
Preconditions:
Actions:
Barista
:
Prepare drink per order.
Goal: Pastry is prepared per order.
Preconditions:
Actions:
Server
:
Place order pastry on tray.
Goal: Serve customer order.
Preconditions:
Drink is prepared per order.
Pastry is prepared per order.
Actions:
Server
:
Deliver drink and pastry per order.
Role: Barista -- Draw expresso per order.
Role:
Barista.
Action:
Draw expresso per order.
Pack__ with coffee per order.
Install__ under spigot.
Press button.
Role: Barista -- Prepare cappuccino per order.
Role:
Barista.
Action:
Prepare cappuccino per order.
(TODO: Correct this procedure.)
Steam milk per order.
(skim or regular milk)
Draw expresso per order.
(decade or regular coffee)
Pour expresso into cappuccino-cup.
Pour steamed-milk into cappuccino-cup.
Stir mixture in cappuccino-cup.
Role: Barista -- Prepare drink per order.
Role:
Barista.
Action:
Prepare drink per order.
Follow recipe for drink.
Role: Barista -- Steam milk per order.
Role:
Barista.
Action:
Steam milk per order.
Fill jug to mark with milk-flavor specified by order.
Apply steam to milk in jug.
Role: Server -- Deliver drink and pastry per order.
Role:
Server.
Action:
Deliver drink and pastry per order.
Place drink on tray.
Place order pastry on tray.
Move tray to customer table per order.
Role: Server -- Place order pastry on tray.
Role:
Server.
Action:
Place order pastry on tray.
Pull order pastry from shelf.
Place order pasty on pastry dish.
Place pastry dish on tray.
View: Order.


Black Box
Determine where the hidden balls are in the box, by observing the behaviour of light beams fired into the box from the sides.
Click in a square around the edge of the box to send a beam into the box. Possible results are 'H' (the beam hit a ball dead-on and stopped), 'R' (the beam was either reflected back the way it came or there was a ball just to one side of its entry point) or a number appearing in two squares (indicating that the beam entered one of those squares and emerged from the other).
Click in the middle of the box to place your guessed ball positions. When you have placed enough, a green button will appear in the top left; click that to indicate that you think you have the answer. You can also right-click to mark squares as definitely known.


GIT-UPLOAD-ARCHIVE(1) Git Manual GIT-UPLOAD-ARCHIVE(1) NAME git-upload-archive - Send archive back to git-archive SYNOPSIS git upload-archive <directory> DESCRIPTION Invoked by git archive --remote and sends a generated archive to the other end over the git protocol. This command is usually not invoked directly by the end user. The UI for the protocol is on the git archive side, and the program pair is meant to be used to get an archive from a remote repository. OPTIONS <directory> The repository to get a tar archive from. GIT Part of the git(1) suite Git <IP_ADDRESS> 11/24/2012 GIT-UPLOAD-ARCHIVE(1)


Hunting unicorns is legal in Michigan.
Vending machines are bigger threats to humanity than sharks.
Lobsters communicate with their bladders.


Each log view can be filtered and sorted based on each header column. Filtering a log does not affect which API calls are logged; it simply changes the view in the current log pane. The log pane is, by default, sorted by the timestamp of the API call. This can be changed to sort on any column.
To filter on a column:
1) Right-click the column to filter on.
2) Select Custom Filterů
3) The following shows up for Category filtering
4) Select which categories to include and click OK.
Enable filter will automatically be selected. If a column has a filter set the column text will be shown in blue.
To remove a filter reselect Custom Filterů from the log column and uncheck "Enable Filter"
To sort a column:
Clicking the column header once sorts the column in ascending order; clicking the column again will sort the column in descending order.
The column the log file is currently is sorted by is represented by a grey arrow to the right of the column header.
Note: Function filters in the log pane only apply to top level nodes. For instance, if you filter out a function, it may still show as a child of some other function. This also means that if you filter a function that has unfiltered children, those children will never show in the log since the parent was filtered out. This does not apply if you change which functions are logged in this case the functions are never intercepted.


{% extends "pretixcontrol/auth/base.html" %} {% load i18n %} {% load bootstrap3 %} {% load compress %} {% load static %} {% block content %}
{% if form.backend.url %} {% blocktrans trimmed with login_provider=form.backend.verbose_name %}We just want to make sure it's really you. Please re-authenticate with '{{ login_provider }}'.{% endblocktrans %} {% else %} {% trans "We just want to make sure it's really you. Please re-enter your password to continue." %} {% endif %}
{% trans "Alternatively, you can use your WebAuthn device." %}


| Home | Trees | Indices | Help |
|
|---|
|
|
Probability density functions.
This module defines AbstractDensity: a common interface for all PDFs. Each AbstractDensity describes a specific type of probability distribution, for example Normal is an implementation of the Gaussian distribution:
>>> pdf = Normal(mu=10, sigma=1.1) >>> pdf.mu, pdf['sigma'] 10.0, 1.1
Every PDF provides an implementation of the AbstractDensity.evaluate method, which evaluates the PDF for a list of input data points:
>>> pdf.evaluate([10, 9, 11, 12]) array([ 0.3626748 , 0.2399147 , 0.2399147 , 0.06945048])
PDF instances also behave like functions:
>>> pdf(data) # the same as pdf.evaluate(data)
Some AbstractDensity implementations may support drawing random numbers from the distribution (or raise an exception otherwise):
>>> pdf.random(2) array([ 9.86257083, 9.73760515])
Each implementation of AbstractDensity may support infinite number of estimators, used to estimate and re-initialize the PDF parameters from a set of observed data points:
>>> pdf.estimate([5, 5, 10, 10]) >>> pdf.mu, pdf.sigma (7.5, 2.5) >>> pdf.estimator <csb.statistics.pdf.GaussianMLEstimator>
Estimators implement the AbstractEstimator interface. They are treated as pluggable tools, which can be exchanged through the AbstractDensity.estimator property (you could create, initialize and plug your own estimator as well). This is a classic Strategy pattern.
| Submodules | |
|
| Classes | |
|
AbstractDensity Defines the interface and common operations for all probability density functions. |
|
|
AbstractEstimator Density parameter estimation strategy. |
|
|
BaseDensity Base abstract class for all PDFs, which operate on simple float or array-of-float parameters. |
|
| Dirichlet | |
| DirichletEstimator | |
| EstimationFailureError | |
| Gamma | |
| GammaMLEstimator | |
| GaussianMLEstimator | |
| GenNormalBruteForceEstimator | |
| GeneralizedInverseGaussian | |
| GeneralizedNormal | |
| GumbelMaxMomentsEstimator | |
| GumbelMaximum | |
| GumbelMinMomentsEstimator | |
| GumbelMinimum | |
| IncompatibleEstimatorError | |
| InverseGamma | |
| InverseGaussian | |
| InverseGaussianMLEstimator | |
| Laplace | |
| LaplaceMLEstimator | |
| MultivariateGaussian | |
| MultivariateGaussianMLEstimator | |
| Normal | |
|
NullEstimator Does not estimate anything. |
|
| ParameterNotFoundError | |
| ParameterValueError |
| Variables | |
EULER_MASCHERONI = 0.577215664902
|
|
__package__ =
|
|
fabs = <ufunc 'fabs'>
|
|
pi = 3.14159265359
|
|
power = <ufunc 'power'>
|
|
sqrt = <ufunc 'sqrt'>
|
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Tue Jul 4 20:19:04 2017 | http://epydoc.sourceforge.net |


[gecode-users] search engine and space state
Guido Tack
tack at gecode.org
Tue Jul 20 18:44:51 CEST 2010
Kish Shen wrote:
> I am looking at some possible (non-default) behaviour with the ECLiPSe interface to Gecode. By default, (full) propagation happens after any `events' (calls to Gecode, approximately) that may change the state. It is implemented as a separate event, so it is possible to delay propagation so that multiple events can be posted without propagation.
> However, looking at the code carefully now, it seems possible for a Space to not have propagated when I try to clone it, and also when I create a search engine for s Space.
>
> In the documentation, it is stated that a Space must be stable and non-failed for cloning -- by stable I think this means there has been a full propagation. There is no corresponding requirement in the documentation (I looked at both the reference doc and MPG) about Space there, but cloning of space is mentioned, so am I correct in thinking that the Space needs to be stable and non-failed when a search engine is created for it (even if you are not cloning)?
If you use the default Gecode search engines, they will always make sure that the space is stable before beginning the search (i.e., before calling clone() for the first time). They will also work on failed spaces. If you clone the space yourself, you must make sure it is stable (by calling status()) before doing so, and check that it's not failed.
Cheers,
Guido
--
Guido Tack, http://people.cs.kuleuven.be/~guido.tack/
More information about the users
mailing list


A Proud Canadian Website Since a couple days ago
TM
Adam's
Legit
Networking Part Shop
Shop Now!
Essential Items For Your Home Network!
NETGEAR XR500 Router
CDN$ 427.02
Buy Now!
TP-Link ArcherCR700 Modem
CDN$ 185.81
Buy Now!
axGear Cat6 Network Cable
CDN$ 15.99
Buy Now!
Linksys RE9000 Wifi Extender
CDN$ 149.99
Buy Now!
Purchase an Internet & TV Package
CDN$ 124.99 - 149.99 / Month
Buy Now!
RJ45 2 Port Ethernet Card
CDN$ 28.99
Buy Now!


@@include("partials/topbar.html") @@include("partials/sidebar.html")
Email Compose
Apaxy
Email
Email Compose
Compose
Inbox
(18)
Starred
Important
Draft
Sent Mail
Trash
Labels
Theme Support
Freelance
Social
Friends
Family
Updates
Social
Team Manage
Updates
Social
Team Manage
More
Mark as Unread
Mark as Important
Add to Tasks
Add Star
Mute
To
Subject
Hello Summer note
Select a text to reveal the toolbar.
Edit rich document on-the-fly, so elastic!
End of air-mode area
Send
@@include("partials/footer.html")
@@include("partials/right-sidebar.html")


Play and SBT
One of the key features in Play is its ability, unlike most JVM based framework, to hot reload all code modifications in DEV mode without relying on any external tool (You don't need JRebel). In order to understand how that works, we first need to see how Play uses SBT to compile classes, and how SBT is tightly integrated into Play.
We've seen in the previous article that SBT in the entry point of any play application, and that the play
command is essentially just an alias on sbt
. The crucial part making a play application different from a typical scala application built with SBT is play's sbt plugin.
As you can see, this is a pretty big SBT plugin. There's a good reason for that: It does A LOT.
First of all, play adds a bunch of settings:
play-assets-directories play-build-require-assets play-closure-compiler-options play-coffeescript-entry-points play-coffeescript-options play-common-classloader play-compile-everything play-conf play-copy-assets play-default-port play-dev-settings play-dist play-external-assets play-javascript-entry-points play-less-entry-points play-less-options play-monitored-files play-onStarted play-onStopped play-package-everything play-plugin play-reload play-require-js play-require-js-folder play-require-js-shim play-require-native-path play-routes-imports play-templates-formats play-templates-imports play-version
It also adds Tasks:
classpath Display the project classpath. clean Clean all generated files. compile Compile the current application. console Launch the interactive Scala console (use :quit to exit). dependencies Display the dependencies summary. dist Construct standalone application package. exit Exit the console. h2-browser Launch the H2 Web browser. license Display licensing informations. package Package your application as a JAR. play-version Display the Play version. publish Publish your application in a remote repository. publish-local Publish your application in the local repository. reload Reload the current application build file. run <port> Run the current application in DEV mode. test Run Junit tests and/or Specs from the command line eclipse generate eclipse project file idea generate Intellij IDEA project file sh <command to run> execute a shell command start <port> Start the current application in another JVM in PROD mode. update Update application dependencies.
Now you want to have a look at PlaySettings.scala
. This is where all the default settings are defined. We're interested in run
.
Typing play run
calls playRunSetting
, which is defined in PlayRun.scala
.
Let's have a look at what it does:
- it keeps the sbt classloader (l72).
- it creates a "common" classloader able to load "common" jars (l74). Those jar are used both by your application and sbt. They won't be reloaded.
- it creates the application classloader, child of the common classloadder, which loads all the application dependencies (l90).
This particular classloader is especially interesting.
First of all, it's the one "in charge" of class reloading.
Although it's not a child of sbtClassloader
, it will delegate the loading of shared classes to it.
Running a play application
So we've created a fancy classloader hierarchy. We're now ready to run the application. Obviously, like for start
, it's just a matter of calling a main
somewhere. We've seen in the previous article that main is in play.core.server.NettyServer
.
Interestingly, play is not using a SBT setting here, the class name is just hardcoded.
So, all we have to do is to invoke mainDevHttpMode
.
We're almost there, but hey, we haven't talked about class reloading yet! The methods is given a reloader
.
That reloader has type SBTLink
.
Each time a request hits the server, the application calls the reloader, asking to check if there's any code changes. The reloader will then delegate recompilation (or other necessary tasks, like copying static assets) to SBT.
Ok that was fairly simple, but why should we bother creating an SBTLink
when SBT is absolutely capable of watching files for modifications natively?
Two reasons:
- First, Play needs to know when a compilation error happens, so that it can pop a nice error page in your browser.
- Then, Hot reload of course! It's nice to have code recompiled, but the application is still running on the old classes. There's more todo
Where the magic begins
Here's the real trick. Assuming the compilation succeeded, we need to update the loaded classes in the JVM. How do we do that? Simple. We just remove the old application classloader, and create a new one with the updated classes.
Then, we simply restart the application, and only the application. No need to restart the JVM.
And that's it! New code is executed. All happened in a few seconds (hopefully), developers are happy :)
It's a tradeoff
Replacing classloader to hot reload code is simple and works very well, but it comes at a price.
First of all, it's only possible because Play is stateless, and is pretty lightweight (quick start). Then, it creates a tight dependency between the build system and the framework.
Most Java or Scala framework can be used with any build system you like, in play, you're not getting rid of SBT anytime soon.
Finally, it occasionally messes with with certain libraries that are not using the "correct" classloader.
Why it's not possible in JEE frameworks.
Wait a minute! If it's THAT simple why is not everybody using that technique !!!??? I mean... I wait for my beloved "Java Enterprise Server®" to restart for AGES every day! Also, My
ruby on rails
coworkers are making fun of me.Why are those people wasting my time, making me feel miserable !!!??? Enterprise Java Architect, having an epiphany
The answer is pretty simple. Because your application is stateful!
You're keeping object instances in memory between requests. Assuming the code changed, what do you do with those "old" object instances ? Their class definitions may have changed. If you discard the classloader, you're also discarding all the instances it has created. That would typically mean loosing all session data at each reload, which in a typical application, would be very annoying.
In a JEE app, redeploying also means restarting a bunch of "services" provided by the application server (JNDI, Database connections pools, EBJ, JMX, CDI, etc.), which takes a long long time. Hot reload is not the only problem here.
Since play is completely stateless and fairly lightweight, trashing everything is not a problem a all.
The "all inclusive" philosophy of a enterprise application servers comes at a price, and let's face it, your not using 10% of the features anyway.
I don't care, I use JRebel!
Good for you!
Since Jrebel is not open source, it's pretty hard to know how exactly it is working. Their faq does not say a lot, but they published a blog post a while ago explaining the basics:
It adds a java agent that rewrite the bytecode loaded into the JVM which:
- adds a field to each class, holding references to fields added to the object
- adds a field to each class, holding references to anonymous classes with actual methods implementations
- modify the methods of the classes to mask the above changes.
Of course when a class is modified you need to track the changes impact, and "reload" classes accordingly. That alone is pretty hard.
TD;DR
- Play simply reloads code by trashing the application classloader and restarting everything, which comes at the price of SBT being deeply integrated into the framework.
- The JEE architecture is stateful, and too heavy anyway to allow that kind of feature.
- JRebel is rocket surgery (yes, surgery) compared to play.
Next time we'll see how play routes request and invoke the application code. It should be the last article of the series.
Play, Anatomy of a web framework: The Web Server. Play, Anatomy of a web framework: Routing.


{% extends "base.html" %} {% load workshop_action_button %} {% block header %}
{{voting.workshop_rating.name}} :{{voting.rating}}
Volunteer required: {{ form.number_of_volunteers }}
Do you need travel/stay financial support ?: {{ form.tutor_reimbursement_flag }}
Provide details on reimbrusement: {{ form.comments }}


Before Change
if restore_lr:
learning_rate = self.opt.get("final_learning_rate", learning_rate)
self.model = self.compile(self.model, optimizer_name=optimizer, loss_name=loss,
learning_rate=learning_rate, learning_rate_decay=learning_rate_decay)
self._change_not_fixed_params(**given_opt)
summary = ["Model was successfully initialized!", "Model summary:"]
After Change
Initialize model using parameters
from opt dictionary (from config), if model is being initialized from saved.
if learning_rate is None and isinstance(learning_rate_decay, float):
learning_rate = 0.01
elif learning_rate is None and learning_rate_decay is None:
learning_rate = 0.01
learning_rate_decay = 0.
elif isinstance(learning_rate, float) and "learning_rate_drop_patience" in kwargs:
learning_rate_decay = "no"
if classes is not None:
classes = list(classes)
given_opt = {"embedding_size": embedding_size,


Colin Ferris Final Compiler Project
Code Input
For IF and WHILE statements, code gen only works with id to id, like if(a == b)
Compile
Lexer Output
Parser Output
Semantic Output
Code Output


Simple And Minimal SMTP Server
Table of Contents
1 Introduction
Quite often web applications need to send email notifications. For example Moodle needs to notify students and teachers about various events. Without being able to send notifications, Moodle and many other web applications loose half of their usefulness. On many web applications you cannot even finish the registration process and cannot login, unless you verify your email address (the application sends you an email with a link that you have to click).
To send emails, an application needs to contact by SMTP a local or remote mail server. Installing a mail server is not so easy because it needs also some DNS and other configurations, in order to do it properly, otherwise the mails that are sent will end up being classified as spam and most probably will not reach the recipient.
A relatively easy solution is to send emails from GMail SMTP servers, on behalf of the web application. For this you need a GMail account, which often needs to be different for each application. Managing lots of gmail accounts is a bit inconvenient. However the biggest problem is that gmail accounts have a limit on the number of messages that can be sent each month. For many applications this limit may be OK, but for some others it is not. For example Moodle typically needs to send a message for each course subscriber, for each event of the course. Even for a small Moodle site that does not have many active courses, the monthly limit can be reached very quickly.
Another alternative is to install your own mail server, and to configure it properly. This article describes how to do it. The aim of this mail server is not to be a full-fledged system, where users can have accounts and use it daily, but just to support web applications (like Moodle) with sending notifications.
2 Sending Email From GMail SMTP Servers
Before starting with building a SMTP server, let's see first the easy solution, in case this is sufficient for your needs.
- First install Simple SMTP:
apt install ssmtp
- You can create a new GMail account or use an existing one. In both cases you need to enable the two-factor authentication on the google account, and then to create a new application-specific password on this account, as described here: https://www.lifewire.com/get-a-password-to-access-gmail-by-pop-imap-2-1171882
Edit
/etc/ssmtp/
and place a content like<EMAIL_ADDRESS>mailhub=smtp.gmail.com:587<EMAIL_ADDRESS>AuthPass=xyzxyzxyzxyzxyzxyz UseTLS=YES UseSTARTTLS=YES rewriteDomain=gmail.com hostname=localhost FromLineOverride=YES
Here
AuthPass
is the app-specific password generated on the step above.Add this line on
/etc/ssmtp/revaliases
:root:username@gmail.com:smtp.gmail.com:587
To test that it works, create and execute a script called test-ssmtp.sh
with a content like this:
#!/bin/bash -x<EMAIL_ADDRESS>cat <<EOF | sendmail -v $recipient To: $recipient Subject: Testing ssmtp Line 1 Line 2 EOF
Note: Replace<EMAIL_ADDRESS>with your email address or call
the script with your email address as an argument.
3 Minimal DNS Configuration
In order to build a mail server you need to own a domain (say
example.org
) and be able to customize its DNS records.
For each email domain you need something like this on the DNS configuration:
; mail for example.org smtp.example.org. IN A <IP_ADDRESS> example.org. IN MX 1 smtp.example.org. example.org. IN TXT "v=spf1 mx -all"
The first line shows the IP of the server smtp.example.org
. The second
line shows that the mail server (MX
) for the domain example.org
is
smtp.example.org
. Number 1
shows the priority of the mail server
(since there may be more than one mail servers for the same domain).
The third line basically tells to the other SMTP servers that only
this server is allowed to send emails on behalf of this domain, and no
other servers. This is done to prevent spammers from faking your email
addresses. If a spammer tries to send a mail as if it is coming from
your domain, the SMTP server that is getting this email will consult
this DNS record, will figure out that the server of the spammer is not
allowed to send emails on behalf of example.org
, and will
immediately classify that email as spam or reject it at all.
Note: The configuration lines above are suitable for bind9
(they
should normally go to example.org.db
). If you use some other system
for managing your domain records, you should figure out how to do them
properly on it. If you are starting from scratch and don't have yet a
domain for the mail server, I would suggest trying this for managing
its DNS configuration: https://github.com/docker-scripts/bind9
Note: On bind9
, make sure to change the serial number on the
configuration file and then restart the service: systemctl restart
bind9
. It may take a few hours or a couple of days for the DNS changes
to propagate on the internet.
You can use dig
to verify that these settings have already been
activated:
$ dig MX example.org +short 1 smtp.example.org. $ dig A smtp.example.org +short <IP_ADDRESS> $ dig TXT example.org +short "v=spf1 mx -all"
4 Build a Postfix Container With Docker-Scripts
It is easy to build a postfix container with docker-scripts.
4.1 Install Docker-Scripts
sudo su apt install m4 git clone https://github.com/docker-scripts/ds /opt/docker-scripts/ds cd /opt/docker-scripts/ds/ make install
4.2 Install Web-Server Proxy
- Get the scripts:
ds pull wsproxy
- Create a container directory:
ds init wsproxy @wsproxy
- Fix the settings:
cd /var/ds/wsproxy/; vim settings.sh
- Build image, create the container and configure it:
ds make
We need wsproxy
to get and manage letsencrypt SSL certificates for the
postfix
container.
4.3 Install Postfix
- Get the scripts:
ds pull postfix
- Create a container directory:
ds init postfix @smtp.example.org
- Fix the settings:
cd /var/ds/smtp.example.org/ ; vim settings.sh
- Build image, create the container and configure it:
ds make
- Get a letsencrypt SSL certificate:
ds get-ssl-cert
4.4 Activate DKIM Key
DKIM keys are used by mail servers to sign the emails that they send, so that they cannot be changed in transit, and so that it can be verified that they were sent by them. It is an important tool against spams and faked emails. If a smtp server signs the messages that it sends, it is less likely that they will be classified as spam.
Installation scripts generate a DKIM key as well, which is on
config/dkim-keys/example.org/
. To activate it you need to add a
record like this on the DNS configuration of the domain:
mail._domainkey.example.org. IN TXT "v=DKIM1; h=sha256; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQE....kMJdAwIDAQAB"
You can find the content of the public key on the file:
config/dkim-keys/example.org/mail.txt
.
Don't forget to update the serial number of the DNS domain and to
restart or reload the service (systemctl restart bind9
). It may take a
couple of hours or days until these changes are propagated on the
internet.
To check whether it has been activated or not, try the command:
dig TXT mail._domainkey.example.org +short
4.5 Create a DMARC Record
DMARC is a standard that allows you to set policies on who can send email for your domain based on DKIM and SPF. For more details see this: https://postmarkapp.com/support/article/892-what-is-dmarc
You can add a DMARC Record on DNS that will allow you to get weekly reports from major ISPs about the usage of your email domain.
- Go to http://dmarc.postmarkapp.com/ and add your email address where
you want to receive reports, and email domain name (
example.org
). On the DNS configuration of the domain add a TXT record like this:
_dmarc.example.org. IN TXT "v=DMARC1; p=none; pct=100<EMAIL_ADDRESS>sp=none; aspf=r;"
The value of this TXT record is the one generated by the website above.
To check that it has been activated, try the command:
dig TXT _dmarc.example.org. +short
5 Test the SMTP Server
Install
swaks
:cd /var/ds/smtp.example.org/ ds shell apt install swaks
Send a test email and check the logs:
swaks --from<EMAIL_ADDRESS>--to<EMAIL_ADDRESS>-tlso tail /var/log/mail.log
The option
-tlso
tells it to use TLS if possible.Send a test email to a gmail account:
swaks --from<EMAIL_ADDRESS>--to<EMAIL_ADDRESS>-tlso tail /var/log/mail.log
On gmail use "Show original" from the menu, to see the source of the received email.
Try to send a test email from the host (outside the container):
cd /var/ds/smtp.example.org/ swaks --from<EMAIL_ADDRESS>--to<EMAIL_ADDRESS>-tlso tail /var/log/mail.log
It may fail, because the IP of the host may not be on the list of the trusted hosts (that are allowed to send email for the domain
example.org
). Add it onconfig/trusted_hosts
and then runds inject update.sh
. Verify that now you can send emails.Try to send email to
<EMAIL_ADDRESS>:swaks --from<EMAIL_ADDRESS>--to<EMAIL_ADDRESS>-tlso ... <** 550 5.1.1<EMAIL_ADDRESS>Recipient address rejected: User unknown in virtual alias table ...
It may fail because the recipient does not exist on the alias table. On
config/virtual_alias_maps.cf
add a line like<EMAIL_ADDRESS><EMAIL_ADDRESS>Then update the alias db:
ds exec postmap /host/config/virtual_alias_maps.cf
(ords inject update.sh
). Verify that now you can send emails to this address.Send an email to
<EMAIL_ADDRESS>:swaks --from<EMAIL_ADDRESS>--to<EMAIL_ADDRESS>\ --server smtp.example.org -tlso
The automatic reply will give you important information about the status and health of your email server (for example whether the mails sent from it pass the SPF and DKIM checks, whether they are considered spam or not, etc.)
Go to https://www.mail-tester.com/ and send a message to the email address displayed there, like this:
swaks --from<EMAIL_ADDRESS>--to<EMAIL_ADDRESS>\ --server smtp.example.org -tlso
Then click the button for checking the score.
Note: Another way to send test emails (instead of swaks
) is by using
curl
and a script testmail.sh
with a content like this:
#!/bin/bash<EMAIL_ADDRESS><EMAIL_ADDRESS>cat << EOF | curl -v --ssl --upload-file - \ --url 'smtp://smtp.example.org' \ --mail-from $from_address \ --mail-rcpt $to_address From: $from_address To: $to_address Subject: test $(date) Test message. EOF
6 Check the Mail Server
There are lots of tools and websites that help to check the configuration of a mail server (DNS settings, configuration, security features, etc.) These are some of them:
- https://ns.tools/
- https://mxtoolbox.com/
- https://app.dmarcanalyzer.com/
https://github.com/drwetter/testssl.sh/
git clone --depth 1 https://github.com/drwetter/testssl.sh.git cd testssl.sh/ ./testssl.sh -t smtp smtp.example.org:25
7 Add Another Email Domain
The same smtp server can support more than one mail domains. If we
want to add another mail domain, for example example.com
, we have to
do these:
- Edit
config/virtual_alias_domains
and add the domain on a new line. - Edit
config/virtual_alias_maps.cf
and add new email aliases<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>, etc.) Update server configuration with
ds inject update.sh
, or:ds exec postmap /host/config/virtual_alias_maps.cf ds exec postfix reload
- Generate a DKIM key for the domain:
ds dkimkey add example.com
- Go to http://dmarc.postmarkapp.com/ and generate a DMARC record for the new domain.
Update the DNS configuration with records like these:
; mail for example.com example.com. IN MX 1 smtp.example.org. example.com. IN TXT "v=spf1 mx -all" mail._domainkey.example.com. IN TXT "v=DKIM1; h=sha256; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQE....kMJdAwIDAQAB" _dmarc.example.com. IN TXT "v=DMARC1; p=none; pct=100<EMAIL_ADDRESS>sp=none; aspf=r;"
Note that:
- The MX record has the same SMTP server as the primary domain:
smtp.example.org
(not the new domainsmtp.example.com
). - The value of the key for the DKIM record can be found on the file:
config/dkim-keys/example.com/mail.txt
- The value of the DMARC record is the one obtained on the previous step.
You can check these DNS configurations like this:
dig mx example.com. +short dig txt example.com. +short dig txt mail._domainkey.example.com. +short dig txt _dmarc.example.com. +short
- The MX record has the same SMTP server as the primary domain:
8 Using The SMTP Server
Different applications have different methods for configuring the SMTP server. Let's see how to send emails from cron jobs and from Moodle.
Important: For this to work, the IP of the application server should
be on the list config/trusted_hosts
on the smtp server, otherwise it
will refuse to accept and send emails. After adding it on this list,
run ds inject update.sh
to update the configuration of the mail
server.
8.1 Sending Emails From Cron Jobs
Cron jobs (for example logwatch
) send emails to root
through
sendmail
. We can make it work with ssmtp
. First install it with: apt
install ssmtp
. Then edit /etc/ssmtp/ssmtp.conf
like this:
mailhub=smtp.example.org rewriteDomain=example.org UseSTARTTLS=YES FromLineOverride=YES
Test it with: echo test | sendmail -v root
8.2 Sending Emails From Moodle
If we search for smtp
on the GUI menu for administration, we will find
that the place for SMTP configuration is on Dashboard > Site
administration > Server > Email > Outgoing mail configuration
(or on
the location: /admin/settings.php?section=outgoingmailconfig
).
But we can also configure Moodle from command line, like this:
moosh config-set smtphosts smtp.example.org moosh config-set smtpsecure TLS moosh config-set smtpauthtype PLAIN moosh config-set smtpuser '' moosh config-set smtppass '' moosh config-set smtpmaxbulk 100
9 References
- https://www.linux.com/learn/how-set-virtual-domains-and-virtual-users-postfix
- https://tecadmin.net/send-email-smtp-server-linux-command-line-ssmtp/
- https://blog.kruyt.org/postfix-and-tls-encryption/
- https://www.linuxbabe.com/mail-server/setting-up-dkim-and-spf
- https://tecadmin.net/setup-dkim-with-postfix-on-ubuntu-debian/
- https://www.skelleton.net/2015/03/21/how-to-eliminate-spam-and-protect-your-name-with-dmarc/


The 2020 game involves two alliances of three teams each, with each team controlling a robot and performing specific tasks on a field to score points. The game centers around a futuristic city theme involving two alliances consisting of three teams each competing to perform various tasks, including shooting foam balls known as Power Cells into high and low goals to activate a Shield Generator, manipulating a Control Panel to activate this shield, and returning to the Shield Generator to park or climb at the end of the match. The objective is to energize and activate the shield before the match ends and asteroids strike a city.
It involves two alliances of three teams each, with each team controlling a robot and performing specific tasks on a field to score points. The game centers around an outer space theme involving two alliances consisting of three teams each competing to place poly-carbonate hatch panels and orange rubber balls or "cargo" on rockets and cargo ships before returning to their HAB platform to climb at the end of the match.
Is the robotics competition game for the 2018 season. It involves two alliances of three teams each, with each team controlling a robot and performing specific tasks on a field to score points. The game has a retro 8-bit theme and teams are required to place milk crates, or "power cubes", on large balancing scales to tip the scale and gain ownership. Alliances can also trade power cubes for power ups, giving them a temporary advantage in a match. At the end of the match, robots can climb the tower attached to the centre balancing scale using a rung attached to the tower, giving them additional points.


{% if GetInternPerformanceData_perm() %}
{% endif %}
{% if GetInternPerformanceData_perm() %}
{% endif %}
Intern Performance
55% increase in treatment rate over the past 5 days
* Interns with with above average cumulative performance
High Risk Medication
Sorted in Descending Order
{# if there are no doctors returned then the card isn't created #}
{% if get_doctors() | length > 0 %}
{% include "doctors_table.html" %}
{% endif %}
{# if there are no nurses returned then the card isn't created #}
{% if get_nurses() | length > 0 %}
{% include "nurses_table.html" %}
{% endif %}
{# if there are no patients returned then the card isn't created #}
{% if get_patients('') | length > 0 %}
{% include "patients_table.html" %}
{% endif %}


title = "Faq" url = "/faq" layout = "default" is_hidden = 0 == {% partial 'nav' %}
Well basicly you need two things,
-youl need your domain name (www.bla.com)
-and youl need a hosting service, this is like a computor that stores your website.
A domain name costs about 12$ a year,
while hosting varies from around 60$ - 100$ a year depending on how big your site is.
Yes,
I offer hosting services, first year free, and after starting from 60$ a year, again, depending of the size of your site.
Yes,
I offer hosting services, first year free, and after starting from 60$ a year, again, depending of the size of your site.


A | |
| Atom [ConstraintTypes] | An atom is a comparison between two polynomials. |
| Atomizable [ConstraintTypes] | A default atom module. |
B | |
| BaseMath [PolyTypes] | Modules including BaseMath define basic math operations. |
| BasePartialOrder [PolyTypes] | Modules including BasePartialOrder fulfil all requirements to become a partial order. |
C | |
| Constraint [ConstraintTypes] | A constraint is a conjunction of atoms, i.e., we store those atoms in a list. |
E | |
| Evaluable [PolyTypes] | Evaluable is a unified interface of all parts of a polynomial. |
F | |
| Formula [ConstraintTypes] | A formula is a propositional formula, a disjunction of constraints, i.e., a list of constraints or more precisely a list of atom lists. |
M | |
| Math [PolyTypes] | Modules including Math hold a type that defines basic math operations on its elements. |
| Monomial [PolyTypes] | A monomial is a a finite product of powers without a constant factor. |
P | |
| PartialOrder [PolyTypes] | Modules including PartialOrder hold a type that defines a partial order on its elements. |
| Polynomial [PolyTypes] | A Polynomial represents a mathematical polynomial |
R | |
| Ring [PolyTypes] | Providing the construct for the algebraic structure of a ring. |
S | |
| ScaledMonomial [PolyTypes] | A scaled monomial is a monomial multiplied with a coefficient. |
V | |
| Valuation [PolyTypes] | A valuation is a function which maps from a finite set of variables to values. |


Publications
You can find an up to date list of my publications on Google Scholar
- B. Okal and K. O. Arras, “Learning socially normative robot navigation behaviors with Bayesian inverse reinforcement learning,” in Proc. of IEEE International Conference on Robotics and Automation (ICRA), May 2016.
- B. Okal, R. Triebel, and K. O. Arras, “Real-time social activity detection for mobile service robots,” in Proc. of IEEE International Symposium on Robot and Human Interactive Communication (RO-MAN), August 2016.
- B. Okal, H. Gilbert, and K. O. Arras, “Efficient inverse reinforcement learning using adaptive state graphs,” in Proc. of Learning from Demonstration: Inverse optimal control, Reinforcement learning and Lifelong learning Workshop at Robotics: Science and Systems (RSS), July 2015.
- P. S. Thomas, B. Okal, “A notation for Markov decision processes”, arXiv preprint arXiv:1512.09075, 2015.
- R. Triebel, K. Arras, R. Alami, L. Beyer, S. Breuers, R. Chatila, M. Chetouani, D. Cremers, V. Evers, M. Fiore, H. Hung, O. A. I. Ramirez, M. Joosse, H. Khambhaita, T. Kucner, B. Leibe, A. J. Lilienthal, T. Linder, M. Lohse, M. Magnusson, B. Okal, L. Palmieri, U. Rafi, M. van Rooij, and L. Zhang, “Spencer: A socially aware service robot for passenger guidance and help in busy airports,” in Proc. of Field and Service Robotics (FSR), June 2015.
- B. Okal and K. O. Arras, “Towards group-level social activity recognition for mobile robots,” in Proc. of Assistive and Service Robotics Workshop at IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), September 2014.
- D. Vasquez, B. Okal, and K. O. Arras, “Inverse reinforcement learning algorithms and features for robot navigation: An experimental comparison,” in Proc. of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), September 2014.
- B. Okal and A. Nüchter, “Sliced curvature scale space for representing and recognizing 3d objects,” in Proc. of the 16th International Conference on Advanced Robotics (ICAR), November 2013.
- G. Demisse, R. Mihalyi, B. Okal, D. Poudel, J. Schauer, and A. Nüchter, “Mixed palletizing and task completion for virtual warehouses,” in Proc. of Virtual Manufacturing Automation Competition (VMAC) Workshop at IEEE International Conference Robotics and Automation (ICRA), May 2012.
- B. Okal and O. Dunkley, “Development of a cheap chess robot: Planning and perception,” in Springer Lecture Notes in Informatics, Gesellschaft für Informatik (GI) Edition, March 2012.
- B. Okal, “Open source robotics: An enabling platform,” in Proc. of the 4th International Conference on ICT for Africa (ICIA), March 2011.


--- layout: default title: EHST'17 - Keynote Speakers meta: The list of keynote speakers who will be presenting their lectures within the topics of control, dynamic systems and robotics at EHST. keyword: solar thermal energy, solar cell theory and applications, biomass, biofuel, bioenergy, smart buildings, smart lightings, wind energy, geothermal energy, wave energies, tide energies, nuclear energies, prospects, issues, battery energy storage, energy storage, hydroenergy, energy financing, energy companies challenges, energy distribution, energy conversion, electric vehicles, fossil fuels, energy change, climate change, energy pollution, environmental pollution, energy, nanotechnology, low carbon technologies, energy infrastructures, marketing, economy, societal aspects, global energy policy, energy and transportation, sustainable energy, energy efficiency-achievements and challenges, energy management, fuel cells ---
We are very happy to announce the following keynote speakers for the International Conference of Energy Harvesting, Storage, and Transfer (EHST'17):
Dr. Jules Thibault
Jules Thibault obtained his bachelor of chemical engineering at the Royal Military College. He later obtained a PhD in Chemical Engineering from McMaster where he worked on the topic of heat transfer in nuclear reactors. He then spent four years in the Canadian Armed Forces including two six-month postings to Egypt and Cyprus with the United Nations. From 1981 to 1984, he taught in the Department of Chemistry and Chemical Engineering at the Royal military College. In 1984, he joined the Department of Chemical Engineering of Laval University. In 2000, he moved to the Department of Chemical and Biological Engineering at the University of Ottawa. His research interests are in biochemical engineering, transport phenomena and process simulation, control and optimization.
Topic of Keynote: Water Extraction from Air: Potential and Limitation
Keynote AbstractDr. Michael Fowler
Dr. Michael Fowler is a Professor in the Department of Chemical Engineering at the University of Waterloo with a research interest in electrochemical power sources. Specifically his research focuses on fuel cell system design and reliability, fuel cell and battery materials durability and green power systems. His research includes modelling of hydrogen production and distribution systems, including Power-to-Gas. With the University of Waterloo Alternative fuel team he is the co-advisor of the development of a number of fuel cell and plug-in hybrid vehicles. The University of Waterloo is one of Canada's leading comprehensive universities with extensive graduate and undergraduate programs.
Topic of Keynote: Power-to-Gas Pathways to a Fossil Free Energy System
Keynote Abstract


- send() - Method in class com.technipun.dc.algorithm.Message
-
- send(WaveProcessNode, MessageType) - Method in class com.technipun.dc.algorithm.WaveProcessNode
-
Send to a node.
- send(WaveProcessNode, MessageType, Object) - Method in class com.technipun.dc.algorithm.WaveProcessNode
-
Send.
- sender - Variable in class com.technipun.dc.algorithm.MessageHeader
-
The sender.
- sendToken(WaveProcessNode, MessageType) - Method in class com.technipun.dc.algorithm.ElectionProcessNode
-
Send token for election process.
- sendToken(WaveProcessNode, MessageType) - Method in class com.technipun.dc.algorithm.WaveProcessNode
-
Send token for wave process
- setCandidate(boolean) - Method in class com.technipun.dc.algorithm.ElectionProcessNode
-
Sets the candidate.
- setHadReceiveAction(boolean) - Method in class com.technipun.dc.algorithm.WaveProcessNode
-
Sets the had receive action.
- setHadSendAction(boolean) - Method in class com.technipun.dc.algorithm.WaveProcessNode
-
Sets the had send action.
- setHeader(MessageHeader) - Method in class com.technipun.dc.algorithm.Message
-
- setInitiator(boolean) - Method in class com.technipun.dc.algorithm.ElectionProcessNode
-
Sets the initiator.
- setMessage(Object) - Method in class com.technipun.dc.algorithm.Message
-
- setMsgType(MessageType) - Method in class com.technipun.dc.algorithm.MessageHeader
-
Sets the msg type.
- setNode(WaveProcessNode) - Method in class com.technipun.dc.algorithm.ReceiveIndicator
-
Sets the node.
- setNodeID(int) - Method in class com.technipun.ds.Node
-
Sets the NodeID.
- setParent(Node) - Method in class com.technipun.ds.Node
-
Sets the parent of the node.
- setReceived(boolean) - Method in class com.technipun.dc.algorithm.ReceiveIndicator
-
Sets the received.
- setReceiver(WaveProcessNode) - Method in class com.technipun.dc.algorithm.MessageHeader
-
Sets the receiver.
- setRunDiffusion(boolean) - Method in class com.technipun.dc.algorithm.WaveProcessNode
-
Sets the run diffusion.
- setSender(WaveProcessNode) - Method in class com.technipun.dc.algorithm.MessageHeader
-
Sets the sender.
- silentNeigh - Variable in class com.technipun.dc.algorithm.WaveProcessNode
-
The silent neigh.
- size() - Method in class com.technipun.ds.MessageQueue
-
Size of the message queue
- state - Variable in class com.technipun.dc.algorithm.ElectionProcessNode
-
The state.
- State() - Constructor for enum com.technipun.dc.algorithm.ElectionProcessNode.State
-
- status - Variable in class com.technipun.dc.algorithm.WaveProcessNode
-
The status.
- Status() - Constructor for enum com.technipun.dc.algorithm.WaveProcessNode.Status
-


2005-2009: DTU - Technical University of Denmark
2009-2014: BioGasol ApS - Scientist/ Senior Scientist
2014-2019: Novozymes A/S - Senior Scientist


--- layout: page title: Members date: 2014-11-21 11:13:09.000000000 -06:00 type: page parent_id: '39' published: true password: '' status: publish categories: [] tags: [] meta: _edit_last: '16309375' _wp_page_template: default geo_public: '0' _publicize_pending: '1' author: login: acfquizbowl email<EMAIL_ADDRESS>display_name: acfquizbowl first_name: '' last_name: '' permalink: "/aboutus/members/" ---
| Name and Affiliation | Contributions |
| Rahul Keyal University of Californa, Berkeley |
ACF Fall 2018 Editor |
| JinAh Kim Alumna, University of Pennsylvania |
ACF Nationals 2019 Editor |
| Olivia Lamberti Stanford University |
ACF Fall 2018 Editor |
| Evan Lynch Ph.D Student, University of Southampton Alumnus, University of Cambridge |
ACF Fall 2017 Editor |
| Itamar Naveh-Benjamin Alumnus, University of Missouri |
ACF Fall 2016 Editor |
| Benji Nguyen Alumnus, Stanford University |
ACF Regionals 2017 Editor |
| Ashwin Ramaswami Stanford University |
Communications Officer, 2018-2019 ACF Fall 2018 Editor ACF Fall 2017 Editor |
| Nitin Rao University of Pennsylvania |
ACF Fall 2018 Editor |
| Graham Reid Ph.D Student, University of Maryland |
ACF Regionals 2019 Editor |
| Rebecca Rosenthal Swarthmore College |
ACF Nationals 2019 Assistant TD |
| Kenji Shimizu Alumnus, University of Michigan |
ACF Regionals 2018 Editor |
| Margaret Tebbe University of Pennsylvania |
ACF Nationals 2019 Host Logistics Contact |
| Name and Affiliation | Contributions |
| Evan Adams Alumnus, University of Virginia Law School Alumnus, Virginia Commonwealth University |
ACF Nationals 2017 Editor ACF Regionals 2014 Head Editor ACF Fall 2010 Head Editor ACF Fall 2009 Editor |
| Bruce Arthur Alumnus, Harvard Law School Alumnus, University of Chicago |
ACF Nationals 2013 Editor ACF Nationals 2012 Editor ACF Nationals 2011 Contributor |
| Ezequiel Berdichevsky J.D., George Washington University Law School M.A., Ph.D. Candidate (ABD), English Literature, University of Michigan Alumnus, University of Maryland |
ACF Nationals 2010 Head Editor ACF Nationals 2004 Head Editor ACF Regionals 2002 Head Editor |
| Will Butler Ph.D. Student, Biology, Georgia Tech Alumnus, University of Virginia |
ACF Regionals 2012 Editor ACF Fall 2010 Editor |
| Trevor Davis Graduate Student, University of Alberta Alumnus, Carnegie Mellon University |
ACF Regionals 2015 Editor ACF Regionals 2012 Head Editor ACF Winter 2010 Editor ACF Fall 2008 Editor |
| Susan Ferrari Ph.D., Cancer Biology, University of Chicago Alumna, University of Chicago |
Communications Officer, 2011-2014 ACF Nationals Editor 2012 ACF Nationals Editor 2011 ACF Nationals Editor 2010 |
| Ted Gioia Alumnus, Harvard University |
ACF Nationals Editor 2014 ACF Regionals Editor 2011 ACF Regionals Editor 2010 ACF Fall Editor 2008 |
| David Hamilton Fellow, Casualty Actuarial Society M.B.A., Elon University Love School of Business Alumnus, University of Maryland |
ACF Nationals 2001 Editor ACF Nationals 2000 Editor ACF Regionals 1999 Editor |
| Jeff Hoppes M.A., History, University of California - Berkeley Alumnus, Princeton University |
ACF Regionals 2005 Editor |
| Matthew Jackson Alumnus, Yale University |
Lead writer, August 2016 ACF rules revision ACF Nationals 2015 Assistant Tournament Director ACF Regionals 2015 Head Editor ACF Regionals 2014 Editor |
| Dennis Jang Alumnus, Brown University |
ACF Winter 2010 Editor ACF Winter 2009 Editor ACF Fall 2008 Editor |
| Gautam Kandlikar Alumnus, University of Minnesota |
Treasurer 2015-2017 ACF Fall 2014 co-Head Editor ACF Fall 2009 Head Editor ACF Fall 2008 Editor |
| Matt Keller Alumnus, Vanderbilt University |
|
| Eddie Kim SoCal Quizbowl |
ACF Fall 2016 Editor ACF Fall 2015 Editor |
| Matthew Lafer Alumnus, University of Michigan |
ACF Nationals 2009 Editor ACF Nationals 2008 Editor ACF Regionals 2006 Editor |
| John Lawrence PhD Candidate, University of Chicago Alumnus, Yale University |
ACF Regionals 2016 Head Editor ACF Regionals 2013 Editor ACF Fall 2013 Editor ACF Regionals 2012 Editor ACF Fall 2010 Editor |
| Paul Litvak Ph.D., Behavioral Decision Making, Carnegie Mellon University Alumnus, University of Michigan |
ACF Nationals 2004 Editor |
| Subash Maddipoti Alumnus, University of Chicago |
ACF Nationals 2001 Editor |
| Wesley Matthews Alumnus, Indiana University |
|
| Trygve Meade Alumnus, Southern Illinois University Law School Alumnus, University of Illinois |
ACF Regionals 2010 Editor ACF Winter 2009 Editor |
| Eric Mukherjee University of Pennsylvania MD/Ph.D. program Alumnus, Brown University |
ACF Regionals 2019 Editor ACF Winter 2010 Editor ACF Regionals 2009 Editor |
| Jason Paik MD/Ph.D., Cancer Biology, University of Alabama School of Medicine Alumnus, Washington University, St. Louis |
ACF Nationals 2004 Editor |
| Chris Ray Graduate Student, University of Chicago Alumnus, University of Maryland |
ACF Regionals 2016 Editor ACF Regionals 2013 Head Editor ACF Regionals 2010 Editor |
| Matt Reece Ph.D., Theoretical Physics, Cornell University Alumnus, University of Chicago |
|
| Max Schindler Univeristy of Chicago |
ACF Regionals 2016 Editor ACF Fall 2014 Editor |
| Michael Angelo Sorice Ph.D. Candidate, Nuclear, Plasma, and Radiological Engineering, University of Illinois |
ACF Nationals 2013 Editor ACF Regionals 2006 Head Editor ACF Regionals 2005 Editor |
| Guy Tabachnick Alumnus, Brown University |
ACF Regionals 2012 Editor ACF Fall 2010 Editor |
| Seth Teitler Ph.D., Astrophysics, University of Chicago Alumnus, University of California - Berkeley |
ACF Fall 2009 Adviser ACF Regionals 2007 Head Editor ACF Fall 2005 Editor |
| Nathan Weiser Stanford University |
ACF Fall 2018 Head Editor ACF Regionals 2017 Editor ACF Fall 2015 Editor |
| Dwight Wynne Ph.D. Candidate, Biomedical Engineering, University of California - Irvine Alumnus, University of California - Los Angeles |
Designer of A-value qualification system ACF Regionals 2011 Editor ACF Regionals 2010 Editor ACF Nationals 2009 Editor |
| Andrew Yaphe J.D., Stanford University Law School Alumnus, University of Virginia |
ACF Nationals Head Editor, 2005-07 ACF Regionals Head Editor, 2000, 2005 ACF Fall 2007 Head Editor ACF Nationals 2001 Editor |
| Richard Yu Alumnus, Washington University in St. Louis |
ACF Fall 2017 Editor ACF Fall 2015 co-Head Editor ACF Fall 2014 Editor |


We can't find that (404)
We can't find what you're looking for.
Try going back to the homepage and starting from there, or contact us at<EMAIL_ADDRESS>We can't find what you're looking for.
Try going back to the homepage and starting from there, or contact us at cbm@openup.org.za


Chromebook Review
So I’ve been using a Chromebook now for a few weeks and I thought I’d say a few words on it.  However, whilst that’s pretty apt, I thought I’d mention my thoughts on it.
Chromebook
I purchased the Samsung Series 3 Chromebook, partly due to it’s similarities to the Macbook Air. Yes, I’d probably prefer a Macbook Air but the cost is to high to justify on a laptop that I wouldn’t use much. The Chromebooks pricing was far more attractive. So yes, the Macbook style Chromebook beat the contenders from Acer for various reasons - size and battery life being big decider’s, even if the Acer one is an x86 based CPU machine and this Samsung one is an ARM chip (as it turns out, that makes no difference).
Weight wise and size wise, it’s a fantastic laptop to carry around. It fits my Pantagonia Mini Mass bag perfectly fine (without a case or cover) and that’s also with my iPad and Kindle in. I can suddenly see why people were raving about the Macbook Air.
Usage
In the run up to getting one, I forced myself to become more familiar with the Google ecosystem again (I left Mail and Calendar for iCloud when iCloud was released). I also forced myself to use Chrome over the more commonly used Firefox on my work and home machines. This move back to the Google Services eased my transition to the Chromebook.
The biggest move was from Dropbox to Google Drive - a few snagging issues there that I’ll talk about perhaps in another post but for now, the main points I found there was the slight difference in how Google Drive overwrites files you upload on the website (i.e. it doesn’t overwrite them!) - not something that applies to much to the Chromebook it appears.
However, when I got the Chromebook, I eagerly opened the box and got ready to get started.
Starting Up
So getting started with the Chromebook was simple - charge up the device (a bit a shame in comparison to Apple’s “buy, open and go” policy). However, once charged, you’re greeted with signing on to a wifi network (you’ll need wifi, the Samsung model has no ethernet connection). Once done, it asks for your Google account details (and supports 2 factor authentication for those that have it enabled) and it then checks for software updates. 15 minutes later and I was logged in and ready to go. I should point out that typical bootup time is as Samsung and Google suggest - 7 seconds or so give or take.
And that’s it - no downloading of programs or anything. Sign in and you’re ready to go. Simple.
Day to Day Use
My main concern was that of offline access. The Chromebook is designed to use web services and that means that without the web, the benefits of the Chromebook aren’t perhaps as apparent. It’s partly the reason I enabled the Developer mode on my Chromebook, solely so I could access the terminal/shell and through that, Vim. I’m not a fan of Vim but it lets me edit my LaTeX files offline. Which is what I need for editing my thesis on the go. However, when online, I use the excellent Neutron Drive application that combines nicely with my Google Drive account to allow me to edit my files. So therefore, the main reasons I bought the Chromebook is covered.
Day to day use is otherwise good - the syncing of the Chrome browser is great and allows all the extensions I use on the desktop to sync across to the Chromebook and vice versa. This means my workflow is unaffected by changes in platform less.
Whilst I initially disagreed with the use of Google Docs, I’ve become more of a fan. For basic documents, it’s not to bad. For anything academic or with some more advanced features, it falls down. Its ability to convert Word documents is lacking - it means I can’t edit work documents as the work template is completely mangled by the conversion process. But it works well for allowing me to write up notes, letters and magazine articles where I don’t need to insert references and cross linking.
Music wise, Google Music allows you to upload 20,000 songs and then stream them for free. This works fantastically well with the Chromebook where you have a decent connection. However, if you have the files stored on a USB or SD card, you can easily access them and play them locally which is a great boon for me as I love having my music nearby (to be fair, I do have a 120GB iPod with me most of the time that I would use as well).
Minor Niggles
Installation of new fonts is not supported. I can hack the Chromebook to allow me to install fonts of my choice but means that I can’t disable developer mode without a downloading and installing a recovery image from Google.
The other niggle is because I have enabled developer mode, the Chromebook displays a notification I have on startup - this remains on screen for 30 seconds or until you press Ctrl+D.
Overall
Overall I’ve been happy with the purchase - not only has it allowed me to stay mobile and get work done, more so than my iPad and keyboard combo, it’s helped focus me. On the move with no wifi, you can only open files that the Chromebook supports (and that’s if you’ve already downloaded them or they’re on a USB drive) and write Google Docs in the Writer. This means that the ability to turn off the wifi and I’m straight away plunged into a pure writing environment. Even better if I’m in Vim writing LaTeX, as it’s a full screen terminal with nothing else to distract.
As a second computer, laptop or a cheap computer, the Chromebook performs and provides the ability to do what most people need of a portable machine. Teamed up with Chrome Remote Desktop, it makes for a fantastic, lightweight, terminal for a remote server/desktop. Which I’ve got setup for those occasions that I need to access a server remotely and run something that the Chromebook can’t do (LaTeX compiling on my home Mac for example).


Tapmodo
/
Jcrop Plugin
Jcrop Image Cropping Plugin
Jcrop
is the image cropping plugin for
jQuery
.
You've successfully unpacked Jcrop.
Static Demos
Hello World
— default behavior
Basic Handler
— basic form integration
Aspect Ratio w/ Preview Pane
— nice visual example
Animation/Transitions
— animation/fading demo
API Interface
— real-time API example
Styling Example
— style Jcrop dynamically with CSS
New in 0.9.10
Non-Image Elements
— attach to other DOM block elements
New in 0.9.10
Live Demo
PHP Cropping Demo
— requires PHP/gd support
Jcrop Links
Jcrop Home
Jcrop Manual


Iran Marinho
Web Developer Student at
home
.
I am an Web Developer. I love games and coffee.
Profissional Projects
Custom Linux Desktop
Woocommerce Site
Work Experience
Dates
Work
2008-2019
IT Suport at Sesau/AL
Skills
HTML 5
⭐⭐⭐⭐
CSS 3
⭐⭐
Javascript
⭐⭐⭐
NODEJS
⭐⭐
Git/Github
⭐⭐⭐
MongoDB
⭐
My Hobbies
Contact Me


ozpIwc.ApiBase Class
The base class for APIs. Use ozpIwc.createApi to subclass this.
Leader State Management
The base API uses locks.api to always have a single leader at a time. An api instance goes through a linear series of states: member -> loading -> leader
- member does not service requests
- loading is a transitory state between acquiring the leader lock and being ready to serve requests
- leader actively serves requests and broadcasts a death scream upon shutdown
The member state has two substates-- ready and dormant
- ready queues requests in case it has to become leader. switches back to dormant on discovering a leader
- dormant silently drops requests. Upon hearing a deathScream, it switches to ready.
Constructor
ozpIwc.ApiBase
-
config
Parameters:
-
config
Object-
name
StringThe api address (e.g. "names.api")
-
[participant]
ozpIwc.ClientMixin optionalThe connection to use for communication
-
[router=ozpIwc.defaultRouter]
ozpIwc.Router optionalThe router to connect to
-
Item Index
Methods
- addCollector
- addWatcher
- broadcastDeathScream
- broadcastLeaderReady
- changedHandler
- checkAuthorization
- createApi
- createDeathScream
- createdHandler
- createNode
- createNodeObject
- deliverRequestQueue
- disconnectHandler
- enableRequestQueue
- flushRequestQueue
- getCollection
- getPreference
- initializeData
- loadFromEndpoint
- markForChange
- matchingNodes
- receiveBusPacket
- receiveCoordinationPacket
- receivePacketContext
- removeCollector
- removeDeadWatchers
- removeWatcher
- resolveChangedNode
- resolveChangedNodes
- shutdown
- transitionToLeader
- transitionToLoading
- transitionToMemberDormant
- transitionToMemberReady
- updateCollectionNode
- updateCollections
- useDefaultRoute static
Properties
- allActions static
- defaultHandler static
- packetContext
- packetContext
Methods
addCollector
-
node
Adds the given node to the collector list. It's collection list will be updated on api data changes.
Parameters:
-
node
Object
addWatcher
-
resource
-
watcher
Marks that a node has changed and that change notices may need to be sent out after the request completes.
Parameters:
-
resource
Stringname of the resource to watch
-
watcher
Object-
resource
Stringname of the resource to watch
-
src
StringAddress of the watcher
-
replyTo
String | NumberThe conversation id that change notices will go to
-
broadcastDeathScream
-
deathScream
Broadcasts to other instances of this API on the bus this APIs state.
Parameters:
-
deathScream
Objectthe state data to pass on.
broadcastLeaderReady
()
Broadcasts to other instances of this API on the bus that it is ready to lead.
changedHandler
-
node
-
entity
-
packetContext
A handler function called after a node is changed but before it's watchers are notified.
Parameters:
-
node
Object -
entity
Object -
packetContext
Object
checkAuthorization
-
node
-
context
-
packet
-
action
Authorize the request for the given node.
Parameters:
-
node
ozpIwc.ApiNode -
context
Object -
packet
ozpIwc.TransportPacket -
action
String
Returns:
createApi
-
init
Creates a subclass of ApiBase and adds some static helper functions.
Parameters:
-
init
Functionthe constructor function for the class
Returns:
A new API class that inherits from the ApiBase class.
createDeathScream
()
Object
Create the data that needs to be handed off to the new leader.
Intended to be overridden by subclasses
Subsclasses can override this if they need to add additional handoff data. This MUST be a synchronous call that returns immediately.
Returns:
the data that will be passed to the new leader
createdHandler
-
node
A handler function for when a node is created. Can be overridden by inherited APIs.
Parameters:
-
node
Object
createNode
-
config
Creates a node appropriate for the given config, puts it into this.data, and fires off the right events.
Parameters:
-
config
ObjectThe ApiNode configuration.
Returns:
createNodeObject
-
config
-
NodeType
Creates a node appropriate for the given config. This does NOT add the node to this.data. Default implementation returns a plain ozpIwc.ApiNode.
Intended to be overridden by subclasses
Subsclasses can override this for custom node types that may vary from resource to resource.
Parameters:
-
config
ObjectThe ApiNode configuration.
-
NodeType
FunctionThe contructor call for the given node type to be created.
Returns:
deliverRequestQueue
()
private
Routes all queued packets and turns off request queueing.
disconnectHandler
-
address
A handler function called when an instance of this API has disconnected from the bus.
Parameters:
-
address
String
enableRequestQueue
()
private
Enables the API's request queue, all requests will be held until deliverRequestQueue or flushRequestQueue is called.
flushRequestQueue
()
private
Empties the queue of requests without processing and turns off queuing.
getCollection
-
pattern
Gathers the collection data for a node given its pattern only if it has a pattern.
Parameters:
-
pattern
String
Returns:
getPreference
-
prefName
Gathers the desired preference from the data API.
Parameters:
-
prefName
String
Returns:
initializeData
-
deathScream
Called when the API has become the leader, but before it starts serving data. Receives the deathScream of the previous leader if available, otherwise undefined.
Intended to be overridden by subclasses
Subsclasses can override this to load data from the server.
Parameters:
-
deathScream
Object
Returns:
a promise that resolves when all data is loaded.
loadFromEndpoint
-
endpoint
-
headers
Loads data from the provided endpoint. The endpoint must point to a HAL JSON document that embeds or links to all resources for this api.
Parameters:
-
endpoint
ozpIwc.Endpoint -
headers
Array
Returns:
resolved when all data has been loaded.
markForChange
-
nodes...
Marks that a node has changed and that change notices may need to be sent out after the request completes.
Parameters:
-
nodes...
ApiNode
matchingNodes
-
prefix
Returns a list of nodes that start with the given prefix.
Parameters:
-
prefix
String
Returns:
a promise that resolves when all data is loaded.
receiveBusPacket
-
packetContext
Handles packets received with a destination of "$bus.multicast".
Parameters:
-
packetContext
Object
Returns:
receiveCoordinationPacket
-
packetContext
Handles packets received regarding leadership actions.
Parameters:
-
packetContext
Object
Returns:
receivePacketContext
-
packet
-
context
Any request packet that does not match a route ends up here. By default, it replies with BadAction, BadResource, or BadRequest, as appropriate.
Parameters:
-
packet
ozpIwc.TransportPacket -
context
ozpIwc.TransportPacketContext
removeCollector
-
node
Removes the given node from the collector list. It's collection list will no longer be updated on api data changes.
Parameters:
-
node
Object
removeDeadWatchers
-
address
If the the given address is watching a resource, it will be removed from the watch list. Router addresses will remove all of its participants watch registrations.
Parameters:
-
address
String
removeWatcher
-
resource
-
watcher
Removes mark that a node has changed and that change notices may need to be sent out after the request completes.
Parameters:
-
resource
Stringname of the resource to unwatch
-
watcher
Object-
src
StringAddress of the watcher
-
replyTo
String | NumberThe conversation id that change notices will go to
-
resolveChangedNode
-
resource
-
snapshot
-
packetContext
Notifies watchers of changes of the resource since the given snapshot.
Parameters:
-
resource
String -
snapshot
Object -
packetContext
Object
resolveChangedNodes
-
packetContext
Called after the request is complete to send out change notices.
Parameters:
-
packetContext
Objectthe packet that caused this change.
shutdown
()
Shuts down the api, issuing a deathscream and releasing the lock, if possible.
Returns:
transitionToLeader
()
private
transitionToLoading
()
Promise
private
Returns:
a promise that resolves when all data is loaded.
transitionToMemberDormant
()
Promise
private
Returns:
transitionToMemberReady
-
deathScream
Parameters:
-
deathScream
Object
Returns:
updateCollectionNode
-
cNode
Removes the collector node resource from the collectors list if deleted. Removes references to nodes in the given collectors collection property if said referenced node is deleted. Adds newly created nodes to the collection property if said node's resource matches the collection nodes pattern property.
Parameters:
-
cNode
Objectthe collector node to update
updateCollections
()
Itterates over all collectors of the API for updates
useDefaultRoute
-
actions
-
resource="{resource:.*}"
Install the default handler and filters for the provided actions and resources.
Parameters:
-
actions
String | String -
resource="{resource:.*}"
StringThe resource template to install the default handler on.
Properties
allActions
String
static
A list of all of the default actions.
defaultHandler
Object
static
A collection of default action handlers for an API.
packetContext
Object
private
Routes a packet received from the participant.
packetContext
Object
private
Routes a request to the proper handler and takes care of overhead such as change requests.


No longer perceiving the world as nature intended, watching the world from a god’s point of perspective becoming part of everyone. A world where we view ourselves from game characters perspective, from seeing our needs to that of advertisements that relate to those needs. Life would be more convenient and less stressful as helpful indicators would be there at all times, crime would be near non-existent as everything is watched.
What does it mean to be a watcher?
Even more about the watcher
What does being a watcher entail
Sign up now, be part of the game
Try our collection of fun activities
We have helpful systems in place


 That secure job would be a 9-to-5 job of some sort. When you get home from work every day, you eat dinner, maybe go to the gym, and you hang out with friends. That’s just kind of what everybody does down there. On top of growing up with the usual Southern traditions, I was a total math nerd. I was extremely left-brained and barely knew what a feeling was. I continued to get further trained in expanding my left brain when I became a pilot and got my degree in engineering. As if I wasn’t already enough of a control freak, I chose career paths that only trained me how to be that much more of a control freak.
So I did the process—go to school, get good grades, and get the secure job—except when I walked into my new cubicle after landing a fairly prestigious job as a Top Secret Aerospace Engineer, I felt my soul get completely sucked out through my toes. At the same time I watched my soul leave my body, I looked down at my body and gawked at the atrocious business casual outfit I was wearing. I knew in that moment that I had to find a way out. I couldn’t do the cubicle life, especially one that had bosses.
I knew I needed out before I ever sat down at my new desk.


Cookies Store
Add Sales Data
add new Branch
Branch Name
Minimum Order
Maximum Order
Avrege Order
Sales Table
Home
Salees
Slaes of Cookies Stand branchs


The template class of the matrix. It is final and implements Curiously Recurring Templates Pattern. These matrices have immutable dimension and shapes will not change once created.
More...
|
| auto | get (size_t i, size_t j) const |
| | returns element at i, j position in the matrix. More...
|
| |
| auto & | get (size_t i, size_t j) |
| | returns element at i, j position in the matrix by reference. It can be used to assign values to i,j as well. More...
|
| |
| auto | get (size_t i) const |
| | Returns the value from the ith position in flat array. More...
|
| |
| auto & | get (size_t i) |
| | Returns the value from the ith position in flat array by reference. More...
|
| |
| auto | get_dimension () const |
| | Get the dimension of the matrix. More...
|
| |
| auto | get_format () const |
| | Get the format policy object.   More...
|
| |
| template<typename E > |
| | matrix (expression< E > const &expr) |
| | Construct a new matrix object from an expression type. The Expression will be evaluated to initialize the new variable. More...
|
| |
| template<typename E > |
| | matrix (expression< E > &&expr) |
| | Construct a new matrix object from an rvalue expression. More...
|
| |
| template<typename E > |
| auto & | operator= (expression< E > const &expr) |
| | Assignment from an expression will cause the expression to be evaluated. More...
|
| |
| template<typename E > |
| auto & | operator= (expression< E > &&expr) |
| | Assignment from an expression will cause the expression to be evaluated. It evaluates the lvalue and swaps with this. More...
|
| |
| auto & | operator= (matrix const &other) |
| | Assignment from other Matrix Variable. More...
|
| |
| matrix & | operator= (matrix &&other) |
| | Assignment from other Matrix Variable. More...
|
| |
| template<typename E > |
| matrix & | operator+= (expression< E > const &expr) |
| | Add and Assignment overload with expression. It will cause expression to be evaluated. More...
|
| |
| template<typename E > |
| matrix & | operator-= (expression< E > const &expr) |
| | Subtract and Assignment overload with expression. It will cause expression to be evaluated. More...
|
| |
| template<typename E > |
| matrix & | operator*= (expression< E > const &expr) |
| | Multiply and Assignment overload with expression. It will cause expression to be evaluated. More...
|
| |
| template<typename E > |
| matrix & | operator/= (expression< E > const &expr) |
| | Division and Assignment overload with expression. It will cause expression to be evaluated. More...
|
| |
| template<typename T > |
| void | scalar_add (T t) |
| | Scaler Addition to all the elements in the matrix. Type must have an overload with + operator to dtype of matrix. More...
|
| |
| template<typename T > |
| void | scalar_sub (int t) |
| | Scaler subtraction to all the elements in the matrix. Type must have an overload with - operator to dtype of matrix. More...
|
| |
| template<typename T > |
| void | scalar_mul (T t) |
| | Scaler Multiplication to all the elements in the matrix. Type must have an overload with * operator to dtype of matrix. More...
|
| |
| void | view (std::ostream &stream=std::cout) |
| | Prints the content of a matrix to the stream. Default to std::cout. More...
|
| |
| auto | get (size_t i) const |
| | returns the expression at i More...
|
| |
| auto | get_dimension () const |
| | Get the dimension of expression object. More...
|
| |
| auto | get_format () const |
| | Get the format object. More...
|
| |
template<typename value_t, class format_t = policy::RowMajorPolicy<value_t>, class storage_t = std::vector<value_t>>
class test::matrix< value_t, format_t, storage_t >
The template class of the matrix. It is final and implements Curiously Recurring Templates Pattern. These matrices have immutable dimension and shapes will not change once created.
- Template Parameters
-
| dtype | the type that this matrix will hold. |


Is used to add, update, or delete line items in a Cart .
More...
|
| void | AddOrUpdate (string variantId, long? quantity=null, List< AttributeInput > customAttributes=null) |
| | Adds or updates an existing line item using a variant id. More...
|
| |
| void | AddOrUpdate (ProductVariant variant, long? quantity=null, List< AttributeInput > customAttributes=null) |
| | Adds or updates a line item using a ProductVariant . More...
|
| |
| void | AddOrUpdate (Product product, Dictionary< string, string > selectedOptions, long? quantity=null, List< AttributeInput > customAttributes=null) |
| | Adds a new line item using a Product and selected options. If an existing line item exists for the variant id, then that line item will be updated. More...
|
| |
| List< CheckoutLineItemInput > | All () |
| | Returns all Line Items that have been created. More...
|
| |
| CheckoutLineItemInput | Get (string variantId) |
| | Returns one Line Item based on a variant id. If no line item exists for the variant id null will be returned. More...
|
| |
| CheckoutLineItemInput | Get (ProductVariant variant) |
| | Returns one Line Item based on a ProductVariant . If no line item exists for the variant, null will be returned. More...
|
| |
| CheckoutLineItemInput | Get (Product product, Dictionary< string, string > selectedOptions) |
| | Returns one Line Item based on a product and selected options. If no line item exists for the matching variant, null will be returned. More...
|
| |
| bool | Delete (string variantId) |
| | Deletes one Line Item based on a variant id. If a line item was deleted, true will be returned. If no line items were deleted, false will be returned. More...
|
| |
| bool | Delete (ProductVariant variant) |
| | Deletes one Line Item based on a ProductVariant . If a line item was deleted, true will be returned. If no line items were deleted, false will be returned. More...
|
| |
| bool | Delete (Product product, Dictionary< string, string > selectedOptions) |
| | Deletes one Line Item based on a Product and selected options. If a line item was deleted, true will be returned. If no line item was deleted, false will be returned. More...
|
| |
Is used to add, update, or delete line items in a Cart
.
◆ AddOrUpdate() [1/3]
| void Shopify.Unity.CartLineItems.AddOrUpdate |
( |
string |
variantId, |
|
|
long? |
quantity = null , |
|
|
List< AttributeInput > |
customAttributes = null |
|
) |
| |
|
inline |
Adds or updates an existing line item using a variant id.
- Parameters
-
| variantId | variant id for a ProductVariant |
| quantity | the number of items you'd like to order for variantId |
| customAttributes | can be used to define extra information for this line item |
Cart cart = ShopifyBuy.Client().Cart();
cart.LineItems.AddOrUpdate(variantId, 3);
◆ AddOrUpdate() [2/3]
| void Shopify.Unity.CartLineItems.AddOrUpdate |
( |
ProductVariant |
variant, |
|
|
long? |
quantity = null , |
|
|
List< AttributeInput > |
customAttributes = null |
|
) |
| |
|
inline |
Adds or updates a line item using a ProductVariant .
- Parameters
-
| variant | ProductVariant whose id will be used to create or update a line item |
| quantity | the number of items you'd like to order for variantId |
| customAttributes | can be used to define extra information for this line item |
Cart cart = ShopifyBuy.Client().Cart();
cart.LineItems.AddOrUpdate(variant, 3);
◆ AddOrUpdate() [3/3]
| void Shopify.Unity.CartLineItems.AddOrUpdate |
( |
Product |
product, |
|
|
Dictionary< string, string > |
selectedOptions, |
|
|
long? |
quantity = null , |
|
|
List< AttributeInput > |
customAttributes = null |
|
) |
| |
|
inline |
Adds a new line item using a Product and selected options. If an existing line item exists for the variant id, then that line item will be updated.
- Parameters
-
| product | product to check selected options against |
| selectedOptions | a Dictionary used to define user selected options |
| quantity | the number of items you'd like to order for variantId |
| customAttributes | customAttributes can be used to define extra information for this line item |
Throws when no matching variant could be found for selected options in product
Cart cart = ShopifyBuy.Client().Cart();
Dictionary<string, string> selectedOptions = new Dictionary<string, string>() {
{"Size", "Small"},
{"Color", "Red"}
};
cart.LineItems.AddOrUpdate(product, selectedOptions, 3);
◆ All()
Returns all Line Items that have been created.
Cart cart = ShopifyBuy.Client().Cart();
Debug.Log("The cart has " + cart.LineItems.All().Count + " line items");
◆ Delete() [1/3]
| bool Shopify.Unity.CartLineItems.Delete |
( |
string |
variantId | ) |
|
|
inline |
Deletes one Line Item based on a variant id. If a line item was deleted, true
will be returned. If no line items were deleted, false
will be returned.
- Parameters
-
| variantId | variant id used to delete a line item |
Cart cart = ShopifyBuy.Client().Cart();
Debug.Log("Did delete? " + cart.LineItems.Delete(variantId));
◆ Delete() [2/3]
Deletes one Line Item based on a ProductVariant . If a line item was deleted, true
will be returned. If no line items were deleted, false
will be returned.
- Parameters
-
| variant | variant to provide the ID to delete a line item |
Cart cart = ShopifyBuy.Client().Cart();
Debug.Log("Did delete? " + cart.LineItems.Delete(variant));
◆ Delete() [3/3]
| bool Shopify.Unity.CartLineItems.Delete |
( |
Product |
product, |
|
|
Dictionary< string, string > |
selectedOptions |
|
) |
| |
|
inline |
Deletes one Line Item based on a Product and selected options. If a line item was deleted, true
will be returned. If no line item was deleted, false
will be returned.
- Parameters
-
| product | product whose options will be used to determine which line item is deleted |
| selectedOptions | a Dictionary used to define user selected options |
Cart cart = ShopifyBuy.Client().Cart();
Dictionary<string, string> selectedOptions = new Dictionary<string, string>() {
{"Size", "Small"},
{"Color", "Red"}
};
Debug.Log("Did delete? " + cart.LineItems.Delete(product, selectedOptions));
◆ Get() [1/3]
Returns one Line Item based on a variant id. If no line item exists for the variant id null
will be returned.
- Parameters
-
| variantId | variant id used to create a line item |
Cart cart = ShopifyBuy.Client().Cart();
Debug.Log(cart.LineItems.Get(variantId).quantity);
◆ Get() [2/3]
Returns one Line Item based on a ProductVariant . If no line item exists for the variant, null
will be returned.
- Parameters
-
| variant | variant whose variant id used to create a line item |
Cart cart = ShopifyBuy.Client().Cart();
Debug.Log(cart.LineItems.Get(variant).quantity);
◆ Get() [3/3]
Returns one Line Item based on a product and selected options. If no line item exists for the matching variant, null
will be returned.
- Parameters
-
| product | product whose options will be selected |
| selectedOptions | a Dictionary used to define user selected options |
Cart cart = ShopifyBuy.Client().Cart();
Dictionary<string, string> selectedOptions = new Dictionary<string, string>() {
{"Size", "Small"},
{"Color", "Red"}
};
Debug.Log(cart.LineItems.Get(product, selectedOptions).quantity);
The documentation for this class was generated from the following file:
- Assets/Shopify/Unity/Cart.cs


if (this.canUpdate()) window.UC_X++;
this.super();
if (this.canUpdate()) window.UC_Y++;
this.super();
assert.equal(0, this.inner.x);
assert.equal(0, this.inner.y);
assert.equal('#cccccc', this.inner.bgcolor);
assert.equal(10, this.v1.x);
assert.equal(10, this.v1.y);
assert.equal('#00ff00', this.v1.bgcolor);
assert.equal(0, this.v2.x);
assert.equal(10, this.v2.y);
assert.equal('#00ff00', this.v2.bgcolor);
assert.equal(10, this.v3.x);
assert.equal(0, this.v3.y);
assert.equal('#00ff00', this.v3.bgcolor);
assert.equal(0, this.v4.x);
assert.equal(10, this.v4.y);
assert.equal('#ff0000', this.v4.bgcolor);
// Verify changing ignorelayout notifies the correct layouts.
assert.equal(2, this.layoutX.subviews.length, '2 subview are managed for layoutX.');
assert.equal(3, this.layoutY.subviews.length, '3 subview are managed for layoutY.');
assert.equal(3, this.layoutBgcolor.subviews.length, '3 subview are managed for layoutBgcolor.');
this.v4.setAttribute('ignorelayout', true);
assert.equal(2, this.layoutX.subviews.length, '2 subview are managed for layoutX.');
assert.equal(2, this.layoutY.subviews.length, '2 subview are managed for layoutY.');
assert.equal(3, this.layoutBgcolor.subviews.length, '3 subview are managed for layoutBgcolor.');
this.v4.setAttribute('ignorelayout', '{"*":true, "layoutY":false}');
assert.equal(2, this.layoutX.subviews.length, '2 subview are managed for layoutX.');
assert.equal(3, this.layoutY.subviews.length, '3 subview are managed for layoutY.');
assert.equal(3, this.layoutBgcolor.subviews.length, '3 subview are managed for layoutBgcolor.');
var container = this.container,
layoutX = container.layoutX,
layoutY = container.layoutY,
layoutBgcolor = container.layoutBgcolor,
v1 = container.v1,
v2 = container.v2,
v3 = container.v3,
v4 = container.v4;
// Verify update was only called once
assert.equal(1, UC_X, 'The early declaration layout was only updated once.');
assert.equal(1, UC_Y, 'The late declaration layout was only updated once.');
assert.equal(10, this.container2.inner.v1.x, 'First view should have an x value of 10');
assert.equal(5, this.container2.inner.v1.y, 'First view should have a y value of 5');
// Test ignorelayout gets set with the correct type.
assert.equal(false, v1.ignorelayout, 'The ignorelayout attribute should default to boolean false.');
assert.equal(true, v3.ignorelayout, 'Third view should have ignorelayout equal to boolean true.');
assert.equal(false, v4.ignorelayout, 'Fourth view should have ignorelayout equal to boolean false.');
// Test ignore method
assert.equal(false, layoutX.ignore(v1), 'Calling the ignore method should be false for a view with the default ignorelayout.');
assert.equal(true, layoutX.ignore(v3), 'Calling the ignore method should be true for a view with ignorelayout:true.');
assert.equal(false, layoutX.ignore(v4), 'Calling the ignore method should be false for a view with ignorelayout:false.');
// Test initial update
assert.equal(10, v1.x, 'First view should have an x value of 10');
assert.equal(10, v2.x, 'Second view should have an x value of 10');
assert.equal(0, v3.x, 'Third view, with ignorelayout true, should not be updated.');
assert.equal(10, v4.x, 'Fourth view should have an x value of 10');
assert.equal(5, v1.y, 'Each view should have an y value of 5');
assert.equal(5, v2.y, 'Each view should have an y value of 5');
assert.equal(0, v3.y, 'Views with ignorelayout true should not be updated.');
assert.equal(5, v4.y, 'Each view should have an y value of 5');
// Test that layouts are stored in a layouts array on their parent node.
assert.equal(3, container.layouts.length, 'Two layouts should exist.');
// Test that layout locked values are set
assert.equal(false, layoutX.locked, 'By default layouts are not locked.');
assert.equal(true, layoutBgcolor.locked, 'The locked attribute is a boolean.');
// Test that the managed views are stored in a subviews array on the layout.
assert.equal(3, layoutX.subviews.length, 'Three views should be managed.');
assert.equal(3, layoutY.subviews.length, 'Three views should be managed.');
assert.equal(3, layoutBgcolor.subviews.length, 'Three views should be managed.');
// Test changing ignorelayout to true removes a managed view
v4.setAttribute('ignorelayout', true);
assert.equal(2, layoutX.subviews.length, 'Two views should be managed.');
assert.equal(2, layoutY.subviews.length, 'Two views should be managed.');
assert.equal(2, layoutBgcolor.subviews.length, 'Two views should be managed.');
// Test updating the layout value gets applied to the managed views
layoutX.setAttribute('value', 7);
assert.equal(7, v1.x, 'First view should have an x value of 7');
assert.equal(7, v2.x, 'Second view should have an x value of 7');
assert.equal(0, v3.x, 'Third view should have an x value of 0 since it was never managed.');
assert.equal(10, v4.x, 'Fourth view should have an x value of 10 since it is no longer managed');
// Test changing ignorelayout to false and/or back to false adds a managed view
v3.setAttribute('ignorelayout', false);
v4.setAttribute('ignorelayout', false);
assert.equal(4, layoutX.subviews.length, 'Four views should be managed.');
assert.equal(4, layoutY.subviews.length, 'Four views should be managed.');
assert.equal(4, layoutBgcolor.subviews.length, 'Four views should be managed.');
assert.equal(7, v3.x, 'Third view should now have an x value of 7.');
assert.equal(7, v4.x, 'Fourth view should now have an x value of 7.');
assert.equal(5, v3.y, 'Third view should now have a y value of 5.');
// Destroying a view should unmanage it
v4.destroy();
assert.equal(3, layoutX.subviews.length, 'Three views should be managed.');
assert.equal(3, layoutY.subviews.length, 'Three views should be managed.');
assert.equal(3, layoutBgcolor.subviews.length, 'Three views should be managed.');
// Creating a view should manage it
var v5 = this.createChild({class: 'item', parent:container, name:'v5'});
assert.equal(4, layoutX.subviews.length, 'Four views should be managed.');
assert.equal(4, layoutY.subviews.length, 'Four views should be managed.');
assert.equal(4, layoutBgcolor.subviews.length, 'Four views should be managed.');
assert.equal(7, v5.x, 'Fifth view should now have an x value of 7.');
assert.equal(5, v5.y, 'Fifth view should now have a y value of 5.');
// Creating a view with ignorelayout:true should leave it unmanaged
var v6 = this.createChild({class: 'item', parent:container, name:'v6', ignorelayout:true});
assert.equal(4, layoutX.subviews.length, 'Four views should be managed.');
assert.equal(4, layoutY.subviews.length, 'Four views should be managed.');
assert.equal(4, layoutBgcolor.subviews.length, 'Four views should be managed.');
assert.equal(0, v6.x, 'Sixth view should now have an x value of 0 since it is unmanaged.');
assert.equal(0, v6.y, 'Sixth view should now have a y value of 0 since it is unmanaged.');
// Destroying a layout should work
layoutY.destroy();
assert.equal(2, container.layouts.length, 'One layouts should exist.');
v6.setAttribute('ignorelayout', false);
assert.equal(5, layoutX.subviews.length, 'Five views should be managed.');
assert.equal(7, v6.x, 'Sixth view should now have an x value of 7 since it is managed.');
assert.equal(0, v6.y, 'Sixth view should still have a y of 0 since there is no layout to manage it.');
// Changing the attribute of a layout should work
assert.equal(50, v1.width, 'First view should have a width of 50.');
assert.equal(50, v2.width, 'Second view should have a width of 50.');
assert.equal(50, v3.width, 'Third view should have a width of 50.');
assert.equal(50, v5.width, 'Fourth view should have a width of 50.');
assert.equal(50, v6.width, 'Sixth view should have a width of 50.');
layoutX.setAttribute('attribute', 'width');
assert.equal(7, v1.width, 'First view should have a width of 7.');
assert.equal(7, v2.width, 'Second view should have a width of 7.');
assert.equal(7, v3.width, 'Third view should have a width of 7.');
assert.equal(7, v5.width, 'Fourth view should have a width of 7.');
assert.equal(7, v6.width, 'Sixth view should have a width of 7.');
// Changing the value of the layout should only update the current attribute
layoutX.setAttribute('value', 25);
assert.equal(7, v1.x, 'First view should have an x of 7.');
assert.equal(7, v2.x, 'Second view should have an x of 7.');
assert.equal(7, v3.x, 'Third view should have an x of 7.');
assert.equal(7, v5.x, 'Fourth view should have an x of 7.');
assert.equal(7, v6.x, 'Sixth view should have an x of 7.');
assert.equal(25, v1.width, 'First view should have a width of 25.');
assert.equal(25, v2.width, 'Second view should have a width of 25.');
assert.equal(25, v3.width, 'Third view should have a width of 25.');
assert.equal(25, v5.width, 'Fourth view should have a width of 25.');
assert.equal(25, v6.width, 'Sixth view should have a width of 25.');
// Adding a new layout should work
assert.equal(10, v1.height, 'First view should have a height of 10.');
assert.equal(10, v2.height, 'Second view should have a height of 10.');
assert.equal(10, v3.height, 'Third view should have a height of 10.');
assert.equal(10, v5.height, 'Fourth view should have a height of 10.');
assert.equal(10, v6.height, 'Sixth view should have a height of 10.');
var layoutH = this.createChild({class: 'constantlayout', parent:container, name:'layoutH', attribute:'height', value:8});
assert.equal(3, container.layouts.length, 'Two layouts should exist.');
assert.equal(5, layoutH.subviews.length, 'Five views should be managed.');
assert.equal(8, v1.height, 'First view should have a width of 8.');
assert.equal(8, v2.height, 'Second view should have a width of 8.');
assert.equal(8, v3.height, 'Third view should have a width of 8.');
assert.equal(8, v5.height, 'Fourth view should have a width of 8.');
assert.equal(8, v6.height, 'Sixth view should have a width of 8.');
// Calling update on a locked layout should not update
assert.equal(false, layoutBgcolor.canUpdate(), 'The canUpdate method should return false.');
assert.equal('#666666', v1.bgcolor, 'First view should have a bgcolor of #666666.');
layoutBgcolor.update();
assert.equal('#666666', v1.bgcolor, 'First view should have a bgcolor of #666666.');
// Unlocking a layout should update
layoutBgcolor.setAttribute('locked', false);
assert.equal(true, layoutBgcolor.canUpdate(), 'The canUpdate method should return true.');
assert.equal(false, layoutBgcolor.locked, 'Layout should now be unlocked.');
assert.equal('#00ff00', v1.bgcolor, 'First view should have a bgcolor of #00ff00.');