Perception, Planning, and Control
© Russ Tedrake, 2020-2023
Last modified .
How to cite these notes, use annotations, and give feedback.
Note: These are working notes used for a course being taught at MIT. They will be updated throughout the Fall 2023 semester.
| Previous Chapter | Table of contents | Next Chapter |
There are a few more essential skills that we need in our toolbox. In this chapter, we will explore some of the powerful methods of kinematic trajectory motion planning.
In fact, if you ran the clutter clearing demo, I would say that motion planning failures were the biggest limitation of that solution so far: the hand or objects could sometimes collide with the cameras or bins, or the differential-inverse kinematics strategy (which effectively ignored the joint angles) would sometime cause the robot to fold in on itself. In this chapter we'll develop the tools to make that much better!
I do need to make one important caveat. For motion planning in manipulation, lots of emphasis is placed on the problem of avoiding collisions. Despite having done some work in this field myself, I actually really dislike the problem formulation of collision-free motion planning. I think that on the whole, robots are too afraid of bumping into the world (because things still go wrong when they do). I don't think humans are solving these complex geometric problems every time we reach... even when we are reaching in dense clutter. I actually suspect that we are very bad at solving them. I would much rather see robots that perform well even with very coarse / approximate plans for moving through a cluttered environment, that are not afraid to make incidental contacts, and that can still accomplish the task when they do!
The goal of this chapter is to solve for motion trajectories. But I would argue that if you really understand how to solve inverse kinematics, then you've got most of what you need to plan trajectories.
We know that the forward kinematics give us a (nonlinear) mapping from joint angles to e.g. the pose of the gripper: $X^G = f_{kin}(q)$. So, naturally, one would think that the problem of inverse kinematics (IK) is about solving for the inverse map, $q = f^{-1}_{kin}(X^G).$ But, like we did with differential inverse kinematics, I'd like to think about inverse kinematics as the more general problem of finding joint angles subject to a rich library of costs and constraints; and the space of possible kinematic constraints is indeed rich.
For example, when we were evaluating grasp candidates for bin picking, we had only a soft preference on the orientation of the hand relative to some antipodal grasp. In that case, specifying 6 DOF pose of the gripper and finding one set of joint angles which satisfies it exactly would have been an overly constrained specification. I would say that it's rare that we have only end-effector pose constraints to reason about, we almost always have costs or constraints in joint space (like joint limits) and others in Cartesian space (like non-penetration constraints).
With its obvious importance in robotics, you probably won't be
surprised to hear that there is an extensive literature on inverse
kinematics. But you may be surprised at how extensive and complete the
solutions can get. The forward kinematics, $f_{kin}$, is a nonlinear
function in general, but it is a very structured one. In fact, with rare
exceptions (like if your robot has a helical
joint, aka screw joint), the equations governing the valid Cartesian
positions of our robots are actually polynomial. "But wait! What
about all of those sines and cosines in my kinematic equations?" you say.
The trigonometric terms come when we want to relate joint angles with
Cartesian coordinates. In $\Re^3$, for two points, $A$ and $B$, on the
same rigid body, the (squared) distance between them, $\|p^A - p^B\|^2,$
is a constant. And a joint is just a polynomial constraint between
positions on adjoining bodies, e.g. that they occupy the same point in
Cartesian space. See
Understanding the solutions to polynomial equations is the subject of
algebraic geometry. There is a deep literature on kinematics theory, on
symbolic algorithms, and on numerical algorithms. For even very complex
kinematic topologies, such as four-bar
linkages and Stewart-Gough
platforms, we can count the number of solutions, and/or understand
the continuous manifold of solutions. For instance,
While the algebraic-geometry methods are mostly targeted for offline
global analysis, they are not designed for fast real-time inverse
kinematics solutions needed in a control loop. The most popular tool
these days for real-time inverse kinematics for six- or seven-DOF
manipulators is a tool called "IKFast", described in Section 4.1
of
These explicit solutions are important to understand because they provide deep insight into the equations, and because they can be fast enough to use inside a more sophisticated solution approach. But the solutions don't provide the rich specification I advocated for above; in particular, they break down once we have inequality constraints instead of equality constraints. For those richer specifications, we will turn to optimization.
Rather than formulate inverse kinematics as $$q = f^{-1}_{kin}(X^G),$$ let's consider solving the same problem as an optimization: \begin{align} \min_q & \quad |q - q_0|^2, \\ \subjto &\quad X^G = f_{kin}(q), \end{align} where $q_0$ is some comfortable nominal position. While writing the inverse directly is a bit problematic, especially because we sometimes have multiple (even infinite) solutions or no solutions. This optimization formulation is slightly more precise -- if we have multiple joint angles which achieve the same end-effector position, then we prefer the one that is closest to the nominal joint positions. But the real value of switching to the optimization perspective of the problem is that it allows us to connect to a rich library of additional costs and constraints.
We have already discussed the idea of solving differential inverse kinematics as an optimization problem. In that workflow, we started by using the pseudo-inverse of the kinematic Jacobian, but then graduated to thinking about the least-squares formulation of the inverse problem. The more general least-squares setting, we could add additional costs and constraints that would protect us from (nearly) singular Jacobians and could take into account additional constraints from joint limits, joint velocity limits, etc. We could even add collision avoidance constraints. Some of these constraints are quite nonlinear / nonconvex functions of the configuration $q$, but in the differential kinematics setting we were only seeking to find a small change $\Delta q$ around the nominal configuration, so it was quite reasonable to make linear/convex approximations of these nonlinear/nonconvex constraints.
Now we will consider the full formulation, where we try to solve the nonlinear / nonconvex optimization directly, without any constraints on only making a small change to an initial $q$. This is a much harder problem computationally. Using powerful nonlinear optimization solvers like SNOPT, we are often able to solve the problems, even at interactive rates (the example below is quite fun). But there are no guarantees. It could be that a solution exists even if the solver returns "infeasible".
Of course, the differential IK problem and the full IK problem are closely related. In fact, you can think about the differential IK algorithm as doing one step of (projected) gradient descent or one-step of Sequential Quadratic Programming, for the full nonlinear problem.
Drake provides a nice InverseKinematics
class that makes it easy to assemble many of the standard
kinematic/multibody constraints into a
MathematicalProgram
. Take a minute to look at the
constraints that are offered. You can add constraints on the relative
position and/or orientation on two bodies, or that two bodies are more
than some minimal distance apart (e.g. for non-penetration) or closer
than some distance, and more. This is the way that I want you to think
about the IK problem; it is an inverse problem, but one with a
potentially very rich set of costs and constraints.
Despite the nonconvexity of the problem and nontrivial computational cost of evaluating the constraints, we can often solve it at interactive rates. I've assembled a few examples of this in the chapter notebook:
In the first version, I've added sliders to let you control the desired pose of the end-effector. This is the simple version of the IK problem, amenable to more explicit solutions, but we nevertheless solve it with our full nonlinear optimization IK engine (and it does include joint limit constraints). This demo won't look too different from the very first example in the notes, where you used teleop to command the robot to pick up the red brick. In fact, differential IK offers a fine solution to this problem, too.
In the second example, I've tried to highlight the differences between the nonlinear IK problem and the differential IK problem by adding an obstacle directly in front of the robot. Because both our differential IK and IK formulations are able to consume the collision-avoidance constraints, both solutions will try to prevent you from crashing the arm into the post. But if you move the target end-effector position from one side of the post to the other, the full IK solver can switch over to a new solution with the arm on the other side of the post, but the differential IK will never be able to make that leap (it will stay on the first side of the post, refusing to allow a collision).
With great power comes great responsibility. The inverse kinematics toolbox allows you to formulate complex optimizations, but your success with solving them will depend partially on how thoughtful you are about choosing your costs and constraints. My basic advice is this:
Let's use IK to grasp a cylinder (call it a hand rail). Suppose it doesn't matter where along the cylinder we grasp, nor the orientation at which we grasp it. Then we should write the IK problem using only the minimal version of those constraints.
In the notebook, I've coded up one version of this. I've put the cylinder's pose on the sliders now, so you can move it around the workspace, and watch how the IK solver decides to position the robot. In particular, if you move the cylinder in $\pm y$, you'll see that the robot doesn't try to follow... until the hand gets to the end of the cylinder. Very nice!
One could imagine multiple ways to implement that constraint. Here's how I did it:
ik.AddPositionConstraint(
frameB=gripper_frame, p_BQ=[0, 0.1, -0.02],
frameA=cylinder_frame, p_AQ_lower=[0, 0, -0.5], p_AQ_upper=[0, 0, 0.5])
ik.AddPositionConstraint(
frameB=gripper_frame, p_BQ=[0, 0.1, 0.02],
frameA=cylinder_frame, p_AQ_lower=[0, 0, -0.5], p_AQ_upper=[0, 0, 0.5])
In words, I've defined two points in the gripper frame; in the notation
of the AddPositionConstraint
method they are ${}^Bp^{Q}$.
Recall the gripper frame is such
that $[0, .1, 0]$ is right between the two gripper pads; you should
take a moment to make sure you understand where $[0,.1,-0.02]$ and
$[0,.1,0.02]$ are. Our constraints require that both of those points
should lie exactly on the center line segment of the cylinder. This
was a compact way for me to leave the orientation around the cylinder
axis as unconstrained, and capture the cylinder position constraints
all quite nicely.
We've provided a rich language of constraints for specifying IK problems, including many which involve the kinematics of the robot and the geometry of the robot and the world (e.g., the minimum-distance constraints). Let's take a moment to appreciate the geometric puzzle that we are asking the optimizer to solve.
Let's return to the example of the iiwa reaching into the shelf. This IK problem has two major constraints: 1) we want the center of the target sphere to be in the center of the gripper, and 2) we want the arm to avoid collisions with the shelves. In order to plot these constraints, I've frozen three of the joints on the iiwa, leaving only the three corresponding motion in the $x-z$ plane.
To visualize the constraints, I've sampled a dense grid in the three joint angles of the planarized iiwa, assigning each grid element to 1 if the constraint is satisfied or 0 otherwise, then run a marching cubes algorithm to extract an approximation of the true 3D geometry of this constraint in the configuration space. The "grasp the sphere" constraint produces the nice green geometry I've pictured above on the right; it is clipped by the joint limits. The collision-avoidance constraint, on the other hand, is quite a bit more complicated. To see that, you'd better open up this 3D visualization so you can navigate around it yourself. Scary!
To help you appreciate the problem that we've formulated, I've made a visualization of the optimization landscape. Take a look at the landscape here first; this is only plotting a small region around the returned solution. You can use the Meshcat controls to show/hide each of the individual costs and constraints, to make sure you understand.
As recommended, I've kept the cost landscape (the green surface) to be simply the quadratic joint-centering cost. The constraints are plotted in blue when they are feasible, and red when they are infeasible:
You should also take a quick look at the full optimization landscape. This is the same set of curves as in the visualization above, but now it's plotted over the entire domain of joint angles within the joint limits. Nonlinear optimizers like SNOPT can be pretty amazing sometimes!
For unconstrained inverse kinematics with exactly six degrees of freedom, we have closed-form solutions. For the generalized inverse kinematics problem with rich costs and constraints, we've got a nonlinear optimization problem that works well in practice but is subject to local minima (and therefore can fail to find a feasible solution if it exists). If we give up on solving the optimization problem at interactive rates, is there any hope of solving the richer IK formulation robustly? Ideally to global optimality?
This is actually and extremely relevant question. There are many applications of inverse kinematics that work offline and don't have any strict timing requirements. Imagine if you wanted to generate training data to train a neural network to learn your inverse kinematics; this would be a perfect application for global IK. Or if you want to do workspace analysis to see if the robot can reach all of the places it needs to reach in the workspace that you're designing for it, then you'd like to use global IK. Some of the motion planning strategies that we'll study below will also separate their computation into an offline "building" phase to make the online "query" phase much faster.
In my experience, general-purpose global nonlinear solvers -- for instance, based on mixed-integer nonlinear programming (MINLP) approaches or the interval arithmetic used in satisfiability-modulo-theories (SMT) solvers -- typically don't scale the complexity of a full manipulator. But if we only slightly restrict the class of costs and constraints that we support, then we can begin to make progress.
Drake provide an implementation of the GlobalInverseKinematics
approach described in
When should we use IK vs Differential IK? IK solves a more global problem, but is not guaranteed to succeed. It is also not guaranteed to make small changes to $q$ as you make small changes in the cost/constraints; so you might end up sending large $\Delta q$ commands to your robot. Use IK when you need to solve the more global problem, and the trajectory optimization algorithms we produce in the next section are the natural extension to producing actual $q$ trajectories. Differential IK works extremely well for incremental motions -- for instance if you are able to design smooth commands in end-effector space and simply track them in joint space.
In our first version of grasp selection using sampling, we put an objective that rewarded grasps that were oriented with the hand grasping from above the object. This was a (sometimes poor) surrogate for the problem that we really wanted to solve: we want the grasp to be achievable given a "comfortable" position of the robot. So a simple and natural extension of our grasp scoring metric would be to solve an inverse kinematics problem for the grasp candidate, and instead of putting costs on the end-effector orientation, we can use the joint-centering cost directly as our objective. Furthermore, if the IK problem returns infeasible, we should reject the sample.
There is a quite nice extension of this idea that becomes quite natural once we take the optimization view, and it is a nice transition to the trajectory planning we'll do in the next section. Imagine if the task requires us not only to pick up the object in clutter, but also to place the object carefully in clutter as well. In this case, a good grasp is finds a pose for the hand relative to the object that simultaneously optimizes both the pick configuration and the place configuration. This is actually quite natural to do with inverse kinematics; one can formulate an optimization problem with decision variables for both $q_{pick}$ and $q_{place}$, with constraints enforcing that ${}^OX^{G_{pick}} = {}^OX^{G_{place}}$.
Once we add in all of our other rich costs and constraints, this becomes a quite sophisticated approach. In the dish-loading project at TRI, this approach proved to be very important. Both picking up a mug in the sink and placing it in the dishwasher rack are highly constrained, so we needed the simultaneous optimization to find successful grasps.
Once you understand the optimization perspective of inverse kinematics, then you are well on your way to understanding kinematic trajectory optimization. Rather than solving multiple inverse kinematics problems independently, the basic idea now is to solve for a sequence of joint angles in the same optimization. Even better, let us define a parameterized joint trajectory, $q_\alpha(t)$, where $\alpha$ are parameters. Then a simple extension to our inverse kinematics problem would be to write something like \begin{align} \min_{\alpha,T} & \quad T, \\ \subjto &\quad X^{G_{start}} = f_{kin}(q_\alpha(0)),\\ & \quad X^{G_{goal}} = f_{kin}(q_\alpha(T)), \\ & \quad \forall t , \quad \left|\dot{q}_\alpha(t)\right| \le v_{max} \label{eq:vel_limits}. \end{align} I read this as "find a trajectory, $q(t)$ for $t \in [0, T]$, that moves the gripper from the start to the goal in minimum time".
The last equation, (\ref{eq:vel_limits}), represents velocity limits; this is the only way we are telling the optimizer that the robot cannot teleport instantaneously from the start to the goal. Apart from this line which looks a little non-standard, it is almost exactly like solving two inverse kinematics problems jointly, except instead of having the solver take gradients with respect to $q$, we will take gradients with respect to $\alpha$. This is easily accomplished using the chain rule.
The interesting question, then, becomes how to do we actually parameterize the trajectory $q(t)$ with a parameter vector $\alpha$? These says, you might think that $q_\alpha(t)$ could be a neural network that takes $t$ as an input, offers $q$ as an output, and uses $\alpha$ to represent the weights and biases of the network. Of course you could, but for inputs with a scalar input like this, we often take much simpler and sparser parameterizations, often based on polynomials.
There are many ways one can parameterize a trajectory with polynomials. For example in dynamic motion planning, direct collocation methods uses piecewise-cubic polynomials to represent the state trajectory, and the pseudo-spectral methods use Lagrange polynomials. In each case, the choice of basis functions is made so that algorithm can leverage a particular property of the basis. In dynamic motion planning, a great deal of focus is on the integration accuracy of the dynamic equations to ensure that we obtain feasible solutions to the dynamic constraints..
When we are planning the motions of our fully-actuated robot arms, we typically worry less about dynamic feasibility, and focus instead on the kinematics. For kinematic trajectory optimization, the so-called B-spline trajectory parameterization has a few particularly nice properties that we can leverage here:
Note that B-splines are closely related to Bézier curves. But the "B" in "B-spline" actually just stands for "basis" (no, I'm not kidding) and "Bézier-splines" are slightly different.
The default KinematicTrajectoryOptimization
class in Drake optimizes a trajectory defined using a B-spline to
represent a path, $r(s)$ over the interval $s \in [0,1]$, plus an
additional scalar decision variable corresponding to the trajectory
duration, $T$. The final trajectory combines the path with the
time-rescaling: $q(t) = r(t/T).$ This is a particularly nice way to
represent a trajectory of unknown duration, and has the excellent feature
that the convex hull property can still be used. Velocity constraints are
still linear; constraints on acceleration and higher derivatives do
become nonlinear, but if satisfied they still imply strict bounds
$\forall t \in [0, T].$
Since the KinematicTrajectoryOptimization
is written
using Drake's MathematicalProgram
, by default it will
automatically select what we think is the best solver given the available
solvers. If the optimization has only convex costs and constraints, it
will be dispatched to a convex optimization solver. But most often we add
in nonconvex costs
and constraints from kinematics. Therefore in most cases, the default
solver would again be the SQP-solver, SNOPT. You are free to experiment
with others!
One of the most interesting set of constraints that we can add to our kinematic trajectory optimization problem is the MinimumDistanceConstraint; when the minimum distance between all potential collision pairs is greater than zero then we have avoided collisions. Please note, though, that these collision constraints can only be enforced at discrete samples, $s_i \in [0,1]$, along the path. They do not guarantee that the trajectory is collision free $\forall t\in[0,T].$ It required very special properties of the derivative constraints to leverage the convex hull property; we do not have them for more general nonlinear constraints. A common strategy is to add constraints at some modest number of samples along the interval during optimization, then to check for collisions more densely on the optimized trajectory before executing it on the robot.
As a warm-up, I've provided a simple example of the planar iiwa reaching from the top shelf into the middle shelf.
If you look carefully at the code, I actually had to solve this trajectory optimization twice to get SNOPT to return a good solution (unfortunately, since it is a local optimization, this can happen). For this particular problem, the strategy that worked was to solve once without the collision avoidance constraint, and then use that trajectory as an initial guess for the problem with the collision avoidance constraint.
Another thing to notice in the code is the "visualization callback" that I use to plot a little blue line for the trajectory as the optimizer is solving. Visualization callbacks are implemented by e.g. telling the solver about a cost function that depends on all of the variables, and always returns zero cost; they get called every time the solver evaluates the cost functions. What I've done here can definitely slow down the optimization, but it's an excellent way to get some intuition about when the solver is "struggling" to numerically solve a problem. I think that the people / papers in this field with the fastest and most robust solvers are highly correlated with people who spend time visualizing and massaging the numerics of their solvers.
We can use KinematicTrajectoryOptimization
to do the
planning for our clutter clearing example, too. This optimization was
more robust, and did not require solving twice. I only seeded it with a
trivial initial trajectory to avoid solutions where the robot tried to
rotate 270 degrees around its base instead of taking the shorter
path.
There are a number of related approaches to kinematic trajectory
optimization in the motion planning literature, which differ either by
their parameterization or by the solution technique (or both). Some of
the more well-known include CHOMP
KOMO, for instance, is one of a wave of trajectory optimization
techniques that use the Augmented
Lagrangian method of transcribing a constrained optimization problem
into an unconstrained problem, then using a simple but fast
gradient-based solver
When kinematic trajectory optimizations succeed, they are an incredibly satisfying solution to the motion planning problem. They give a very natural and expressive language for specifying the desired motion (with needing to sample nonlinear constraints as perhaps the one exception), and they can be solved fast enough for online planning. The only problem is: they don't always succeed. Because they are based on nonconvex optimization, they are susceptible to local minima, and can fail to find a feasible path even when one exists.
Consider the extremely simple example of finding the shortest path from the start (blue star) to the goal (green star) in the image above, avoiding collisions with the red box. Avoiding even the complexity of B-splines, we can write an extremely simple optimization of the form: \begin{aligned} \min_{q_0, ..., q_N} \quad & \sum_{n=0}^{N-1} | q_{n+1} - q_n|_2^2 & \\ \text{subject to} \quad & q_0 = q_{start} \\ & q_N = q_{goal} \\ & |q_n|_1 \ge 1 & \forall n, \end{aligned} where the last line is the collision-avoidance constraint saying that each sample point has to be outside of the $\ell_1$-ball.
Once a nonlinear solver is considering paths that go right around the obstacle, it is very unlikely to find a solution that goes left around the obstacle, because the solution would have to get worse (violate the collision constraint) before it gets better.
To deal with this limitation, the field of collision-free motion planning has trended heavily towards sampling-based methods.
The Open Motion Planning Library. We have our own implementations in Drake that are optimized for our collision engines.
Once we have a motion plan, a natural question is: what is the fastest that we can execute that plan, subject to velocity, acceleration, and torque-limit constraints?
To study this, let's define a trajectory $\bq(t)$ defined over the interval $t \in [t_0, t_f]$ via a path parameterization, ${\bf r}(s)$, and a time parameterization, $s(t)$, such that $$\bq(t) = {\bf r}(s(t)), \text{ where }s(t) \in [0,1], s(t_0) = 0, s(t_f) = 1.$$ We will constrain $\forall t \in [t_0, t_f], \dot{s}(t) > 0,$ so that the inverse mapping from $s$ to $t$ always exists. The advantage of this parameterization is that when ${\bf r}(s)$ is fixed, many of the objectives and constraints that we might want to put on $\bq(t)$ are actually convex in the derivatives of $s(t).$ To see this, using the shorthand ${\bf r}'(s) = \pd{\bf r}{s}, {\bf r}''(s) = \pd{^2 {\bf r}}{s^2},$ etc., write \begin{align*} \dot\bq &= {\bf r}'(s)\dot{s},\\ \ddot\bq(t) &= {\bf r}''(s) \dot{s}^2 + {\bf r}'(s)\ddot{s}.\end{align*} Even more important/exciting, substituting these terms into the manipulator equations yields: $$\bu(s) = {\bf m}(s)\ddot{s} + {\bf c}(s)\dot{s}^2 + \bar{\bf \tau}_g(s),$$ where $\bu(s)$ is the commanded torque at the scaled time $s(t)$, and \begin{align} {\bf m}(s) &= {\bf M}({\bf r}(s)){\bf r}'(s), \\ {\bf c}(s) &= {\bf M}({\bf r}(s)){\bf r}''(s) + \bC({\bf r}(s), {\bf r}'(s)) {\bf r}'(s), \\ \bar{\bf \tau}_g(s) &= {\bf \tau}_g({\bf r}(s)).\end{align}
The next key step is to introduce a change of variables: $b(s(t)) =
\dot{s}^2(t) ,$ and note† that $b'(s) = 2 \ddot{s}.$
These time-optimal path parameterizations (TOPP) were studied
extensively throughout the 1980's (e.g.

