This page tracks the new paper links made to my list of SGP 2011 papers.
Page maintained by Ke-Sen Huang.
If you have additions or changes, send an e-mail.
September 14, 2011
- On the shape of a Set of Points and Lines in the Plane
(TR)
August 15, 2011
- Large-Scale Integer Linear Programming for Orientation Preserving 3D Shape Matching
July 29, 2011
- Skeleton Computation of Orthogonal Polyhedra
July 25, 2011
- Deformable 3D Shape Registration Based on Local Similarity Transforms
July 9, 2011
- Multiscale Biharmonic Kernels
- A Multiscale Metric for 3D Mesh Visual Quality Assessment
- Surface Patches from Unorganized Space Curves
- On Approximation of the Laplace-Beltrami Operator and the Willmore Energy of Surfaces
- An Optimization Approach to Improving Collections of Shape Maps
July 6, 2011
- Localized Delaunay Refinement for Volumes
July 1, 2011
- A Condition Number for Non-Rigid Shape Matching
- Rational Bi-cubic G2 Splines for Design with Basic Shapes
- As-Killing-As-Possible Vector Fields for Planar Deformation
- An optimal transport approach to robust reconstruction and simplification of 2D shapes
()
()
(Thesis)
- A Multiscale Approach to Optimal Transport
- On the shape of a Set of Points and Lines in the Plane
(TR)
June 26, 2011
- Functional Webs for Freeform Architecture
- CubeCover - Parameterization of 3D Volumes
- All-Hex Mesh Generation via Volumetric PolyCube Deformation
- Coarse-to-Fine Combinatorial Matching for Dense Isometric Shape Correspondence
- Deformable 3D Shape Registration Based on Local Similarity Transforms
- A Complex View of Barycentric Mappings
- VASE: Volume-Aware Surface Evolution for Surface Reconstruction from Incomplete Point Clouds
- An optimal transport approach to robust reconstruction and simplification of 2D shapes
(Thesis)
- Page published
kesen.huang@gmail.com


Designed for PROfessionals Introducing the most advanced 3D printing pen from the maker of the original 3D printing pen. Designed to meet the demands and ambitions of creative professionals - architects, engineers, designers, artists and more. The 3Doodler PRO is an invaluable prototyping and tactile design tool like no other, enabling you to efficiently communicate your unique creative vision in 3D form.
of #AllNaturalVines, freelance filmmaker and animator who creates high quality Stop Motion design often using basic materials like clay, paper, wood or plastic. work Dylan was studying Economics when first discovered Vine - and used it to clear his mind during finals. Three years later, and this past-time has become part of Dylan's career as an animator with extraordinary stop-motion Vines. Dylan now works full-time on stop-motion animation, motion graphics, 2D cel animation, and 3D animation to create unique & stunning visual results.
past work I’ve always been fascinated by platonic solids. In a lot of my videos, low poly paper craft shapes are used as part of the sets. What intrigued me with this project in particular was the ability to be able to see every edge and connecting point of the shape, since all that’s needed to hold it together is the wireframe. With this project I wanted to show the very foundation of the PRO pen. It is just as you expect, drawing in 3D space. By transitioning from a flat square to a cube, the goal was to illustrate that with the PRO pen, you literally ‘lift your imagination off the page’. And by implementing more and more complex shapes as the video goes on, the viewer realizes that the things you can create go beyond just the basics. I like to draw on stencils first, which allows me to get the most accurate representation of the designs. Thanks to the ability to mold and weld the material with the tip of the PRO pen, edges and corners can easily be achieved, turning flat Doodles into 3D objects. Usually it helps if I create a mockup in 3D software. You can never get the same organic and crafty feel with computer generated imagery though, and that’s where I like to grab the PRO pen and turn my design into a piece of art that you can actually grasp. With speed and temperature adjustments right at your fingertips, the PRO pen is highly customizable, making it the most advanced 3D drawing experience yet.


One of the most widely used Javascript widgets is carousel, it is used everywhere from photo slides, product highlights, page navigation, top stories panel, and others. All literally are carousel but with different look and feel.
Pluit Carousel is a simple carousel written to be as bare and simple as possible; so you can use it right away, or easily
customize to meet your carousel needs. The idea is to use the same semantically structured HTML and Javascript
initialization codes, and applying different skins for customized look and feel. And If you need more advanced
behavior, you can easily extend Pluit.Carousel
.
If you have created new skins that you would like to share with others, ping me so that I can include the references on this page. Thanks!
Tested on Prototype 1.6.1 and Scriptaculous 1.8.3.
<link rel="stylesheet" href="css/pluit-carousel.css" type="text/css" media="screen">

css/pluit-carousel-skins.css
,
append to pluit-carousel
class, e.g. big-nav-skin for larger navigation buttons:
 ...

| Name | Default |
|---|---|
| circular | false |
| hideAutoNav | false |
| effect | move (default) or fade |
| animDuration | 0.5 |
| autoPlay | false |
| slideDuration | 3 |
| viewportClassName | viewport |
| navClassName | nav |
| prevClassName | prev |
| nextClassName | next |
| pagesClassName | pages |
| pageClassNamePrefix | page- |
| activeClassName | active |
You can browse the source codes from github: http://github.com/jugend/pluit-carousel. To check out the source codes:
git clone git@github.com:jugend/pluit-carousel.git


This program is the Hello World of the LINQ samples and is designed to show you how simple LINQ to Objects queries can be. It shows the minimal code necessary to write a LINQ to Objects query over a list.


SHOWKEY(1) SHOWKEY(1) NAME showkey - examine the codes sent by the keyboard SYNOPSIS showkey [-h|--help] [-a|--ascii] [-s|--scancodes] [-k|--keycodes] DESCRIPTION showkey prints to standard output either the scan codes or the keycode or the `ascii' code of each key pressed. In the first two modes the program runs until 10 seconds have elapsed since the last key press or release event, or until it receives a suitable signal, like SIGTERM, from another process. In `ascii' mode the program terminates when the user types ^D. When in scancode dump mode, showkey prints in hexadecimal format each byte received from the keyboard to the standard output. A new line is printed when an interval of about 0.1 seconds occurs between the bytes received, or when the internal receive buffer fills up. This can be used to determine roughly, what byte sequences the keyboard sends at once on a given key press. The scan code dumping mode is primarily intended for debugging the keyboard driver or other low level interfaces. As such it shouldn't be of much interest to the regular end-user. However, some mod‐ ern keyboards have keys or buttons that produce scancodes to which the kernel does not associate a keycode, and, after finding out what these are, the user can assign keycodes with setkeycodes(8). When in the default keycode dump mode, showkey prints to the standard output the keycode number or each key pressed or released. The kind of the event, press or release, is also reported. Keycodes are numbers assigned by the kernel to each individual physical key. Every key has always only one associated keycode number, whether the keyboard sends single or multiple scan codes when pressing it. Using showkey in this mode, you can find out what numbers to use in your personalized keymap files. When in `ascii' dump mode, showkey prints to the standard output the dec‐ imal, octal, and hexadecimal value(s) of the key pressed, according to he present keymap. OPTIONS -h --help showkey prints to the standard error output its version number, a compile option and a short usage message, then exits. -s --scancodes Starts showkey in scan code dump mode. -k --keycodes Starts showkey in keycode dump mode. This is the default, when no command line options are present. -a --ascii Starts showkey in `ascii' dump mode. 2.6 KERNELS In 2.6 kernels key codes lie in the range 1-255, instead of 1-127. Key codes larger than 127 are returned as three bytes of which the low order 7 bits are: zero, bits 13-7, and bits 6-0 of the key code. The high order bits are: 0/1 for make/break, 1, 1. In 2.6 kernels raw mode, or scancode mode, is not very raw at all. Scan codes are first translated to key codes, and when scancodes are desired, the key codes are translated back. Various transformations are involved, and there is no guarantee at all that the final result corresponds to what the keyboard hardware did send. So, if you want to know the scan codes sent by various keys it is better to boot a 2.4 kernel. Since 2.6.9 there also is the boot option atkbd.softraw=0 that tells the 2.6 kernel to return the actual scan codes. SEE ALSO loadkeys(1), dumpkeys(1), keymaps(5), setkeycodes(8) 1 Feb 1998 SHOWKEY(1)


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object EigenMeat.EigenMaze.Vect3d
XYZ Vector class.
| Field Summary | |
float |
x
|
float |
y
|
float |
z
|
| Constructor Summary | |
Vect3d()
Default constructor for Vect3d. |
|
Vect3d(double x,
double y,
double z)
Constructor. |
|
Vect3d(float x,
float y,
float z)
Constructor. |
|
Vect3d(Vect3d v)
Copy constructor that allows you to copy another Vect3d object. |
| Method Summary | |
void |
add(Vect3d add)
Add a vector. |
void |
addm(Vect3d vector,
float scalar)
Helper function that multiplies a vector by a scalar before using it for addition. |
Vect3d |
cross(Vect3d v)
Performs a cross product operation. |
void |
div(float scalar)
Divide vector by a scalar. |
float |
dot(Vect3d v)
Performs a dot product operation on the vector. |
boolean |
equals(Vect3d rhs)
|
float |
getAngle(Vect3d v)
Gets the angle between 2 vectors. |
float[] |
getArray()
|
static void |
getBounceVect(Vect3d vel,
Vect3d normal,
Vect3d result)
Get the resulting vector after a bounce against a plane. |
static Vect3d |
getClosestPointOnLine(Vect3d a,
Vect3d b,
Vect3d p)
Get the closest point on the line between it and another point. |
float |
getDistance(Vect3d point)
|
static float |
getDistanceBetweenPoints(Vect3d a,
Vect3d b)
Get the distance between two points. |
float |
getX()
Accessor method for X coordinate. |
float |
getY()
Accessor method for Y coordinate. |
float |
getZ()
Accessor method for Z coordinate. |
void |
invert()
Inverts the vector. |
float |
length()
Returns the vector length. |
void |
mult(float scalar)
Multiply vector by a scalar. |
void |
mult(float scalar,
Vect3d result)
Multiply vector by a scalar and store the result in another vector. |
void |
normalize()
Normalize the vector. |
void |
rotateY(float angle)
Rotate vector around the Y Axis by an angle. |
void |
set(float x,
float y,
float z)
Set method for XYZ coordinate. |
void |
set(Vect3d v)
Sets XYZ coordinates using another Vect3d object. |
void |
sub(Vect3d s)
Subtract the vector by another vector |
void |
sub(Vect3d s,
Vect3d result)
Subtract by a vector and store the results in another vector. |
void |
subm(Vect3d vector,
float scalar)
Helper function that multiplies a vector by a scalar before using it for subtraction |
java.lang.String |
toString()
Method used to print the vector. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
public float x
public float y
public float z
| Constructor Detail |
public Vect3d()
public Vect3d(float x, float y, float z)
x
- x coordinatey
- y coordinatez
- z coordinatepublic Vect3d(double x, double y, double z)
x
- x coordinatey
- y coordinatez
- z coordinatepublic Vect3d(Vect3d v)
v
- Vect3d object to copy.| Method Detail |
public float getX()
public float getY()
public float getZ()
public void set(float x, float y, float z)
x
- x coordinatey
- y coordinatez
- z coordinatepublic void set(Vect3d v)
v
- Vect3d object to copypublic void invert()
public float length()
public void normalize()
public float dot(Vect3d v)
v
- The second vector to use for dot product operation
public Vect3d cross(Vect3d v)
v
- The second Vect3d object to use for the cross product.
public float getAngle(Vect3d v)
v
- The second vector
public void mult(float scalar)
scalar
- The number to multiply the vector with.public void div(float scalar)
scalar
- The number to divide the vector with.public void mult(float scalar, Vect3d result)
scalar
- The number to multiply the vector with.result
- The vector the result is stored in.public void sub(Vect3d s)
s
- The vector used to subtract with.public void sub(Vect3d s, Vect3d result)
s
- The vector used to subtract with.result
- The vector the results are stored in.public void add(Vect3d add)
add
- The vector used for addition.public void addm(Vect3d vector, float scalar)
vector
- the Vector used for additionscalar
- scalar number to multiply vector before adding with itpublic void subm(Vect3d vector, float scalar)
vector
- vector to use for subtractionscalar
- the number to multiply the vectorpublic void rotateY(float angle)
angle
- The angle to rotate the vectorpublic boolean equals(Vect3d rhs)
public float getDistance(Vect3d point)
public float[] getArray()
public java.lang.String toString()
public static void getBounceVect(Vect3d vel, Vect3d normal, Vect3d result)
vel
- the initial vector before the bouncenormal
- the normal of the surface to bounce the vector aroundresult
- the resulting bounced vectorpublic static Vect3d getClosestPointOnLine(Vect3d a, Vect3d b, Vect3d p)
a
- starting point of a lineb
- end point of a linep
- a point
public static float getDistanceBetweenPoints(Vect3d a, Vect3d b)
a
- first pointb
- second point
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


