Boundary conditions¶
Boundary conditions are imposed each time step by filling ghost cells adjacent to the edge of each grid patch. See Chapter 4 of [LeVeque-FVMHP] for more details.
Boundary conditions are set by the library routines:
- $CLAW/classic/src/Nd/bcN.f for the classic code (N = 1, 2, 3).
- $CLAW/amrclaw/src/Nd/bcNamr.f for the amrclaw code (N = 2, 3).
Several standard choices of boundary condition procedures are provided in these routines, and can be selected at each boundary by setting the input parameters bc_lower and bc_upper in each dimension (see Specifying classic run-time parameters in setrun.py) to one of the following:
1 or ‘extrap’ : extrapolation (non-reflecting outflow)
In this case values from the grid cell adjacent to the boundary are copied into all ghost cells moving in the direction normal to the boundary. This gives a fairly good approximation to a non-reflecting or outgoing boundary condition that lets waves pass out of the boundary without reflection, particularly in one space dimension. In more than one direction this is not perfect for waves that hit the boundary at an oblique angle.
2 or ‘periodic’ : periodic boundary conditions
In this case ghost cell values are set by copying from interior cells at the opposite boundary so that periodic boundary conditions are perfectly imposed. Normally periodic boundary conditions would be imposed by setting this value for both bc_lower and bc_upper in some dimension, but this is not required.
3 or ‘wall’ : solid wall boundary conditions are imposed for systems where the second component of q is the x velocity or momentum in one dimension (and where the third component of q is also the y velocity/momentum in more dimensions, etc.) This is true, for example, if the acoustics equations are solved with components q = (p, u, v) or shallow water equations with q = (h, hu, hv).
In this case the normal velocity/momentum at a wall is reflected about the boundary (copied to a ghost cell from the cell equally far from the boundary on the interior side) while all other components are extrapolated.
Reflecting boundary conditions can also often be used on a line of symmetry of a solution in order to reduce the computational domain to be only half of the physical domain.
Note that this option does not work on a mapped grid... Add pointer to modified version
If none of the above boundary conditions are desired, the user can modify the subroutine bcN so that setting the appropriate component of bc_lower or bc_upper to 0 will execute code added by the user. In this case it is best to put the modified version of bcN.f in the application directory and modify the Makefile to point to the modified version. See User-defined boundary conditions below.
Boundary conditions for adaptive refinement¶
When AMR is used, any interior patch edges (not at a domain boundary) are filled automatically each time step, either by copying from adjacent patches at the same level or by interpolating (in both space and time) from coarser levels if needed.
The user must still specify boundary conditions at the edges of the computational domain. The same set of choices for standard boundary conditions as described above are implemented in the library routine bcNamr.f, and so specifying these boundary conditions requires no change to setrun.py when going from Classic Clawpack to AMRClaw. However, if special boundary conditions have been implemented in a custom version of bcN.f then the same procedure for setting ghost cells will have to be implemented in a custom version of bcNamr.f. This routine is slightly more complicated than the single-grid Classic version, since one must always check whether each ghost cell lies outside the computational domain (in which case the custom boundary condition procedure must be applied) or lies within the domain (in which case ghost cell values are automatically set by the AMR code and the user bcNamr routine should leave these values alone.
Boundary conditions for GeoClaw¶
For tsunami modeling or other geophysical flows over topography the computational domain has artificial boundaries that are placed sufficiently far from the region of interest that any flow or waves leaving the domain can be ignored and there should be no incoming waves. Extrapolation boundary conditions are then appropriate. If the ocean is truncated at some point then these generally have been found to give very small spurious reflection of outgoing tsunami waves. Extroplation boundary conditions can also be used on dry land (where the depth h is zero).
In some cases reflecting boundary conditions might be more appropriate, e.g. along the walls of a wave tank.
The library routine $CLAW/geoclaw/src/2d/shallow/bc2amr.f is modified from the amrclaw version only by extrapolating the depth at the boundaries into ghost cells.
Boundary conditions for clamshell grids on the sphere¶
In 2D AMRClaw and GeoClaw, an additional option is available for bc_lower and bc_upper that is implemented in the library routines:
4 or ‘sphere’ : sphere boundary conditions
Must set bc_lower[0:2] = bc_upper[0:2] = 4 (i.e. at all 4 boundaries)
These boundary conditions are similar to periodic boundary conditions, but for the clamshell grid introduced in [CalhounHelzelLeVeque] for solving problems on the sphere using a single logically rectangular grid. This is best envisioned by folding a rectangular piece of paper in half, gluing the edges together, and inflating to a sphere. See the animations on the website for the original paper See also [BergerCalhounHelzelLeVeque] for further examples.
User-defined boundary conditions¶
If none of the boundary conditions described above is suitable at one or more boundaries of the domain, then you will have to modify the library routine to implement the desired boundary condition. See Chapter 4 of [LeVeque-FVMHP] for hints on how to specify the ghost cell values each time step.
Suppose you need to specify different boundary conditions at the boundary xlower, for example. Then in setrun.py you should set bc_lower[0] = 0 and modify the library boundary condition routine to insert your desired boundary conditions at the point indicated in the code, where it says:
c # user-specified boundary conditions go here in place of error output
in the section marked left boundary. The details of how this is done differ a bit between the classic and AMR codes and also depend on the number of space dimensions. Examine the way other boundary conditions are implemented and follow the model in your own code.
TODO: Give some hints on how things work in AMR code – must check which ghost cells extend outside the physical domain and which are filled automatically from adjacent grid patches or by interpolation from coarser patches if they are interior to the domain.


This tests that pausing on (uncaught) exceptions properly leaves the Wasm frames in an inspectable state in the DevTools. This is important, as pause on exception usually becomes important when it's hard to reproduce the problem, and so re-running with additional debugging is usually non-trivial.
foo
on top of the stack, called from Wasm function bar
bar
in the Call Stack and try to inspect the parameter value


Biography
Hello! My name is Andrew Kyllo. I graduated with a BS in Physics from the university of Washington in 2012. My father is a highschool science and math teacher so I have a strong background in the sciences. For the last 8 years I worked as a service advisor at an Audi dealership. This was one of the most draining jobs I've had as i worked around 55 hours a week in a fast paced and high stress environment. I lived in Japan for 5 years of my younger life which provided me with a very unique and open minded approach to life. In my free time I enjoy snowboarding, hanging out with friends, and attending music festivals. In going through the Code Fellows curriculum I hope to gain the tools to join the tech workforce as a software engineer and be challenged on a daily basis.


Apollo Expeditions to the Moon
CHAPTER 11.5
THE BOY IN THE CANDY STORE
ARMSTRONG: There were a lot of things to do, and we had a
hard time getting, them finished. We had very little trouble,
much less trouble than expected, on the surface. It was a
pleasant operation. Temperatures weren't high. They were very
comfortable. The little EMU, the combination of spacesuit and
backpack that sustained our life on the surface, operated
magnificently. The primary difficulty was just far too little
time to do the variety of things we would have liked. We had the
problem of the five-year-old boy in a candy store.
ALDRIN: I took off jogging to test my maneuverability. The
exercise gave me an odd sensation and looked even more odd when I
later saw the films of it. With bulky suits on, we seemed to be
moving in slow motion. I noticed immediately that my inertia
seemed much greater. Earth-bound, I would have stopped my run in
just one step, but I had to use three of four steps to sort of
wind down. My Earth weight, with the big backpack and heavy suit,
was 360 pounds. On the Moon I weighed only 60 pounds.
At one point I remarked that the surface was "Beautiful,
beautiful. Magnificent desolation." I was struck by the contrast
between the starkness of the shadows and the desert-like
barrenness of the rest of the surface. It ranged from dusty gray
to light tan and was unchanging except for one startling sight:
our LM sitting there with its black, silver, and bright yellow-
orange thermal coating shining brightly in the otherwise
colorless landscape. I had seen Neil in his suit thousands of
times before, but on the Moon the unnatural whiteness of it
seemed unusually brilliant. We could also look around and see the
Earth, which, though much larger than the Moon the Earth was
seeing, seemed small - a beckoning oasis shining far away in the
sky.
As the sequence of lunar operations evolved, Neil had the
camera most of the time, and the majority of pictures taken on
the Moon that include an astronaut are of me. It wasn't until we
were back on Earth and in the Lunar Receiving Laboratory looking
over the pictures that we realized there were few pictures of
Neil. My fault perhaps, but we had never simulated this in our
training.


---
layout: post
title: You Should Come See Me Demo at @Siggraph
published: true
---
Come see me demo some Computer Vision and Kinect hacking with the
Vancouver Hackspace this week at
Siggraph 2011. Why? Because it's going to be awesome. There will also be free soldering and 3d printing workshops as well.


Slate
Mother Jones
The New Yorker
MSNBC
The Guardian
NPR
Colbert Report
Al Jazeera America
The New York Times
PBS
BBC
Buzzfeed
HuffPost / The Huffington Post
Washington Post
The Economist
Politico
Reuters
Associated Press
CNN
NBC
USA Today
ABC News
CBS News
Google News
Wall Street Journal
Fox News
The Weekly Standard
National Review
Drudge Report
The Rush Limbaugh Show
TheBlaze
The Sean Hannity Show
Glenn Beck Program
Breitbart


Introduction
Gordon Stevens
Gordon Stevens is a Canadian based in Toronto, Canada and the Greater Toronto Area. With over a decade of work experience in business, software development, information technology, security, education, and postgraduate research Gordon has an excellent mix of experiences in several industries with a focus on building profitability and corporate sustainability through corporate social responsibility and effective leadership.
Education is an excellent way to build a foundation for experience, and Gordon actively pursues it. Previously, Gordon's education included education in Chemical Technology, Software Development, Business Administration, International Business, Import and Export Business, International Trade Specialization, and Supply Chain Management/Global Logistics.
Gordon is currently pursuing masters degrees in Business Leadership and Management, Business Administration and Leadership, as well as Education in Data Science, including big data, data management, artificial intelligence, and data analysis for business.
Gordon is very passionate about small and medium enterprise (SME) business as it composes over 99% of Canadian business, and entrepreneurship is the foundation of all business excellence. SMEs often lack access tools and knowledge which larger businesses use, such as data analytics to discover trends and emergent patterns, which help predict future demand for products and services. Corporate social responsibility, also known as the triple-bottom-line was created to seek enrichment to people, planet, and profitability from business activity. Focusing on people and the environment, in addition to profits helps many businesses create a much more enriched culture in the workplace, not to mention much more sustainable. Companies who practice this often have been afforded an elevated position in the marketplace to create a 100-year sustainability plan, such as Shopify.
In technology, Gordon has specialized in web development, creating secure corporate web portals, websites with full marketing campaigns including a Wordpress front website optimized for search engine discovery, as well as copywriting content, newsletter integration with services like Survey Monkey and Constant Contact, with a project and sales backend system.
In all industries which Gordon participates in, it is important to have education and experience in business. This is illustrated well in Software Development, which requires attention to stakeholder management, productivity, return on investment, advertising, customer engagement, and brand management, with other attention to business details.
Programming
Began programming on a Commodore computer at a very young age.
First Job
Taught members of the community how to use a fledging Internet. Also started to create websites for businesses. Contract renewed three times.
Research Assistant: Genetics
Research included genetic manipulation to disrupt a pathogen commonly found in rain water.
Research Assistant: Chemical Engineering
Chemical reactor research supervised by a doctoral researcher.
B2C and B2B Sales
Sold office supplies solutions to entrepreneurs.
Loyalist College:
Chemical Engineering Technology
Studied chemistry, biology, mathematics, scientific research methodologies. Specialized in Extraction Technology.
Centennial College:
Software Engineering Technician
Most people thinking programming is just code. Nope, it's serious strategy and business procedures.
Full-Stack Web Developer
Worked with WordPress, custom hand-made sites like this one, and large portal projects, complete with databases, management, different views and more.
Cape Breton University:
Master of Business Administration
Coursework in the MBA Community Economic Development Program. Decided to switch to International Business.
Seneca College:
International Business Management Graduate Certificate
Studied international business in a dynamic team of 4 people for 8 months.
Seneca College:
Import/Export Business Certificate
Studied for the Import and Export Business Certificate, with extra content in international trade documentation.
Seneca College:
Supply Chain Management, Global Logistics Graduate Certificate
Studied Supply Chain Management (SCM), with topics in SCM, procurement, accounting, finance, risk management and resilience.
Seneca College:
International Trade Specialist
Studied the International Trade Specialist Certificate, with extra content in international market entry.
Robert Gordon University:
MSc Business Leadership and Management
Studied business including coursework in global business management, global marketing, global resilience, strategic management, and global leadership.
Seneca College and AlteX Academy:
Advanced Drone Pilot Licence
Studied Advanced Remote Piloted Aircraft Systems Operations in Canadian airspaces. Using aircraft controlled from the ground in photography, surveys, and inspections.
Centennial College:
Artifical Intelligence
Studying how machines learn.
Software Development and Artificial Intelligence
My work in Software Development, Web Development, and Artificial Intelligence
Read MoreChemical Engineering Research
Research in chemical reactor technology. Trained in Inorganic, Organic, Instrumentation, Radio chemistry. Specialized in super critical extraction technology.
Read MoreInternational Business, Business Administration, Business Leadership, and Supply Chain Management
MBA and MSc Business Leadership Degrees Candidate.
Read MoreBiology/Genetics Research
Mobile genetics research to disrupt water-bourne pathogen commonly found in rain water in Africa.
Read MoreArchery
Competitive archery, and recreational archery. I use traditional recurve bows, as well as modern compound bows.
Canoeing and Kayaking
I canoe and kayak during the summer months.
International Food
I love to eat and photograph food from around the world.
Amateur Radio
As an operator, I get to learn about signal propagation, electronics, software defined radio, and more.
Camping
Sometimes it's nice to get away from the city, just for a little while.
Coffee and Tea
I frequently enjoy coffee and tea, and with as much variety as possible.


In addition to the exercises provide here, the Case Studies at the Calling Bullshit 1 course, hosted by the University of Washington Center for an Informed Public, provide a rich set of fully developed opportunities to explore how quantitative skills can be used to detect "fake news." Instructors are encouraged to explore and use these materials in conjunction with this text.
in-context


JSON for C++
Main Page
Classes
Files
Class List
Class Index
Class Hierarchy
Class Members
Class Hierarchy
Go to the textual class hierarchy
Generated by
1.8.11


(#) Proguard.cfg file contains generic Android rules
!!! WARNING: Proguard.cfg file contains generic Android rules
This is a warning.
Id
: `ProguardSplit`
Summary
: Proguard.cfg file contains generic Android rules
Severity
: Warning
Category
: Correctness
Platform
: Android
Vendor
: Android Open Source Project
Feedback
: https://issuetracker.google.com/issues/new?component=192708
Affects
: Shrinking configuration files
Editing
: This check runs on the fly in the IDE editor
Implementation
: [Source Code](https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:lint/libs/lint-checks/src/main/java/com/android/tools/lint/checks/ProguardDetector.java)
Tests
: [Source Code](https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:lint/libs/lint-tests/src/test/java/com/android/tools/lint/checks/ProguardDetectorTest.kt)
Copyright Year
: 2011
Earlier versions of the Android tools bundled a single `proguard.cfg`
file containing a ProGuard configuration file suitable for Android
shrinking and obfuscation. However, that version was copied into new
projects, which means that it does not continue to get updated as we
improve the default ProGuard rules for Android.
In the new version of the tools, we have split the ProGuard
configuration into two halves:
* A simple configuration file containing only project-specific flags, in
your project
* A generic configuration file containing the recommended set of
ProGuard options for Android projects. This generic file lives in
the SDK install directory which means that it gets updated along
with the tools.
In order for this to work, the proguard.config property in the
`project.properties` file now refers to a path, so you can reference
both the generic file as well as your own (and any additional files
too).
To migrate your project to the new setup, create a new
`proguard-project.txt` file in your project containing any project
specific ProGuard flags as well as any customizations you have made,
then update your project.properties file to contain:
`proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt`
(##) Example
Here is an example of lint warnings produced by this check:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~text
myfile.txt:8:Warning: Local ProGuard configuration contains general
Android configuration: Inherit these settings instead? Modify
project.properties to define
proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:myfile.txt
and then keep only project-specific configuration here [ProguardSplit]
-keep public class * extends android.app.Activity
^
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Here is the source file referenced above:
`myfile.txt`:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ linenumbers
-optimizationpasses 5
-dontusemixedcaseclassnames
-dontskipnonpubliclibraryclasses
-dontpreverify
-verbose
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
-keep public class * extends android.app.Activity
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class * extends android.app.backup.BackupAgentHelper
-keep public class * extends android.preference.Preference
-keep public class com.android.vending.licensing.ILicensingService
-keepclasseswithmembernames class * {
native


(HMR16) Gradient descent learns linear dynamical systems
Posted: 2016-12-27 , Modified: 2016-12-27
Tags: dynamical systems, quasi-convexity
Posted: 2016-12-27 , Modified: 2016-12-27
Tags: dynamical systems, quasi-convexity
Main theorem:
Note:
A function \(f\) is \(\tau\)-weakly-quasi-convex (\(\tau\)-WQC) over \(B\) with respect to a global minimum \(\te^*\) if there is a positive \(\tau>0\) such that for all \(\te\in B\), \[ \nb f(\te)^T(\te-\te^*) \ge \tau (f(\te) - f(\te^*)). \] \(f\) is \(\Ga\)-weakly smooth if \[ \ve{\nb f(\te)}^2 \le \Ga(f(\te)-f(\te^*)). \]
Note a convex function satisfies \[ f(\te^*) - f(\te) \ge \nb f(\te)^T (\te^*-\te) \] so is 1-WQC. If \(f''\ge a\) everywhere, then \(f(\te)-f(\te^*) \ge \ve{\nb f(\te)}^2\) so \(f\) is \(4a\)-weakly smooth.
For stochastic gradient descent, weak QC and S are enough for convergence guarantees.
Theorem. Suppose \(f\) is \(\tau\)-WQC and \(\Ga\)-WS and \(r\) is an unbiased estimator for \(\nb f(\te)\) with variance \(V\), \(\te^*\in B\), \(\ve{\te_0-\te^*}\le R\). Then projected SGD with a suitable learning rate returns \(\te_K\) with error \[ \E f(\te_K)-f(\te^*) \le O\pa{ \max\bc{\fc{\Ga R^2}{\tau^2 K}, \fc{R\sqrt V}{\tau \sqrt K}} }. \] (Dependence on \(K\) is most important here. Check this.) (Variance makes the convergence \(\rc{\sqrt K}\) rather than \(\rc K\).)
(This is a SISO - single-input single-output system.) The population risk is \[ f(\wh \Te) = \EE_{\{x_t\}, \{\xi_t\}} \ba{ \rc T \sumo tT \ve{\wh y_t - y_t}^2 } \] where \(\wh y_t\) is generated from the estimated parameters without noise. Evert SISO of order \(n\) can be put into controllable canonical form \[ A = \matt{\vec 0}{I_{n-1}}{-a_n}{-a_{n-1:1}}, \quad B = \colthree{0}{\vdots}{1} = e_n. \] Write \(A=CC(a)\), where \(a=-[a_n,\ldots, a_1]\).
A SISO is controllable iff \([B|AB|\cdots|A^{n-1}B]\) has rank \(n\). (See Control theory/2 Controllability.)
Let \[ p_a(z) = z^n + a_1z^{n-1}+\cdots + a_n = \det (zI-A) \] be the characteristic polynomial of \(A\).
The transfer function of the linear system is \[\begin{align} G(z) &= C(zI - A)^{-1}B=:\fc{s(z)}{p(z)}\\ & = \sumo t{\iy} z^{-t} \ub{CA^{t-1}B}{r_{t-1}}\\ & = \fc{c_1+\cdots + c_n z^{n-1}}{z^n + a_1z^{n-1}+\cdots + a_n} \end{align}\]where \(p\) is monic. (We have \(M^{-1} = \fc{\text{cofactor}(M)}{\det(M)}\).)
(Why is the transfer function useful?)
Define the idealized risk as \[ g(\wh A, \wh C) = \sumz k{\iy} (\wh C\wh A^k B - CA^k B)^2. \] In the Fourier domain, \[ g(\wh A, \wh C) = \int_0^{2\pi} |\wh G (e^{i\te}) - G(e^{i\te})|^2\,d\te \] (The hat on the parameters means “estimate”, the hat on \(G\) means “Fourier transform”.)
Explanation. By unfolding the recurrences, then taking the average, \[\begin{align} \E [\ve{\wh y_t - y_t}^2] & = \ve{\wh D - D}^2 + \sumo k{t-1} \ve{\wh C \wh A^{t-k-1} \wh B - CA^{t-k-1} B}^2 + \E[\ve{\xi_t}^2]\\ f(\wh \Te) & = \ve{\wh D - D}^2 + \sumo k{t-1} \pa{1-\fc kT}\ve{\wh C \wh A^{k-1} B - CA^{k-1} B}^2 + \si^2. \end{align}\] The idealized risk takes \(T\to \iy\), and ignores the first term. Now by Parseval’s Theorem, \[\begin{align} G(z) &= \sumo t{\iy} CA^{t-1} Bz^{-t}\\ \wh G(z) &= \sumo t{\iy} \wh C \wh A^{t-1} B z^{-t}\\ \int_0^{2\pi} |\wh G(e^{i\te}) - G(e^{i\te})|^2 & = \sumo t{\iy} \ve{CA^{t-1}B - \wh C \wh A^{t-1} B}^2. \end{align}\](This can give some motivation for definition of \(G\). Simply put \(CA^kB\) as coefficients of power series; we get \(G\). This also motivates looking at the Fourier series.)
(Why is it useful to pass to the Fourier domain?)
Rouche’s Theorem. wikipedia
Let \(T_1=\fc T4\). Using loss function \[ \ell((x,y),\wh\Te) = \rc{T-T_1} \sum_{t>T_1} \ve{\wt y_t - y_t}^2, \] gradients wrt \(\wh a, \wh C, \wh D\) are almost (exponentially) unbiased.
Omitted.
Ex. when we can’t hope to properly recover: \(G(z) = G_1(z) \fc{z^n-r_1^n}{z^n-r_2^n}\) where \(r_1\approx r_2\approx 1\). They are exponentially close but the characteristic polys are very different.
Approximation: Prove that the inverse of a poly can be easily approximated (cf. proof for conjugate gradients, Chebyshev approx).
Using the approximation result, get \(\ab{\fc{pu}{z^{n+d}} - 1} <0.5\), so \(\fc{pu}{z^{n+d}}\in C\) for appropriate \(\tau_i\).


Event-driven Programming
DtCraft applies event-driven programming to enable efficient IO multiplexing. Event-driven programming is a programming paradigm where events (input, output, timeout) determines the program flow. Instead of using famous 3rd-party library such as Libevent and Libev, we developed our own reactor class to dispatch events. The reactor is the core of DtCraft. All kernel components, master, agent, and executor are derived from the reactor. In fact, people also use DtCraft to develop event-driven applications with modern C++.
Example: Timout Event
The example below shows how to create a timeout event that expires after one second and a periodic event that expires at every 100 milliseconds in DtCraft.
// create a reactor with 2 threads
dtc::Reactor reactor(2);
// create a timeout event of 1 s
auto ev1 = reactor.insert<dtc::TimeoutEvent>(
std::chrono::seconds(1),
[] (dtc::Event& e) {
std::cout << "1 s passed" <<'\n';
}
);
// create a periodic event running every 100 ms
auto ev2 = reactor.insert<dtc::TimeoutEvent>(
std::chrono::milliseconds(100),
true, // true to include the moment of this call
[] (dtc::Event& e) {
std::cout << "100 ms passed" <<'\n';
}
);
// dispatch events
reactor.dispatch();
Example: I/O Event
The example below shows how to create a read event that operates on a domain socket pair in DtCraft.
// create a reactor with 4 threads
dtc::Reactor reactor(4);
// create a domain socket device pair (std::shared_ptr)
auto [rdev, wdev] = dtc::make_socket_pair();
// create a read event
auto rev = reactor.insert<dtc::ReadEvent>(
std::move(rdev),
[] (dtc::Event& ev) {
std::cout << "read event on fd=" << ev.device()->fd() << '\n';
}
);
// write one byte to the socket
auto one {'a'};
wdev->write(&one, sizeof(one));
// dispatch events
reactor.dispatch();
Reactor
Reactor is the main gateway to create events, remove events, and dispatch your program to an event-driven loop. Our reactor is written in modern C++ and has many distinct features compared to existing libraries:
- DtCraft reactor is multi-threaded and thread-pooled by default.
- DtCraft reactor uses
std::shared_ptr
to manage ownership of events. - DtCraft reactor applies task-based parallelism via
std::future
andstd::promise
. - DtCraft reactor allows users to customize events through class inheritance.
- DtCraft event is flat in types, requiring no confusing bitwise operator
|
to union different types. - DtCraft event stores callback in powerful and flexible
std::function
. - DtCraft event uses handy
std::chrono
to determine timeout.
The code below shows a list of commonly used methods of the reactor. All methods are thread-safe.
class Reactor {
const std::thread::id owner {std::this_thread::get_id()};
size_t num_events() const;
size_t num_workers() const;
template <typename C>
void break_loop_on(C&&);
auto break_loop();
void threshold(size_t);
template <typename T, typename... ArgsT>
auto insert(ArgsT&&... args);
template <typename C>
auto promise(C&&);
template <typename C>
auto async(C&&);
void dispatch();
bool is_owner() const;
auto remove(auto&&... events);
auto freeze(auto&&... events);
auto thaw(auto&&... events);
};
Here is a brief explanation for each method:
num_events
returns the number of events at the moment of call.num_workers
returns the number of worker threads.break_loop_on
sets a stopping criteria to cease the event loop.break_loop
lifts the flag to stop the event loop.threshold
stops the event loop when the number of events is below or equal to a given value.insert
creates an event of typeT
, forwardingargs
to its constructor.promise
requests a task to execute by the reactor owner (often the master thread).async
requests a task to execute by a worker thread, or by the master thread if no worker threads exist.dispatch
makes the reactor enters the event loop.is_owner
tells whether the calling thread is the reactor owner.remove
removes a batch of events from the reactor at one time.freeze
freezes a batch of events in the reactor at one time.thaw
unfreezes a batch of events in the reactor at one time.
The source code of the reactor is placed in include/dtc/event
and src/event
, respectively.
Create a Reactor
Before using any event operations, you need to create one or more Reactor
objects.
Each reactor object holds a set of events and polls to determine which events are active.
When an event becomes active, the reactor dispatches it to a thread executing its callback.
Example: Create a Reactor with Four Threads
The example below creates a reactor with four threads, one master and three workers.
dtc::Reactor reactor(4);
Note: When an event is in the context of its callback, the reactor will not poll it in the subsequent loops. Polling will continue when the execution thread completes its callback.
Request a Promise/Async
Reactor uses a thread pool to schedule event operations on threads to maximize the performance.
We use single-producer multiple-consumer model to deliver task-based parallelism.
The producer is the owner of the reactor, often the master thread creating the reactor in your application,
and consumers are threads to execute event callbacks.
You can requests task to run on the master thread through promise
and worker threads through async.
Both methods return std::future
objects for you to retrieve the task results.
Our reactor imposes strong and clear onwership between the master thread and worker threads.
This largely facilitates the design of an event-driven application with multiple threads.
Example: Execute a Task on the Master Thread
The example below demonstrates how to execute a task on the master thread (reactor owner).
std::future future = reactor.promise([] () {
std::cout << "This task only runs on the master thread" << '\n';
return 1;
});
Example: Execute a Task on a Worker (or Master) Thread
The example below demonstrates how to execute a task on a worker thread. The master thread will execute the task if the reactor has only one thread.
std::future future = reactor.async([] () {
std::cout << "This task runs on a worker thread" << '\n';
});
Note: Requesting a promise from the reactor can be useful when tasks need to synchronize at a certain point to avoid data race.
Event
Event is the basic unit of operation. Currently, there are four types of events, TIMEOUT
, PERIODIC
, READ
, and WRITE
.
Each event is a unique entity and is exclusive to each other.
You can derive your event class inheriting one of the four event bases TimeoutEvent
,
PeriodicEvent
, ReadEvent
, and WriteEvent
.
// Base class to create a timeout event.
// d: duration in std::chrono
// c: callable object (callback)
class TimeoutEvent : public Event {
template <typename D, typename C>
TimeoutEvent(D&& d, C&& c);
};
// Base class to create a periodic event.
// d: duration in std::chrono
// from_now: start from now or next cycle (now + duration)
// c: callable object (callback)
class PeriodicEvent : public Event {
template <typename D, typename C>
PeriodicEvent(D&& d, const bool from_now, C&& c);
};
// Base class to create a read event.
// d: device pointer
// c: callable object (callback)
class ReadEvent : public Event {
template <typename C>
ReadEvent(std::shared_ptr<Device> d, C&& c);
};
// Base class to create a write event.
// d: device pointer
// c: callable object (callback)
class WriteEvent : public Event {
template <typename C>
WriteEvent(std::shared_ptr<Device> d, C&& c);
};
DtCraft represents every event in std::shared_ptr
to ensure multiple threads
can perform event operations correctly. It is completely safe to, for example, ask a thread to
remove an event from the reactor while another thread is running the event's callback and vice versa.
The event class inherits std::enable_shared_from_this
and allows an event holder
to safely generate additional std::shared_ptr
instances that share ownership of the event.
The bottom-most event callback is of the form
std::function<dtc::Event::Signal(dtc::Event&)>
.
The callback takes an event argument by which you can
access the underlying handle or create another shared ownership of the event.
The return value is a handy feature to signal reactor an action after the callback is finished.
Example: Define an Event Callback
The example below shows how to define an event callback and use the return value to interact with the reactor.
auto callback = [a=rand()%2] (dtc::Event& event) {
auto another_owner = event.shared_from_this();
assert(another_owner.count() >= 2);
return a == 1 ? dtc::Event::REMOVE : dtc::Event::DEFAULT;
};
Note: The thread in the context of an event callback holds a shared ownership of that event.
Example: Derive a Timeout Event
The example below declares a timeout class that prints a pre-defined message after one second.
struct MyTimeoutEvent : public dtc::TimeoutEvent {
const std::string message {"hello"};
MyTimeoutEvent() : TimeoutEvent(std::chrono::seconds(1), [this](dtc::Event& e){
std::cout << message << '\n';
}) {}
};
Create an Event
DtCraft reactor does not allow users to directly create an event object.
We use factory design pattern to instantiate any event types.
To create an event, you simply need to call the method Reactor::insert
.
It takes an event type T
and arguments to forward to the constructor.
class Reactor {
template <typename T, typename... ArgsT>
auto insert(ArgsT&&...);
};
The return is a std::future
object of a shared pointer to the event
(std::future<std::shared_ptr<T>>
).
It is important to be aware of our reactor runs in a multi-threaded environment by default.
A successful event creation takes two steps:
(1) the event is allocated from the memory and
(2) the event is inserted to the reactor backend for polling.
Calling get
on the future object blocks until the two steps complete.
Example: Create a Periodic Event
The example below creates a periodic event that expires every two seconds.
auto event = reactor.insert<dtc::PeriodicEvent>(
std::chrono::seconds(2),
false,
[] (dtc::Event& e) {
std::cout << "timeout" << '\n';
}
).get();
assert(event.count() == 2); // two owners, one reactor, one user
Note: The reactor retains shared ownership of every event it created.
Remove an Event
Removing events from a reactor is accomplished through the method Reactor::remove
.
Similary, this method returns a std::future
object of a std::tuple
of bools.
Each bool in the tuple indicates whether or not the corresponding event is removed from the reactor.
class Reactor {
auto remove(auto&&... events);
};
Calling get
on the returned future
object guarantees the event is removed from
the reactor and will no longer enter the subsequent event loops.
Example: Remove Events from the Reactor
The example below removes two events from the reactor.
auto [b1, b2] = reactor.remove(event1, event2).get();
if(b1) std::cout << "event b1 is removed" << '\n';
if(b2) std::cout << "event b2 is removed" << '\n';
Note: The reference count of the event decreases by one when it is removed from the reactor.
Run an Event Loop
Once you have a reactor with events registered, the next step is to start the event loop and let the reactor to dispatch events to the associated handlers.
class Reactor {
void dispatch();
};
By default, the method Reactor::dispatch
enters a while loop until there are no more
events to poll or reaching pre-defined stopping conditions.
This means your program will persist in memory where the reactor owner, often the master thread,
repeatedly checks if any events has triggered.
Once this happens, it marks all triggered events as active and
dispatches them to worker threads to run the callbacks.
Here is a sketch for how the event loop works to help with understanding. Only the reactor owner can run the event loop.
while (1) { 1. Execute callable objects in the promise queue. 2. if (no registered events or stopping criteria reached) break; 3. Poll I/O events (select or epoll). 4. Synchronize the clock with std::chrono::steady_clock::now(). 5. Poll timeout events. }
Example: Start an Event Loop
The example below starts the event loop of a reactor.
reactor.dispatch();
Stop an Event Loop
By default, the reactor stops when no events are pollable.
However, you can stop an active event loop at any time with any threads depending on your program flow.
There are three ways to stop an event loop, break_loop
, threshold
,
and break_loop_on
. Calling break_loop
lifts the
stopping flag to true
and will subsequently stop the reactor.
The function threshold
tells the reactor to stop when the number of registered events is
under a given value.
The function break_loop_on
stops the event loop when a given condition is reached.
class Reactor {
std::future<bool> break_loop();
void threshold(size_t);
template<typename C>
void break_loop_on(C&&);
};
Example: Stop an Event Loop on a Given Threshold
The example below tells the reactor to stop the event loop when the number of registered events is fewer than or equal to two.
reactor.threshold(2);
Example: Customize Stopping Criteria for an Event Loop
The example below stops the event loop after 1000 iterations.
reactor.break_loop_on([cnt=0] (dtc::Reactor& reactor) mutable {
return (cnt++ > 1000);
});
Note: Breaking the event loop might leave requested promises unfinished. It is user's responsibility to ensure critical promises are processed before stopping the reactor.
I/O Device
Another key difference of our Reactor to other libraries is the process of I/O event.
We do not apply raw file descriptor to our events as it can be dangerous and confusing in
multi-threaded I/O. Instead, each I/O is wrapped in a Device
object managed by
std::shared_ptr
. By default, a DtCraft device is non-blocking and
close-on-exec, and supports a set of basic read and write operations.
When a device vanishes, its destructor closes the associated file descriptor.
The source code of device is in src/device.cpp
and include/dtc/device.hpp
.
Create a Device
We have provided functions to create devices for
socket,
pipe, and
notifier.
Upon successful creation, you get a shared pointer to the device
(std::shared_ptr<Device>
) that manages a file descriptor.
Built-in device support can be found in include/dtc/ipc/
.
Example: Create a Pipe Device
The example below creates a device pair for pipe, one read and one write.
auto [rend, wend] = dtc::make_pipe();
Example: Create a Domain Socket Pair
The example below creates a device pair for domain socket, capable of read/write at both ends.
auto [rend, wend] = dtc::make_socket_pair();
Example: Create a Socket Server
The example below creates a socket device binding to a given port "9990"
.
auto socket = dtc::make_socket_server("9990");
Example: Create a Socket Client
The example below creates a socket device connecting to the remote server at
"server-host-name"
through port "9990"
.
auto socket = dtc::make_socket_client("server-host-name", "9990");
Example: Get the File Descriptor Associated with a Device
The example below acquires the raw file descriptor managed by a device.
auto fd = device->fd();
Read/Write through a Device
Each DtCraft device provides read
and write
methods to read and write data
through a device.
These two methods are nothing but safe wrappers of POSIX
read and
write to
perform one-time synchronization between user-space data and the underlying file descriptors.
class Device {
std::streamsize read(void*, std::streamsize) const;
std::streamsize write(const void*, std::streamsize) const;
};
On success, the number of bytes read or written is returned. If the return is -1,
a non-blocking condition incurs.
On error, exception is thrown to indicate system error except EAGAIN
and EWOULDBLOCK
.
Example: Write through a Device
The example below performs a write synchronization through a device.
try {
std::string data {"test"};
if(device->write(data.c_str(), data.size()) == -1) {
std::cout << "Device is busy. Try later.\n";
}
}
catch (const std::system_error& se) {
std::cout << se.what() << '\n';
}
Example: Read through a Device
The example below performs a read synchronization through a device.
try {
char data[1024];
if(device->read(data, 1024) == -1) {
std::cout << "Device is busy. Try later.\n";
}
}
catch (const std::system_error& se) {
std::cout << se.what() << '\n';
}
Note: DtCraft does not treat the non-blocking condition as an error. It is users' responsibility to check the return value to see if the synchronization requires another try.
Create a Read Event from a Device
A read event becomes active when the associated device is ready to read. The reactor dispatches an active read event to a worker executing its callback. In DtCraft, read events are level-triggered. The reactor continues to dispatch a read event until its kernel buffer is emptied out.
Example: Create a Read Event on a Given Device
The example below creates a read event on a given device and reads a character from the device. On error, the callback returns a removal signal to remove this event from the reactor.
reactor.insert<dtc::ReadEvent>(
std::move(device),
[] (dtc::Event& e) {
std::cout << "Read event on fd=" << e.device()->fd() << '\n';
char c;
try {
e.device()->read(&c, sizeof(c));
}
catch(...) {
std::cout << "Error occurs on read\n" <<
return dtc::Event::REMOVE;
}
return dtc::Event::DEFAULT;
}
);
Note: A read device can only be managed by one read event at one time. Creating two or more read events on a read device results in undefined behavior.
Create a Write Event from a Device
A write event becomes active when the associated device is ready to write.
However, unlike read events, write events are not autonomously triggered by the reactor
because it is decided by users when to write.
By default, write events are frozen and users must explicitly call Reactor::thaw
to unfreeze write events. A write event will enter the I/O polling only when thawed.
We delegate this control to users to ensure write events are triggered when needed,
for example, user-space buffer has data to write, rather than proactively invoking the callback.
Example: Create a Write Event on a Given Device
The example below creates a write event on a given device and freezes it for polling to write a character.
auto event = reactor.insert<dtc::WriteEvent>(
std::move(device),
[] (dtc::Event& e) {
std::cout << "Write event on fd=" << e.device()->fd() << '\n';
char c {'a'};
e.device()->write(&c, sizeof(c));
}
).get();
reactor.thaw(event);
Note 1: A write device can only be managed by one write event at one time. Creating two or more write events on a write device results in undefined behavior.
Note 2: When a worker thread leaves the callback of a write event, it freezes the write event again. It is users' responsibility to check if another thaw is required to flush all necessary data.
Where to Go from Here?
Congratulations on learning event-driven programming using DtCraft reactor! In the next chapter, we will cover more DtCraft features and functionalities to process data in an event-driven environment. You will get in-depth overview of:
- Input stream and output stream event interface to enable asynchronous I/O.
- Archiver interface for data serialization and de-serialization.


I've been in college for 2 and one-half semesters. I've done Marijuana, LSD, LSA, Alcohol, DMT, Ritilin, Dramamine, Vicoden, Opium, Crack and a few others I cant remember. I came back to school one evening and my hall-mate asked me if I wanted to smoke some Salvia, I said hell yea, I've done lots of research for every drug I've done so I have read up on it quite alot. He packed what looked like one hit of 20x in my bowl, he gave me some instructions on how to hold it in as long as possible and (beforehand I had been drinking some vodka) I told him if I got dizzy or somthing it was just because of the vodka. I had a cigarette behind my ear as I leaned up against the wall behind my dorm to steady myself cause I read of what salvia does so I wanted to try to be ready for anything.
 I felt it go in but barely, so smooth it was like a cigarette. I look at my friend and he says 'Good shit, huh?' or something to that effect and that's when I thought I felt it coming on, some sort of slight difference in everything, kinda like the coming on to period for acid. Then the machines came.
From every and any direction they came. I didn't know what they wanted to do before it was too late. I tried to move but the whole world was totally flattened by the machines and it was getting hard to breath because I was only inches thick. I heard only the noise of the machines for the while that this was going on, about a minute, seemed like seconds, then I could hear my friend coaching me on like I was in some sort of swim race, it kinda felt like I was swimming then. As that started to happen my body started to rip itself from the flattened position it was in layer by layer, like a post-it book. Finally I was pieced back together enough to realize that the trip was over and I was lying on the ground. The ripping sensation still was felt through my body but it was wearing off.
Turns out that after my friend talked to me I fell to my knees (bruised now) and almost planted my face in the pavement but my friend said he caught me, lucky, and rolled around on the ground.
WOW, try it but sit down or something, do that and your fine. I liked it.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


new LiveOSC(opts)
LiveOSC sets up communication with LiveOSC and holds the song object.
Options are as follows:
opts.host = host to listen on, default <IP_ADDRESS>
opts.port = port to listen on, default 9006
opts.liveHost = host live is running on, default <IP_ADDRESS>
opts.livePort = port live is listening on, default 9005
opts.waitTime = time to wait before sending ready event
Parameters:
| Name | Type | Description |
|---|---|---|
opts |
Object | options |


This inspection searches for links whose link text does not match the heading text referenced by the link anchor ref.


dadada
View the Project on GitHub chuchovidalz/SimpleRTC
A Live Blogging application build using Go and PubNub
Visit the site and see progress at liveblogr.appspot.com!


driver.hh File Reference
#include <gecode/minimodel.hh>
#include <gecode/search.hh>
#include <gecode/gist.hh>
#include <gecode/support/auto-link.hpp>
#include <gecode/driver/options.hpp>
#include <gecode/driver/script.hpp>
Go to the source code of this file.
Classes | |
| class | Gecode::Driver::BaseOption |
| Base class for options. More... | |
| class | Gecode::Driver::StringValueOption |
| String-valued option. More... | |
| class | Gecode::Driver::StringOption |
| String-valued option (integer value defined by strings). More... | |
| class | Gecode::Driver::StringOption::Value |
| Option value. More... | |
| class | Gecode::Driver::IntOption |
| Integer option. More... | |
| class | Gecode::Driver::UnsignedIntOption |
| Unsigned integer option. More... | |
| class | Gecode::Driver::DoubleOption |
| Double option. More... | |
| class | Gecode::Driver::BoolOption |
| Boolean option. More... | |
| class | Gecode::Driver::IplOption |
| Integer propagation level option. More... | |
| class | Gecode::Driver::TraceOption |
| Trace flag option. More... | |
| class | Gecode::BaseOptions |
| Base class for script options. More... | |
| class | Gecode::Options |
| Options for scripts More... | |
| class | Gecode::Options::_I |
| Helper class storing Gist inspectors. More... | |
| class | Gecode::SizeOptions |
| Options for scripts with additional size parameter More... | |
| class | Gecode::InstanceOptions |
| Options for scripts with additional instance parameter More... | |
| class | Gecode::Driver::ScriptBase< BaseSpace > |
| Parametric base-class for scripts. More... | |
| class | Gecode::Driver::ExtractStepOption< BaseSpace > |
| Class to extract the step option value. More... | |
| class | Gecode::Driver::IgnoreStepOption< BaseSpace > |
| Class to ignore the step option value. More... | |
Namespaces | |
| namespace | Gecode::Driver |
Script commandline driver. | |
| namespace | Gecode |
Gecode toplevel namespace | |
Defines | |
| #define | GECODE_DRIVER_EXPORT |
| #define | GECODE_LIBRARY_NAME "Driver" |
Typedefs | |
| typedef Driver::ScriptBase < Driver::IgnoreStepOption < Space > > | Gecode::Script |
| Base-class for scripts. | |
| typedef Driver::ScriptBase < Driver::IgnoreStepOption < IntMinimizeSpace > > | Gecode::IntMinimizeScript |
| Base-class for scripts for finding solution of lowest integer cost. | |
| typedef Driver::ScriptBase < Driver::IgnoreStepOption < IntMaximizeSpace > > | Gecode::IntMaximizeScript |
| Base-class for scripts for finding solution of highest integer cost. | |
| typedef Driver::ScriptBase < Driver::IgnoreStepOption < IntLexMinimizeSpace > > | Gecode::IntLexMinimizeScript |
| Base-class for scripts for finding solution of lexically lowest integer costs. | |
| typedef Driver::ScriptBase < Driver::IgnoreStepOption < IntLexMaximizeSpace > > | Gecode::IntLexMaximizeScript |
| Base-class for scripts for finding solution of lexically highest integer costs. | |
| typedef Driver::ScriptBase < Driver::ExtractStepOption < FloatMinimizeSpace > > | Gecode::FloatMinimizeScript |
| Base-class for scripts for finding solution of lowest float cost. | |
| typedef Driver::ScriptBase < Driver::ExtractStepOption < FloatMaximizeSpace > > | Gecode::FloatMaximizeScript |
| Base-class for scripts for finding solution of highest float cost. | |
Enumerations | |
| enum | Gecode::ScriptMode { Gecode::SM_SOLUTION, Gecode::SM_TIME, Gecode::SM_STAT, Gecode::SM_GIST, Gecode::SM_CPPROFILER } |
Different modes for executing scripts. More... | |
| enum | Gecode::RestartMode { Gecode::RM_NONE, Gecode::RM_CONSTANT, Gecode::RM_LINEAR, Gecode::RM_LUBY, Gecode::RM_GEOMETRIC } |
Different modes for restart-based search. More... |


Old man seeks resumption of monthly assistance
by Special CorrespondentTIRUNELVELI
A 70-year-old man, who came to the Collectorate on Monday with his two mentally challenged daughters, submitted a petition to Collector Shilpa Prabhakar Satish appealing to her to issue orders for resuming the distribution of monthly assistance for them.
The frail-looking old man also appealed to the Collector to give a suitable job for another daughter, who has done her postgraduation in mathematics.
According to petitioner V. Narasimhan of Perinba Street in Palayamkottai, his two daughters — Chandrakala, 45, and Sri Sabhari, 28, both mentally challenged, were getting monthly assistance from 2009 to 2015.
However, the assistance was stopped abruptly without any prior information that landed the family, living in a rented house, in deep trouble.
“As my daughter Maharajothi, 26, has done M.Sc in mathematics, the Collector should recommend to the government to give her employment.  If a free house is given to us, it will be of great help,” Mr. Narasimhan said.


Online Learning
As a teacher, I always believed that the best person to teach you is yourself. In the classroom / lecture theatre, the students that learn are those that have already built themselves a mental framework for the material being taught, through thorough preparation.
- edX Especially the 'Introduction to Computing' course 6.00.1x
- coursera Andrew Ng's Machine Learning course is accessible, well taught, clear..
- MIT OpenCourseWare all of MIT's teaching resources, video lectures, available for a very wide range of courses
- W3school.com Where I learned to make this website
- Santa Fe Institute Complexity courses These look fascinating, courses for a range of maths ability..
Machine Learning
- Deep Learning A new set of deep learning courses on Coursera
- TensorFlow Loads of useful tools for machine learning
- Pandas Python data analysis tools, really useful data structures and io tools
Other
- xkcd Great cartoon for programmers and people
- Inference Lab Dr Ben Vincent is an old friend of mine working at the human end of intelligence, rather than the artificial
- Molecule of the Month I am a chemist too!


Nesting Depth Restoration
Main
Top-level content.
Outer section header
Section within main.
Inner section header
Section inside the section within main.


§232-25 Amendment of assessment list to conform to decision. The assessor shall alter or amend the assessment and the assessment list in conformity with the decision or judgment of the last board or court to which an appeal may have been taken. [L 1932 2d, c 40, §56; RL 1935, §1954; am L 1939, c 208, §14; RL 1945, §5220; RL 1955, §116-22; HRS §232-25]


© 2019-2021 Mey Research Group. Adapted from Allan Lab. This site is made with Jekyll; copy and modify it for your own research group. Icons made by Dave Gandy from www.flaticon.com.
We are part of the School of Chemistry at the University of Edinburgh.


START
Created by CATCH
SPECIAL THANKS
Miracle CG - 3D Model
AKASHIC RECORDS - Music
BACK
Your Score
0
Home
Restart
Credits
HP:
SCORE:
0
Click Anywhere To Resume
HP:
SCORE:
0
HP:
SCORE:
0
ON


As custom dictates, you and your team are to approach the kingdom’s wisest man. Socrates is guarded by a
moat, across which you should trek. But the bridge belongs to a vicious Troll, who says:
"A challenge summons you
From high on above,
To defeat the dragon, to seek glory and love,
Look at this task, before you proceed,
Guess the outcome, pay my words heed
Your future lies in the number below,
Do not forget it, in your mind keep it stowed. "


Whisp Engine
Empty Whisper
Smile and wave boys
Whisper Engine is a 3D video game engine. It has been developed in the subject of Game Engines in the third year of the university degree of videogames of CITM-UPC. The subject was to make an engine from scratch using OpenGL, and here is the result.
We hope you like it!
1rs Assigment
- Core Loop
- GameObject class
- Components
- Transformations
- GameObject Hierarchy
- FBX Importer
- Hierarchy Panel
- Console Panel
- ShortCuts System
- Integration JSON Parser
2nd Assigment
- Octree
- Components properties on inspector
- Octree
- Scene Serialization (Load and Save)
- Part of Bounding Boxes
- Own Format
- Resource manager
- Start/Pause/Stop and recover init state
3rd Assigment
- Scripting Structure
- integrate LuaBridge to structure
- Script Component
- Script class
- Prefabs
- Game Builds
- Integrate a Script Editor in Engine
1rs Assigment
- Camera Movement Controls
- About Panel
- Part of Configuration Panel
- Docking
- Outline selected GameObjects (parent and children)
- Wireframe Shapes
- Icon Logo
- DockSpace
- Brofiler added
2nd Assigment
- Frustum
- Camera Culling
- Camera Preview
- Help Marker
- ImGuizmo
- Viewport System
- Mouse Picking
3rd Assigment
- Scripting Tank game in Unity
- Some Tank scripts in Lua
- Autodestroy Objects Lua
- Bullet Prefab
- Tank Scene
- zBuffer
- Skybox editor
- Video Trailer
GameObjects
The GameObjects are the core of the engine and the future game. It is a container, an instance that stores different components. A GameObject by itself has nothing special, components, a name, a unique identifier, a reference to the father and a vector with references to the children, which provides the possibility of creating GameObjects hierarchies.
Components
The components are what give the GameObjects useful. Each component has a use and features that are displayed and can be edited in the GameObjects inspector. In WhispEngine we have a few.
The Transform component will always exist alongside the GameObject. It contains two transformation matrices, a global one with the position, rotation and scale with respect to the world and a local one with respect to the father's global matrix.
Mesh component contains the mesh to be rendered and is responsible for painting each frame, it also has the bounding boxes, the AABB and the OBB.
Material component is responsible for painting a texture in the mesh or, if it does not have any, of a specific color.
Camera component is used to paint the scene in the game, it has several values to modify such as the FOV, the aspect ratio or the distance of the near and far plane.
Component script is the one that is responsible for executing a lua script, saving its variables and displaying the public ones in the inspector so that they can be modified.
Prefabs
Prefabs are hierarchies of GameObjects with components that are saved to instantiate several or have some in the scene, change a value of a variable and the change is reflected in the other objects.
Hierarchy
A hierarchy is simply GameObjects' relationship with his father and his children. Each scene has an invisible parent object that is the root and that GameObject is the one that has as children the objects we see in the scene.
Scenes
The scene saves the hierarchy, next to the position and rotation of the viewport camera under a name.
Octree
Octree are a way to optimize, and Whisp Engine is not far behind when it comes to optimization. When a GameObject is set as static it is added to the octree, dividing it into 8 if it is positioned in an empty quadrant. The octree are a much faster way to check collisions, in our case with the mouse picking raycast or with the frustum.
Frustum
The frustum acts as a container space for the camera, from it you can vary the FOV, the maximum and minimum distance of rendering and finally its transformation. It is possible to create camera components for each object, which come embedded with a frustum and the previously mentioned functionalities.
Viewport
The Engine uses a viewports system to show both in the scene, in the game panel and in the preview game panel all the rendering. These viewports can be separated as single panels and moved and scaled across all screens of your computer.
Camera Culling
Camera culling can be activated inside the camera component, in the inspector and allows you to render only what is inside the frustum. It is a very good way of optimization.
Camera Preview
Camera preview is a feature that by clicking on a game object that contains a camera component, allows you to visualize what the frustum sees.
Docking
The docking allows you to attach panels to each other, this creates a very good organization between the panels of the engine and its a better way to work.
Mouse Picking
Mouse Picking allows you to select objects from the scene with the mouse. So, you don't have to go to the hierarchy to select, it uses raycast.
Outline Stencil Buffer
We have used the Stencil Buffer to create an orange outline in the selected objects, there is also the blue outline that is used for the child objects of the selected objects.
ZBuffer
ZBuffer allows, from a grey scale, to find out the distance of the pixels rendered on screen within the 3D environment. As darker pixel, more closer the viewport will be to it.
Skybox
The Skybox is simply a large sphere with the UVs reversed, which when you put a texture on it you will see from the inside. It can be customized in the configuration panel.
ShortCuts
ShortCuts system allows to put a concatenation of three keys and a pointer to a function. Every time you push the keys, the function will be called. We used them as call of panels active/deactive. It also has a panel to edit that shortcuts in order to set your own keys.
Play, Pause and One Frame
We want to separate the time creating the game and the time the game is playing. We have trhee buttons in order to do this task.
Play will start the game. Starting the game timer, compiling the scripts and creating a temporary save file of current scene. Pressing Play during game run, will stop the game, loading the scene that was before start.
Pause will pause all GameObjects, avoiding update scripts.
One Frame will reanude the game for one frame.
Library
Load Fbx from file is so slow, in order to speed up we create a file that contain the data we need from assets in our own file format because loading from own file format is a lot faster. On the other hand, if we have a mesh of a house and we instantiate it more than one time, the mesh will be loaded in memory more than one, but we don't want this, so, having a resource of that mess and the component mesh stores that resource will share the resource with other component meshes but only have loaded in memory one mesh
Here we have the simple flow diagram of scripting structure:
First we have to talk about the language we chose, Lua. Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description.
Lua is a good option also for the great integration in C. We have also integrate LuaBridge, a very good library to relate Lua with and C++ code of engine and vice versa.
Scripting Flow
First, we count with two main files: ModuleScripting and ComponentScript. We will talk
about the component script later. ModuleScripting is a Sub Class of Module that will have the Lua State in order
to use lua scripts in the engine. On the init of Engine will create an instance of Lua State and init all lua
libraries. After, Application
wil call a virtual function in Module called LuaRegister()
in charge of register all functions and
fields that we want to use in scripts, for example the Module Input will Register its functions GetKey,
GetMouseButton...
After the init and start of all modules, starts the Update loop. ModuleScripting does not
have any instructions to do in the loop, all logic is in component script. The update of GameObjects do the
update of all its components. The main structure of Component Script is drawed in the diagram above. Once the
engine is in game mode, will check if is the first time the component do the first update, if not, the engine
will compile the script and saved a copy of the lua table in a LuaRef (we will talk later when we explain the
component). After compiling, or not if was already compiled, the script pushes global variables to the lua
state. This is made because you will want to access to the GameObject attached to component script but lua has
not know what GameObject is the object you are calling. Lua allows you to set global variables, so we push the
pointer of GameObject of the component and called it "gameObject", so now in script when we type "gameObject" we
will refering to the GameObject of the script. We made the same with transform
and with public vars
in inspector.
Once all variables are pushed we see if we have to call Start
or
Update
. Is important to call the function from LuaRef because we can have more than one GameObject
with the same script and if we execute the script as normal the variables will we shared with all GameObject
that have the same script (in the script sctructure we will see why we do like that).
After execute the script it is the time to pop the global variables we pushed before in order that other scripts do not access to other GameObjects and other vars. We pushed from lua stack. Also we update the public variables because we send a copy of that variables.
This is the Update of component script. After finish the Update, engine will check if the user wants to exit, if he want, will destroy all modules. ModuleScripting will close Lua State. And finally close all application.
The component script will be the container that will compile and execute the script and save the public variables in order to print them in the inspector. Here we have the class diagram:
The most important in the component is the LuaRef var and the script_path. LuaRef is a structure of LuaBridge that keep the reference of any variable in a Lua script. To set some context, here we have the Model Script:
This is the script Model, when you create a script inside the engine, will copy that and
change the name class for the name you setted. As we can see, all is in a function that returns a local table.
Because you cannot get local variables in C++ from Lua we have a complete function that returns a local table.
With that we save some headaches with the shared scripts with some GameObjects. The main variable here is the
Model
(or the name you setted to the script) that will act like a class in C++. Model is a table
that has three different variables. Variables
is a table that will keep the public variables that
we want to see in the inspector in order to modify in the engine. We also have Start
and
Update
that we have explained before. The user can create new variables inside Model table. Every
time a component script compile a script, will execute the Init function and save in a LuaRef the table.
In order to have public vars that user can edit we have to consider some things specials in
lua. Firs of all, lua is dynamically typed so you can have a number and later assign a string, this will be
difficult to get in the inspector. Lua types are nil, boolean, number (only "float", int does not exist),
string, userdata, function, thread, and table. WhispEngine can hold in editor the next types: boolean, int,
float, string, GameObject and Prefab. to store that variables in editor we have to read from the raw script and
save in a container. The two classes above were made to store that data and print in the inspector.
PublicVar
is the base class and Property class is the class to store data, inheriting from
PublicVar. We made that way because we want to save in the same vector different type of data. Each script
component will save a map of string and PublicVar. PublicVar also keeps the variable type and a list of macros
in order to edit the way variables show in the inspector. WhispEngine for the moment has four macros.
ISGAMEOBJECT is when you declare a GameObject to know that will be a GameObject. This can sound a little weird,
but it is necessary in lua because it is not like c# that you have GameObject variable_name;
in lua
is like this: variable_name
, and that could be a GameObject, a number, a string... and the same
with Prefabs. So in order to let the engine understand what will be you have to initialize all variables that
you want in the inspector. This are an example:
Script
In engine Inspector
GameObject vars are treated as GameObject pointers, to assign a GameObject to a public variable in the inspector just drag a Gameobject from the hierarchy to the variable in the inspector. The Engine will save all variables in the scene with the data you setted. If you want to instantiate a Gameobject from a script the better way is to create a prefab of that GameObject and create a public var in the script. To assign a Prefab just Drag from Resource panel the prefab you want to the variable prefab. Don't forget to set the macros, in the case of GameObjects is: variable_name = nil, --[GameObject]. And for Prefabs is: variable_name = nil, --[Prefab].
Introduction
Here you will find the functions and global variables that uses the scripting system in order to create your own scripts. WhispEngine has an autocomplete for ZeroBrane editor (see Configuration/ZeroBrane/README.md)
Public variables
All the variables you set in the table of Variables will be public in the inspector. to access later in the script you will have to add the prefix "var".
For example if you have speed = 5, later in code you will have to refer to it as var.speed to access the value in the inspector.
GameObject
GameObject is a class of C++ that you can use in lus scripts. All GameObjects you have in scripts will have that fields:
active:
Changes the active bool of GameObject.
gameObject.active = false --> deactive the GameObject
name:
Changes the name of GameObject.
gameObject.name = 'Tina' --> Sets the name of GameObject to 'Tina'
transform:
Gets the transform object of the GameObject.
GameObject
GameObject is also a namespace. You can use this functions from GameObject namespace
Instantiate:
Crates an instance of a Prefab. Sends a Prefab and return a GameObject pointer.
Destroy:
Destroys a GameObject. Sends a GameObject pointer.
SetColor:
Change the color of a GameObject. Send a GameObject pointer and three numbers from RGB.
gameObject
The word "gameObject" is reserved for the GameObject pointer of the GameObject attached to that script component.
Vector3
Vector3 is a class and a namespace. You can use this functions and fields
(Constructor):
To create a Vector3 you can send nothing or three numbers. vec = Vector3() or vec = Vector3(0,0,0).
x:
Gets x value.
y:
Gets y value.
z:
Gets z value.
Normalize:
Normalize the Vector3.
Normalized:
Returns the Vector3 normalized.
Magnitude:
Returns the magnitude.
sqrMagnitude:
Returns the magnitude sqrt.
toString:
Returns a string with the info of the Vector3.
FromEuler:
Creates a Quaternion from euler angles XYZ.
Quaternion
Quaternion is a class and a namespace. You can use this functions and fields
(Constructor):
To create a Quaternion you have to send x y z and w numbers. quat = Quaternion(x,y,z,w).
x:
Gets x value.
y:
Gets y value.
z:
Gets z value.
Normalize:
Normalize the Quaternion.
Normalized:
Returns the Quaternion normalized.
toString:
Returns a string with the info of the Quaternion.
ToEuler:
Creates a Vector3 from euler angles XYZ.
SetFromAxisAngle:
Set the Quaternion from an axis and an angle.
FromEuler:
Set the Quaternion from a Vector3 Euler Angles.
RotateAxisAngle:
Rotates the Quaternion from an axis and an angle.
RotateX:
Rotates the Quaternion in X axis the given the angle in radians.
RotateY:
Rotates the Quaternion in Y axis the given the angle in radians.
RotateZ:
Rotates the Quaternion in Z axis the given the angle in radians.
Random
Random is a namespace.
Range:
Gives a random int between the given 2 numbers.
Rangef:
Gives a random float between the given 2 numbers.
Log
Log is a function.
Logs in console the message you send.
Time
Time is a namespace.
deltaTime:
Returns the Delta Time.
time:
Returns the time in seconds since game starts.
transform
The word "transform" is reserved for the Transform pointer of the GameObject attached to that script component. All GameObjects you have in scripts will have that fields:
gameObject:
Is the GameObject of the own Transform.
parent:
The parent of the GameObject of the Transform.
position:
The Local position referenced to parent.
gposition:
The Global position.
rotation:
The Local Rotation.
grotation:
The Global Rotation.
forward:
Forward vector of the global rotation.
up:
Upper vector of the global rotation.
right:
Right vector of the global rotation.
scale:
Local Scale.
SetPositionv:
Function to set the position of the GameObject. The argument is a Vector3.
transform:SetPositionv(Vector3(1, 0, 0)) --> Set the position to position (1, 0, 0)
SetPosition3f:
Function to set the position of the GameObject. The argument are 3 numbers.
transform:SetPosition3f(1, 0, 0) --> Set the position to position (1, 0, 0)
transform
The word "transform" is reserved for the Transform pointer of the GameObject attached to that script component. All GameObjects you have in scripts will have that fields:
gameObject:
Is the GameObject of the own Transform.
parent:
The parent of the GameObject of the Transform.
position:
The Local position referenced to parent.
gposition:
The Global position.
rotation:
The Local Rotation.
grotation:
The Global Rotation.
forward:
Forward vector of the global rotation.
up:
Upper vector of the global rotation.
right:
Right vector of the global rotation.
scale:
Local Scale.
input
input is a namespace.
getKey:
Returns true while pressing that key.
getKeyDown:
Returns true on press that key.
getKeyUp:
Returns true on release that key.
getMouseDown:
Returns true on press that mouse button.
getMouse:
Returns true while that mouse button.
getMouseUp:
Returns true on release that mouse button.
getMouseX:
Returns the X coordenate of mouse on screen.
getMouseY:
Returns the Y coordenate of mouse on screen.
getMouseZ:
Returns the Z coordenate of mouse on screen.
Copyright © 2018 - All Rights Reserved - Empty Whisper
Template by OS Templates


[gecode-users] a propagator for the Context-Free-Grammar constraint
Christian Schulte
cschulte at kth.se
Tue Sep 23 09:24:15 CEST 2014
Hi Pierre,
Thanks for the announcement. If there is anybody who is interested, maybe
that person could also be interested to clean the implementation up, design
a nice interface to the propagator for CFGs (in the style of regular
expressions or DFAs in Gecode).
If you are interested, please get in touch with me!
Cheers
Christian
--
Christian Schulte, www.ict.kth.se/~cschulte/
> -----Original Message-----
> From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On
> Behalf Of Pierre Flener
> Sent: Tuesday, September 23, 2014 8:55 AM
> To: users at gecode.org
> Cc: Jun He
> Subject: [gecode-users] a propagator for the Context-Free-Grammar
constraint
>
> Hi all,
>
> As a useful complement to the built-in REGULAR constraint of Gecode,
> constraining a fixed-length sequence of variables to form a word that
belongs to
> the regular language defined by a regular expression (RE) or
(non-)deterministic
> finite automaton (NFA/DFA), there exists the CFG constraint, which
constrains a
> fixed-length sequence of variables to form a word that belongs to the
context-
> free language defined by a context-free grammar (CFG). Languages of words
of
> fixed length are finite, and hence regular, so a CFG constraint over
fixed-length
> sequences is theoretically not needed. However, there are languages where
a
> context-free grammar is much more compact than an RE/DFA/NFA, to the point
> that the cubic-time propagation of the CFG constraint pays off versus the
much
> lower time complexity of a REGULAR propagator. So far, Gecode
unfortunately
> lacks a CFG constraint.
>
> The state-of-the-art propagator for the CFG constraint described in
>
> J. He, P. Flener, J. Pearson, and W. M. Zhang.
> Solving string constraints: The case for constraint programming.
> In: Ch. Schulte (editor), CP 2013, pages 381-397. Lecture Notes in
> Computer Science, volume 8124.
> Springer, 2013.
> http://dx.doi.org/10.1007/978-3-642-40627-0_31
> http://www.it.uu.se/research/group/astra/publications/CP13cfg.pdf
> http://cp2013.a4cp.org/slides/44.pdf
>
> was implemented in Gecode by Jun He (Cc:ed) and is made available at
> http://www.it.uu.se/research/group/astra/software#cfg : note that the
> implementation is provided as is, and does not fully comply yet with
Gecode
> style, but we hope it will already be useful to some.
>
> Cheers,
> Pierre
>
>
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
More information about the users
mailing list


Fountainize is the easiest way to write screenplays with Google Docs:
The default - if it doesn't follow another rule, it's an action!
Write CHARACTERS in all caps.
Dialogue always follows a character or paranthetical.
Start the line with "int." or "ext."
Start the line with a bracket
End the line with TO:


The main process of SDE is written in AppConsole.java. It is developed based on DEPTA method invented by Yanhong Zhai and Bing Liu. DEPTA extracts structured data from a web page in these following steps:
The general architecture of the DEPTA system (Zhai and Liu, 2006)
First, we build a tag tree for the web page. SDE uses NekoHTML Parser to create the DOM tree of the web page, then it creates the tag tree based on the DOM tree. The input parameter is a string parameter in URI format. It refers to the input web page. The ignoreFormattingTags parameter is a boolean parameter. If its value is true, then HTML style formatting tags like B, I, U, etc. will be ignored in the tag tree building (it will be treated as ordinary text).
TagTreeBuilder builder = new DOMParserTagTreeBuilder();
TagTree tagTree = builder.buildTagTree(input, ignoreFormattingTags);
After the tag tree has been built, SDE will create a TreeMatcher object that will be used to calculate similarity score between subtrees in the tag tree. SDE uses an implementation of Simple Tree Matching algorithm. The TreeMatcher objec will be passed as a parameter in MiningDataRegions constructor. MiningDataRegions is an implementation of Mining Data Regions algorithm to identify data regions that exists in the web page. To find those data regions, SDE will call findDataRegions method in the MiningDataRegions object. The method will return a list of DataRegion objects; We can customize parameter values used in Mining Data Regions algorithm like maximum node in generalized nodes (default 9) and similarity treshold (default 90%).
TreeMatcher matcher = new SimpleTreeMatching();
DataRegionsFinder dataRegionsFinder = new MiningDataRegions( matcher );
List<DataRegion> dataRegions = dataRegionsFinder.findDataRegions(tagTree.getRoot(), maxNodeInGeneralizedNodes, similarityTreshold);
For each data region, SDE will extract its data records (rows in a table structure) by calling findDataRecords method in MiningDataRecords object. The method will return an array of DataRecord object.
DataRecordsFinder dataRecordsFinder = new MiningDataRecords( matcher );
DataRecord[][] dataRecords = new DataRecord[ dataRegions.size() ][];
for( int dataRecordArrayCounter = 0; dataRecordArrayCounter < dataRegions.size(); dataRecordArrayCounter++)
{
DataRegion dataRegion = dataRegions.get( dataRecordArrayCounter );
dataRecords[ dataRecordArrayCounter ] = dataRecordsFinder.findDataRecords(dataRegion, similarityTreshold);
}
For each array of DataRecord, SDE will align their data items to transform them into a table (in rows and column) structure. SDE doing that by calling alignDataRecords method in a ColumnAligner object. The method will return a two dimensional array of string that contains extracted data items. SDE uses an implementation of Partial Tree Alignment algorithm in the column alignment. We can choose whether to use the similarity of the data items in the column alignment process or not. If we choose to use the similarity of the data items, SDE will use an implementation of Enhanced Simple Tree Matching algorithm instead of Simple Tree Matching in calculating similarity score in the partial tree alignment process. SDE implementation of Enhanced Simple Tree Matching is not a full implementation because it doesn't use visual information as described by Zhai and Liu (2006).
ColumnAligner aligner = null;
if ( useContentSimilarity )
{
aligner = new PartialTreeAligner( new EnhancedSimpleTreeMatching() );
}
else
{
aligner = new PartialTreeAligner( matcher );
}
List<String[][]> dataTables = new ArrayList<String[][]>();
for(int tableCounter=0; tableCounter< dataRecords.length; tableCounter++)
{
String[][] dataTable = aligner.alignDataRecords( dataRecords[tableCounter] );
if ( dataTable != null )
{
dataTables.add( dataTable );
}
}


JMU AOI
Erratic Driving Reports
Recent Reports
Past Reports
Statistics
Try me
HH:MM:SS
Reported: YES
Location:
DD:MM:YYYY
HH:MM:SS
Reported: NO
Location:
webdesign münchen


My background is in computational fluid dynamics and, during my career, I transitioned from being a domain scientist to my current role as an HPC software engineer at ETHZ and as a freelancer.
I enjoy understanding the interaction among different layers of the software stack and the hardware and how it affects performance.
Lately I started to get interested in code generation and domain specific languages in the context of optimizing kernels programmatically for different hardware.
I obtained my M.Sc. and PhD degrees in aerospace engineering from the University of Southern California, USA, in 2011 and 2015 respectively, while my B.Sc. in mechanical engineering was obtained at the Polytechnic University of Milan, Italy, in 2009.
My PhD thesis was related to high-fidelity turbulence modeling for separated and transitional flows, and the quantification of numerical errors.
After my doctoral appointment, I worked at Tesla Motors as a computational fluid dynamics analyst in both the thermal and external aerodynamics groups.
While at Tesla I submitted a patent for a novel vent design.
In 2016, I was a postdoctoral scholar at the California Institute of Technology (USA) working on high-fidelity simulations of multi-species supercritical flows.
When I moved to Imperial College (UK) in 2018, I worked on high-order unstructured methods for shock-wave boundary layer interactions.
Here I started my transition from domain scientist to software developer working on the open-source spectral finite element solver Nektar++.
Among other topics, I ported a few kernels that utilize the single instruction multiple data (SIMD) paradigm for which I wrote a simple,
header-only SIMD library.
HPC Software Engineer for QuICC, a software for dynamo (magnetohydrodynamics) simulations.
Refactoring for hybrid parallelization (mpi+GPU/threads).
Refactored building (CMake) and testing infrastructure (CI/CD).
Freelance Software Engineer working on the C++ based, open-source, spectral finite element framework Nektar++.
Implementing a DSL using MLIR framework for generating performance critical kernels for different back-ends.
Implemented Arm SVE back-end for in-house SIMD library.
HPC Software Performance Engineer in the HPC team at the Blue Brain Project.
Developer for HBP (Human Brain Project) STEPS (STochastic Engine for Pathway Simulation).
Investigated explicit SIMD libraries as a possible alternative to auto-vectorization in CoreNEURON.
Senior developer of the C++ based, open-source, spectral finite elementframework Nektar++.
High fidelity simulations (LES/DNS) to predict shock wave unsteadiness in turbofan intake cowls at off-design conditions.
Implementation and validation of shock capturing schemes in an open-source high-order finite element CFD software.
DNS simulations of multi-species, high-pressure flows relevant to fuel injection.
Implemented a thermodynamic model to predict phases of fuel-air mixtures.
Responsible for researching alternative CFD methodologies.
Responsible for HVAC aerodynamics of Model 3.
US patent for novel air vent design (US010464397B2)
.
Prediction of laminar separation bubbles over wing/blade geometries.
Large Eddy Simulations.
Quantification of numerical dissipation.
Immersed Boundary, Finite Volume code.
Parallel computing.
Summer internship, simulations run on a cluster with STAR-CCM+ software.
AME 499 Turbine Design and Analysis.
AME 408 Computer-Aided Design of Mechanical Systems (SolidWorks/CosmosWorks).
AME 301 Dynamics.
AME 150 Introduction to Computational Methods (MATLAB).
Computational Fluid and Solid Mechanics track.
Exchange student, Erasmus program.


Urb.
Shrub,
1.5-2
di.
high.
Coastal
thickets,
Guanica.
Brother
Alain
Liogier
December
1963
01071664
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


The Clover SDK for Android facilitates development of applications running on Clover devices, see below for more information about the functionality provided by this SDK.
Interfaces to use with bound Clover services that allow management of a merchant's data: orders, inventory, customers, employees, printers, properties, etc. Service classes starting with 'I' are the underlying AIDL interfaces. Clover provides corresponding ServiceConnector classes for simpler usage.
For more information about binding to services, refer to the Android documentation: Bound Services.
Intents are used to send and receive broadcast messages in Android as well as start activities and services. The {@link com.clover.sdk.v1.Intents} class has definitions for most commonly used intents for broadcasts sent by Clover and starting Clover activities.
Clover devices offer additional functionality beyond standard Android, such as:
Searching for and displaying large amounts of data is best done through a content provider. Inserting, updating and deleting Clover data objects via content provider is generally not supported.
For more information about content providers, refer to the Android documentation: Content Provider Basics.
The v1 data objects and associated interfaces tend to conform to the deprecated Clover v1 and v2 web REST API, the v3 objects and associated interfaces tend to conform to the Clover v3 web REST API. Changes to Clover data objects must be sent to the appropriate service interface to take effect.
Clover data objects offer interfaces to convert to and from JSON as well as being Parcelable.
For complete examples and more information about Clover development please visit the Clover development website.


‘Wrongdoers will not be spared’
Naidu’s threats to police smack of arrogance: Chief Whip
by Special CorrespondentGovernment Chief Whip G. Srikanth Reddy on Wednesday took exception to TDP national president N. Chandrababu Naidu allegedly issuing threats to the police and accusing them of booking cases against party leader Chintamaneni Prabhakar.
Speaking at the YSRCP central office at Tadepalli, Mr. Srikanth Reddy said people were laughing at Mr. Naidu for being “arrogant” even after losing power.
Dig at Yanamala
The YSRCP government was neutral in its governance and would not hesitate to initiate action against the wrongdoers, regardless of their party affiliation, he said. Mr. Naidu, during his tenure, had weakened the police department, and was now unable to digest the fact that the police was taking an upright stand without any bias, Mr. Srikanth Reddy said. Stating that a rowdy-sheet had been opened against Mr. Prabhakar for allegedly committing atrocities against Dalits and weaker sections, he criticised former Finance Minister Yanamala Ramakrishnudu for supporting Mr. Prabhakar.
The Opposition leader was adopting double standards on the issue of medium of instruction in the government schools, Mr. Srikanth Reddy alleged.
Claiming that in its six-month-rule, the YSRCP government had introduced a series of programmes for the welfare of the poorer sections of society, he said the TDP leader should realise that his party had lost its hold not only in A.P. but also in Telangana. The TDP would be wiped out in A.P. soon, he added.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Uses of Job in org.apache.hadoop.mapreduce |
|---|
| Methods in org.apache.hadoop.mapreduce that return Job | |
|---|---|
Job[] |
Cluster.getAllJobs()
Deprecated. Use Cluster.getAllJobStatuses() instead. |
static Job |
Job.getInstance()
Creates a new Job with no particular Cluster . |
static Job |
Job.getInstance(Cluster ignored)
Deprecated. Use getInstance() |
static Job |
Job.getInstance(Cluster ignored,
Configuration conf)
Deprecated. Use getInstance(Configuration) |
static Job |
Job.getInstance(Cluster cluster,
JobStatus status,
Configuration conf)
Creates a new Job with no particular Cluster and given
Configuration and JobStatus . |
static Job |
Job.getInstance(Configuration conf)
Creates a new Job with no particular Cluster and a
given Configuration . |
static Job |
Job.getInstance(Configuration conf,
String jobName)
Creates a new Job with no particular Cluster and a given jobName. |
static Job |
Job.getInstance(JobStatus status,
Configuration conf)
Creates a new Job with no particular Cluster and given
Configuration and JobStatus . |
Job |
Cluster.getJob(JobID jobId)
Get job corresponding to jobid. |
| Uses of Job in org.apache.hadoop.mapreduce.lib.aggregate |
|---|
| Methods in org.apache.hadoop.mapreduce.lib.aggregate that return Job | |
|---|---|
static Job |
ValueAggregatorJob.createValueAggregatorJob(Configuration conf,
String[] args)
Create an Aggregate based map/reduce job. |
static Job |
ValueAggregatorJob.createValueAggregatorJob(String[] args,
Class<? extends ValueAggregatorDescriptor>[] descriptors)
|
| Uses of Job in org.apache.hadoop.mapreduce.lib.chain |
|---|
| Methods in org.apache.hadoop.mapreduce.lib.chain with parameters of type Job | |
|---|---|
static void |
ChainMapper.addMapper(Job job,
Class<? extends Mapper> klass,
Class<?> inputKeyClass,
Class<?> inputValueClass,
Class<?> outputKeyClass,
Class<?> outputValueClass,
Configuration mapperConf)
Adds a Mapper class to the chain mapper. |
static void |
ChainReducer.addMapper(Job job,
Class<? extends Mapper> klass,
Class<?> inputKeyClass,
Class<?> inputValueClass,
Class<?> outputKeyClass,
Class<?> outputValueClass,
Configuration mapperConf)
Adds a Mapper class to the chain reducer. |
static void |
ChainReducer.setReducer(Job job,
Class<? extends Reducer> klass,
Class<?> inputKeyClass,
Class<?> inputValueClass,
Class<?> outputKeyClass,
Class<?> outputValueClass,
Configuration reducerConf)
Sets the Reducer class to the chain job. |
| Uses of Job in org.apache.hadoop.mapreduce.lib.db |
|---|
| Methods in org.apache.hadoop.mapreduce.lib.db with parameters of type Job | |
|---|---|
static void |
DataDrivenDBInputFormat.setInput(Job job,
Class<? extends DBWritable> inputClass,
String inputQuery,
String inputBoundingQuery)
setInput() takes a custom query and a separate "bounding query" to use instead of the custom "count query" used by DBInputFormat. |
static void |
DBInputFormat.setInput(Job job,
Class<? extends DBWritable> inputClass,
String inputQuery,
String inputCountQuery)
Initializes the map-part of the job with the appropriate input settings. |
static void |
DataDrivenDBInputFormat.setInput(Job job,
Class<? extends DBWritable> inputClass,
String tableName,
String conditions,
String splitBy,
String... fieldNames)
Note that the "orderBy" column is called the "splitBy" in this version. |
static void |
DBInputFormat.setInput(Job job,
Class<? extends DBWritable> inputClass,
String tableName,
String conditions,
String orderBy,
String... fieldNames)
Initializes the map-part of the job with the appropriate input settings. |
static void |
DBOutputFormat.setOutput(Job job,
String tableName,
int fieldCount)
Initializes the reduce-part of the job with the appropriate output settings |
static void |
DBOutputFormat.setOutput(Job job,
String tableName,
String... fieldNames)
Initializes the reduce-part of the job with the appropriate output settings |
| Uses of Job in org.apache.hadoop.mapreduce.lib.input |
|---|
| Methods in org.apache.hadoop.mapreduce.lib.input with parameters of type Job | |
|---|---|
static void |
FileInputFormat.addInputPath(Job job,
Path path)
Add a Path to the list of inputs for the map-reduce job. |
static void |
MultipleInputs.addInputPath(Job job,
Path path,
Class<? extends InputFormat> inputFormatClass)
Add a Path with a custom InputFormat to the list of
inputs for the map-reduce job. |
static void |
MultipleInputs.addInputPath(Job job,
Path path,
Class<? extends InputFormat> inputFormatClass,
Class<? extends Mapper> mapperClass)
Add a Path with a custom InputFormat and
Mapper to the list of inputs for the map-reduce job. |
static void |
FileInputFormat.addInputPaths(Job job,
String commaSeparatedPaths)
Add the given comma separated paths to the list of inputs for the map-reduce job. |
static void |
SequenceFileInputFilter.setFilterClass(Job job,
Class<?> filterClass)
set the filter class |
static void |
FileInputFormat.setInputDirRecursive(Job job,
boolean inputDirRecursive)
|
static void |
FileInputFormat.setInputPathFilter(Job job,
Class<? extends PathFilter> filter)
Set a PathFilter to be applied to the input paths for the map-reduce job. |
static void |
FileInputFormat.setInputPaths(Job job,
Path... inputPaths)
Set the array of Path s as the list of inputs
for the map-reduce job. |
static void |
FileInputFormat.setInputPaths(Job job,
String commaSeparatedPaths)
Sets the given comma separated paths as the list of inputs for the map-reduce job. |
static void |
FileInputFormat.setMaxInputSplitSize(Job job,
long size)
Set the maximum split size |
static void |
FileInputFormat.setMinInputSplitSize(Job job,
long size)
Set the minimum input split size |
static void |
NLineInputFormat.setNumLinesPerSplit(Job job,
int numLines)
Set the number of lines per split |
| Uses of Job in org.apache.hadoop.mapreduce.lib.jobcontrol |
|---|
| Methods in org.apache.hadoop.mapreduce.lib.jobcontrol that return Job | |
|---|---|
Job |
ControlledJob.getJob()
|
| Methods in org.apache.hadoop.mapreduce.lib.jobcontrol with parameters of type Job | |
|---|---|
void |
ControlledJob.setJob(Job job)
Set the mapreduce job |
| Constructors in org.apache.hadoop.mapreduce.lib.jobcontrol with parameters of type Job | |
|---|---|
ControlledJob(Job job,
List<ControlledJob> dependingJobs)
Construct a job. |
| Uses of Job in org.apache.hadoop.mapreduce.lib.map |
|---|
| Methods in org.apache.hadoop.mapreduce.lib.map with parameters of type Job | ||
|---|---|---|
static
|
MultithreadedMapper.setMapperClass(Job job,
Class<? extends Mapper<K1,V1,K2,V2>> cls)
Set the application's mapper class. |
|
static void |
MultithreadedMapper.setNumberOfThreads(Job job,
int threads)
Set the number of threads in the pool for running maps. |
| Uses of Job in org.apache.hadoop.mapreduce.lib.output |
|---|
| Methods in org.apache.hadoop.mapreduce.lib.output with parameters of type Job | |
|---|---|
static void |
MultipleOutputs.addNamedOutput(Job job,
String namedOutput,
Class<? extends OutputFormat> outputFormatClass,
Class<?> keyClass,
Class<?> valueClass)
Adds a named output for the job. |
static void |
FileOutputFormat.setCompressOutput(Job job,
boolean compress)
Set whether the output of the job is compressed. |
static void |
MultipleOutputs.setCountersEnabled(Job job,
boolean enabled)
Enables or disables counters for the named outputs. |
static void |
SequenceFileOutputFormat.setOutputCompressionType(Job job,
org.apache.hadoop.io.SequenceFile.CompressionType style)
Set the SequenceFile.CompressionType for the output SequenceFile . |
static void |
FileOutputFormat.setOutputCompressorClass(Job job,
Class<? extends CompressionCodec> codecClass)
Set the CompressionCodec to be used to compress job outputs. |
static void |
LazyOutputFormat.setOutputFormatClass(Job job,
Class<? extends OutputFormat> theClass)
Set the underlying output format for LazyOutputFormat. |
static void |
FileOutputFormat.setOutputPath(Job job,
Path outputDir)
Set the Path of the output directory for the map-reduce job. |
static void |
SequenceFileAsBinaryOutputFormat.setSequenceFileOutputKeyClass(Job job,
Class<?> theClass)
Set the key class for the SequenceFile |
static void |
SequenceFileAsBinaryOutputFormat.setSequenceFileOutputValueClass(Job job,
Class<?> theClass)
Set the value class for the SequenceFile |
| Uses of Job in org.apache.hadoop.mapreduce.lib.partition |
|---|
| Methods in org.apache.hadoop.mapreduce.lib.partition with parameters of type Job | ||
|---|---|---|
static void |
KeyFieldBasedComparator.setKeyFieldComparatorOptions(Job job,
String keySpec)
Set the KeyFieldBasedComparator options used to compare keys. |
|
void |
KeyFieldBasedPartitioner.setKeyFieldPartitionerOptions(Job job,
String keySpec)
Set the KeyFieldBasedPartitioner options used for
Partitioner |
|
static
|
InputSampler.writePartitionFile(Job job,
org.apache.hadoop.mapreduce.lib.partition.InputSampler.Sampler<K,V> sampler)
Write a partition file for the given job, using the Sampler provided. |
| Uses of Job in org.apache.hadoop.mapreduce.tools |
|---|
| Methods in org.apache.hadoop.mapreduce.tools with parameters of type Job | |
|---|---|
protected void |
CLI.displayTasks(Job job,
String type,
String state)
Display the information about a job's tasks, of a particular type and in a particular state |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Police fight protesters on Caribbean island of Dominica
by The Associated PressST. JOHN’S, Antigua (AP) — Officials say a protest over election reform erupted on the Caribbean island of Dominica, with more than 200 people fighting police before being dispersed with tear gas.
Assistant Police Commissioner Richmond Valentine says more 200 protesters clashed with police when they tried to march to President Charles Savarin’s home on Monday evening.
Police fired tear gas after protesters removed metal street barriers. No fatalities or major injuries were reported.
The former French and British colony of about 75,000 residents holds elections on Dec. 6. The opposition United Workers’ Party has been pushing the ruling party to enact reforms that could reduce the ruling party’s electoral advantage.
Prime Minister Roosevelt Skerrit’s government has not enacted the reforms, leading to charges of unfairness.
The Associated Press


Stanisław Góra
The aim of this project is to create an application for viewing Wikipedia's pages in a new and innovative way: by visualizing connections between articles. Additional tools - such as the timeline and the currently selected subpage preview - will allow for analysis of the presented data.
The project is conducted at the Gdańsk University of Technology Immersive 3D Visualization Lab as an bachelor thesis project.


{% extends "registration/registration_base.html" %} {% load i18n %} {% block title %}{% trans "Account Activation Resent" %}{% endblock %} {% block content %}
{% blocktrans %} We have sent an email to {{ email }} with further instructions. {% endblocktrans %}
{% endblock %} {% comment %} **registration/resend_activation_complete.html** Used after form for resending account activation is submitted. By default has the following context: ``email`` The email address submitted in the resend activation form. {% endcomment %}