For this exercise, you will implement a optimization-based inverse kinematics solver to open a cupboard door. You will work exclusively in . You will be asked to complete the following steps:
For this exercise, you will implement and analyze the RRT algorithm introduced in class. You will work exclusively in . You will be asked to complete the following steps:
Due to the random process by which nodes are generated, the paths output by RRT can often look somewhat jerky (the "RRT dance" is the favorite dance move of many roboticists). There are many strategies to improve the quality of the paths and in this question we'll explore two. For the sake of this problem, we'll assume path quality refers to path length, i.e. that the goal is to find the shortest possible path, where distance is measured as Euclidean distance in joint space.
For this exercise, you will implement part of the IRIS algorithm
| Previous Chapter | Table of contents | Next Chapter |


[% page.title = "Public Forum Archive Policy" %]
Public fora, which include all developer and user mailing lists, wikis, and issue reporting systems, are essential to perl.org. It should be understood that communications sent to such fora may be available to the public for eternity.
Maintaining a publicly accessible archive of those communications is a vital component of the services we provide to our community. They serve as a both a public historical record and a searchable repository of our activities.
On rare occasions it becomes necessary to make modifications to our own archives. This document describes the circumstances and procedures under which such modifications may be made. Please note that it is common practice for others not affiliated with perl.org to provide archives of our public fora as well. This document pertains solely to the archives made directly available through hosts within the perl.org domain.
All communication sent to our public fora - the public mailing lists, wikis, issue reporting systems and any other perl.org contribution mechanism - is deemed to be published by the sender of that communication and made public without condition. Any disclaimers that may be attached to said communication that describe it as private or non-redistributable are self-contradictory and thus null and void. perl.org is not responsible for removing or otherwise concealing your communication after you caused it to become public.
We generally only consider requests for editing or existing material contained in the archive when requested by the sender of the archived communication. We will consider each case on its individual merit, and weigh each modification against the damage done by altering the historical record. In the past we have denied more requests than we have honored, in order to protect the integrity of the archives.
We will usually edit or remove information only in the event of an inadvertent disclosure of confidential information, such as a social security number; however, a sender's contact information (name, email address, phone number, etc.) does not fall into that category. We most certainly do not edit the archives as a means of reducing one's exposure to spam.
The sender of the archived communication should submit a request to webmaster at perl.org. Each request should include the following:
Each request will be handled confidentially and with appropriate care; however, please keep in mind that perl.org is a volunteer organization. We will do our best to handle each request as quickly as we can.