A view for displaying ads delivered through Admob.
You should explicitly size the ad to one of the following predefined sizes (width x height). An appropriate ad will be loaded from the server automatically:
The publisher ID for admob.
The background color used for the ad.
Whether or not admob should be run in testing mode. Running in testing mode returns test ads to the simulator when running in simulator, and the current device when running from device.
A date object representing the user's date of birth that should be used for determining ad delivery.
The user's gender for the purpose of determining ad delivery. This should be "male" or "female", in lower case.
Keywords used to determine ad delivery.
A dictionary with the location of the user for location-based ads:
Sent when an ad request loaded an ad. This is a good opportunity to add this view to the hierarchy if it has not yet been added. If the ad was received as a part of the server-side auto refreshing, you can examine the hasAutoRefreshed property of the view.
Sent when an ad request failed. Normally this is because no network connection was available or no ads were available (i.e. no fill).
Sent just before presenting the user a full screen view, such as a browser, in response to clicking on an ad. Use this opportunity to stop animations, time sensitive interactions, etc.
Normally the user looks at the ad, dismisses it, and control returns to your application by firing off "didDismissScreen":. However if the user hits the Home button or clicks on an App Store link your application will end. In that case, "willLeaveApplication" would fire.
Sent just before dismissing a full screen view.
Sent just after dismissing a full screen view. Use this opportunity to restart anything you may have stopped as part of "willPresentScreen".
Sent just before the application will background or terminate because the user clicked on an ad that will launch another application (such as the App Store).


| Package | Description |
|---|---|
| ms.ipp.iterable.tree |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractTree<F>
A basic abstract implementation of all features shared by the concrete
sub-implementations.
|
class |
DelegatingTree<F> |
class |
StdMultiTree<F>
A
Tree -wrapper around a Map<String, List<F>> which allows
multiple elements with the same name to co-exist. |
class |
StdTree<F>
A
Tree -wrapper around a Map<String, F> which doesn't allow
multiple elements with the same name to co-exist. |
class |
SyntheticTree<F>
A concrete implementation of
Tree , in which the associative and
the iterative structures are determined by external methods. |
| Modifier and Type | Method and Description |
|---|---|
<T> Tree<T> |
DelegatingTree.get(java.lang.Class<T> clazz)
Returns the first delegate in the list which is associated with a given Class
or null if none are found.
|
Tree<F> |
DelegatingTree.get(int index)
Returns the delegate with a given index.
|
Tree<F> |
DelegatingTree.remove()
Removes and returns returns the delegate with the highest index.
|
Tree<F> |
DelegatingTree.remove(int index)
Removes and returns the delegate with a given index.
|
| Modifier and Type | Method and Description |
|---|---|
<T extends F> |
DelegatingTree.add(java.lang.Class<T> key,
Tree<T> delegate)
Adds a new delegate
Tree to the end of the list of all existing
delegates and returns the index at which it was added. |
<T extends F> |
DelegatingTree.add(java.lang.Class<T> key,
Tree<T> delegate,
int index)
Adds a new delegate
Tree at a given index in the list of all existing
delegate Trees. |
int |
DelegatingTree.add(Tree<F> delegate)
Adds a new delegate
Tree to the end of the list of all existing
delegates and returns the index at which it was added. |
void |
DelegatingTree.add(Tree<F> delegate,
int insert)
Adds a new delegate
Tree at a given index in the list of all existing
delegate Trees. |


Urban slack is your Urban Dictionary Slack bot. Use /urban command to decipher all the pop-culture references your team colleagues throw around Slack channels ever so freely, assuming that everyone understands them.
Urban Slack is super-easy to add to your slack team. Hit the add-to-slack button, authorize your team to use Urban Slacck and you can start using /urban command within seconds inside your Slack team.
Urban Slack is an open-source project under MIT license. Report bugs, submit feature request and contribute to the project at GitHub. All ideas suggestions and pull requests are more than welcome :)


Combo Button
Example
Normal
CTA
Primary
Focus
Add f-combobutton-focus
class to node.
Disabled
Add aria-disabled="true"
to node.
Open
- Set
aria-expanded
totrue
. - Set two attribute to popup node :
aria-labelledby="combobutton"
role="menu"
. - Set
30px
offset atY axle
from button node to popup node.
Open & focus
Combination of several state
Set 31px
offset at Y axle
from button node.


ABOUT
Currently based in Vietnam // I am a 500 hour self trained web developer // I am a storyteller and a creator // Digital media, web design, journalism and visually pleasing layouts combining with insights from data are the ways I can tell a narrative.
LANGUAGES
HTML5 // CSS // Javascript // Reactjs // Python // Flask // SQL


Radu-Alexandru Bulai
Hi!
I'm a current graduate of the Faculty of Electronics, UPB, Computer Science Department.
I'm passionate about Software Engineering, Front-end and Back-end Development, as well as Machine Learning and Computer Vision.
Hi!
I'm a current graduate of the Faculty of Electronics, UPB, Computer Science Department.
I'm passionate about Software Engineering, Front-end and Back-end Development, as well as Machine Learning and Computer Vision.
Specialization in Computers and Information Technology.
Relevant studies: Computer Programming, Data Structures and Algorithms, Object-Oriented Programming, Database Design, APIs, Image processing and analysis, Artificial Intelligence
Developer Certification, representing over 30 hours of coursework. Issued on November 2020, by freeCodeCamp.
See Credential
Application Main Features:
- Responsive UI for desktop and mobile using Bootstrap4
- Registered users can leave likes and comments on each blog article
- Rich Text-Editor for blog articles and comments (with text formatting, code snippets, and more using CKEditor)
- Media Files are stored using Google Drive Storage (free alternative to Amazon S3 Bucket)
Android App for managing a Database with 5 tables (Doctors, Patients, Medicines and their corresponding association tables Sections and Consultations). The DB is stored locally using SQLite and permits CRUD operations, as well as accesing the app by logging in either as a Client user or as an Administrator.
Automatic age and gender classification in real-time, using Convolutional Neural Networks (based on MobileNet v1), optimized for Raspberry Pi 4 system using a .tflite model. The application is wrapped in a simple and modern UI using PyQt5.
Android App with multiple features such as ToDo List, Journal (with titles, entries and time stamps), Countdown timer, and a Quiz that generates different responses based on question answers (like a Personality test).
You can find all my finished projects on my GitHub repositories.


[gecode-users] how to start?
Oliver Kullmann
O.Kullmann at swansea.ac.uk
Thu Jan 8 19:55:00 CET 2009
Hello,
I'm relatively familiar with the concepts of
constraint satisfaction and constraint programming
(say, at the level of [Dechter, Constraint Processing],
[Apt, Principles of Constraint Programming], or
[Handbook of Constraint Programming], however
when trying to get into Gecode, then I'm lost:
I even don't know what it's all about?
At
http://www.gecode.org/gecode-doc-latest/index.html
one finds under "Getting started" how to install it
(no problem), some notational convention (which I
somehow can imagine what it wants to say, but which
seems at this point rather irrelevant), and then
we have the glossary, which seems rather circular
to me, and which doesn't say much when you are not
already familiar with the library.
That seems to be it: "Programming tasks" seem to speak
only about some specifics (again, if the whole is not known
that it doesn't seem to make so much sense), and the rest
looks alike.
So where to start?? Is there no definition of the whole problem
area (what kind of "constraint satisfaction problems" are
considered?), the basic algorithms supported (there are quite
a few algorithmic models out there), what are the basic abstraction
about "variables, values, constraints" (abstract data types)?
Perhaps Gecode assumes familiarity with some other CSP-library?
I'm coming from the SAT world, and I'm not aware of any other
framework than Gecode (which could be used as a role model).
Of course, I could start with some examples, but there seem to
be no complete examples, just classes (like http://www.gecode.org/gecode-doc-latest/classGraphColor.html;
I guessed that graph colouring would be rather easy), which don't say
much without the framework.
At http://www.gecode.org/gecode-doc-latest/group__Example.html it says
"All scripts are compiled into simple standalone programs. ", but I don't understand
what "script" here means? Clicking on "Scripts for problems" I only get
some (specific) classes?
Perhaps one needs to search for those files in the installed library?
(Somehow I'm of the old-fashioned opinion that documentation should be
somehow self-contained.)
But for example "graph-color.cc" doesn't give definitions/explanations (about the
concepts involved)? It all seems to assume that the basic concepts are known.
This is now my second attempt to gain a bit of familiarity with Gecode, but
I can't find no bridge.
Is it necessary to start reading the source code, looking at all the examples,
and deciphering myself what are the underlying concepts?
Perhaps there is some fundamental piece of documentation I'm missing.
Or, if not, then I would guess it wouldn't be too hard to outline
somewhere the basic concepts (from an abstract point of view).
Once one knows the main direction, then guessing what examples
and code fragments could mean becomes much easier.
Hoping for some hints
Confused Oliver
--
Dr. Oliver Kullmann
Computer Science Department
Swansea University
Faraday Building, Singleton Park
Swansea SA2 8PP, UK
http://cs.swan.ac.uk/~csoliver/
More information about the gecode-users
mailing list


Note
This tutorial was generated from a Jupyter notebook that can be downloaded here.
Linear solve¶
In this notebook we discuss how to linearly solve for the posterior over spherical harmonic coefficients of a map given a light curve. This is similar to what we did in the Eclipsing Binary notebook. The idea is to take advantage of the linearity of the starry
solution to analytically compute the posterior over maps consistent with the data.
[3]:
import matplotlib.pyplot as plt
import numpy as np
import starry
np.random.seed(12)
starry.config.lazy = False
starry.config.quiet = True
We’re going to demonstrate the linear solve feature using a map in reflected light, since the presence of a day/night terminator breaks many degeneracies and makes the mapping problem much less ill-posed. Let’s begin by instantiating a reflected light map of the Earth. We’ll give it the same obliquity as the Earth and observe it at an inclination of 60 degrees. We’ll also give it an amplitude of 0.16
: this is the value that will scale the surface map everywhere, which
we can see leads to a continental albedo of about 0.4
, which is (very) roughly what we expect for the Earth:
[4]:
map = starry.Map(ydeg=10, reflected=True)
map.load("earth", force_psd=True)
map.amp = 0.16
map.obl = 23.5
map.inc = 60
map.show(illuminate=False, colorbar=True, projection="moll")
Note
The force_psd
keyword in load()
forces the map to be positive semi-definite (PSD),
that is, it forces the albedo to be non-negative everywhere on the surface. Ensuring a
spherical harmonic expansion is PSD is not trivial; we do this numerically, so it takes
a little longer than if force_psd
were False
. It’s also not perfect, since the
numerical search for the map minimum is tricky. After it’s done, starry
re-normalizes
the map so that minimum value is nudged to zero.
Now we generate a dataset. We’ll assume we have 10,000 observations over the course of a full orbit of the planet. We further take the planet’s rotation period to be one-tenth of its orbital period. This will give us good coverage during all seasons, maximizing the amount of data we have for all the different regions of the planet:
[5]:
# Make the planet rotate 10 times over one full orbit
npts = 10000
nrot = 10
time = np.linspace(0, 1, npts)
theta = np.linspace(0, 360 * nrot, npts)
# Position of the star relative to the planet in the orbital plane
t = np.reshape(time, (1, -1))
p = np.vstack((np.cos(2 * np.pi * t), np.sin(2 * np.pi * t), 0 * t))
# Rotate to an observer inclination of 60 degrees
ci = np.cos(map.inc * np.pi / 180)
si = np.sin(map.inc * np.pi / 180)
R = np.array([[1, 0, 0], [0, ci, -si], [0, si, ci]])
xs, ys, zs = R.dot(p)
# Keywords to the `flux` method
kwargs = dict(theta=theta, xs=xs, ys=ys, zs=zs)
[6]:
# Compute the flux
flux0 = map.flux(**kwargs)
sigma = 0.0005
flux = flux0 + sigma * np.random.randn(npts)
# Normalize it to a maximumm of unity
flux /= np.max(flux)
[7]:
fig, ax = plt.subplots(1, figsize=(12, 4))
ax.plot(time, flux)
ax.set_xlabel("orbital phase", fontsize=18)
ax.set_ylabel("flux [normalized]", fontsize=18);
Now the fun part. Let’s instantiate a new map so we can do inference on this dataset:
[8]:
map = starry.Map(ydeg=10, reflected=True)
map.obl = 23.5
map.inc = 60
We now set the data vector (the flux and the covariance matrix):
[9]:
map.set_data(flux, C=sigma ** 2)
And now the prior, which is also described as a multivariate gaussian with a mean \(\mu\) and covariance \(\Lambda\). This is the prior on the amplitude-weighted spherical harmonic coefficients. In other words, if \(\alpha\) is the map amplitude (map.amp
) and \(y\) is the vector of spherical harmonic coefficients (map.y
), we are placing a prior on the quantity \(x \equiv \alpha y\). While this may be confusing at first, recall that the coefficient of the
\(Y_{0,0}\) harmonic is fixed at unity in starry
, so we can’t really solve for it. But we can solve for all elements of the vector \(x\). Once we have the posterior for \(x\), we can easily obtain both the amplitude (equal to \(x_0\)) and the spherical harmonic coefficient vector (equal to \(x / x_0\)). This allows us to simultaneously obtain both the amplitude and the coefficients using a single efficient linear solve.
For the mean \(\mu\), we’ll set the first coefficient to unity (since we expect \(\alpha\) to be distributed somewhere around one, if the light curve is properly normalized) and all the others to zero (since our prior is isotropic and we want to enforce some regularization to keep the coefficients small).
For the covariance \(\Lambda\) (L
in the code), we’ll make it a diagonal matrix. The first diagonal entry is the prior variance on the amplitude of the map, and we’ll set that to \(1\). The remaining entries are the prior variance on the amplitude-weighted coefficients. We’ll pick something small – \(10^{-5}\)– to keep things well regularized. In practice, this prior is related to our beliefs about the angular power spectrum of the map.
[10]:
mu = np.empty(map.Ny)
mu[0] = 1
mu[1:] = 0
L = np.empty(map.Ny)
L[0] = 1e0
L[1:] = 1e-5
map.set_prior(L=L)
Finally, we call solve
, passing in the kwargs
from before. In this case, we’re assuming we know the orbital information exactly. (When this is not the case, we need to do sampling for the orbital parameters; we cover this in more detail in the Eclipsing Binary tutorial).
[11]:
%%time
mu, cho_cov = map.solve(**kwargs)
CPU times: user 635 ms, sys: 88.4 ms, total: 723 ms
Wall time: 695 ms
The solve
method sets the map coefficicents to the maximum a posteriori (MAP) solution. Let’s view this mean map:
[12]:
map.show(illuminate=False, colorbar=True, projection="moll")
Note that the normalization is different (unphysical even!), but that’s only because we normalized our flux vector. Because we divided out the maximum flux, there’s nothing in the data telling us what the actual albedo of the surface is. (When modeling a real dataset, if we knew the distance from the planet to the star and modelled the flux in real units, we could easily fix this).
We can also draw a random sample from the posterior (which automatically sets the map amplitude and coefficients) by calling
[13]:
np.random.seed(3)
map.draw()
[14]:
map.show(illuminate=False, colorbar=True, projection="moll")
We can verify that we got a good fit to the data from this random sample:
[15]:
fig, ax = plt.subplots(1, figsize=(12, 4))
ax.plot(time, flux)
plt.plot(time, map.flux(**kwargs))
ax.set_xlabel("Orbital phase", fontsize=18)
ax.set_ylabel("Normalized flux", fontsize=18);


Class (Touch To Start)
Creation Of Objects (Touch To Start)
Methods (Touch To Start)
Constructor(Touch To Start)
This Keyword (Touch To Start)
One And Two Dimensional Array (Touch To Start)
Jagged Array (Touch To Start)
Access Modifier/Encapsulation (Touch To Start)
Method Overloading (Touch To Start)
Inheritance (Touch To Start)


Hi! How are you?
My name is Anzu. I am 25 years old. I am from Chongqing. I like your page. How often do you visit the site? I really want to communicate with you.
I am good at Thai massage and really like to eat fish. What about you? I guess that we will have many topics to talk about.
Do you have some social networks? I will be waiting for your letter.
Best wishes.


System Architect Picture "Timepoint Valued Characteristic"
Parent Diagram:
Subject Characteristic
(OMT Object Model)


Hi I am a 21 year old college student that currently goes to Northern Illinois University. At NIU I am studying OM&IS which stands for Operational Management and Information Systems. In simpler terms I do a lot of data work and procurement / warehouse work. You get to choose one or the other to specialize in. I choose the IS side because I love to work on computers and do math to find a solution to a problem. I am currently in my last year here at NIU and I loved every second of it. I met some of the best people I have ever had the privilege of meeting who became my best friends. I got the chance to join a fraternity (Sigma Nu) where I met a lot of these people. I love to travel and play sports with my friends. You can find more information about that on the My Interest page. I was born and raised in Illinois and love the state. That’s pretty much everything about me. Thanks for looking at my website!


DOM modification is the key to creating “live” pages.
Here we’ll see how to create new elements “on the fly” and modify the existing page content.
Let’s demonstrate using an example. We’ll add a message on the page that looks nicer than alert
.
Here’s how it will look:
```html autorun height=“80” !Hi there! You’ve read an important message.
/! ```
That was the HTML example. Now let’s create the same div
with JavaScript (assuming that the styles are in the HTML/CSS already).
To create DOM nodes, there are two methods:
document.createElement(tag)
Creates a new element node with the given tag:
document.createTextNode(text)
Creates a new text node with the given text:
Most of the time we need to create element nodes, such as the div
for the message.
Creating the message div takes 3 steps:
// 1. Create
 element
let div = document.createElement('div');
// 2. Set its class to "alert"
div.className = "alert";
// 3. Fill it with the content
div.innerHTML = "Hi there! You've read an important message.";
We’ve created the element. But as of now it’s only in a variable named div
, not in the page yet. So we can’t see it.
To make the div
show up, we need to insert it somewhere into document
. For instance, into
element, referenced by document.body
.
There’s a special method append
for that: document.body.append(div)
.
Here’s the full code:
```html run height=“80”```
Here we called append
on document.body
, but we can call append
method on any other element, to put another element into it. For instance, we can append something to

by calling div.append(anotherElement)
.
Here are more insertion methods, they specify different places where to insert:
node.append(...nodes or strings)
– append nodes or strings at the end of node
,node.prepend(...nodes or strings)
– insert nodes or strings at the beginning of node
,node.before(...nodes or strings)
–- insert nodes or strings before node
,node.after(...nodes or strings)
–- insert nodes or strings after node
,node.replaceWith(...nodes or strings)
–- replaces node
with the given nodes or strings.Arguments of these methods are an arbitrary list of DOM nodes to insert, or text strings (that become text nodes automatically).
Let’s see them in action.
Here’s an example of using these methods to add items to a list and the text before/after it:
```html autorun```
Here’s a visual picture of what the methods do:
So the final list will be:
As said, these methods can insert multiple nodes and text pieces in a single call.
For instance, here a string and an element are inserted:
html run

Please note: the text is inserted “as text”, not “as HTML”, with proper escaping of characters such as <
, >
.
So the final HTML is:
html run *!*
Hello
 */!*

In other words, strings are inserted in a safe way, like elem.textContent
does it.
So, these methods can only be used to insert DOM nodes or text pieces.
But what if we’d like to insert an HTML string “as html”, with all tags and stuff working, in the same manner as elem.innerHTML
does it?
For that we can use another, pretty versatile method: elem.insertAdjacentHTML(where, html)
.
The first parameter is a code word, specifying where to insert relative to elem
. Must be one of the following:
"beforebegin"
– insert html
immediately before elem
,"afterbegin"
– insert html
into elem
, at the beginning,"beforeend"
– insert html
into elem
, at the end,"afterend"
– insert html
immediately after elem
.The second parameter is an HTML string, that is inserted “as HTML”.
For instance:
html run

…Would lead to:
html run
Hello

Bye

That’s how we can append arbitrary HTML to the page.
Here’s the picture of insertion variants:
We can easily notice similarities between this and the previous picture. The insertion points are actually the same, but this method inserts HTML.
The method has two brothers:
elem.insertAdjacentText(where, text)
– the same syntax, but a string of text
is inserted “as text” instead of HTML,elem.insertAdjacentElement(where, elem)
– the same syntax, but inserts an element.They exist mainly to make the syntax “uniform”. In practice, only insertAdjacentHTML
is used most of the time. Because for elements and text, we have methods append/prepend/before/after
– they are shorter to write and can insert nodes/text pieces.
So here’s an alternative variant of showing a message:
```html run```
To remove a node, there’s a method node.remove()
.
Let’s make our message disappear after a second:
```html run untrusted```
Please note: if we want to move an element to another place – there’s no need to remove it from the old one.
All insertion methods automatically remove the node from the old place.
For instance, let’s swap elements:
html run height=50
First

Second

How to insert one more similar message?
We could make a function and put the code there. But the alternative way would be to clone the existing div
and modify the text inside it (if needed).
Sometimes when we have a big element, that may be faster and simpler.
elem.cloneNode(true)
creates a “deep” clone of the element – with all attributes and subelements. If we call elem.cloneNode(false)
, then the clone is made without child elements.An example of copying the message:
```html run height=“120”Hi there! You’ve read an important message.
```
DocumentFragment
is a special DOM node that serves as a wrapper to pass around lists of nodes.
We can append other nodes to it, but when we insert it somewhere, then its content is inserted instead.
For example, getListContent
below generates a fragment with

items, that are later inserted into

:
```
Please note, at the last line (*)
we append DocumentFragment
, but it “blends in”, so the resulting structure will be:
DocumentFragment
is rarely used explicitly. Why append to a special kind of node, if we can return an array of nodes instead? Rewritten example:
```
We mention DocumentFragment
mainly because there are some concepts on top of it, like template element, that we’ll cover much later.
[old]
There are also “old school” DOM manipulation methods, existing for historical reasons.
These methods come from really ancient times. Nowadays, there’s no reason to use them, as modern methods, such as append
, prepend
, before
, after
, remove
, replaceWith
, are more flexible.
The only reason we list these methods here is that you can find them in many old scripts:
parentElem.appendChild(node)
Appends node
as the last child of parentElem
.
The following example adds a new

to the end of

:
```
parentElem.insertBefore(node, nextSibling)
Inserts node
before nextSibling
into parentElem
.
The following code inserts a new list item before the second <li>
:
``To insert
newLi` as the first element, we can do it like this:
parentElem.replaceChild(node, oldChild)
oldChild
with node
among children of parentElem
.
parentElem.removeChild(node)
Removes node
from parentElem
(assuming node
is its child).
The following example removes first <li>
from <ol>
:
```
All these methods return the inserted/removed node. In other words, parentElem.appendChild(node)
returns node
. But usually the returned value is not used, we just run the method.
There’s one more, very ancient method of adding something to a web-page: document.write
.
The syntax:
html run
Somewhere in the page...
 *!*  */!*
The end

The call to document.write(html)
writes the html
into page “right here and now”. The html
string can be dynamically generated, so it’s kind of flexible. We can use JavaScript to create a full-fledged webpage and write it.
The method comes from times when there was no DOM, no standards… Really old times. It still lives, because there are scripts using it.
In modern scripts we can rarely see it, because of the following important limitation:
The call to document.write
only works while the page is loading.
If we call it afterwards, the existing document content is erased.
For instance:
html run
After one second the contents of this page will be replaced...
 *!*  */!*
So it’s kind of unusable at “after loaded” stage, unlike other DOM methods we covered above.
That’s the downside.
There’s an upside also. Technically, when document.write
is called while the browser is reading (“parsing”) incoming HTML, and it writes something, the browser consumes it just as if it were initially there, in the HTML text.
So it works blazingly fast, because there’s no DOM modification involved. It writes directly into the page text, while the DOM is not yet built.
So if we need to add a lot of text into HTML dynamically, and we’re at page loading phase, and the speed matters, it may help. But in practice these requirements rarely come together. And usually we can see this method in scripts just because they are old.
document.createElement(tag)
– creates an element with the given tag,document.createTextNode(value)
– creates a text node (rarely used),elem.cloneNode(deep)
– clones the element, if deep==true
then with all descendants.node.append(...nodes or strings)
– insert into node
, at the end,node.prepend(...nodes or strings)
– insert into node
, at the beginning,node.before(...nodes or strings)
–- insert right before node
,node.after(...nodes or strings)
–- insert right after node
,node.replaceWith(...nodes or strings)
–- replace node
.node.remove()
–- remove the node
.Text strings are inserted “as text”.
parent.appendChild(node)
parent.insertBefore(node, nextSibling)
parent.removeChild(node)
parent.replaceChild(newElem, node)
All these methods return node
.
html
, elem.insertAdjacentHTML(where, html)
inserts it depending on the value of where
:
"beforebegin"
– insert html
right before elem
,"afterbegin"
– insert html
into elem
, at the beginning,"beforeend"
– insert html
into elem
, at the end,"afterend"
– insert html
right after elem
.Also there are similar methods, elem.insertAdjacentText
and elem.insertAdjacentElement
, that insert text strings and elements, but they are rarely used.
document.write(html)
After the page is loaded such a call erases the document. Mostly seen in old scripts.


| Interface | Description |
|---|---|
| TreeOutputStream.WriterListener |
An interface for a callback to announce the writing of a given node.
|
| Class | Description |
|---|---|
| DiskIndexedTree |
Compact representation of a tree.
|
| LogDownloadManager |
A class for managing downloading of log data.
|
| LogLizard |
Dialog for showing the log tree.
|
| LogTreeAdapter |
Class for navigating a log tree.
|
| LogTreeModel |
A tree model that manages a big log tree.
|
| LogTreeModel.Node |
A node for showing log entries in a JTree.
|
| TreeOutputStream |
A stream to insert nodes into a
DiskIndexedTree . |
LogLizard is the tool that allows to inspect the workings of the engine behind a story. It will show the numbers behind each decision and behavior. All the data will be expressed in terms of the objects the author has constructed in the storyworld.
The nature of this data, as the nature of the history of executing a program, is inherently tree-like. So the server and the client (where LogLizard resides) will be passing pieces of a big tree (the Log Tree) from one to the other.
LogLizard is one of the most complex tools at the implementation level. The complexity arises from the fact that a story runs in the server, and that it generates so many information that it cannot be transfered without severe penalties in bandwidth, memory and performance.
This solved the bandwidth problem, but still remained the space and performance problems on the server. There is so many data to save on the server side, just in the case the author wants to inspect it later, that it still required a lot of space and effort to store.
The solution to the space problem, was to generate the data as requested by the author. So the server does not need to store any data, but just waits for a request of the author to run the story with recorded input and pick the interesting observations.
Now, it only remained the performance problem. It could consume significant cpu power to run the story from the beginning up to the point where the interesting data was generated. To solve this problem, intermediate engine states are saved to disk, and when a request of data arrives, the closest state is loaded and the data is collected.
Saving the intermediate engine states would look like introducing the space problem again. But in fact, the engine states are quite compact so it's feasible saving a few of them per session.
Ok, what happens if the story is so long that we run out of space to save the intermediate engine states? Well, we just discard some of the older states, so we make room for new states. Whenever we run out of space, we really discard at once the states at even positions, thus we free up half of the space. As repeated, this process tends to make more sparse the states that are at the beginning of the story.
The performance could be bad if the user request a piece of information in the first half of the story, but in normal use I think it is unlikely that this be the typical case. In general, I believe the author will prefer to run a few steps of the story from a saved point, and then she will check LogLizard. If it doesn't happen like this, I think that the performance behavior of the server will coerce the author into using that way.
The first problem is that the data the user wants to inspect could already need
more memory than available. So the data obtained from the server is saved to disk
and loaded from there as the author explores it (class DiskIndexedTree
).
The other problem is that the server data can arrive in chunks that does not match exactly the requests. For instance, LogLizard can ask for branches of events 10 to 20, but the server sends first branch 10 to half of branch 15, and then the remaining of branch 15 to branch 20. And the delivery could be further divided in smaller chunks.
This is so, because each branch can have just 10 nodes or 600000 nodes. Therefore, it will be needed for the server to send those nodes in chunks in order to don't make its internal buffers explode.
So once LogLizard finishes processing the first chunk of data, it must be able to resume
that processing when the next chunk of data arrives, exactly at the same node it have
previously stopped. For this, the client must keep track of the recursion stacks it uses
to build its tree branches as the data arrives. All of this is handled in the class
LogTreeModel
.


This section explains how you may read the different accelerometer datas mesured by the drone.
The accelerometer block makes it possible read the different accelerometer datas mesured by the drone. Each output port gives the accelerometer data for a specific axis :
The values are given in G. So when the drone is motionless on the ground, the readings should be (0,0,-1).


| DOSE: |
1 capsl |
oral |
MDMA |
(capsule) |
One night my girlfriend and I decided to take XTC. For her it was the 2nd time, I took it it like 10 times before. we were having a very pleasant walk trough the city we lived, really feeling relaxed and happy. And then, all of a sudden we heared somebody moan in great pains. It appeared that some guy had tried to kill himself by jumping out of a window on the 2nd floor of a building onto the street. It looked like he only brooke his legs. The scen was pretty shocking. Luckily for us, some other people, neighbours I guess, were there just before us; they told us, also with horror in their eyes, to walk on, they would take care of the situation, so we did.
Ofcourse the night was ruined for us. But not only that, because of the XTC we were much more open, so it took us weeks to loose the sad and horrified feeling; it was like some friend had lied there on the street. Even now I get cold shivers writing this down.
Afterwards I decided only to use XTC in safe environments; which I forgot later etc. I think we just had bad luck, but I still think it's a neglected risk of taking E, a bad experience can just became a total nightmare.
Thanks for reading.
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.


Previous: Interpreting Pathname Component Values, Up: Pathnames
Merging takes a pathname with unfilled components and supplies values for those components from a source of defaults.
If a component’s value is nil, that component is considered to be unfilled. If a component’s value is any non-nil object, including :unspecific, that component is considered to be filled.
Except as explicitly specified otherwise, for functions that manipulate or inquire about files in the file system, the pathname argument to such a function is merged with *default-pathname-defaults* before accessing the file system (as if by merge-pathnames).
| • Examples of Merging Pathnames: |


Sends a text message to a given destination and returnd a Job ID.
This JobID together with a token can be validated and will then return either "true" or "false"
Usage:
http://localhost:8080/send
get reputation information for a single IPV4 address
http://localhost:8080/reputation/?net=<IP_ADDRESS>/24
get a reputation for each address in the CIDR network as a list.


KotlinCommons
/
bvanseg.kotlincommons.annotations
Package bvanseg.kotlincommons.annotations
Annotations
Beta
Designates a certain piece of code as unstable and subject to change.
annotation
class
Beta


Open Source projects are a project to improve your JavaScript knowledge with JavaScript documentations, design patterns, books.


There are no legal obligations for your organisation to stop dealing with a customer involved in a suspicious matter. It is up to your organisation to decide whether to:
|
• |
refrain from providing a designated service, including terminating the business relationship |
|
• |
continue providing a designated service or maintaining the business relationship with the customer |
This decision will depend on your organisation's risk-based systems and controls on enhanced and ongoing customer due diligence.
If your organisation decides to terminate the business relationship with the customer, it still must not disclose to the customer that a suspicion on reasonable grounds has been formed and/or communicated to AUSTRAC.


You are connected as {{ session['login'] }}.
Firstname: {{ user['lastname'] }}
Lastname: {{ user['firstname'] }}
{{ user['email_adress'] }}
{{ user['institution'] }}


Functions | |
| int | GetAMDAdapterIndex (LPADLContext myContext) |
| int | ADL2_ApplicationProfiles_System_Reload (ADL_CONTEXT_HANDLE context) |
| Function to Reload System appprofiles. | |
| int | ADL_ApplicationProfiles_System_Reload () |
| Function to Reload System appprofiles. | |
| int | ADL2_ApplicationProfiles_User_Load (ADL_CONTEXT_HANDLE context) |
| Function to Load User appprofiles. | |
| int | ADL_ApplicationProfiles_User_Load () |
| Function to Load User appprofiles. | |
| int | ADL2_ApplicationProfiles_User_Unload (ADL_CONTEXT_HANDLE context) |
| Function to Unload User appprofiles. | |
| int | ADL_ApplicationProfiles_User_Unload () |
| Function to Unload User appprofiles. | |
| int | ADL2_ApplicationProfiles_ProfileOfAnApplication_Search (ADL_CONTEXT_HANDLE context, const char *FileName, const char *Path, const char *Version, const char *AppProfileArea, ADLApplicationProfile **lppProfile) |
| Function to retrieve the profile of an application defined in driver. | |
| int | ADL_ApplicationProfiles_ProfileOfAnApplication_Search (const char *FileName, const char *Path, const char *Version, const char *AppProfileArea, ADLApplicationProfile **lppProfile) |
| Function to retrieve the profile of an application defined in driver. | |
| int | ADL2_ApplicationProfiles_HitLists_Get (ADL_CONTEXT_HANDLE context, int iListType, int *lpNumApps, ADLApplicationData **lppAppList) |
| Function to retrieve the recent application list from registry. | |
| int | ADL_ApplicationProfiles_HitLists_Get (int iListType, int *lpNumApps, ADLApplicationData **lppAppList) |
| Function to retrieve the recent application list from registry. | |
| int | ADL2_ApplicationProfiles_HitListsX3_Get (ADL_CONTEXT_HANDLE context, int iListType, int *lpNumApps, ADLApplicationDataX3 **lppAppList) |
| Function to retrieve the recent application list from registry. | |
| int | ADL2_ApplicationProfiles_HitListsX2_Get (ADL_CONTEXT_HANDLE context, int iListType, int *lpNumApps, ADLApplicationDataX2 **lppAppList) |
| Function to retrieve the recent application list from registry. | |
| int | ADL_ApplicationProfiles_HitListsX2_Get (int iListType, int *lpNumApps, ADLApplicationDataX2 **lppAppList) |
| Function to retrieve the recent application list from registry. |
| int GetAMDAdapterIndex | ( | LPADLContext | myContext | ) |
| int ADL2_ApplicationProfiles_System_Reload | ( | ADL_CONTEXT_HANDLE | context | ) |
Function to Reload System appprofiles.
This function Reloads System appprofiles by reloading system profile and loading user profile.
| [in] | context,: | Client's ADL context handle ADL_CONTEXT_HANDLE obtained from ADL2_Main_Control_Create. |
| int ADL_ApplicationProfiles_System_Reload | ( | ) |
Function to Reload System appprofiles.
This function Reloads System appprofiles by reloading system profile and loading user profile.
| int ADL2_ApplicationProfiles_User_Load | ( | ADL_CONTEXT_HANDLE | context | ) |
Function to Load User appprofiles.
This function Loads User appprofiles by loadding system profile and user profile.
| [in] | context,: | Client's ADL context handle ADL_CONTEXT_HANDLE obtained from ADL2_Main_Control_Create. |
| int ADL_ApplicationProfiles_User_Load | ( | ) |
Function to Load User appprofiles.
This function Loads User appprofiles by loadding system profile and user profile.
| int ADL2_ApplicationProfiles_User_Unload | ( | ADL_CONTEXT_HANDLE | context | ) |
Function to Unload User appprofiles.
This function Unloads User appprofiles by unloading user profile.
| [in] | context,: | Client's ADL context handle ADL_CONTEXT_HANDLE obtained from ADL2_Main_Control_Create. |
| int ADL_ApplicationProfiles_User_Unload | ( | ) |
Function to Unload User appprofiles.
This function Unloads User appprofiles by unloading user profile.
| int ADL2_ApplicationProfiles_ProfileOfAnApplication_Search | ( | ADL_CONTEXT_HANDLE | context, | |
| const char * | FileName, | |||
| const char * | Path, | |||
| const char * | Version, | |||
| const char * | AppProfileArea, | |||
| ADLApplicationProfile ** | lppProfile | |||
| ) |
Function to retrieve the profile of an application defined in driver.
This function retrieves the profile information of an application. This API uses the Caller's Memory Allocation Callback Function to allocate memory pointed by lppProfile. Caller is responsible to de-allocate the memory.
| [in] | context,: | Client's ADL context handle ADL_CONTEXT_HANDLE obtained from ADL2_Main_Control_Create. |
| [in] | FileName | Specifies the application file name |
| [in] | Path | Specifies the application file path |
| [in] | Version | Specifies the application version |
| [in] | AppProfileArea | Specifies the area the profile works on (like 'PX', 'D3D', etc. ) |
| [out] | lppProfile | The pointer to the pointer to the retrieved application profile. Set it to NULL prior to call this API. |
Clients can use ADL2 version of the API to assure that there is no interference with other ADL clients that are running in the same process . Such clients have to call ADL2_Main_Control_Create first to obtain ADL_CONTEXT_HANDLE instance that has to be passed to each subsequent ADL2 call and finally destroyed using ADL2_Main_Control_Destroy.
| int ADL_ApplicationProfiles_ProfileOfAnApplication_Search | ( | const char * | FileName, | |
| const char * | Path, | |||
| const char * | Version, | |||
| const char * | AppProfileArea, | |||
| ADLApplicationProfile ** | lppProfile | |||
| ) |
Function to retrieve the profile of an application defined in driver.
This function retrieves the profile information of an application. This API uses the Caller's Memory Allocation Callback Function to allocate memory pointed by lppProfile. Caller is responsible to de-allocate the memory.
| [in] | FileName | Specifies the application file name |
| [in] | Path | Specifies the application file path |
| [in] | Version | Specifies the application version |
| [in] | AppProfileArea | Specifies the area the profile works on (like 'PX', 'D3D', etc. ) |
| [out] | lppProfile | The pointer to the pointer to the retrieved application profile. Set it to NULL prior to call this API. |
| int ADL2_ApplicationProfiles_HitLists_Get | ( | ADL_CONTEXT_HANDLE | context, | |
| int | iListType, | |||
| int * | lpNumApps, | |||
| ADLApplicationData ** | lppAppList | |||
| ) |
Function to retrieve the recent application list from registry.
This function retrieves the recent application list from registry. This API uses the Caller's Memory Allocation Callback Function to allocate memory pointed by lppAppList. Caller is responsible to de-allocate the memory.
| [in] | context,: | Client's ADL context handle ADL_CONTEXT_HANDLE obtained from ADL2_Main_Control_Create. |
| [in] | iListType | Specifies the type of the list to retrieve, defined in ApplicationListType |
| [out] | lpNumApps | The pointer to the number of applications in the list. |
| [out] | lppAppList | The pointer to the pointer to the retrieved application list from registry. Set it to NULL prior to call this API. |
Clients can use ADL2 version of the API to assure that there is no interference with other ADL clients that are running in the same process . Such clients have to call ADL2_Main_Control_Create first to obtain ADL_CONTEXT_HANDLE instance that has to be passed to each subsequent ADL2 call and finally destroyed using ADL2_Main_Control_Destroy.
| int ADL_ApplicationProfiles_HitLists_Get | ( | int | iListType, | |
| int * | lpNumApps, | |||
| ADLApplicationData ** | lppAppList | |||
| ) |
Function to retrieve the recent application list from registry.
This function retrieves the recent application list from registry. This API uses the Caller's Memory Allocation Callback Function to allocate memory pointed by lppAppList. Caller is responsible to de-allocate the memory.
| [in] | iListType | Specifies the type of the list to retrieve, defined in ApplicationListType |
| [out] | lpNumApps | The pointer to the number of applications in the list. |
| [out] | lppAppList | The pointer to the pointer to the retrieved application list from registry. Set it to NULL prior to call this API. |
| int ADL2_ApplicationProfiles_HitListsX3_Get | ( | ADL_CONTEXT_HANDLE | context, | |
| int | iListType, | |||
| int * | lpNumApps, | |||
| ADLApplicationDataX3 ** | lppAppList | |||
| ) |
Function to retrieve the recent application list from registry.
This function retrieves the recent application list from registry. This API uses the Caller's Memory Allocation Callback Function to allocate memory pointed by lppAppList. Caller is responsible to de-allocate the memory.
| [in] | context,: | Client's ADL context handle ADL_CONTEXT_HANDLE obtained from ADL2_Main_Control_Create. |
| [in] | iListType | Specifies the type of the list to retrieve, defined in ApplicationListType |
| [out] | lpNumApps | The pointer to the number of applications in the list. |
| [out] | lppAppList | The pointer to the pointer to the retrieved application list from registry including process id. Set it to NULL prior to call this API. |
Clients can use ADL2 version of the API to assure that there is no interference with other ADL clients that are running in the same process . Such clients have to call ADL2_Main_Control_Create first to obtain ADL_CONTEXT_HANDLE instance that has to be passed to each subsequent ADL2 call and finally destroyed using ADL2_Main_Control_Destroy.
| int ADL2_ApplicationProfiles_HitListsX2_Get | ( | ADL_CONTEXT_HANDLE | context, | |
| int | iListType, | |||
| int * | lpNumApps, | |||
| ADLApplicationDataX2 ** | lppAppList | |||
| ) |
Function to retrieve the recent application list from registry.
This function retrieves the recent application list from registry. This API uses the Caller's Memory Allocation Callback Function to allocate memory pointed by lppAppList. Caller is responsible to de-allocate the memory.
| [in] | context,: | Client's ADL context handle ADL_CONTEXT_HANDLE obtained from ADL2_Main_Control_Create. |
| [in] | iListType | Specifies the type of the list to retrieve, defined in ApplicationListType |
| [out] | lpNumApps | The pointer to the number of applications in the list. |
| [out] | lppAppList | The pointer to the pointer to the retrieved application list from registry. Set it to NULL prior to call this API. |
Clients can use ADL2 version of the API to assure that there is no interference with other ADL clients that are running in the same process . Such clients have to call ADL2_Main_Control_Create first to obtain ADL_CONTEXT_HANDLE instance that has to be passed to each subsequent ADL2 call and finally destroyed using ADL2_Main_Control_Destroy.
| int ADL_ApplicationProfiles_HitListsX2_Get | ( | int | iListType, | |
| int * | lpNumApps, | |||
| ADLApplicationDataX2 ** | lppAppList | |||
| ) |
Function to retrieve the recent application list from registry.
This function retrieves the recent application list from registry. This API uses the Caller's Memory Allocation Callback Function to allocate memory pointed by lppAppList. Caller is responsible to de-allocate the memory.
| [in] | iListType | Specifies the type of the list to retrieve, defined in ApplicationListType |
| [out] | lpNumApps | The pointer to the number of applications in the list. |
| [out] | lppAppList | The pointer to the pointer to the retrieved application list from registry. Set it to NULL prior to call this API. |


| Up | TOC | Index | |||||
| << 7 Included Tools | < 8.45 Indirect Routine Calling | Up: 8 API Reference | 8.47 Graphics Constants > | 9 Release Notes >> |
8.46 Memory Constants
8.46.1 Microsoft Windows Memory Protection Constants
These constant names are taken right from Microsoft's Memory Protection constants.
<IP_ADDRESS> PAGE_EXECUTE
include std/memconst.e namespace memconst public constant PAGE_EXECUTE
You may run the data in this page
<IP_ADDRESS> PAGE_EXECUTE_READ
include std/memconst.e namespace memconst public constant PAGE_EXECUTE_READ
You may read or run the data
<IP_ADDRESS> PAGE_EXECUTE_READWRITE
include std/memconst.e namespace memconst public constant PAGE_EXECUTE_READWRITE
You may run, read or write in this page
<IP_ADDRESS> PAGE_EXECUTE_WRITECOPY
include std/memconst.e namespace memconst public constant PAGE_EXECUTE_WRITECOPY
You may run or write in this page
<IP_ADDRESS> PAGE_WRITECOPY
include std/memconst.e namespace memconst public constant PAGE_WRITECOPY
You may write to this page.
<IP_ADDRESS> PAGE_READWRITE
include std/memconst.e namespace memconst public constant PAGE_READWRITE
You may read or write in this page.
<IP_ADDRESS> PAGE_READONLY
include std/memconst.e namespace memconst public constant PAGE_READONLY
You may only read data in this page
<IP_ADDRESS> PAGE_NOACCESS
include std/memconst.e namespace memconst public constant PAGE_NOACCESS
You have no access to this page
8.46.2 Standard Library Memory Protection Constants
Memory Protection Constants are the same constants names and meaning across all platforms yet possibly of different numeric value. They are only necessary for allocate_protect
The constant names are created like this: You have four aspects of protection READ, WRITE, EXECUTE and COPY. You take the word PAGE and you concatonate an underscore and the aspect in the order above. For example: PAGE_WRITE_EXECUTE The sole exception to this nomenclature is when you will have no acesss to the page the constant is called PAGE_NONE.
<IP_ADDRESS> PAGE_NONE
include std/memconst.e namespace memconst public constant PAGE_NONE
You have no access to this page.
<IP_ADDRESS> PAGE_READ_EXECUTE
include std/memconst.e namespace memconst public constant PAGE_READ_EXECUTE
You may read or run the data An alias to PAGE_EXECUTE_READ
<IP_ADDRESS> PAGE_READ_WRITE
include std/memconst.e namespace memconst public constant PAGE_READ_WRITE
You may read or write to this page An alias to PAGE_READWRITE
<IP_ADDRESS> PAGE_READ
include std/memconst.e namespace memconst public constant PAGE_READ
You may only read to this page An alias to PAGE_READONLY
<IP_ADDRESS> PAGE_READ_WRITE_EXECUTE
include std/memconst.e namespace memconst public constant PAGE_READ_WRITE_EXECUTE
You may run, read or write in this page An alias to PAGE_EXECUTE_READWRITE
<IP_ADDRESS> PAGE_WRITE_EXECUTE_COPY
include std/memconst.e namespace memconst public constant PAGE_WRITE_EXECUTE_COPY
You may run or write to this page. Data will copied for use with other processes when you first write to it.
<IP_ADDRESS> PAGE_WRITE_COPY
include std/memconst.e namespace memconst public constant PAGE_WRITE_COPY
You may write to this page. Data will copied for use with other processes when you first write to it.


"""
Module for mini-batching data. At this stage of development batch.py has only one batcher class
but several more will be added for rnn models taking multivariate stream input (sequences will need 3-way arrays),
batching over several epochs, etc. Also, new batch splitting functions will be added for data applications on
as case by case basis.
"""
import numpy as np
[docs]class OnlineBatcher:
"""
For batching data too large to fit into memory. Written for one pass on data!!!
"""
def __init__(self, datafile, batch_size):
"""
:param datafile: File to read lines from.
:param batch_size: Mini-batch size.
"""
self.f = open(datafile, 'r')
self.batch_size = batch_size
self.index = 0
[docs] def next_batch(self):
"""
:return: until end of datafile, each time called,
returns mini-batch number of lines from csv file
as a numpy array. Returns shorter than mini-batch
end of contents as a smaller than batch size array.
Returns None when no more data is available(one pass batcher!!).
"""
matlist = []
l = self.f.readline()
if l == '':
return None
rowtext = np.array([float(k) for k in l.strip().split(',')])
matlist.append(rowtext)
for i in range(self.batch_size - 1):
l = self.f.readline()
if l == '':
break
rowtext = np.array([float(k) for k in l.strip().split(',')])
matlist.append(rowtext)
data = np.array(matlist)
self.index += self.batch_size
return data
[docs]def split_batch(batch, spec):
"""
:param batch: A numpy array of data collected from the stream with shape (batch_size, num_features)
:param specs: A python dict containing information about which indices in the incoming data point correspond to which features.
Entries for continuous features list the indices for the feature, while entries for categorical features
contain a dictionary- {'index': i, 'num_classes': c}, where i and c are the index into the datapoint, and number of distinct
categories for the category in question.
:return: A dictionary of numpy arrays of the split 2d feature array.
"""
assert spec['num_features'] == batch.shape[1], "Wrong number of features: spec/%s\tbatch/%s" % (spec['num_features'], batch.shape[1])
datadict = {}
for dataname, value in spec.iteritems():
if dataname != 'num_features':
if type(value) is dict:
datadict[dataname] = batch[:, value['index']].astype(int)
else:
datadict[dataname] = batch[:, value]
return datadict


Custom Summary
- Choose the type of report from the "Filter By" dropdown menu to generate the needed summary report.
- Click the "Print" button to have a printed copy of the summary report.
| Docket No. |
Product Name |
Customer Name |
Truck Code |
User |
Weight In |
Weight Out |
Net Weight |
Unit |
Comp.(%) |


The Plains Indians made their homes in the part of the country between the Mississippi River and the Rocky Mountains. This part is known as the Great Plains. It has grasslands, sterams, valleys, and hills. Some Plains tribes hunted and followed the buffalo as they roamed. Other tribes hunted, raised crops, and lived in villages. Tribes also hunted deer, rabbits, and birds. Tribes picked berries and other plants for food and other uses. Some tribes traded supplies with other tribes. Many Plains tribes lived in tepees. The Plains Indians had many ceremonies. One was named the Sun Dance. It included dancing, singing, and drumming. It lasted for a few days in the summer. The Plains Indians told storiesand legends. These tales were always about times from the past. Children were told stories to help them learn about the past.
in-context


Index A | C | F | G | H | I | L | M | S | T A AggregateFeatures (class in featuregen.aggregates) C CalendarFeatures (class in featuregen.time_features) CartesianProduct (class in featuregen.functionals) F fit() (featuregen.aggregates.AggregateFeatures method) (featuregen.aggregates.SubLevelFeatures method) (featuregen.functionals.CartesianProduct method) (featuregen.functionals.TrainingFeatures method) (featuregen.time_features.CalendarFeatures method) (featuregen.time_features.HolidayAndEventFeatures method) (featuregen.time_features.LagFeatures method) (featuregen.variables.GroupedVariableTransformation method) (featuregen.variables.IndexMapper method) G get_all_index() (featuregen.variables.IndexMapper method) get_all_names() (featuregen.variables.IndexMapper method) get_index() (featuregen.variables.IndexMapper method) get_name() (featuregen.variables.IndexMapper method) GroupedVariableTransformation (class in featuregen.variables) H HolidayAndEventFeatures (class in featuregen.time_features) I IndexMapper (class in featuregen.variables) inverse_transform() (featuregen.variables.GroupedVariableTransformation method) (featuregen.variables.IndexMapper method) L LagFeatures (class in featuregen.time_features) M measure() (featuregen.metrics.SummarizeRegression method) S SubLevelFeatures (class in featuregen.aggregates) summarize() (featuregen.metrics.SummarizeRegression method) summarize_date() (featuregen.metrics.SummarizeRegression method) summarize_key() (featuregen.metrics.SummarizeRegression method) summarize_overall() (featuregen.metrics.SummarizeRegression method) SummarizeRegression (class in featuregen.metrics) T TrainingFeatures (class in featuregen.functionals) transform() (featuregen.aggregates.AggregateFeatures method) (featuregen.aggregates.SubLevelFeatures method) (featuregen.functionals.CartesianProduct method) (featuregen.functionals.TrainingFeatures method) (featuregen.time_features.CalendarFeatures method) (featuregen.time_features.HolidayAndEventFeatures method) (featuregen.time_features.LagFeatures method) (featuregen.variables.GroupedVariableTransformation method) (featuregen.variables.IndexMapper method)


Started to blog with Jekyll
24 Nov 2013Starting a blog using the Left theme for Jekyll.
Compared to other solutions, this uses the org-ruby
parser
to export .org
files into HTML. You can check the source
for this site here: https://github.com/wallyqs/wallyqs.github.io
puts "Syntax highlighting works!"
There are still some pending things that I would like to improve:
- Use the re-org tool to create and organize the posts that
would finally go into the
_posts
directory for publishing. I think in the end using a YAML file would have been better than having to use environment variables. - Try to extend or patch Jekyll so that I can avoid having to write:
--- layout: post title: Hello world category: posts ---
And instead cover this with Org syntax like:
#+layout: post #+title: Hello world #+category: posts
Other than that, the setup promises to be very comfortable for writing, I’ll see how it goes.


| Package | Description |
|---|---|
| com.opengamma.strata.loader.csv |
Loader that reads market data from CSV files.
|
| com.opengamma.strata.market.curve |
Definitions of curves.
|
| com.opengamma.strata.market.curve.node |
Curve nodes.
|
| com.opengamma.strata.measure.curve |
Integration code that allows strata-calc to use and calibrate curves.
|
| com.opengamma.strata.measure.rate |
Base package for calculation functions.
|
| com.opengamma.strata.pricer |
Calculators for financial instruments.
|
| com.opengamma.strata.pricer.credit |
Calculators for credit instruments, such as Credit Default Swap (CDS).
|
| com.opengamma.strata.pricer.curve |
Provides the ability to calibrate curves.
|
| com.opengamma.strata.pricer.fx |
Calculators for FX instruments, such as FX forward and FX swap.
|
| com.opengamma.strata.pricer.rate |
Calculators for rates instruments, such as Forward Rate Agreement (FRA) and interest rate swap.
|
| com.opengamma.strata.pricer.sensitivity |
Calculators for sensitivities.
|
| Class and Description |
|---|
| CurveGroup
A group of curves.
|
| CurveGroupDefinition
Provides the definition of how to calibrate a group of curves.
|
| Class and Description |
|---|
| AddFixedCurve
A curve formed from two curves, the fixed curve and the spread curve.
|
| AddFixedCurve.Meta
The meta-bean for
AddFixedCurve . |
| ConstantCurve
A curve based on a single constant value.
|
| ConstantCurve.Meta
The meta-bean for
ConstantCurve . |
| Curve
A curve that maps a
double x-value to a double y-value. |
| CurveGroup
A group of curves.
|
| CurveGroup.Builder
The bean-builder for
CurveGroup . |
| CurveGroup.Meta
The meta-bean for
CurveGroup . |
| CurveGroupDefinition
Provides the definition of how to calibrate a group of curves.
|
| CurveGroupDefinition.Meta
The meta-bean for
CurveGroupDefinition . |
| CurveGroupDefinitionBuilder
A mutable builder for creating instances of
CurveGroupDefinition . |
| CurveGroupEntry
A single entry in the curve group definition.
|
| CurveGroupEntry.Builder
The bean-builder for
CurveGroupEntry . |
| CurveGroupEntry.Meta
The meta-bean for
CurveGroupEntry . |
| CurveGroupId
An identifier used to access a curve group by name.
|
| CurveGroupId.Meta
The meta-bean for
CurveGroupId . |
| CurveGroupName
The name of a curve group.
|
| CurveId
An identifier used to access a curve by name.
|
| CurveId.Meta
The meta-bean for
CurveId . |
| CurveInfoType
The type that provides meaning to additional curve information.
|
| CurveInputs
The input data used when calibrating a curve.
|
| CurveInputs.Builder
The bean-builder for
CurveInputs . |
| CurveInputs.Meta
The meta-bean for
CurveInputs . |
| CurveInputsId
An identifier used to access the inputs to curve calibration.
|
| CurveInputsId.Meta
The meta-bean for
CurveInputsId . |
| CurveMetadata
Metadata about a curve and curve parameters.
|
| CurveName
The name of a curve.
|
| CurveNode
A node in the configuration specifying how to calibrate a curve.
|
| CurveNodeDate
The date of the curve node.
|
| CurveNodeDate.Meta
The meta-bean for
CurveNodeDate . |
| CurveNodeDateType
The types of curve node date.
|
| CurveParallelShifts
Perturbation which applies a parallel shift to a curve.
|
| CurveParallelShifts.Meta
The meta-bean for
CurveParallelShifts . |
| CurveParameterSize
The curve name and number of parameters.
|
| CurveParameterSize.Meta
The meta-bean for
CurveParameterSize . |
| CurvePointShifts
A perturbation that applies different shifts to specific points on a curve.
|
| CurvePointShifts.Meta
The meta-bean for
CurvePointShifts . |
| CurvePointShiftsBuilder
Mutable builder for building instances of
CurvePointShifts . |
| DefaultCurveMetadata
Default metadata for a curve.
|
| DefaultCurveMetadata.Meta
The meta-bean for
DefaultCurveMetadata . |
| DefaultCurveMetadataBuilder
Builder for curve metadata.
|
| InterpolatedNodalCurve
A curve based on interpolation between a number of nodal points.
|
| InterpolatedNodalCurve.Builder
The bean-builder for
InterpolatedNodalCurve . |
| InterpolatedNodalCurve.Meta
The meta-bean for
InterpolatedNodalCurve . |
| InterpolatedNodalCurveDefinition
Provides the definition of how to calibrate an interpolated nodal curve.
|
| InterpolatedNodalCurveDefinition.Builder
The bean-builder for
InterpolatedNodalCurveDefinition . |
| InterpolatedNodalCurveDefinition.Meta
The meta-bean for
InterpolatedNodalCurveDefinition . |
| JacobianCalibrationMatrix
Jacobian matrix information produced during curve calibration.
|
| JacobianCalibrationMatrix.Meta
The meta-bean for
JacobianCalibrationMatrix . |
| NodalCurve
A curve based on
double nodal points. |
| NodalCurveDefinition
Provides the definition of how to calibrate a nodal curve.
|
| ParallelShiftedCurve
A curve with a parallel shift applied to its y-values.
|
| ParallelShiftedCurve.Meta
The meta-bean for
ParallelShiftedCurve . |
| Class and Description |
|---|
| CurveNode
A node in the configuration specifying how to calibrate a curve.
|
| CurveNodeDate
The date of the curve node.
|
| Class and Description |
|---|
| Curve
A curve that maps a
double x-value to a double y-value. |
| CurveGroup
A group of curves.
|
| CurveGroupId
An identifier used to access a curve group by name.
|
| CurveId
An identifier used to access a curve by name.
|
| CurveInputs
The input data used when calibrating a curve.
|
| CurveInputsId
An identifier used to access the inputs to curve calibration.
|
| CurveName
The name of a curve.
|
| Class and Description |
|---|
| CurveGroup
A group of curves.
|
| CurveGroupDefinition
Provides the definition of how to calibrate a group of curves.
|
| CurveGroupName
The name of a curve group.
|
| CurveId
An identifier used to access a curve by name.
|
| CurveName
The name of a curve.
|
| Class and Description |
|---|
| Curve
A curve that maps a
double x-value to a double y-value. |
| Class and Description |
|---|
| CurveMetadata
Metadata about a curve and curve parameters.
|
| CurveName
The name of a curve.
|
| NodalCurve
A curve based on
double nodal points. |
| Class and Description |
|---|
| CurveGroupDefinition
Provides the definition of how to calibrate a group of curves.
|
| CurveName
The name of a curve.
|
| CurveParameterSize
The curve name and number of parameters.
|
| JacobianCalibrationMatrix
Jacobian matrix information produced during curve calibration.
|
| Class and Description |
|---|
| NodalCurve
A curve based on
double nodal points. |
| Class and Description |
|---|
| Curve
A curve that maps a
double x-value to a double y-value. |
| InterpolatedNodalCurve
A curve based on interpolation between a number of nodal points.
|
| Class and Description |
|---|
| Curve
A curve that maps a
double x-value to a double y-value. |
| CurveParameterSize
The curve name and number of parameters.
|
Copyright 2009-Present by OpenGamma Inc. and individual contributors
Apache v2 licensed
Additional documentation can be found at opengamma.github.io/StrataDocs.


Copyright © 2020 STMicroelectronics
This software component is licensed by ST under BSD-3-Clause license, the “License”; You may not use this component except in compliance with the License. You may obtain a copy of the License at:
https://opensource.org/licenses/BSD-3-Clause
The STM32Cube HAL and LL, an STM32 abstraction layer embedded software, ensure maximized portability across STM32 portfolio.
The Portable APIs layer provides a generic, multi instanced and simple set of APIs to interact with the upper layer (application, libraries and stacks). It is composed of native and extended APIs set. It is directly built around a generic architecture and allows the build-upon layers, like the middleware layer, to implement its functions without knowing in-depth the used STM32 device. This improves the library code reusability and guarantees an easy portability on other devices and STM32 families.
The Low Layer (LL) drivers are part of the STM32Cube firmware HAL that provide basic set of optimized and one shot services. The Low layer drivers, contrary to the HAL ones are not Fully Portable across the STM32 families; the availability of some functions depend on the physical availability of the relative features on the product. The Low Layer (LL) drivers are designed to offer the following features:
First Official Release
First official release of LL / HAL Drivers for STM32WLxx series.
None
Supported Devices:
Not applicable
None


It works!
You can edit this file in /srv/www/index.html
All rights go to the original author of nweb Nigel Griffiths<EMAIL_ADDRESS>Feedback is welcome to Nigel Griffiths nag@uk.ibm.com


Media objects are a commonly used UI component that feature a left- or right-aligned image alongside a block of text.
By default, the
.media-label
is in-line with the heading text.
A modifier class of
.media-heading-stacked
can be added to the
.media-heading
element. This allows the
.media-label
to stack above (or below) the header text.


Home
About
☰
IWS Feature System
This project was developed for a hiring process
Project developed by Igor Rodrigues