Chapter 3 Applications
Some significant applications are demonstrated in this chapter.
3.1 Example one
3.2 Example two
relational databases
TIPS
Be aware, the flu and dengue data contains metadata that should be stripped from the data on load. Think of a way to create valid country names that fit with the gapminder data. Remember (!) that in the end, this assignment needs to be reported by a .Rmd file for your portfolio. So save what you are doing, save your SQL scripts, make screenshots if you want, and in general design a clear and attractive report in RMarkdown to showcase your SQL/database-skills in your portfolio. You may be sending this to propspective employers in the future! (also, the portfolio is what we as teachers will be grading. But definitely think about the future rather than only about “passing the course”) Assignment
Load the flu (“./data/flu_data.csv), the dengue (.”/data/dengue_data.csv) and the gapminder ({dslabs} package) into three separate dataframes in R
Check if they are in the right shape. Is the data in the ‘tidy’ format? If not change the format to ‘tidy’
Change the country and date variables of the three tables so that they coincide in terms of data type, class and values
Store the three tables as separate (so six in total) .csv and .rds files.
In Dbeaver create a new PostgreSQL database “workflowsdb”
Using RPostgreSQL, insert the tables into the database.
Inspect the contents of the tables with SQL (in DBeaver) and save the SQL script.
Inspect the contents of the tables with dplyr (in R) and save a RMarkdown showing what you are doing.
Load the gapminder data in R and change the dataframe in such as way that you could join it to dengue and flue.
Save this clean gapminder data in the “workflowsdb” database
Perform some joins (your choice) with SQL (can be done in DBeaver or with dplyr.
Generate a joined table, and export this from the database to R.
Show some descriptive statistics with this table, and at least 3 visualisations using ggplot2.
show all of your actions in this assignment in a Rmd file, perhaps with pictures and provide text explaining and showcasing your skills.
library(tidyverse)
library(dslabs)
<- as_tibble(gapminder)
gapminder <- read.csv(url("https://raw.githubusercontent.com/ClaudiavdZ/tlsc-dsfb26v-20_workflows/main/data/flu_data.csv"), skip = 11)
flu_data<- as_tibble(flu_data)
flu_data <- read.csv(url("https://raw.githubusercontent.com/ClaudiavdZ/tlsc-dsfb26v-20_workflows/main/data/dengue_data.csv"), skip = 11)
dengue_data
write.table(dengue_data , file = "dengu_data.csv")
write.table(dengue_data , file = "dengu_data.RDS")
write.table(flu_data , file = "flu_data.csv")
write.table(flu_data , file = "flu_data.RDS")
write.table(gapminder , file = "gapminder.csv")
write.table(gapminder , file = "gapminder.RDS")
library(DBI)
<- dbConnect(RPostgres::Postgres(),
con dbname = "myfirstdb",
host="localhost",
port="5432",
user="postgres",
password="Veroni36")
dbListTables(con)
## [1] "test" "gapminder" "flu_data" "dengue_data"
#dbWriteTable(con, "dengue_data", dengue_data)
#dbWriteTable(con, "flu_data", flu_data)
#dbWriteTable(con, "gapminder", gapminder)
library(janitor)
##
## Attaching package: 'janitor'
## The following objects are masked from 'package:stats':
##
## chisq.test, fisher.test
<- as.data.frame(t(gapminder))
gapminder_usd <- gapminder_usd %>% row_to_names(row_number = 1) gapminder_usd
## Warning in row_to_names(., row_number = 1): Row 1 does not provide unique names.
## Consider running clean_names() after row_to_names().


Things I shoot/write about include food, travel, travel-in-Japan, books, walking, plants, places. From time to time, I wear other hats: travel consultant, tour guide, translator, interpreter, transcriber. After leaving my home country (Malaysia), I spent a few years in London and Kyoto before moving to Tokyo. My newsletter is called the adventures of furochan. You can find me on Instagram for food, doors, and plants. To say hello, please click here.
For more information, including setup and configuration instructions, bug reports or feature requests head over to GitHub.


or A star is a path search algorithm used in many fields
of computer science
n: node
G (cost between start and n):
H (heuristic function estimating the cost of
the cheapest path from n to goal):
F (G + H):
Right click on the path to see his G, H and F values
You can also drag and drop start and end points anywhere!
The cost between nodes is ≃ 40 since the grid nodes have
40px width and height
Click on an empty node to create an obstacle


Base type: System.Entity
Summary: This entity presents the Exchange server replication status information. Used in alerting.
| Name | Type | Notes |
|---|---|---|
| ID | System.Int32 | The unique integer representation of replication status. |
| ApplicationID | System.Int32 | The unique integer representation of parent SAM application. |
| CheckName | System.String | The string value that contains replication entity name (ClusterService, ReplayService, ActiveManager...) |
| Status | System.Int32 | The integer value that contains replication entity status. |
| Error | System.String | The string value that contains error message. |
| NodeID | System.Int32 | The unique integer representation of parent node. |
| DisplayName | System.String | |
| Description | System.String | |
| InstanceType | System.Type | |
| Uri | System.String | |
| InstanceSiteId | System.Int32 | Default='0'. |
| ReplicationStatus | Orion.APM.Exchange.ReplicationStatus | Defined by relationship Orion.APM.Exchange.ReplicationStatusAlertReferencesReplicationStatus (System.Reference) |


{% extends 'core/base.html' %} {% load static %} {% block styles %} {% endblock %} {% block content %}
Country Code
You have successfully signed up to PDA application. Please login to access the application.


a new board and start from scratch. Add as many moves and variations as you'd like, marking the board and adding commentary along the way.
and share an SGF file containing a game you recently played, a difficult tsumego problem, or a professional game you don't quite understand.
and discover the kifus other people have uploaded. Contribute to the community by finding a game that interests you and adding a comment or variation.


'Execute' will run 'CubicVR.primitives.box'. 'Message' and 'Error' will produce as their name suggests within 1 second.
Messages
Errors


Slideshow application to cheer you !
Photos and music that are stored on your iPhone , will be displayed at random along with the words of encouragement .
In the gap time such as travel and rest , please start the app .  Favorite song raise your feelings . One step away , it might bring out the power to do my best .
■ Application name : Cheer-Slide
■ Version information : ver.1.0.0
■ Released: 2013 / 12
■ Development : YUKIKO NAGAOKA
Features of this app
Free
Anyone can be used free . You can extend the functionality to buy "In-App Purchase".
Simple initialization
Follow the instructions on the screen , the initial configuration is easy . Only three steps ( photo selection , registration of words of encouragement , the choice of music ) . Immediately , you can enjoy the Slideshow .
Automatic Slideshow
The chosen music flows as BGM, words and photos are displayed at random . Photos are deformated expansion and rotation . Every time , new Slideshow is automatically generated .
Simple editing photos
When you select a photo in the photo library , you can pinch amd trim the photo and cut out a favorite part .
In-App Purchase (Option)
If you like this app , please consider buying a "pro version " . Two features can be added .
1. Ad at the top of the Slideshow is hidden. You can focus on slide show.
2. You can create multi projects (=slide show) up to 1000. You can create projects of various situations to enjoy for sports, examination, and job hunting etc.
Disclaimer
■ The service of " kokucy " , there might be changes , to cancel without notice any . YUKIKO NAGAOKA shall not be liable for any loss or damage that occurred as the cause of these .
■ with respect to loss or damage arising from the inability to use or that use the services of " kokucy " , YUKIKO NAGAOKA does not take any responsibility .
■ The use and availability of information and software from " kokucy " , please disclaims liability for any damages caused by the user's self . Against loss or damage arising from the information and software is not available from " kokucy " , by obtaining and get in , YUKIKO NAGAOKA does not take any responsibility .
■ against loss or damage arising from the inability to use , or by using the software obtained from the " kokucy " , YUKIKO NAGAOKA does not take any responsibility .
Theme Song
Believe in My Heart/BEST SELLECTION of Ys Ⅲ/Copyright© Nihon Falcom Corporation
Tap under-left button of 'Home' screen to stop Theme Song . Set off 'Theme Song' swich of 'Setting' screen to prevent use music .
Watch YouTube
http://youtu.be/mOeHbMBsqpw
Contact information
To increase features , it is continuing to develop further . Please contact us from the email link . We are waiting to your bug report and your ideas. Thank you .
.


Face/Off A film review by Marty Mapes Copyright 1997 Marty Mapes
**1/2 (out of 4) Of all the John Woo movies I've seen, THE KILLER is the most fascinating. It is difficult to watch because of all the blood and violence, but it seems Woo chose violence as his medium, not his message. The violence is the texture of the movie, not the movie itself.
Since coming to America, his movies seem pretty tame by comparison. I haven't seen his first U.S. film, HARD TARGET, but BROKEN ARROW and FACE/OFF both seem much more polished and mainstream than THE KILLER. Woo still includes tons of bullets, big explosions, and thematic descants that float above the violence on-screen, but the violence is no longer non-stop. It is no longer the canvas; it is now the flourish.
In trying to appreciate Woo on his own level, it seemed that his whole purpose, like Quentin Tarantino's in RESERVOIR DOGS, was to take the violence inherent in the action genre and carry it so far that no action movie could ever be viewed the same again. Rather than continuing that experiment, Woo is now just making action movies.
Woo does have a talent for making action movies, and many of his signature pieces grace FACE/OFF. One brutal gunfight is partially shown from a child's point of view, both visually and aurally, giving the scene an emotionally confusing feel. There's also plenty of Woo's trademark, a mutually-assured-destruction standoff, each participant holding a gun to the other's head.
FACE/OFF is smarter than many other action movies, but it lacks heart. It's interesting to ponder, but it doesn't suck you in.
Sean Archer (John Travolta) works for a secret anti-terrorism branch of the government. He's tracking Castor Troy (Nicolas Cage), a notorious criminal who has planted a bomb somewhere in L.A. After losing a game of cat-and-mouse, Castor goes into a coma, unable to talk (and therefore, unable to tell Archer the location of the bomb). Archer's last hope is to somehow convince Castor's brother Pollux to talk.
Like their mythological namesakes, Castor and Pollux are very close brothers, and Archer knows Pollux would never squeal. A new "morphogenetic" mask, however, along with a computer chip implanted in the larynx, would allow Archer to perfectly adopt the look and sound of Castor, allowing Archer to get close enough to Pollux to learn the location of the bomb. A modern-day Trojan horse.
The plot takes an interesting twist when Castor wakes up without a face. He and his cronies strongarm the doctors into putting Archer's face onto Castor, and now the roles are completely reversed, and the bad guys have the upper hand.
It really does sound like it should be a good movie, and there are lots of details that are well executed. For example, Nicolas Cage does a wonderful job at playing John Travolta. All of the facial expressions we got used to in GET SHORTY and PULP FICTION are copied exactly by Cage. During a later standoff, Castor and Archer have trapped each other on opposite sides of a mirror, an interesting metaphor for their switcheroo. The Trojan War references that run through the movie are interesting too - It was an archer who found the weakness in and killed Achilles; pay attention to how Archer finally finishes off his nemesis.
In fact, there are many aspects of FACE/OFF that can be praised, from the careful costume design (Cage wears a big black billowing cape and a blood red silk shirt), to the cool gross face effects.
But one has to wonder if Woo's talent doesn't translate to Hollywood as well as it could. The speed boat sequence at end was top notch, but the stunt doubles didn't really match the actors (it'll play better on your TV). The fight scenes were more edited and less choreographed than I expected and hoped from Woo. Worst of all, FACE/OFF lacks that essential spark that draws you in and makes you care about the outcome of the movie.
I'm starting to wonder if Woo is slipping or if I'm remembering his Hong Kong films too flatteringly.
Check out more current movie reviews at http://www.indra.com/~mmapes/
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


We will introduce domain names and ICANN in this section and give examples of them.
A domain name is an identification string that defines a realm of administrative autonomy, authority or control within the Internet. Domain names are used in various networking contexts and for application-specific naming and addressing purposes. In general, a domain name identifies a network domain, or it represents an Internet Protocol (IP) resource, such as a personal computer used to access the Internet, a server computer hosting a website, or the web site itself or any other service communicated via the Internet. In 2017, 330.6 million domain names had been registered.
Domain names are formed by the rules and procedures of the Domain Name System (DNS). Any name registered in the DNS is a domain name. Domain names are organized in subordinate levels (subdomains) of the DNS root domain, which is nameless. The first-level set of domain names are the top-level domains (TLDs), including the generic top-level domains (gTLDs), such as the prominent domains com, info, net, edu, and org, and the country code top-level domains (ccTLDs). Below these top-level domains in the DNS hierarchy are the second-level and third-level domain names that are typically open for reservation by end-users who wish to connect local area networks to the Internet, create other publicly accessible Internet resources or run web sites.
The registration of these domain names is usually administered by domain name registrars who sell their services to the public.
A fully qualified domain name (FQDN) is a domain name that is completely specified with all labels in the hierarchy of the DNS, having no parts omitted. Traditionally a FQDN ends in a dot (.) to denote the top of the DNS tree. Labels in the Domain Name System are case-insensitive, and may therefore be written in any desired capitalization method, but most commonly domain names are written in lowercase in technical contexts.
The Internet Corporation for Assigned Names and Numbers is an American multi-stakeholder group and nonprofit organization responsible for coordinating the maintenance and procedures of several databases related to the namespaces and numerical spaces of the Internet, ensuring the network's stable and secure operation. ICANN performs the actual technical maintenance work of the Central Internet Address pools and DNS root zone registries pursuant to the Internet Assigned Numbers Authority (IANA) function contract. The contract regarding the IANA stewardship functions between ICANN and the National Telecommunications and Information Administration (NTIA) of the United States Department of Commerce ended on October 1, 2016, formally transitioning the functions to the global multistakeholder community.
Much of its work has concerned the Internet's global Domain Name System (DNS), including policy development for internationalization of the DNS system, introduction of new generic top-level domains (TLDs), and the operation of root name servers. The numbering facilities ICANN manages include the Internet Protocol address spaces for IPv4 and IPv6, and assignment of address blocks to regional Internet registries. ICANN also maintains registries of Internet Protocol identifiers. ICANN's primary principles of operation have been described as helping preserve the operational stability of the Internet; to promote competition; to achieve broad representation of the global Internet community; and to develop policies appropriate to its mission through bottom-up, consensus-based processes.
ICANN's creation was announced publicly on September 17, 1998, and it formally came into being on September 30, 1998, incorporated in the U.S. state of California. Originally headquartered in Marina del Rey in the same building as the University of Southern California's Information Sciences Institute (ISI), its offices are now in the Playa Vista neighborhood of Los Angeles in Facebook's old office.
1.
2.
One task that ICANN was asked to do was to address the issue of domain name ownership resolution for generic top-level domains (gTLDs). ICANN's attempt at such a policy was drafted in close cooperation with the World Intellectual Property Organization (WIPO), and the result has now become known as the Uniform Dispute Resolution Policy (UDRP). This policy essentially attempts to provide a mechanism for rapid, cheap and reasonable resolution of domain name conflicts, avoiding the traditional court system for disputes by allowing cases to be brought to one of a set of bodies that arbitrate domain name isputes. According to ICANN policy, domain registrants must agree to be bound by the UDRP —- they cannot get a domain name without agreeing to this.
Examination of the UDRP decision patterns has caused some to conclude that compulsory domain name arbitration is less likely to give a fair hearing to domain name owners asserting defenses under the First Amendment and other laws, compared to the federal courts of appeal in particular.
Domain names serve to identify Internet resources, such as computers, networks, and services, with a text-based label that is easier to memorize than the numerical addresses used in the Internet protocols.
An important function of domain names is to provide easily recognizable and memorizable names to numerically addressed Internet resources.
Domain names are also used as simple identification labels to indicate ownership or control of a resource.
ICANN's primary principles of operation have been described as helping preserve the operational stability of the Internet; to promote competition; to achieve broad representation of the global Internet community; and to develop policies appropriate to its mission through bottom-up, consensus-based processes.


${self.sitename()}
% if user is not UNDEFINED and user:
Logout
% else:
Login
Register
% endif
Summary
Network
Contacts
Pay/Receive
${next.body()}


+
◀
▶
⌂
⟳
🔎
🔦
➕
➖
aA
<
>
Browser Exit?
Do you really want to exit browser?
Yes
No
Permit
Stop
Chrome Feature Not Supported
The feature highlighted by this sample app is not supported in your version of Chrome. Make sure your browser is up to date. If you still see this message after updating your browser, try installing a
dev channel
build of Chrome.


x1 = PowerOn - Simulates reset that most ECUs perform after the ignition OFF/ON cycle.
x2= Power On While Maintaining Communication - Simulates reset that most ECUs perform after the ignition OFF/ON cycle but maintains communication with the client (tester).


LookML Tools¶
This repository contains some tools to handle best practices of a set of developers working on LookML files.
There are three tools:
LookML updater
LookML linter
LookML grapher
Sites:
source: https://github.com/ww-tech/lookml-tools
documentation: https://ww-tech.github.io/lookml-tools/
Pypi: https://pypi.org/project/lookml-tools/
LookML updater¶
The first tool helps solve a problem of official definitions of dimensions
and measures
—such as in a business glossary—getting out of sync from some other system. The solution implemented here is to have a remote master list whose definitions are propagated to LookML. Thus, given some remote definition for a given LookML dimension
, dimension_group
, or measure
, inject it in the LookML.
Full documentation is here.
LookML linter¶
The second tool helps us check that our LookML conforms to some given coding standards and LookML developer best practices. It runs a series of checks over our LookML files and reports which files
, or which dimensions
, dimension_groups
, or measures
, fail those checks.
Full documentation is here.
LookML grapher¶
The third tool creates a “network diagram” of the model - explore - view
relationships and writes to an PNG
image file. The code will also identify any orphans
i.e. views not referenced by any models or explores.
Full documentation is here.
Installation¶
For the grapher, you will need to install grapviz:
brew install graphviz
For all tools, you will need to install dependencies:
pip install -r requirements.txt
You can install the Python codebase of lookml-tools
via pip:
pip install lookml-tools
One user reported having to install a specific version of pandas (pandas==0.24.0
) to make this all work. YMMV.
Alternatively, you can install with
python setup.py install
Unit tests¶
There is a test suite with close to 100% code coverage
Run with
pip install pytest-cov
python -m pytest --cov=lkmltools/ test/*.py ; coverage html
Contribute¶
We would love to have your feedback, suggestions, and especially contributions to the project. Create a pull request!
You can reach me directly at<EMAIL_ADDRESS>as well as @leapingllamas on Twitter.
Release notes¶
2019-07-17: 2.0.1¶
Adding missing lkml
to requirements.txt
2019-07-17: 2.0.0¶
Given the impact of the following two changes, this is a major release:
swapped out the node-based LookML parser with Josh Temple’s new Python lkml parser (https://pypi.org/project/lkml/). This simplifies install, dependency management, and underlying parsed JSON format.
added layer of abstraction via
LookML
andLookMLField
classes so that rules and other code can query LookML attributes via methods instead of inspecting raw JSON.
Other changes:
lkmltools.RuleFactory
is now a singleton so it is easier for users to register their own rules.Can now parameterize any rule in the configuration by adding additional keys to the dictionary for that rule. For instance, if the config defines
{"name": "MyAwesomeRule", "run": true, "debug": true, "strict_mode":true, length: 6}
then this whole dictionary is passed into the constructor during rule instantiation.
2019-06-10: 1.0.0¶
initial release
License¶
Copyright 2019 WW International, Inc.
Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


--- title: "Fun with pitchRx and animint" date: "2014-03-09" categories: [PITCHfx, interactive graphics] tags: [pitchRx, animint] ---
If you are anything like me, you spend most of the day wrangling data with plyr (or dplyr) and visualizing it with ggplot2. For this reason, I got really excited when I heard about the animint package which allows one to create linked, interactive (even animated) web graphics using ggplot2 code.
This short post demonstrates linked plots using data from the pitchRx package. If you click on the bars in the bar chart below, the corresponding start versus end speed scatterplot should change to reflect the current selection. I really want to spend more time with animint since it seems to fill a void where other similar (and also great) packages like rCharts and ggvis currently fall short.
library(pitchRx)
pitches$type <- with(
pitches,
interaction(pitch_type, pitcher_name)
)
counts <- dplyr::count(pitches, pitch_type, pitcher_name, type)
library(animint)
viz <- list(
bars = ggplot() +
geom_bar(
aes(x = factor(pitch_type),
y = n, fill = pitcher_name,
clickSelects = type),
position = "dodge",
stat = "identity",
data = counts
) + theme(legend.position = "none"),
scatter = ggplot() +
geom_point(
aes(start_speed, end_speed,
fill = pitcher_name, showSelected = type),
alpha = 0.65,
data = pitches)
)
animint2gist(viz)


This controls the amount of distortion applied to the combined voices belonging to the virtual {_instrument}. Positive settings provide symmetric distortion which produces primarily odd harmonics, while negative settings provide asymmetric distortion which yields more even harmonics.
This is contained in the {Control_tone_cluster tone cluster} within the {Control_section}.
This is contained in the FILTER section of the right panel, under the following parameter number:
| {sw-set-split.png height=48} {sw-37.png height=48} |
This appears in the display as Distortion.
This is accessed via {_NRPN} 0,23. Since it is a {_bipolar} parameter, the values are offset by 64.
| MIDI | display | ||
| 0 | \-100% | ||
| \b\n\b\n\b | \b\n\b\n\b | ||
| 64 | off | (default) | |
| \b\n\b\n\b | \b\n\b\n\b | ||
| 127 | +100% |


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev
Next
Frames
No Frames
All Classes
A
C
D
E
G
L
M
N
O
R
U
A
add(double)
- Method in class com.appstatistics.collection.
LinkedListImp
addNode(ListNode)
- Method in class com.appstatistics.collection.
ListNode
App
- Class in
com.appstatistics
Hello world!
App()
- Constructor for class com.appstatistics.
App
apply(Function<Double, Double>)
- Method in class com.appstatistics.collection.
LinkedListImp
average(LinkedListImp)
- Static method in class com.appstatistics.operation.
Operation
C
com.appstatistics
- package com.appstatistics
com.appstatistics.collection
- package com.appstatistics.collection
com.appstatistics.collection.exceptions
- package com.appstatistics.collection.exceptions
com.appstatistics.data
- package com.appstatistics.data
com.appstatistics.operation
- package com.appstatistics.operation
com.appstatistics.operation.exception
- package com.appstatistics.operation.exception
com.appstatistics.ui
- package com.appstatistics.ui
contain(double)
- Method in class com.appstatistics.collection.
ListNode
contains(double)
- Method in class com.appstatistics.collection.
LinkedListImp
D
Data
- Class in
com.appstatistics.data
Data()
- Constructor for class com.appstatistics.data.
Data
deviation(LinkedListImp)
- Static method in class com.appstatistics.operation.
Operation
E
emptyListInvalidRemove
- Static variable in exception com.appstatistics.collection.exceptions.
ListException
G
getChild()
- Method in class com.appstatistics.collection.
ListNode
getData(File)
- Method in class com.appstatistics.data.
Data
getValue()
- Method in class com.appstatistics.collection.
ListNode
L
length()
- Method in class com.appstatistics.collection.
LinkedListImp
LinkedListImp
- Class in
com.appstatistics.collection
LinkedListImp()
- Constructor for class com.appstatistics.collection.
LinkedListImp
Lista de numeros reales vacia
ListException
- Exception in
com.appstatistics.collection.exceptions
ListException(String)
- Constructor for exception com.appstatistics.collection.exceptions.
ListException
ListNode
- Class in
com.appstatistics.collection
ListNode(double)
- Constructor for class com.appstatistics.collection.
ListNode
M
main(String[])
- Static method in class com.appstatistics.
App
MainFrame
- Class in
com.appstatistics.ui
MainFrame()
- Constructor for class com.appstatistics.ui.
MainFrame
Ventana Principal
N
notDeviation
- Static variable in exception com.appstatistics.operation.exception.
OperationException
O
Operation
- Class in
com.appstatistics.operation
Operation()
- Constructor for class com.appstatistics.operation.
Operation
OperationException
- Exception in
com.appstatistics.operation.exception
OperationException(String)
- Constructor for exception com.appstatistics.operation.exception.
OperationException
R
removeFirst()
- Method in class com.appstatistics.collection.
LinkedListImp
U
unvalidDivision
- Static variable in exception com.appstatistics.operation.exception.
OperationException
A
C
D
E
G
L
M
N
O
R
U
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev
Next
Frames
No Frames
All Classes
Copyright © 2020. All rights reserved.


fun mkdir(file: File): Unit
Creates the directory, a specific file refers to. It is assumed, that the parent directories already exist. If the parent directories should be created as well, use the method mkdirs instead.


This is a simple, random quote generator.

Click For More Wisdom


This is a paragraph.
More Information
This is more information.
Yet more Information
This is yet more information.
Another red heading
This is blue content, with a red heading.
A different typeface
This is blue is so bright you can't even read the text!


Week 4: Social Networks. Part 2.
Thinking about social networks made me realize that my typical social networks are all out of whack right now. Normally I’d be living at home – either in Chicago with my family, or in St Paul, as I am finally doing now, with my roommates. When I’m with these people I talk to them in person and don’t interact with them as much online. We communicate mainly with our voices, not our phones or computers. Since I started quarantining, the people I communicate with has changed a lot. When I realized this I went right to my phone to look at my texts and had the unsettling realization that I have an obnoxiously unnecessary number of group texts consisting of mainly the same people.
First, here’s what that looks like. Next, I’ll go through the upsetting reasons they’re all apparently necessary.
Let’s start by taking a look at some basic and disturbing facts about this graph…
I’m going to use some terminology here for networks:
- Nodes: each person here is a “node” or, a thing that can be connected to other things to show some sort of meaningful relationship.
- Edges: each line is an edge. These edges show how nodes are connected to each other. In this case, each edge shows two people who are connected by being in the same group chat. The color tells which group chat connects them.
- Degree: degree measures the number of edges going into or out of a node. This helps us understand how important or how connected one node is in relation to others in the graph. For example, the ME node has the highest degree because this is a narcissistic graph about me and I only care about the group chats I am in.
Now some facts:
- There are 9 nodes in this graph.
- There are 7 distinct edge colors.
- Unsurprisingly, I have the highest degree. I have more than my sister, Maddie, so this makes me happy.
- My mom is the least connected one in the family. Sorry, mom.
- Sam is the least connected overall, but this will soon change.
So why are these all necessary and why will Sam soon be moved from the bottom? Let’s go through the chats one by one.
Samuca and the Newts: Me, Coleen, Sam, Mathea
This group must exist because it provides a communication channel among my roommates and me.
nothing is important here: Me, Coleen, Mathea
This group might seem redundant at first glance. Three of the members are already in a different group together. Why would they need to be in a group without Sam? Because we’re telling ~secrets~, that’s why. Sam’s birthday is April 9th, and this graph was created April 7th. This group will soon be redundant, but not yet.
 Inspired by Lori Lightfoot memes, this group is a way for the family (and my sister’s girlfriend (but not my mom’s fiance?)) to stay connected and in the loop about the infrequent excitement during the coronavirus. This group is necessary for family communication.
Rosh Squad: Me, Maddie, Victoria
This group seems unnecessary too, right? While, it’s not. First reason – it is dedicated exclusively to pictures of my cute dog, Roshi.  This is because my brother, Shane, gets bothered by texts that he deems “unnecessary.”
Shay Shay & Maddie: Me, Shane, Maddie
This group is for the siblings to talk about our mom without her knowing. It’s necessary. Next.
???: Me, Maddie, Shane, Secret People
Why would Maddie, Shane, and I need another group to communicate in? We already have a group to dis our mother in secret and another to dis her in person. You might notice that this group includes other people who are not named on the graph. This group can be revealed later, but for now it has to remain a secret. I promise, it’s necessary.
Bitch Squadron: Me, Mom, Maddie
Bitch Squadron is the oldest group among the groups. The OG group chat between a mother and her daughters. This group exists for the same reason Rosh Squad exists – to appease Shane. He doesn’t want to be bothered.
So, all of these edges are necessary in the current setup. As a person who loves efficiency and optimization, I hate this and have found a solution: remove Shane.
This might seem drastic and barbaric, but hear me out. Removing Shane eliminates three groups – Rosh Squad, Bitch Squadron, Shay Shay & Maddie – because they no longer need to be distinct to avoid disrupting Shane’s day. Communication that existed in them previously can now flow through Stay Yo Ass At Home. Removing Shane also removes 14 edges.
- The 8 edges that connect to Shane through SYAAH, ???, and Shay Shay & Maddie
- The 3 edges that connect Rosh Squad
- The 3 edges that connect Bitch Squadron
Considering that nothing important here will also disappear in two days, removing Shane would:
- bring the group count to 3 (SYAAH, Samuca and the Newts, ???)
- bring the edge count to 14
- bring the node count to 8
- tie my mom and Sam for lowest degree (excluding secret)
Sometimes it’s hard to face the facts of science.
This is the third in a series of posts From Quarantine. Most posts from quarantine are prompted by Aisling Quigley’s Data Storytelling class at Macalester College. This is one of those posts.


dquick.item.text_item
- string[] splitToConservativesWords(in string text);
- This function return an array of string that contains words (array of alphanumerical characters or white characters)
Notice that '\t' characters are transformed into spaces, number is depending on TextItem.spaceSize
Page generated by Ddoc.


| ZotWeb | paper-conference | |
| Src Url | [[Rivières]], [[Smith]] (1984) | |
In a procedurally reflective programming language, all programs are executed not through the agency of a primitive and inaccessible interpreter, but rather by the explicit running of a program that represents that interpreter. In the corresponding virtual machine, therefore, there are an infinite number of levels at which programs are processed, all simultaneously active. It is therefore a substantial question to show whether, and why, a reflective language is computationally tractable. We answer this question by showing how to produce an efficient implementation of a procedurally reflective language, based on the notion of a level-shifting processor. A series of general techniques, which should be applicable to reflective variants of any standard applicative or imperative programming languages, are illustrated in a complete implementation for a particular reflective LISP dialect called 3-LISP.
Rivieres


Properties palette basic tests (part 5)
Background Controls
background-color on a DIV
- New HTML File - desktop hi-fi page - using default Dojo theme (i.e., claro).
- Open Visual Editor (any page) and add a DIV. Select the widget. Resize the DIV to a large size (e.g, 300x300px).
- Expand the Background Section
- Under background-color, type "yellow" into the type-in area. Verify that DIV now has yellow background
- Under background-color, select "green" from the dropdown. Verify that DIV now has green background
- Under background-color, select "Remove value" from the dropdown. Verify that DIV now has no background
- Under background-color, choose "color picker" from the dropdown to bring up the color picker. Pick a color and click OK. Verify that DIV now has the new background color
- Under background-color, click on color switch to bring up color picker. Pick a color and click OK. Verify that DIV now has the new background color
- Under background-color, select the blank (empty) entry from the dropdown. Verify that DIV now has no background
background-color on a Button using claro
- (continuing with previous instructions, which means continue to use claro theme)
- Add a dijit.form.Button widget. It should be styled with claro. Select the widget.
- Expand the Background Section
- Each of the following steps should generate an error prompt saying you cannot modify a read-only theme, and after clicking OK, the background-color value and swatch should be reset to its previous value.
- Under background-color, type "yellow" into the type-in area.
- Under background-color, select "green" from the dropdown.
- Under background-color, click on color switch to bring up color picker. Pick a color and click OK.
- Under background-color, click on the "..." button to bring up the Background dialog. Change the background-color on this dialog and click OK.
background-color on a Button using a custom theme
- Invoke the New Theme... command to clone claro into a new custom theme (e.g., "myclaro"). OK to leave the new theme as an unchanged copy of claro.
- Back in the page editor from previous steps, click on the Switch theme icon and change the desktop theme to "myclaro".
- Select the Button widget.
- Each of the following steps should generate an "are you sure" prompt warning about making global CSS changes that might affect multiple widgets. Click OK for each prompt. After clicking OK, the color value and swatch should retain their new value and not reset to previous value.
- Under background-color, type "yellow" into the type-in area.
- Under background-color, select "green" from the dropdown.
- Under background-color, click on color switch to bring up color picker. Pick a color and click OK.
- Under background-color, click on the "..." button to bring up the Background dialog. Change the background-color on this dialog and click OK.
background-image on a DIV
- Select the DIV.
- Under background-image, type "url(samples/SampleBanner.jpg). " Verify that DIV now has an image background.
- Under background-image, select "" from the dropdown (empty string, first entry). Verify that DIV now has no background image.
- Next to background-image, click on the "..." button to bring up the Background dialog.
In that dialog, select "image" as the "background-image type", then click on the "..." icon to bring up the file picker and choose "SampleBanner.jpg".
Click OK to get out of the dialog(s).
Verify that DIV now has an image background.
- Try out each of the other background-properties on the Properties palette to verify that
it is possible to choose various dropdown menu options and to type values into the text field. Verify that the screen updates to reflect the new values.
- Under background-image, click on the "..." button to bring up the Background dialog.
In that dialog, verify that the type of background-image is "image", that the URL for the image is showing in the dialog,
and that the various detailed options (background-position, etc) have been copied over from the Properties palette.
Click OK to get out of the dialog(s).
Verify that the Properties palette shows the same values you entered into the dialog and that the screen properly reflects
the new property values.
Multiple option changes using Background dialog on a read/write and read/only themes
- Select the Button.
- Under background-image, click on the "..." button to bring up the Background dialog.
In that dialog, click on the "..." icon to bring up the file picker and choose "SampleBanner.jpg".
Change the value a couple of other properties (e.g., background-position and background-repeat).
Click OK to get out of the dialog.
You should see a single dialog warning you about changing a global CSS file. Click OK to proceed.
The Button theming should be updated to reflect your changes.
- Click on the Switch theme dialog and switch back to "claro".
- Under background-image, click on the "..." button to bring up the Background dialog.
In that dialog, make sure background-image type is "image".
Click on the "..." icon to bring up the file picker and choose "SampleBanner.jpg".
Change the value a couple of other properties (e.g., background-position and background-repeat).
Click OK to get out of the dialog(s).
You should see a single error dialog telling you you cannot change properties on a read-only theme.
Click OK to proceed.
Verify that the background properties in the properties palette and the screen revert back to claro styling.
Linear Gradients
- Select the DIV
- Under background-image, click on the "..." button to bring up the Background dialog.
In that dialog, select a background-image type of "linear gradient".
You should see two color stops, white 0% and black 100%.
- For the first color stop, use the menu to choose "blue".
- For the last color stop, use the menu to choose "red".
- Click on the "+" icon to the right of the first color stop.
You should see a new intermediate color stop that is a clone of the first color stop
- For the middle color stop, type "green" into the color field and choose "30%" for the position.
The color swatch on the top-right of the dialog should now show a red-green-blue gradient.
- Click on the "+" icon to the right of the green color stop to clone that stop so there are now 4 color stops.
For the 3rd (new) color stop, choose "Color picker" from the menu and pick a yellowish color in the color picker.
Set the position value to 60%.
The color swatch on the top-right of the dialog should now show a red-green-yellow-blue gradient.
- Click on the "-" icon to the right of the green color stop to remove that stop so there are now 3 color stops.
The color swatch on the top-right of the dialog should now show a red-yellow-blue gradient.
- Set the angle property at the bottom of the dialog to the value: "to right"
- Click OK to get out of the dialog(s).
The DIV on the screen should have a red-yellow-blue left-to-right gradient.
Radial Gradients
- Select the DIV
- Under background-image, click on the "..." button to bring up the Background dialog.
Due to the previous step, the dialog should say background-image type of "linear-gradient".
In that dialog, select a background-image type of "radial gradient".
In the color swatch at the top right, you should see a radial gradient with a red center, then yellow then blue as it expands outward.
- Set properties as follows: Position:60% 40%, Shape: ellipse, Extent: farthest corner.
The color swatch at the top right should update with each of the changes.
- Click OK to get out of the dialog(s).
The DIV on the screen should have a red-yellow-blue radial gradient.
- Save, close, reopen, preview in browser.
The radial gradient should appear in both the page editor and in preview.


Department to take a closer look at BIS study
Piped water rated as below par
by Special CorrespondentThe Bureau of Indian Standards (BIS) study that pegged piped drinking water supplied in the State capital as below par has failed to convince the State Water Resources Department.
The department has decided to take a closer look at the BIS study, Water Resources Minister K. Krishnankutty said. As part of this, the department intends to convene a meeting on Thursday. “The Kerala Water Authority (KWA) is unaware of the locations from where the samples were collected,” the Minister said.
According to the study, all ten samples from Thiruvananthapuram had failed to meet quality parameters for turbidity, aluminium, and coliform.
Ten locations
A close look at the study shows that BIS had chosen ten locations, some of which fell outside the Thiruvananthapuram city limits: ‘ISRO PO’, Kazhakuttam, Medical College, Muttada, Nemom, Neyyattinkara, Ambalamukku, Nalanchira, Karakulam, and Vattapara.
Samples from ‘ISRO PO’ did not conform to the safe levels set for aluminium and coliform, while the samples from Medical College, Nemom, Neyyatinkara, Nalanchira, and Ambalamukku failed to meet the criterion for aluminium.
Coliform levels were high in samples from Kazhakuttam and Muttada.
BIS has cited both turbidity and alumnium as the problems in water collected from Karakulam and Vattappara.
Ram Vilas Paswan, Union Minister for Consumer Affairs, Food and Public Distribution, had released the study, which scanned tap water quality in State capitals, in New Delhi on Saturday.
According to it, Mumbai has the safest tap water while Delhi had the worst.


Oakton CS Club Jan. 31, 2018 Meeting
We briefly introduced
the Swift programming language, and how you can learn it. You should definitely try it out before Apple annouces
this year's WWDC Scholarship (which give you a chance to talk to Apple CEO and etc.) We'll definitely be talking about
machine learning and artificial intelligence in the next meeting. Also,
sign up for HackTJ if you haven't done so.


Version control, also known as revision control or source control,[1] is the management of changes to documents, computer programs, large web sites, and other collections of information.
Changes are usually identified by a number or letter code, termed the "revision number", "revision level", or simply "revision"
For example, an initial set of files is "revision 1". When the first change is made, the resulting set is "revision 2", and so on. Each revision is associated with a timestamp and the person making the change. Revisions can be compared, restored, and with some types of files, merged.
Git was created by Linus Torvalds in 2005 for development of the Linux kernel
Torvalds sarcastically quipped about the name git (which means unpleasant person in British English slang):
"I'm an egotistical bastard, and I name all my projects after myself.
First 'Linux', now 'git'."

That is, the construction of something that has an observable and tangible result
The term build may refer to the process by which source code is converted into a stand-alone form that can be run on a computer or to the form itself.
don't versioning the code of others
Composer is a tool for dependency management in PHP. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you.
composer init
{ "name": "ilbonzo/wp-site", "type": "project", "require": {} }
Vagrant is a tool for building and managing virtual machine environments in a single workflow. With an easy-to-use workflow and focus on automation, Vagrant lowers development environment setup time, increases production parity, and makes the "works on my machine" excuse a relic of the past.
Vagrant support VirtualBox, Hyper-V, VMWare and Docker as provider
vagrant up
vagrant halt
vagrant ssh
vagrant destroy
Vagrant boxes
https://www.vagrantup.com/docs/boxes.htmlvagrant init beet/box vagrant up
mkdir -p site/web vagrant ssh sudo ln -s /vagrant/site/web /var/beetbox mysqladmin -u root password password
// site/index.php <?php phpinfo();
composer require johnpbloch/wordpress
"require": { "johnpbloch/wordpress": "^5.2" }
{ "name": "ilbonzo/wp-site", "type": "project", "config": { "vendor-dir": "web/content/vendor" }, "extra": { "wordpress-install-dir": "web/wp" }, "require": { "johnpbloch/wordpress": "^5.2" } }
// wp-config.php <?php // Load Composer’s autoloader require_once (__DIR__.'/../content/vendor/autoload.php'); // Move the location of the content dir define('WP_CONTENT_DIR', dirname(__FILE__).'/../content'); define( 'WP_CONTENT_URL', '/content');
// index.php <?php /** Loads the WordPress Environment and Template */ require( dirname( __FILE__ ) . '/wp/wp-blog-header.php' );
RewriteEngine on RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_URI} !^/phpmyadmin RewriteRule ^(.*)$ /wp/$1
{ ... "repositories": [ { "type": "composer", "url" : "https://wpackagist.org" } ], "extra": { ... "installer-paths": { "web/content/plugins/{$name}/": ["type:wordpress-plugin"], "web/content/themes/{$name}/": ["type:wordpress-theme"] } }, "require": { ... "wpackagist-theme/twentynineteen": "*" } }
// wp-config.php define('WP_THEME_DIR', dirname(__FILE__).'/../content/themes' ); define('WP_PLUGIN_DIR', dirname(__FILE__).'/../content/plugins' );
composer update
site/web/wp/ site/web/content/vendor/ site/web/content/themes/* site/web/content/plugins/* .vagrant
/* Theme Name: Luna FL partner theme Description: Twenty Nineteen Child Theme Author: John Doe Author URI: http://example.com Template: twentynineteen Version: 1.0.0 License: GNU General Public License v2 or later License URI: http://www.gnu.org/licenses/gpl-2.0.html Tags: light, dark, two-columns Text Domain: twentynineteenchild */
!site/web/content/themes/luna-fl-theme
$ git status new file: .gitignore new file: Vagrantfile new file: site/composer.json new file: site/composer.lock new file: site/web/content/themes/luna-fl-theme/style.css new file: site/web/index.php
curl -LO https://deployer.org/deployer.phar mv deployer.phar /usr/local/bin/dep chmod +x /usr/local/bin/dep
dep init
namespace Deployer; require 'recipe/common.php'; // Project name set('application', 'my_project'); ... // Hosts host('project.com') ->set('deploy_path', '~/{{application}}'); // Tasks ... // [Optional] If deploy fails automatically unlock. after('deploy:failed', 'deploy:unlock');
desc('Deploy your project'); task('deploy', [ 'deploy:info', 'deploy:prepare', 'deploy:lock', 'deploy:release', 'deploy:update_code', 'deploy:shared', 'deploy:writable', 'deploy:vendors', 'deploy:clear_paths', 'deploy:symlink', 'deploy:unlock', 'cleanup', 'success' ]);
dep deploy
dep rollback