Stepping Down
Up until now, we've been exploring the X11 Window System from a somewhat high level. We've talked about Windows and Drawables and Pixmaps but we're always talking about them in terms of the protocol. "You draw on a Drawable with protocol extension RENDER," or "you can configure a window with the protocol request ConfigureWindow", but I haven't really gone into any detail about how that's implemented. I think it's about time we dropped from the abstract to the concrete. Today's article won't be about X11, or even the data structures that are inside of it. Today, we're going to start to unravel 2D Graphics. You can explore the things I'm going to talk about on any operating system, in any programming language, and even on paper.
I often see comments like "oh, if only SVG was implemented with WebGL, then it would be fast", and realize that people do not quite understand the challenges and complications of 2D graphics rendering. Despite it going against your intuition, fast, good looking 2D graphics are actually harder and more computationally expensive to accomplish than 3D graphics, at least on traditional consumer GPUs. I hope to eventually explain why, but unfortunately that won't come today.
Even though fast, good-looking 2D graphics rendering is an extremely difficult problem, the basics and principles behind it aren't. Today, we will be exploring the basics of 2D graphics by writing a software rasterizer of our very own, from the ground up. You should be able to write one of your very own at the end of this article! All of the code you see here was written for this article, from nothing more than basic principles and ideas. It's open source on GitHub, and I've tried to and document it well as a source to learn from.
I hope you're as excited as I am to get started! So, without further ado...
The Pixel Grid
The X11 articles take place in a hand-written X11 server. Regional Geometry took place, well, in the land of geometry. Today's article takes place...
... on the pixel grid! If you can peel your eyes away from the absolute graphical marvel I've created above, we're going to dig into exactly what's going on inside those little squares, and how they interact. This series will go on for multiple parts. Today, we're going to start with the basics of 2D graphics: the graphics buffer and its layout, abstract shapes, a basic introduction to sampling theory, lerping and blending colors, transparency, and end it off by adding a bit of antialiasing!
A bit of note about the interactive demos on display in here today. First, I'm presenting a "zoomed in" buffer so you can see the pixels easier. Specifically, each "demo pixel" here is 16 "real pixels" wide, and the same tall. The grid itself is composed of 46 of these "demo pixels" horizontally, and 10 of them vertically, which are basically a few arbitrary constants I chose to make it fit nicely inside these margins, which are 800 "real pixels" wide.
 Graphics programming often takes place in lots of different coordinate spaces like this. After quite a long time of doing it, I still get confused; it's just part of the job description. If you are having trouble, what helps me is to just turn off the monitor, grab some physical pen and paper, and just draw it out. Often times, just drawing and labelling the parts often shows me my confusion.
What doesn't help is blind trial and error. If you are serious about graphics programming, you
will eventually reach a point when things go wrong, and you'll start peppering x*8
and (y+15)/8
into your code in a vain attempt to just get everything to match up
correctly. You will start fiddling with your plus and minus signs, wildly reversing your
translations and rotations at random in desperation. You might find yourself even getting close,
but later on, finding that it breaks something else. It's OK, and we've all been there. I did it
multiple times writing this article. Just take a break, come back, and try to figure out what's
really going on.
... To prevent any confusion like this, let's start at the beginning.
Coordinates
While I'm sure everyone here doesn't need this refresher, let's over some notation and basic math for how to address pixels in this grid. We often treat pixel buffers as large arrays in memory, and we usually leave them one-dimensional, and do the math ourselves to find a specific index for a given position.
Buffer layouts in the real world have a lot of subtleties: stride alignment, endianness, pixel formats. If you don't know what any of those things are, don't worry, I'll explain them later. In this article series, we'll be using the convention established by HTML5's ImageData API. It sees this pixel grid as a giant, one-dimensional array of bytes, with each pixel taking four bytes: red, green, blue, alpha, in that order.
We can find the index of the first byte of a pixel, and vice versa, with some very simple math:
var BYTES_PER_PIXEL = 4;
function indexForPixelLocation(imageData, x, y) {
return (y * imageData.width + x) * BYTES_PER_PIXEL;
}
function pixelLocationForIndex(imageData, idx) {
var pixelIdx = Math.floor(idx / BYTES_PER_PIXEL);
var y = Math.floor(pixelIdx / imageData.width);
var x = pixelIdx % imageData.width;
return { x: x, y: y };
}
Familiarize yourselves with what these functions do — they convert from the x and y coordinates of pixels on the grid to their index into the array of pixels. Pixels go from top left to bottom right, first in the X direction, then in the Y direction. The top left of the pixel grid is at 0, 0 at index 0. The next pixel in the array, which starts at index 4, is located directly to the right.
Let's Draw a Rectangle
Now that we've established ourselves with the format of the pixel grid, let's try drawing a rectangle. For simplicity's sake, let's just fill it with black for now.
function fillPixel(imageData, x, y) {
var idx = indexForPixelLocation(imageData, x, y);
imageData.data[idx + 0] = 0; // Red
imageData.data[idx + 1] = 0; // Green
imageData.data[idx + 2] = 0; // Blue
imageData.data[idx + 3] = 255; // Alpha
}
function fillRectangle(imageData, x1, y1, width, height) {
for (var y = y1; y < y1 + height; y++)
for (var x = x1; x < x1 + width; x++)
fillPixel(imageData, x, y);
}
And let's try it out!
This should be pretty straightforward, but there are a few peculiarities I do want to go over. First, it may strike some of you as odd to iterate over the "y" first. Graphics programmers often think about things in rows. This is a holdover from early computer graphics, and it's for performance reasons — if you think about the memory layout of our pixel grid, you'll notice that I'm iterating over the indexes in order. While RAM does stand for "random access memory", CPUs cheat and have things called "caches". Just know that it is cheaper to write to indexes in order than it is to actually access randomly.
You will often see this pattern, iterating over the rows, rather than the columns, come up in graphics algorithms, even for things that aren't pixel grids or such. This will become more apparent when we start going over more complex topics.
It should also hopefully be pretty clear how to replace this "black" with another color, so I won't bother explaining that. I will, however, up the ante. Let's try filling this rectangle with something a bit more fancy. ... Let's try a gradient.
Space and Time
Gradients aren't actually that tricky, but we do need some basic grounding in one of the most fundamental concepts of computer graphics: linear interpolation, or, the "lerp" for short. Yes, lerping is that important that we give it a special abbreviation, which can even be used as a verb.
It's actually a simple concept. A lerp takes two values, a position parameter, often called time, and returns something in between. A time of 0 gives you the first value. 1 gives you the second value. 0.5 gives you the value halfway in between both.
function lerp(a, b, t) {
return (a * (1.0 - t)) + (b * t);
// It's also sometimes written as:
// return a + ((b - a) * t);
// ... which might be easier to read for some people.
// The two are mathematically equivalent.
}
function draw(imageData, secs) {
var startX = 1;
var endX = 38;
var x = Math.floor(lerp(startX, endX, secs));
var y = 1;
fillRectangle(imageData, x, y, 8, 8);
}
A few more notes. This time variable is often called "t", but I've also seen "position" or "pos", and "alpha". I don't like "position" because I use that to mean a point on our pixel grid, and I don't like "alpha" since it's confusing when we already have an "alpha channel", which is completely unrelated to the lerp here.
The time parameter, "t", is between 0 and 1. In this case, we derive it from the number of seconds that have passed in the animation, so it is quite literally "time". One obvious thing we can do is to warp time. We can multiply to speed it up, divide it to slow it down, but we can also warp it in more fancy ways. For instance, to make it slow down near the ends, we can warp "t" by passing it through a famous easing curve known as "smoothstep":
function lerp(a, b, t) {
return (a * (1.0 - t)) + (b * t);
}
function smoothstep(t) {
return t*t*(3 - t*2);
}
function draw(imageData, secs) {
var startX = 1;
var endX = 38;
var smoothSecs = smoothstep(secs);
var x = Math.floor(lerp(startX, endX, smoothSecs));
var y = 1;
fillRectangle(imageData, x, y, 8, 8);
}
... which looks a bit easier on the eyes. The etymology behind the time "t" parameter is derived from the math-y "f(t)" sense of the word "time". We don't have to use an input that corresponds to time passing in the real world: we can use any value between 0 and 1 as the input. We also can choose to lerp things other than position. For instance, we can lerp between two colors with just a bit more code.
function newRGB(r, g, b) {
return { r: r, g: g, b: b };
}
// Lerp between colors "color1" and "color2".
function lerpRGB(color1, color2, t) {
var newR = lerp(color1.r, color2.r, t);
var newG = lerp(color1.g, color2.g, t);
var newB = lerp(color1.b, color2.b, t);
return newRGB(newR, newG, newB);
}
This isn't doing anything more fancy than just doing a lerp across all three components in a color, and if we draw a ton of 1px-wide rectangles that all use this:
function fillPixel(imageData, x, y, rgb) {
var idx = indexForPixelLocation(imageData, x, y);
imageData.data[idx + 0] = rgb.r;
imageData.data[idx + 1] = rgb.g;
imageData.data[idx + 2] = rgb.b;
imageData.data[idx + 3] = 255; // Alpha
}
function fillRectangle(imageData, rgb, x1, y1, width, height) {
for (var y = y1; y < y1 + height; y++)
for (var x = x1; x < x1 + width; x++)
fillPixel(imageData, x, y, rgb);
}
function draw(imageData) {
var startX = 1;
var endX = 45;
var y = 1, width = 1, height = 8;
var red = newRGB(255, 0, 0);
var blue = newRGB(0, 0, 255);
for (var x = startX; x < endX; x++) {
var t = (x - startX) / (endX - startX);
var rgb = lerpRGB(red, blue, t);
fillRectangle(imageData, rgb, x, y, width, height);
}
}
... we end up with a smooth transition between the colors, also known as a "linear gradient".
Styling our Rectangle
Let's try applying this knowledge to our rectangle drawing code. The biggest change here is that we'll need to modify what colors we draw based on the position in the image. To help us out, let's introduce a new concept, known as the "fill style". This is a function that takes a position, and returns a color for that position. The simplest possible fill style is a radial gradient, whose color depends on the position from the center.
// Basic fill style.
function newSolidFill(rgb) {
return function(x, y) {
// A solid fill returns the same color, no matter the position.
return rgb;
};
}
function newRadialGradient(centerX, centerY, radius, centerRGB, edgeRGB) {
return function(x, y) {
// Calculate distance from the center point. Basic Pythagoras.
var distX = x - centerX, distY = y - centerY;
var distance = Math.sqrt(distX*distX + distY*distY);
// If we're outside the circle, then just return the color at the edge.
// This is a choice -- we could instead choose to repeat or ping-pong
// between the colors.
if (distance >= radius)
return edgeRGB;
// Translate the [0, radius] ranged value to a [0, 1] ranged value
// so we can lerp the colors.
var t = distance / radius;
return lerpRGB(centerRGB, edgeRGB, t);
};
}
// The same code as above, but slightly adapted to handle fill styles
// and custom colors.
function fillRectangle(imageData, fillStyle, x1, y1, width, height) {
for (var y = y1; y < y1 + height; y++) {
for (var x = x1; x < x1 + width; x++) {
var rgb = fillStyle(x, y);
fillPixel(imageData, x, y, rgb);
}
}
}
function draw(imageData) {
var x = 19;
var y = 1;
var red = newRGB(255, 0, 0), blue = newRGB(0, 0, 255);
var gradient = newRadialGradient(x + 4, y + 4, 6, red, blue);
fillRectangle(imageData, gradient, x, y, 8, 8);
}
The biggest complexity here is figuring out which "t" to use. In the case of a radial gradient, it's actually just the distance from the center point, normalized against the radius.
As an exercise, try working out, using this base, how to have arbitrary gradient stops at different time values, rather than just two colors at the starts and ends.
Drawing Other Shapes
Now that we've become familiarized with the concepts of rendering boxes and fills, let's try our hand at something a tad bit more fancy — rendering other shapes. To start with, let's try a circle. We just learned above how to calculate the distance of a point x, y against the center of a circle with any radius. Once we have that, we can just run over our pixel grid, test when we're "inside" the circle, and if so, choose to fill in the pixel.
The only complication here is that we have to pick some start and end bounds for where we start iterating. We could use our entire pixel grid, but we know a bunch of pixels will never be filled in. We need a tight set of pixels. Thankfully, for a circle, it's quite easy to compute. By definition, the left edge ("x1", since it is the left X coordinate) is the X coordinate of the circle's center minus the radius, and the right edge ("x2") is the center plus the radius. The same thing happens for the top and bottom edges.
function fillCircle(imageData, fillStyle, centerX, centerY, radius) {
var x1 = centerX - radius, y1 = centerY - radius;
var x2 = centerX + radius, y2 = centerY + radius;
for (var y = y1; y < y2; y++) {
for (var x = x1; x < x2; x++) {
var distX = (x - centerX), distY = (y - centerY);
var distance = Math.sqrt(distX*distX + distY*distY);
if (distance <= radius) {
var rgb = fillStyle(x, y);
fillPixel(imageData, x, y, rgb);
}
}
}
}
Oof. What happened here? This doesn't look very... circular. Is it an off-by-one error? It looks like it might be. It's tempting to brute force your way to a possible fix: changing the <= above to a single <, peppering various + 1 and -1s throughout. But, trust me on this, this approach won't net you anything. It's actually not an off-by-one error, it's an off-by-0.5 error.
"Wha?" I hear some of you cry.
There is actually nothing wrong with the above code in the abstract. Instead of this being a simple implementation detail change, the issue with this algorithm is actually a more fundamental and conceptual one, one that causes us to rethink a bit about how we're imagining the pixel grid. You might also have spotted it above in the radial gradient example: the gradient isn't centered, it's sort of down and to the right. These are both related problems.
Sample Location
When we do something like the algorithm above — iterate over a bunch of pixels, and then test whether a pixel should be in or out, we're making use of a concept known as sampling. Basically, we have some functional concept of a shape, like a circle, and we can give it different x and y points and it tells us whether they are inside or outside of the circle. But what do these points actually mean?
Well, we know that in our pixel grid, each one of these numbers corresponds to a pixel. But have we thought about the abstract space where these circle descriptions live? We're talking about a circle centered at, let's say, 5, 5, with a radius of 10. We have to have some concept of mapping this abstract space to the pixel grid. Up until now, we haven't thought about this and have been hacking it together based on what makes sense. But to get this right, we need to think more closely about the relationship between the two.
I'm going to cheat, and for my next figure, show you what this abstract space circle looks like we've been using so far, laid on top of the pixel grid.
Maybe the revelation is clear now about what's actually going on. If not, don't worry. Right now, when we test each pixel against the abstract space circle, we've been testing whether the top left of each pixel's square is inside the abstract circle. When you think about it, though, that doesn't quite make sense. Really, what we're trying to ask is "is more than 50% of the pixel square inside the circle". Using something like the pixel's center would more accurately answer that question.
function fillCircle(imageData, fillStyle, centerX, centerY, radius) {
var x1 = centerX - radius, y1 = centerY - radius;
var x2 = centerX + radius, y2 = centerY + radius;
for (var y = y1; y < y2; y++) {
for (var x = x1; x < x2; x++) {
var distX = (x - centerX + 0.5), distY = (y - centerY + 0.5);
var distance = Math.sqrt(distX*distX + distY*distY);
if (distance <= radius) {
var rgb = fillStyle(x, y);
fillPixel(imageData, x, y, rgb);
}
}
}
}
And indeed it does! By adjusting our fillCircle function to test distance against the pixel's center in the abstract space, we get something that looks a lot more circular. Since pixel centers are halfway between pixels, all we need to do is add 0.5 to both dimensions before calculating the distance.
This also explains the bizarre gradient bug we were seeing earlier. When we were comparing distances in the gradients, we were also comparing distances with the top left of the pixel, rather than the pixel's center. I'll leave it as an exercise to the reader to add the necessary + 0.5s to fix that one.
If you've worked with graphics APIs before like HTML5 <canvas>, you might have had to add these 0.5 increments yourselves, e.g. to lines, to make the resulting line look sharp. This is because a line is basically a "thin" rectangle which is lineWidth wide, and centered upon the position you give it. HTML5 <canvas> also uses this "pixel center" sampling strategy. Giving it a bit of thought (imagine a tall, skinny rectangle "growing" in width from a pixel's center until it becomes two pixels wide), and it should be obvious why you need to add 0.5 offsets yourself.
Transparency and Blending
OK, so now we have basic shapes, and basic fills. What would be really cool is to try to add transparency, and to blend multiple shapes together. This is actually easier than you think, at least for a toy implementation. But first, the theory. As a term stolen from the visual effects industry, blending multiple transparent shapes together is formally called "alpha compositing", though I don't like that term very much, for reasons that will become clearer as the rest of the article goes on. I prefer "blending".
For our toy implementation, we'll make some simplifications. Our resulting pixel grid is designed to be displayed directly on my monitor. Since my monitor isn't transparent (at least isn't yet!), we won't bother changing its storage, and just assume it's full opaque. However, we'll add a new parameter to our fill color: alpha, or the "A" in "RGBA". Alpha is commonly taken to be identical with "transparency", though this isn't fully accurate, as we'll see later (and one of my personal pet peeves)! If we wanted to take an image we rendered and then reuse it, transparency and all, it would definitely be appropriate to retain the alpha channel. This makes the math a bit too complicated for this basic introduction though, so I'll cheat and omit it for now.
We'll also be a bit more formal about our fill parameters. We'll call the fill pattern the
"source image", and we'll call the pixel grid that's being filled the "destination image". To blend
an RGBA "source image" into the opaque "destination image", instead of just setting the values like
the old fillPixel
did... we lerp them!
function newRGBA(r, g, b, a) {
return { r: r, g: g, b: b, a: a };
}
function getPixel(imageData, x, y) {
var idx = indexForPixelLocation(imageData, x, y);
// Reminder: ImageData stores things as a giant array with bytes
// in "RGBA" order. So index 0 = R, index 1 = G, and index 2 = B.
return newRGB(imageData.data[idx + 0],
imageData.data[idx + 1],
imageData.data[idx + 2]);
}
function blendPixel(imageData, x, y, src) {
// Retrieve the existing pixel in the destination image.
var dst = getPixel(imageData, x, y);
// Lerp using the src's alpha to blend.
var blended = lerpRGBA(dst, src, src.a);
fillPixel(imageData, x, y, blended);
}
It's a bit clunky, but it works fine. If you think about it, it makes sense too: at 0% alpha, you want the untouched pixel grid (the destination), and at 100% alpha, you want the source fully filled in between, and at 50%, you want half of one, half of the other.
Anti-aliasing
So, this is looking a lot better. We have shapes, we have colors and gradients. But it still doesn't look great. The edges are all "jaggies", like you might see out of something made entirely in MS Paint. Looking at the zoomed in pixel grid vs. the abstract one, it should be obvious what the problem is: the pixel grid is much, much coarser than the abstract grid! In signal processing terms, we're aliased: to construct our pixel grid, we're sampling from a much higher frequency space, the abstract grid, and that results in aliasing artifacts.
... OK. If that was a bit too technical, here's a quick signal processing intro: the word "frequency" just means "how fast things change". In our case, these "changes" are basically "how fast" our circle is changing, in the abstract grid case, and how fast our pixels are allowed to change, in the concrete grid case. Our abstract circle changes from "being inside" to "being outside" much faster than how often the grid can change, or, at a "higher frequency".
... Erm, that might also be too technical. Imagine a striped rectangle in our abstract grid that changes rapidly from black to white over and over again.  This is known as a moire pattern, and it happens when we can't sample fast enough or fine enough for the source.
Signal processing theory tells us that in order to prevent artifacts like this, we have two options: sample faster, or just remove the high frequencies altogether. Computer graphics implementations, conceptually, do the former, and then downsample using a special filter that blends the pixels to avoid artifacts.
If that was a bit too abstract for you, let's try writing this in code. The easiest way to sample at a high frequency is to literally just sample more. This is an approach known as supersampling, since we're sampling at a higher, or "more super", frequency. In order to do that, we're going to need to refactor our code a bit and introduce a bit of infrastructure so we can sample at arbitrary positions. The first thing we're going to do is take that if statement testing if the point is inside the circle, and move it out into a new function.
function insideCircle(centerX, centerY, radius, sampleX, sampleY) {
var distX = (sampleX - centerX), distY = (sampleY - centerY);
var distance = Math.sqrt(distX*distX + distY*distY);
return (distance <= radius);
}
We also remove the "center pixel" 0.5 bias now, because this will be part of our passed in sample point. This gives us a nice functional sampling test. Now, for each pixel, we're going to sample it 16 different times, and collect the results. Watch closely. The code below might be a bit dense, but read it line-by-line and it should make sense.
function fillCircle(imageData, fillStyle, centerX, centerY, radius) {
// Sample the shape 16 times in a 4x4 grid.
var nSubpixelsX = 4;
var nSubpixelsY = 4;
var x1 = Math.floor(centerX - radius), y1 = Math.floor(centerY - radius);
var x2 = Math.ceil(centerX + radius), y2 = Math.ceil(centerY + radius);
for (var y = y1; y < y2; y++) {
for (var x = x1; x < x2; x++) {
// Compute the coverage by sampling the circle at "subpixel"
// locations and counting the number of subpixels turned on.
var coverage = 0;
for (var subpixelY = 0; subpixelY < nSubpixelsY; subpixelY++) {
for (var subpixelX = 0; subpixelX < nSubpixelsX; subpixelX++) {
// Sample the center of the subpixel.
var sampX = x + ((subpixelX + 0.5) / nSubpixelsX);
var sampY = y + ((subpixelY + 0.5) / nSubpixelsY);
if (insideCircle(centerX, centerY, radius, sampX, sampY))
coverage += 1;
}
}
// Take the average of all subpixels.
coverage /= nSubpixelsX * nSubpixelsY;
// Quick optimization: if we're fully outside the circle,
// we don't need to compute the fill.
if (coverage === 0)
continue;
var rgba = fillStyle(x, y);
// Apply coverage to the alpha.
rgba = newRGBA(rgba.r, rgba.g, rgba.b, rgba.a * coverage);
blendPixel(imageData, x, y, rgba);
}
}
}
There's quite a lot to go through here, but the core important idea is that for each pixel, we're sampling the abstract grid 16 times, and figuring out how much of the abstract circle this square pixel contains. Once we know this, we compensate by making the pixel more transparent. This makes some intuitive sense: if a circle only covers half of a pixel, the other half should be occupied by what's underneath it, so the two colors get merged into one. This, unfortunately, has a cost: we still only have 8 bits per channel to work with. We are trading color depth for the appearance of more space. This is why it's hard to "un-anti-alias" pictures in Photoshop if you've ever tried to remove a background or similar: because some of the original color was lost!
Secondly, note the use of the word coverage, which tells you how much of the concrete pixel was covered by the abstract shape. Note that we also put this coverage value into the alpha of our source, even though it's conceptually not a transparent image. This is important: the alpha channel of an image isn't only just for transparency, it's also used for pixel coverage, though they do end up blending the same, and so we tend to combine the two into one channel.
One other thing: You might notice that I'm not computing the fill style at every subsample, only the shape's coverage. This is an optimization known in the 3D graphics world as multisampling. The hope is that the fill color of just the pixel's center really doesn't change from an average of all possible sample points, but the coverage does. When you go into a game's advanced settings and turn on "MSAAx16", this is exactly the algorithm that runs there.
You might also notice that the animation still seems a bit "jerky". This is because I'm drawing
the circle locked to the pixel grid with a Math.floor
. But now we can represent
arbitrary sample points thanks to proper antialiasing. Taking the Math.floor
out lets
us draw something like drawCircle(3.5, 2.32, 6.7);
, to pull some numbers out of a hat.
Our abstract grid can represent fractions of pixels just perfectly, and, with us taking multiple
samples, our circle should look a lot more... well... circular, with fractional sample positions.
I've also slowed down time and given you a visualizer tool to see the subpixel sampling in action. Just hover over a pixel to see the details of it.
Also, now that we can draw shapes starting at any pixel, we have to be a bit more careful computing
the bounding box to help accommodate this. Note the additions of Math.floor
and
Math.ceil
above; I sneakily put those in there, but they are required for this to work
correctly. Otherwise, the X and Y values we pass to blendImage
would be fractional,
and our attempts at setting the ImageData array would fail on fractional indexes.
And last, I should mention. Super- or multisampling are not the only approaches to doing antialiasing. Another approach here is to use analytic methods to figure out how much area the shape actually covers. The common algorithm for this is commonly attributed to Raph Levien in the libart rendering library. I might do an interactive article for this some other day, but for now, I'll link to Sean Barrett, who has an excellent whiteboard explanation up on his website. The sampling approaches are easier to understand, much more visualizable and obvious to the theory, and give us pretty great results.
Coming up next...
This was probably already a huge article to read through. Thank you for making it to the bottom!  As always, this is only the starting point of a much deeper subject. I welcome all comments and questions, including ideas for additional demos to help make hard-to-understand concepts either. Email me, open a GitHub issue, play around with the code and see what you can make happen. The code for every single demo seen today is open-source, with extra comments about what's going on. It's also a bit more complete and refactored than what you see in the article itself. Perhaps you can take some inspiration from that!
My plan is that next time, we'll expand on graphics further with fun things like linear transformations, more shapes, like complex filled polygons, Bezier curves, and maybe a bit of extra fun stuff with perspective-textured triangles. That said, these plans aren't finalized, and if you would like me to cover something extra, ideas are always welcome!
Thank you to everyone that left comments on the last article I made. This article has been a long time coming. Since my last one was written, I've made a personal decision to leave the Linux, X11, and Wayland worlds mostly behind. However, I'm still at a job where I interact with graphics every day, and I, of course, will never tire of teaching people stuff. Even if it takes me a year to actually finish an article. I'm hoping the expanded focus will help a lot with my motivation, though.


I work with startups as a freelance designer and help them grow.
I help your startup grow and succeed with bolder online experiences.
I use over a decade of experience in business, advertising, design, and development to create seriously effective interactive experiences for startups.


It is three in the morning, and I am in the nest of Jews. They have cleverly shifted their shapes; one of them has taken the form of a little old woman. You can barely see her horns! She has tried to poison me already. These rats are very clever.
Yagshemash! In U.S. and A., if you want to marry a girl, you cannot just go to her father's house and swap her for 15 gallons of insecticide. Before American woman will allow you in her vazhïn, you must do something called dating.
In Kazakhstan, it is illegal for more than five woman to be in the same place except for in brothel or in grave. In U.S. and A., many womens meet in a groups called feminists.


| Project | Summary | Status of Work | Notes/Tutorials | List of outcomes |
|---|---|---|---|---|
| Cricket Ball Swings Simulations | ||||
| Savonius Wind Turbine Simulations | ||||
| Immersed Boundary Method in OpenFOAM | ||||
| Combined dynamicRefineFvMesh & dynamicOversetFvMesh for adaptive mesh refinement in OpenFOAM with overset solver | ||||
| Shape Optimization code development in OpenFOAM | ||||
| Apps for managing shuttle between SNU and NCR | ||||
| Shape optimization codes with projection method on NS solver and adjoint equation solver. |


tDataCat
Data category
ITS defines data category as an abstract concept for a particular
type of information for internationalization and localization of XML schemas and documents.
For the implementation of ITS, apply the rules in the order:
Default
Rules in the schema
Rules in the document instance
Local attributes
Et voilà ! The last rule wins.


so i got logging my water meter working... 2 pulses each liter so i multiply by 0.5 to get the liter figure... easy enough..
to get the flow rate i use rate of change .. also easy enough....but
now i want a graph that tells me the usage between each reading.... what should i use? pulse difference?????
Re: input processing... yeah again :-D
so i tried to have the emon tx send the used water since start 3 times as 3 different streams as to make it more logical for myself
battery and total water was fine but
even the simple rate of change on the 3rd stream did only count up.. it did not go back to zero as i closed the tap
Re: input processing... yeah again :-D
power to kwh gives a number... but i assume thats an average...
going to pull my hair soon... why is there not a simple way to see liters each hour or min or sec?
Re: input processing... yeah again :-D
got rate of change to rise and drop... now i only need it to match real world.... got it to swing between 0.5 and 1 at full open tab
Re: input processing... yeah again :-D
at a flow of 2 litres per min it barely jumps to 0.5 when i use rate of change
what can i do to make it match?
Re: input processing... yeah again :-D
so a bit more working and at same flow with the puls demo sketch i get a number of -10401.00
as long i keep the tap open it is fairly stable... once i close the tab it stays at last updated value
what i'm doing wrong? it should go to zero once i close and at 2 litres a min it should be 120 litres an hour...
Re: input processing... yeah again :-D
so if i divide by 50 i get the right litre an hour figure..... but i would like for it to go zero once there are no more incomming impulses....
sketch so far:
#define freq RF12_868MHZ // Frequency
const int nodeID = 2; // emonTx node ID
const int networkGroup = 210; // emonTx network group
const int time_between_readings= 5000;
#include <JeeLib.h>
#include <avr/sleep.h>
ISR(WDT_vect) { Sleepy::watchdogEvent(); } // Attached JeeLib sleep function to Atmega328 watchdog -enables MCU to be put into sleep mode inbetween readings to reduce power consumption
long pulse = 0;
unsigned long pulseTime,lastTime;
double flow;
int ppl = 2;
typedef struct {int pulse; int flow; int battery; } Payload;
Payload emontx;
void setup() {
Serial.begin(9600);
// pulse detection interrupt (emontx pulse channel - IRQ0 D3)
attachInterrupt(1, onPulse, FALLING);
rf12_initialize(nodeID, freq, networkGroup); // initialize RFM12B
rf12_sleep(RF12_SLEEP);
}
void loop()
{
emontx.pulse=pulse;
emontx.flow=flow;
emontx.battery=readVcc();
rf12_sleep(RF12_WAKEUP);
// if ready to send + exit loop if it gets stuck as it seems too
int i = 0; while (!rf12_canSend() && i<10) {rf12_recvDone(); i++;}
rf12_sendStart(0, &emontx, sizeof emontx);
// set the sync mode to 2 if the fuses are still the Arduino default
// mode 3 (full powerdown) can only be used with 258 CK startup fuses
rf12_sendWait(2);
rf12_sleep(RF12_SLEEP);
Sleepy::loseSomeTime(time_between_readings);
}
long readVcc() {
long result;
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
delay(2);
ADCSRA |= _BV(ADSC);
while (bit_is_set(ADCSRA,ADSC));
result = ADCL;
result |= ADCH<<8;
result = 1126400L / result;
return result;
}
// The interrupt routine - runs each time a falling edge of a pulse is detected
void onPulse()
{
lastTime = pulseTime;
pulseTime = micros();
pulse = pulse + 1; // count pulse
flow = int((3600000000.0 / (pulseTime - lastTime))/50);
}
Re: input processing... yeah again :-D
*bump*
what am i doing wrong here? i can only get the emontx to report pulses since start.. that i can get emoncms to multiply by 0.5 to get liters....
but how do i get liters per hour? ie 2 liters a min should be 120 an hour... and how do i get emoncms to store the difference between readings and not the total reported by emontx?


'The following webpage contains a script that has a function that uses Math.round, Math.sqrt and Math.floor to round a floating-point number to the nearest integer, calculate the square root of a floating-point number and round it to an integer, round a floating-point number to the nearest tenths position, round a floating-point number to the nearest hunderdths position, and round a floating-point number to the nearest thousandths position.'


See: Description
| Interface | Description |
|---|---|
| BatchAccessor |
Provides access to the row set (record batch) produced by an
operator.
|
| OperatorExec |
Core protocol for a Drill operator execution.
|
| Class | Description |
|---|---|
| IndirectContainerAccessor |
Extension of the container accessor that holds an optional selection
vector, presenting the batch row count as the selection vector
count.
|
| OperatorDriver |
State machine that drives the operator executable.
|
| OperatorRecordBatch |
Modular implementation of the standard Drill record batch iterator
protocol.
|
| SchemaTracker |
Tracks changes to schemas via "snapshots" over time.
|
| TestOperatorRecordBatch |
Test the implementation of the Drill Volcano iterator protocol that
wraps the modular operator implementation.
|
| VectorContainerAccessor |
Wraps a vector container and optional selection vector in an interface
simpler than the entire
RecordBatch . |
| Enum | Description |
|---|---|
| OperatorDriver.State |
This version is an eventual successor to the original implementation which used the "kitchen sink" pattern to combine all functionality into s single, large record batch implementation.
Copyright © 2021 The Apache Software Foundation. All rights reserved.


To import Hosts, enter or paste the information in the text window below. Data fields must be comma delimited. If a data field contains commas, the data field must be double-quoted (e.g. ip and port may contain multiple values separated by a comma).
If no username and password is specified, the default host username and password defined on CSM Server will be used. The first data line must be a header as shown below.
hostname,ip,username,password,connection,port <- header line
myhost1,<IP_ADDRESS>,johnsmith,password,telnet, <- leave port field blank if not needed
myhost2,<IP_ADDRESS>,davidsmith,password,ssh,"2033,2034"


The goal of scorecard
package is to make the development of the traditional credit risk scorecard model easier and efficient by providing functions for some common tasks that summarized in below. This package can also used in the development of machine learning models on binomial classification.
split_df
, replace_na
, one_hot
, var_scale
)woebin
, woebin_plot
, woebin_adj
, woebin_ply
)var_filter
, iv
, vif
)perf_eva
, perf_cv
, perf_psi
)scorecard
, scorecard2
, scorecard_ply
)gains_table
, report
)scorecard
from CRAN with:scorecard
from github with:This is a basic example which shows you how to develop a common credit risk scorecard:
# Traditional Credit Scoring Using Logistic Regression
library(scorecard)
# data preparing ------
# load germancredit data
data("germancredit")
# filter variable via missing rate, iv, identical value rate
dt_f = var_filter(germancredit, y="creditability")
# breaking dt into train and test
dt_list = split_df(dt_f, y="creditability", ratio = 0.6, seed = 30)
label_list = lapply(dt_list, function(x) x$creditability)
# woe binning ------
bins = woebin(dt_f, y="creditability")
# woebin_plot(bins)
# binning adjustment
## adjust breaks interactively
# breaks_adj = woebin_adj(dt_f, "creditability", bins)
## or specify breaks manually
breaks_adj = list(
age.in.years=c(26, 35, 40),
other.debtors.or.guarantors=c("none", "co-applicant%,%guarantor"))
bins_adj = woebin(dt_f, y="creditability", breaks_list=breaks_adj)
# converting train and test into woe values
dt_woe_list = lapply(dt_list, function(x) woebin_ply(x, bins_adj))
# glm / selecting variables ------
m1 = glm( creditability ~ ., family = binomial(), data = dt_woe_list$train)
# vif(m1, merge_coef = TRUE) # summary(m1)
# Select a formula-based model by AIC (or by LASSO for large dataset)
m_step = step(m1, direction="both", trace = FALSE)
m2 = eval(m_step$call)
# vif(m2, merge_coef = TRUE) # summary(m2)
# performance ks & roc ------
## predicted proability
pred_list = lapply(dt_woe_list, function(x) predict(m2, x, type='response'))
## Adjusting for oversampling (support.sas.com/kb/22/601.html)
# card_prob_adj = scorecard2(bins_adj, dt=dt_list$train, y='creditability',
# x=sub('_woe$','',names(coef(m2))[-1]), badprob_pop=0.03, return_prob=TRUE)
## performance
perf = perf_eva(pred = pred_list, label = label_list)
# perf_adj = perf_eva(pred = card_prob_adj$prob, label = label_list$train)
# score ------
## scorecard
card = scorecard(bins_adj, m2)
## credit score
score_list = lapply(dt_list, function(x) scorecard_ply(x, card))
## psi
perf_psi(score = score_list, label = label_list)


File utils.lua
Functions
| gnuplot_cup (traces, nn) | Generate EPS plots for ML-CUP. |
| gnuplot_monks (traces, nn, num, is_test) | Generate EPS plots for a MONKS problem. |
| parse_cup (source_file, has_labels) | Parse ML-CUP data file Parses provided CSV file, applying normalization to input and targets. |
| parse_monks (source_file) | Parse MONKS data file Parses provided CSV file, applying one-hot encoding to input. |
| record_cup (specs, targets) | Write an array of output Tensors to a well-formatted CSV file. |
Functions
- gnuplot_cup (traces, nn)
-
Generate EPS plots for ML-CUP. The file name will tell about the employed hyperparameters.
Parameters
- traces: Standard error/accuracy trace table. traces.validation is optional.
- nn: Neural network that generated the traces. Hyperparameters are read from it.
- gnuplot_monks (traces, nn, num, is_test)
-
Generate EPS plots for a MONKS problem. The file name will tell about the employed hyperparameters.
Parameters
- traces: Standard error/accuracy trace table. traces.validation is required.
- nn: Neural network that generated the traces. Hyperparameters are read from it.
- num: MONKS dataset enumerator (1, 2 or 3)
- is_test: Boolean indicating if traces.validation represents a Test set or Validation set.
- parse_cup (source_file, has_labels)
-
Parse ML-CUP data file Parses provided CSV file, applying normalization to input and targets.
Parameters
- source_file: Path to file with ML-CUP data to parse.
- has_labels: Boolean to distinguish labelled (TR) and unlabelled (TS) sources.
Return value:
input,targets, t_min, t_max where- input: Array-like table with Tensors of input patterns.
- targets: Array-like table with Tensors of target patterns. nil if has_labels == false.
- t_min: Minimum of target patterns. nil if has_labels == false.
- t_max: Maximum of target patterns. nil if has_labels == false.
- parse_monks (source_file)
-
Parse MONKS data file Parses provided CSV file, applying one-hot encoding to input.
Parameters
- source_file: Path to file with Monk data to parse.
Return value:
input,targets where- input: Array-like table with Tensors of input patterns.
- targets: Array-like table with Tensors of target patterns.
- record_cup (specs, targets)
-
Write an array of output Tensors to a well-formatted CSV file. The file will be decorated with the appropriate header and named as specs.team_name.._ML-CUP17-TS.csv.
Parameters
- specs: Tabel of specifications for the output. That is:
- spec.dest_folder Destination folder. Optional. Default: CWD.
- spec.full_name Full name of CUP participant(s).
- spec.team_name Team name of CUP participant(s).
- spec.date Date to attach to results.
- targets: Array-like table of output Tensors. Note the ID corresponds to the ordering.


Samuel’s Schedule
问题描述 :
Welcome to ‘Samuel Design Contest’.Samuel greets you a happy 牛 Year. At new year and always,may peace and love fill your heart,beauty fill your world,joy and contentment fill your life and may you make great progress during the coming year both in your ACM and your study.
The following problems are intended for you,especially for those rookies(usually known as “vegetable bird”in Chinglish).As it always does,the first problem is the easiest,I believe that you can work it out in a few minutes.
The problem goes like this:
Samuel is engaged at this new year’s season and has a lot of things to do. For instance,he needs to buy new clothes,to prepare some food,to decorate the house and the like. Here is the schedule.
Based on the schedule,you need to answer what will Samuel do in N days before the New Year(2009.1.26 i the Spring Festival).
The following problems are intended for you,especially for those rookies(usually known as “vegetable bird”in Chinglish).As it always does,the first problem is the easiest,I believe that you can work it out in a few minutes.
The problem goes like this:
Samuel is engaged at this new year’s season and has a lot of things to do. For instance,he needs to buy new clothes,to prepare some food,to decorate the house and the like. Here is the schedule.
Based on the schedule,you need to answer what will Samuel do in N days before the New Year(2009.1.26 i the Spring Festival).
输入:
The input include 2 parts:
t(an integer,presents the t test cases),n(an integer,means n days before the New Year).
t(an integer,presents the t test cases),n(an integer,means n days before the New Year).
输出:
The input include 2 parts:
t(an integer,presents the t test cases),n(an integer,means n days before the New Year).
t(an integer,presents the t test cases),n(an integer,means n days before the New Year).
样例输入:
3 13 3 2
样例输出:
Samuel will take test. Samuel will stay at home. Samuel will decorate.
(adsbygoogle = window.adsbygoogle || []).push({});
公牛的线不便宜。拾荒的来两次这个问题就解决了。
公牛的线不便宜。拾荒的来两次这个问题就解决了。
公牛的线不便宜。拾荒的来两次这个问题就解决了。
公牛的线不便宜。拾荒的来两次这个问题就解决了。
公牛的线不便宜。拾荒的来两次这个问题就解决了。
公牛的线不便宜。拾荒的来两次这个问题就解决了。
公牛的线不便宜。拾荒的来两次这个问题就解决了。
第36行，struct node **head_ref，怎么理解，那个函数感觉不是很懂啊！？？弱渣求助
很有意思，可惜我很菜啊
为什么暴力求解方法循环到sqrt(n) 就可以了呢
5.1处，反了；“上一个操作符的优先级比操作符ch的优先级大，或栈是空的就入栈。”如代码所述，应为“上一个操作符的优先级比操作符ch的优先级小，或栈是空的就入栈。”
不对吧 你算的an是前面说有的项的和
在第 18行的，while(scanf("%d %dn", &n, &c), n)，这句有错吧
你的理解应该是：即使主持人拿走一个箱子对结果没有影响。这样想，主持人拿走的箱子只是没有影响到你初始选择的那个箱子中有奖品的概率，但是改变了其余两个箱子的概率分布。由 1/3,1/3 变成了 0, 2/3
不考虑最后将结果排序的话，快排的时间复杂度是O(N) ，而堆排的是O(N*logK),这样比较看，快排快
这个条件 “两个数的乘积最小”可以忽略
对，就是把这32位当成一个长度为32的数
大致看了下，算法的时间复杂度没有很本性的提升，算不上高效。
给力的文章，例子也非常好
很强大啊，佩服
刚开始学习，为啥会报错了


Happy Nest
Your happy nest in the heart of Pune
Home
Contact Us
Gallery
Location
Testimonials
to
Submit


I worked for over 20 years as an administrator at small businesses, managing them and taking full responsibility for the company. Now I've decided to follow my own dream. In August 2017 I started my training to become a full stack programmer. I started with the basics for 6 different languages. (See links to certificates below.) Currently I'm studding with www.freecodecamp.org towards a certificate for "Front End Development", and on completion I will also do the certificate for "Back End Development”. I have completed the diploma in phone app development which is internationally recognised. In South Africa it is the equivalent of an NQF5 diploma. I have started the advanced course on phone app development with Shaw Academy as well and hope to complete it in the next tree months as well as their web development course. Completed projects can be viewed below in my portfolio section.
Click on button to follow the link to the certificate.
Clicking on the picture will open the web page


11 April 1997
Disease Outbreak Reported
As at 11 April, a total of 41,699 cases of meningitis with 4,498 deaths had been reported in Africa. These were mainly from countries in West Africa where epidemics have continued to occur. Burkina Faso with 16,775 cases and 1,953 deaths accounted for 40% of the cases reported this year, Ghana with 13,063 and 1,191 deaths for 31% and Mali with 6,119 cases and 587 deaths for 15%. Cases were also reported in Benin (273 cases, 47 deaths), Gambia (856 cases, 119 deaths), Niger (1,813 cases, 208 deaths), Rwanda (10 cases, 4 deaths), Senegal (13 cases, 4 deaths), and Togo (2,619 cases, 360 deaths). Gambia, Ghana and Togo were less affected during the 1997 epidemics when Burkina Faso, Mali, Niger and Nigeria reported widespread outbreaks. Burkina Faso reported 42,129 cases, Mali 7,254 and Niger 16,145 cases in 1997. Nigeria, which reported 77,089 cases in 1997, has not yet reported cases during 1997.


Sticky footer with fixed navbar
Pin a fixed-height footer to the bottom of the viewport in desktop browsers with this custom HTML and CSS. A fixed navbar has been added with padding-top: 60px;
on the body > .container
.
Back to the default sticky footer minus the navbar.


---
layout: post
title: 7/18 progress
date: '2014-07-17T22:34:00.001-06:00'
author: Jacob .
tags:
- progress-reports
modified_time: '2014-07-17T22:45:21.842-06:00'
blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-6184388956565966046
blogger_orig_url: http://www.svlark.com/2014/07/718-progress.html
---
I'm starting to work out how to work in Mountain Time and live on the East Coast. Basically, I still live Mountain Time. I work from 10 to 7 and take lunch at 2. 10 feels like 8; 2 feels like noon; 7 feels like 5. Instead of sleeping from 10ish to 6ish, now I sleep from 12ish to 8ish. The girls have shifted their sleeping and waking similarly. Well, that was easy!
We'll attempt to launch Lark two Saturdays from now. Like all proper boat owners, we have a long and growing list of things we need to do, ought to do and wish we could do. That's how we know we're proper.


This small town lies towards the eastern end of the southern coast of Grande Terre, about 20 NM from Pointe-a-Pitre.
Position 16° 14'51"N, 61° 15'24"W (channel entrance)
There is a squad of Customs and Immigration (Police) based here.
Last updated November 2013.
There is a small marina and a well protected anchorage.
Enter in good light as the channel is narrow with reefs on each side.
Last updated December 2014.


Video Title
Last Modified
Your Videos
LOAD MORE...


Eka doroba ra mphesaphesa ra Giyani a
ku ri na swifanyetana swo pfumala
makaya. A swi amukela xin’wana na
xin’wana lexi siku ri swi
khomeleke swona.
Hi mixo wun’wana a va ri ku sungeni ka
mimete ya vona
endzhaku ka loko va etlerile epatwini
exirhamini. Ku ringeta ku tikufumeta
va tshiverile ndzilo hi nthyaka leri a ri ri
eka xo chela thyaka.
Exikarhi ka swifanyetana leswi a ku ri na
loyi a vitaniwa Matewu. A ku ri yena
lontsongo
eka vona.
In the busy city of Nairobi, far away from a caring life at home, lived a group of homeless boys. They welcomed each day just as it came.
On one morning, the boys were packing their mats after sleeping on cold pavements. To chase away the cold they lit a fire with rubbish.
Among the group of boys was Magozwe. He was the youngest.
Vatswari va Matewu va lovile a ri na
ntlhanu wa malembe. U yile a ya tshama
na malume wa yena. Wanuna loyi a nga ri
na mhaka na Matewu. A nga n’wi nyiki na
swakudya swo enela. A n’wi tirhisa
mitirho yo tika swinene.
When Magozwe’s parents died, he was only five years old. He went to live with his uncle. This man did not care about the child. He did not give Magozwe enough food. He made the boy do a lot of hard work.
Loko Matewu a ringeta ku gungula a
biwa. Loko a kombela ku ya exikolweni
na kona a biwa. Ivi malume wa yena a ku,
“U xiphukuphuku ngopfu wena u nge
pasi.”
Endzhaku ka malembe manharhu a karhi
a xanisiwa, Matewu a kunguhata ku
baleka ekaya. A sungula ku
tshama eswitarateni.
If Magozwe complained or questioned, his uncle beat him.
After three years of this treatment Magozwe ran away from his uncle. He started living on the street.
Vutomi bya le switarateni bya vava na
swona swifanyetana swo tala swa
kayakaya ku kuma swakudya. Mikarhi
yin’wana va khomiwa kumbe va biwa.
Loko va vabya ku lava munhu wova
pfuna.
Ntlawa lowu wa vafana a wu tihanyela hi
mali leyi va yi kumaka loko va famba va
kombela na loko va xavisa tipulasitiki.
Vutomi a byi tikisiwa ngopfu hi mitlawa
leyi a yi tshamela ku lwa leswaku va ta
lawula ndhawu yo
karhi.
Street life was difficult and most of the boys struggled daily just to get food. Sometimes they were arrested, sometimes they were beaten. When they were sick, there was no one to help.
The group depended on the little money they got from begging, and from selling plastics and other recycling.
Life was even more difficult because of fights with rival groups who wanted control of parts of the city.
 A
yi dzudza thyaka a yi chela esakeni ra
yena.
Masiku hinkwawo a humesa buku leyi a
languta swifaniso. A nga koti ku hlaya.
One day while Magozwe was looking through the dustbins, he found an old tattered storybook. He cleaned the dirt from it and put it in his sack.
Every day after that he would take out the book and look at the pictures. He did not know how to read the words.
Swifaniso swa xitori lexi a swi ri swa jaha
leri nga kula ri va muhahisi swa
swihahampfhuka.
Mahewu a hamba a lorha a karhi a
hahisa swihahampfhuka. Mikarhi
yin’wana a tivona ku ri yena jaha leri nga
eka xitori.
The pictures told the story of a boy who grew up to be a pilot.
Magozwe would daydream of being a pilot. Sometimes, he imagined that he was the boy in the story.
Siku rin’wana a ku titimela swinene loko
Mahewu a yimile etlhelo ka patu a karhi a
kombela. Wanuna un’wana a n’wi
tshinelela. “Kunjhani?
Hi mina Tomasi. Ndzi tirha kwala kusuhi
laha u nga kumaka swo miyeta nyoka.”
Ku vula wanuna.

“Ndzi tshemba leswaku u nga ta ku kuma
swakudya.
Mahewu a languta wanuna, a languta
yindlu. “Kumbexana.” Ku vula Mahewu a
karhi a famba.
It was cold and Magozwe was standing on the road begging. A man walked up to him. “Hello, I’m Thomas. I work near here, at a place where you can get something to eat,” said the man.
He pointed to a yellow house with a blue roof. “I hope you will go there to get some food?” he asked.
Magozwe looked at the man, and then at the house. “Maybe,” he said, and walked away.
Eka tinhweti leti landzelaka, Mahewu a
tshamela ku vona Tomasi. Tomasi a
rhandza ku vulavula na vanhu exitarateni.
Tomasi a tlhela a yingisela na swirilo swa
vanhu. A nga heli mbili, a nga rhukani na
swona a hlonipha.
Van’wana va vafana va vo pfumala
matswari va sungule ku fambela endlwini
ya xitshopana na lwangu ra
bulu ku kuma swakudya nanhlikanhi.
Over the months that followed, the homeless boys got used to seeing Thomas around. He liked to talk to people, especially people living on the streets.
Thomas listened to the stories of people’s lives. He was serious and patient, never rude or disrespectful. Some of the boys started going to the yellow and blue house to get food at midday.

“Xana buku leyi yi vulavula hi yini?” ku
vutisa Tomasi.
“Hi jaha leri nga va muhahisi wa
swihahampfhuka.” Ku hlamula
Mahewu.
“Vito raj aha ra kona i mani” Ku vutisa
Tomasi.
“A ndzi tivi, a ndzi swi koti ku hlaya.” Ku
vula Mahewu.
Magozwe was sitting on the pavement looking at his picture book when Thomas sat down next to him.
“What is the story about?” asked Thomas.
“It’s about a boy who becomes a pilot,” replied Magozwe.
“What’s the boy’s name?” asked Thomas.
“I don’t know, I can’t read,” said Magozwe quietly.
Loko va hlangana kambe, Mahewu u
sungurile ku hlamusela Tomasi xitori xa
yena. A ku ri xitori xa leswi nga n’wi
humelela loko a ha tshama na malume
wa yena.
Tomasi a nga vulavulanga ngopfu kambe
o yingisela. A nga vuli leswaku Mahewu u
fanele ku endla yini.
Mikarhi yin’wana a va ta vulavula va karhi
va tidyela endlwini ya lwangu ra bulu.
When they met, Magozwe began to tell his own story to Thomas. It was the story of his uncle and why he ran away.
Thomas didn’t talk a lot, and he didn’t tell Magozwe what to do, but he always listened carefully.
Sometimes they would talk while they ate at the house with the blue roof.
Loko siku ra ku velekiwa ra Mahewu hi
fika, Tomasi u n’wi nyikile buku ya
switori. A ku ri na xitori xa jaha ra le
switandini leri nga kula ri hetelela ri
duma hi ku tlanga
bolo.
 U swi
vona njhani?”

Around Magozwe’s tenth birthday, Thomas gave him a new storybook. It was a story about a village boy who grew up to be a famous soccer player.
Thomas read that story to Magozwe many times, until one day he said, “I think it’s time you went to school and learned to read. What do you think?” Thomas explained that he knew of a place where children could stay, and go to school.
Mahewu u vuye a ehleketa hi mhaka leyi
y ova a ya exikolweni. Kambe a tlhela a
ehleketa leswaku malume wa yena a nga
va a nga hembi leswaku yena i
xiphukuphuku na swona a nge dyondzi
nchumu.
Loko vo n’wi ba kwale xikolweni ke? A
chava swinene. “Kumbe swi antswa ndzi
titshamela kwala switarateni.” Ku hleketa
Mahewu.
Magozwe thought about this new place, and about going to school.
What if they beat him at this new place? He was afraid. “Maybe it is better to stay living on the street,” he thought.
U vuye a kombisa Tomasi leswi a
chavaka swon. Kambe Tomasi u ringetile
ku n’wi kombisa leswaku vutomi byi ta
antswa swinene a nga chavi na nchumu.
He shared his fears with Thomas. Over time the man reassured the boy that life could be better at the new place.
Mahewu u vuye a ya nghena eka yindlu
ya lwangu ra rihlaza. U
fikile a tshama na majaha mambirhi.
Eka yindlu leyi a ku tshama khume wa
vana, Hahani Sindi na nuna wa yena,
timbyana tinharhu, ximanga, na mbuti ya
khale swinene.
And so Magozwe moved into a room in a house with a green roof. He shared the room with two other boys.
Altogether there were ten children living at that house. Along with Auntie Cissy and her husband, three dogs, a cat, and an old goat.
Mahewu u vuye a sungula xikolo. A swi
tika swinene. A fanele ku dyondza swo
tala.
Mikarhi yin’wana a lava na ku tshika.
Kambe a ehleketa hi muhahisi wa
swihahampfhuka na mutlangi wa bolo
eka buku ya switori. Ku fana na vona, a
nga tshikangi.
Magozwe started school and it was difficult. He had a lot to catch up. Sometimes he wanted to give up.
But he thought about the pilot and the soccer player in the storybooks. Like them, he did not give up.
Mahewu a titshamerile jarayini eka yindlu
ya lwangu ra rihlaza a karhi a hlaya buku
ya switori ya le xikolweni. Tomasi u fikile
a tshama etlhelo ka yena.
“Xana xitori xi vulavula hi yini?” ku vutisa
Tomasi.
“I xa mufana loyi a nga va mudyondzisi.”
Ku hlamula Mahewu.
“I mani vito ra jaha leri?” Ku vutisa
Tomasi.
“Vito ra yena i Mahewu.” Ku hlamula
Mahewu a karhi a n’wayitela.
Magozwe was sitting in the yard at the house with the green roof, reading a storybook from school. Thomas came up and sat next to him.
“What is the story about?” asked Thomas.
“It’s about a boy who becomes a teacher,” replied Magozwe.
“What’s the boy’s name?” asked Thomas.
“His name is Magozwe,” said Magozwe with a smile.


Join Axians meeting
%MeetingInfoURL%
| %MeetingNumber%
%TPJoinDescriptionHtml%%JoinByPhoneEntHtml%
%LyncURI%
Can't join the meeting?
%DisclaimerHtml%


new TSystem(step, delta, stepFactor, axiom)
Creates a LSystem for LOGO-style Turtle
Parameters:
| Name | Type | Description |
|---|---|---|
step |
Number | value of Botany.TSystem#step |
delta |
Number | value of Botany.TSystem#delta |
stepFactor |
Number | value of Botany.TSystem#stepFactor |
axiom |
String | value of Botany.TSystem#axiom |
Properties:
| Name | Type | Description |
|---|---|---|
step |
Number | the distance for each step forward |
delta |
Number | the angular distance for each turn |
sFactor |
Number | the amount module:Botany.TSystem#step will change after spawning |
axiom |
String | initial string |
vocabulary |
Object |
- Source:
Extends
Methods
addCommand()
adds a vocabulary entry for a key and its command
- Source:
addSuccessor()
adds a vocabulary entry for a key and its successor
- Source:
- See:
addVocab(key, commopt, succopt)
adds vocabulary term, successor, and command
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
key |
String | the new term | ||
comm |
String |
<optional> |
'F' | the command called by the term |
succ |
String |
<optional> |
'F' | the new successor |
- Overrides:
- Source:
createMissingVocab()
creates new vocabulary entries for missing terms
- Source:
fullyCommanded() → {Boolean}
checks if all terms have successors
- Source:
Returns:
- Type
- Boolean
fullySucceeded() → {Boolean}
checks if all terms have successors
- Source:
Returns:
- Type
- Boolean
getMissingVocab() → {Array}
retunrs the current string terms missing from vocabulary
- Source:
Returns:
terms undocumented in the vocabulary
- Type
- Array
scaleStep()
scales the step attribute by stepFactor
- Source:
segmentCount(term) → {Number}
counts the number of segments produced by the Turtle
Parameters:
| Name | Type | Description |
|---|---|---|
term |
String | the term being evaluated |
- Source:
Returns:
number of segments
- Type
- Number
semantic() → {Boolean}
checks if vocab term has a key/command
- Source:
Returns:
- Type
- Boolean
semFilter() → {Array}
filters all the terms in the string property by sematicity
- Source:
Returns:
semantic terms in the string
- Type
- Array
setAxiom(ax)
sets the axiom attribute
Parameters:
| Name | Type | Description |
|---|---|---|
ax |
String | new axiom |
- Source:
setDelta(dVal)
sets the delta attribute
Parameters:
| Name | Type | Description |
|---|---|---|
dVal |
Number | new delta value |
- Source:
setDelta(sValopt)
sets the step attribute
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
sVal |
Number |
<optional> |
1 | new step value |
- Source:
spawn()
alters string according to the vocabulary succesors, scales step by stepFactor
- Overrides:
- Source:
splitFilter() → {Array}
retrieves all of the semantic characters from DOL.string
- Inherited From:
- Source:
Returns:
an array of semantic characters
- Type
- Array
uncommmandedVocab() → {Array}
finds vocab terms with no command attribute
- Source:
Returns:
vocab terms with no command attribute
- Type
- Array
unsuceededVocab() → {Array}
finds vocab terms with no successor attribute
- Source:
Returns:
vocab terms with no successor attribute
- Type
- Array


Limitations
Limitations are listed in the release notes: (
Master Version
Vergil Safe Version, derived from the Master Version
)


XMLObject interfaces and helper classes for representing digitally signed content and signing/validating content.
Those classes starting with XMLSec use the Apache XML Security library
to provide their functionality. Support for the JSR-105 will be added in the future.


input type=tel
element test
input type=tel
input type=tel
with aria-label
aria-label
should be used as accessible name.
No accessible description.
input type=tel
with aria-labelledby
p
referenced by aria-labelledby
aria-labelledby
should be used as accessible name.
No accessible description.
input type=tel
with label
label
should be used as accessible name.
No accessible description.
input type=tel
with title
attribute
title
should be used as accessible name.
No accessible description.
input type=tel
with aria-describedby
p
referenced by aria-describedby
aria-describedby
should be used as accessible description.
No accessible name.
input type=tel
with label
element & title
attribute
label
should be used as accessible name.
title
should be used as accessible description.
input type=tel
element
with explicit label
,
& required
attribute
Note: placeholder and aria-placeholder are tested as part of the placeholder attribute test.


Rebuild map from challenge 3 as mapWith. This time you're going to use forEach inside of mapWith instead of using a for loop.
var alphabet = ''; var letters = ['a', 'b', 'c', 'd']; forEach(letters, function(char) { alphabet += char; }); console.log(alphabet); //prints 'abcd'


This fixer-upper cottage for sale in Co Roscommon is less than $30k
by IrishCentral StaffThe Beehive Cottage is an "ideal renovation project"
Looking for a fixer-upper Irish cottage? The Beehive Cottage in Elphin, Co Roscommon is surely in need of intense renovations, but with an asking price of only €25k ($28k), it’s a hard offer to pass up.
Read More: Cheap Irish Houses is about to be your new favorite Instagram account
Connaughton Auctioneers is managing the sale of this bungalow in Co Roscommon which has the potential to become a cozy homestead or dreamy vacation spot.
The “attractive” two-bedroom cottage is situated on just over an acre of land and is nearby to Elphin, Strokestown, Rooskey, and Carrick-on-Shannon. The home is also located close to many lakes and the River Shannon.
Read More: Fixer Upper: Your own Irish dream house in “St Tropez of Ireland”
While the bungalow is in need of work, it does currently have mains water, electricity, and a septic tank, which means you wouldn't exactly be starting from scratch if you want to revamp this quaint Irish cottage.
The sellers promise this is “an ideal renovation project” and note that the existing accommodation is “deceptively spacious” and consists of a reception hallway, sitting room, living room / kitchen, and two bedrooms.
Read More: An old stone cottage in County Galway for $23K
You better hurry though - the sellers said they will be accepting their final offers on November 29.
Have you ever taken on a fixer-upper project in Ireland? Tell us about it in the comments!


115 West 3rd Street Emmett ID 83617
6850 VanDeusen Road Emmett Idaho 83617
330 East Main Emmett Idaho 83617


Reports any calls to
Throwable.initCause()
where the exception constructor also takes a
Throwable
cause argument. In this case the
initCause()
call can be removed and its argument added to the call to the exception's constructor.
New in 15.1


Check out what we've been working on!
Here you can find our collections of Squirrels - exposed as JSON from Acorn.
Look, a squirrel! »Check out the content inside our memdisk. Here we're displaying a directory with books from our filesystem.
Read a book »


The TMReadFile API call reads from the file specified by the file handle number 'file_handle' and copies it into the buffer 'read_buffer', not to exceed ‘buff_size’ bytes (which should be the size of the read_buffer being provided). 'file_handle' must be set as a result of a call to TMOpenFile. If the file to read is an ‘add’ file with extension 100 decimal then the file length will be in page increments. For example if the last data byte is in the 30th byte of the file, the length will go to the end of the page which would give a length of (2*28) or 56 bytes. If the file to read is a ‘Monetary File ‘ with extension 101, the length of the buffer is at least 36 bytes long (28 bytes for the ‘Monetary File’ + 8 bytes for the Counter and Tamper bytes to append).
For a description of the above types, see the TMEX Type Descriptions.
Parameters
session_handle
Specifies the session handle returned from the API function TMExtendedStartSession that specifies the desired 1-Wire network port. This parameter is required by most TMEX API functions.
state_buffer
Specifies a pointer to a memory location that TMEX keeps all of the state information for the 1-Wire networks. This parameter is required by most TMEX API functions.
file_handle
Specifies a file handle of the file to read.
read_buffer
Specifies a pointer to a buffer that will hold the data read from the file. It must be at least ‘max_read’ bytes long.
buff_size
Specifies the size of ‘read_buffer’ in bytes. If the file length is longer than ‘buff_size’, an error is returned.
Return Value
>= 0 => file read, and this is the number of bytes
<0 => TMEX File Operations Error Return Code
See Also


2 Kings 20:8
And Hezekiah said unto Isaiah, What shall be the sign that the LORD will heal me, and that I shall go up into the house of the LORD the third day?


Coding Quiz Challenge
Try to answer the following code-related questions within the time limit. Keep in mind that incorrect answers will penalize your score/time by five seconds.
Try to answer the following code-related questions within the time limit. Keep in mind that incorrect answers will penalize your score/time by five seconds.


By accessing this web site, you are agreeing to be bound by these web site Terms and Conditions of Use, all applicable laws and regulations, and agree that you are responsible for compliance with any applicable local laws. If you do not agree with any of these terms, you are prohibited from using or accessing this site. The materials contained in this web site are protected by applicable copyright and trade mark law.
In no event shall The Fermenting Ape, LLC or its suppliers be liable for any damages (including, without limitation, damages for loss of data or profit, or due to business interruption,) arising out of the use or inability to use the materials on The Fermenting Ape, LLC's Internet site, even if The Fermenting Ape, LLC or a The Fermenting Ape, LLC authorized representative has been notified orally or in writing of the possibility of such damage. Because some jurisdictions do not allow limitations on implied warranties, or limitations of liability for consequential or incidental damages, these limitations may not apply to you.
The materials appearing on The Fermenting Ape, LLC's web site could include technical, typographical, or photographic errors. The Fermenting Ape, LLC does not warrant that any of the materials on its web site are accurate, complete, or current. The Fermenting Ape, LLC may make changes to the materials contained on its web site at any time without notice. The Fermenting Ape, LLC does not, however, make any commitment to update the materials.
The Fermenting Ape, LLC has not reviewed all of the sites linked to its Internet web site and is not responsible for the contents of any such linked site. The inclusion of any link does not imply endorsement by The Fermenting Ape, LLC of the site. Use of any such linked web site is at the user's own risk.
The Fermenting Ape, LLC may revise these terms of use for its web site at any time without notice. By using this web site you are agreeing to be bound by the then current version of these Terms and Conditions of Use.
Any claim relating to The Fermenting Ape, LLC's web site shall be governed by the laws of the State of Virginia without regard to its conflict of law provisions.
General Terms and Conditions applicable to Use of a Web Site.


=== Test case: lasp_SUITE:contracted_latency_test/1 (click for source code)
=== Config value:
[{watchdog,<0.501.0>},
<EMAIL_ADDRESS>{tc_group_properties,[]},
{tc_group_path,[]},
{data_dir,"/Users/anne-francevanswieten/lasp/_build/test/lib/lasp/test/lasp_SUITE_data/"},
<EMAIL_ADDRESS>=== Current directory is<EMAIL_ADDRESS>=== Started at 2017-05-05 20:39:31
*** User 2017-05-05 20:39:31.168 ***
Beginning case: contracted_latency_test
*** User 2017-05-05 20:39:31.182 ***
20:39:31.182 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'runner@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 20:39:32.438 ***
20:39:32.438 [info] Enabling membership...
*** User 2017-05-05 20:39:32.439 ***
20:39:32.439 [info] Disabling blocking sync...
*** User 2017-05-05 20:39:32.444 ***
20:39:32.444 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-1@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 20:39:33.928 ***
20:39:33.928 [info] Enabling membership...
*** User 2017-05-05 20:39:33.930 ***
20:39:33.929 [info] Disabling blocking sync...
*** User 2017-05-05 20:39:33.934 ***
20:39:33.934 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-2@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 20:39:35.453 ***
20:39:35.453 [info] Enabling membership...
*** User 2017-05-05 20:39:35.455 ***
20:39:35.455 [info] Disabling blocking sync...
*** User 2017-05-05 20:39:35.460 ***
20:39:35.460 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-3@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 20:39:35.721 ***
Joining node: 'node-3@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 60116
*** User 2017-05-05 20:39:35.725 ***
Joining issued: 'node-3@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 60116
*** User 2017-05-05 20:39:35.725 ***
Joining node: 'node-2@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 60097
*** User 2017-05-05 20:39:35.725 ***
Joining issued: 'node-2@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 60097
*** User 2017-05-05 20:39:35.727 ***
Joining node: 'node-1@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 60085
*** User 2017-05-05 20:39:35.730 ***
Joining issued: 'node-1@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 60085
*** User 2017-05-05 20:39:35.791 ***
Waiting for join to complete with manager: partisan_default_peer_service_manager
*** User 2017-05-05 20:39:35.792 ***
Finished.
*** CT 2017-05-05 20:39:35.804 *** COVER INFO
Adding nodes to cover test: ['runner@MacBook-Pro-de-Anne-France']
*** CT 2017-05-05 20:39:35.812 *** COVER INFO
Successfully added nodes to cover test: []
*** User 2017-05-05 20:39:35.812 ***
Case finished: contracted_latency_test
*** User 2017-05-05 20:39:42.854 ***
20:39:42.854 [info] Application lasp exited with reason: stopped
=== Ended at 2017-05-05 20:39:42
=== successfully completed test case
=== Returned value: ok
Test run history
| Top level test index


| Package | Description |
|---|---|
| adept.common |
Provides common data structures for use in the ADEPT framework, including the input Document and its TokenStream containing every Token, and the output HltContentContainer containing multiple kinds of annotations, such as EntityMention and Relation, which are based on the Chunk class.
|
| adept.data |
Provides interfaces for accessing databases and knowledge-bases such as NELL and the Paraphrase Database (PPDB).
|
| adept.io |
Provides I/O classes that handle reading/write files in different formats, including LDC Gigaword Corpus, ERE, CoNLL, email and plain text.
|
| adept.module |
Provides interfaces and classes to support DEFT TA1 algorithm implementations in the ADEPT framework, primarily based on the AbstractModule class along with a set of Processor interfaces, which together support specific subclasses for analysis, extraction, tagging and other algorithms.
|
| adept.restapi |
Provides interfaces for accessing DEFT algorithms as RESTful services
|
| adept.serialization |
Provides interfaces and classes for ADEPT data (de)serialization in XML, JSON and Binary format
|
| adept.utilities |
Provides utility classes and functions for creating ADEPT Document objects, for tokenization, regression test, benchmark test, profiler, command-line application and file conversions.
|
| Class and Description |
|---|
| AdeptException
The Class AdeptException.
|
| AnomalousText
The Class AnomalousText.
|
| Argument
The Class Argument, which contains one or more Chunk objects along with their associated probabilities.
|
| ArgumentTuple
The Class Relation.
|
| ArgumentTypeFactory
A factory for creating ArgumentType objects.
|
| AsrName
The Enum AsrName.
|
| Audio
The Class Audio.
|
| AudioFileType
The Enum AudioFileType.
|
| AudioOffset
Captures the begin and end time of an audio span.
|
| AuthorshipTheory
The Class AuthorshipTheory.
|
| BeliefMention
Represents a textual belief.
|
| BeliefMention.Builder |
| BoundedList
An extension class of ArrayList which has a fixed size/capacity.
|
| ChannelName
The Enum ChannelName.
|
| CharOffset
Captures the begin and end integer positions of character spans.
|
| Chunk
The Class Chunk, which is a sequence of tokens that comprise
a phrase or other syntactic unit within a sentence.
|
| CommittedBelief
The Class CommittedBelief.
|
| ContentType
The Enum ContentType.
|
| ConversationElement
The Class ConversationElement, which represents the
units of Conversation.
|
| ConversationElementAttributesTypeFactory
A factory for creating ConversationElementAttributesType objects.
|
| ConversationElementEntityRelationTypeFactory
A factory for creating ConversationElementEntityRelationsType objects.
|
| ConversationElementRelationTypeFactory
A factory for creating ConversationElementRelationType objects.
|
| ConversationElementTag
The Class ConversationElementTag, which represents an SGML tag within a structured document.
|
| ConversationType
The Enum ConversationType.
|
| Coreference
The Class Coreference, which is a relationship between two or more words
or phrases in which both refer to the same entity and one stands as a
linguistic antecedent of the other.
|
| Corpus
The Class Corpus.
|
| DeceptionTheory
The Class DeceptionTheory.
|
| Dependency
The Class Dependency.
|
| Document
The Class Document, which represents a piece of written,
printed, or electronic matter that provides information
or evidence or that serves as an official record.
|
| DocumentBelief
Represents a belief at the level of participating document-level entities, relations, and arguments,
rather than strings of text.
|
| DocumentBelief.Builder |
| DocumentEvent
Represents an event at the level of participating document-level entities,
rather than strings of text.
|
| DocumentEvent.Builder |
| DocumentEvent.Provenance
Represents evidence for the existence of an event.
|
| DocumentEventArgument
Represents the argument of an event.
|
| DocumentEventArgument.Builder |
| DocumentEventArgument.Filler
A filler for a role in a document-level event.
|
| DocumentEventArgument.Provenance
Represents the source of an event argument.
|
| DocumentMentalState
Internal abstract class representing the commonality between
DocumentSentiment and DocumentBelief.
|
| DocumentMentalState.Builder |
| DocumentMentalStateArgument |
| DocumentMentalStateArgument.Builder |
| DocumentMentalStateArgument.Filler
A filler for a role in a document-level mental state.
|
| DocumentRelation
Represents a relation at the level of participating document-level entities
and the like, rather than strings of text.
|
| DocumentRelation.Builder |
| DocumentRelationArgument |
| DocumentRelationArgument.Builder |
| DocumentRelationArgument.Filler
A filler for a role in a document-level relation.
|
| DocumentSentiment
Represents a sentiment at the level of participating document-level entities, relations, and arguments,
rather than strings of text.
|
| DocumentSentiment.Builder |
| Entailment
The Class Entailment.
|
| Entailment.Judgment
The Enum Judgment.
|
| Entity
The Class Entity, which is a thing in concrete or abstract reality
that can be identified by its distinct properties, for example persons,
organizations, locations, expressions of times, quantities and
monetary values.
|
| EntityAttributesTypeFactory
A factory for creating EntityAttributesType objects.
|
| EntityMention
The Class EntityMention, which is a sequence of tokens
that refer to an Entity with mention type that is drawn
from an ontology
|
| EntityTypeFactory
A factory for creating EntityType objects.
|
| Event
The Class Event, which represents something
that happens or is regarded as happening;
an occurrence, especially one of some importance.
|
| EventMention
Represents an event where the arguments are particular
chunks of text which may or may not be further resolved.
|
| EventMention.Builder |
| EventMentionArgument
Represents that a particular span of text plays a role in an event.
|
| EventMentionArgument.Builder |
| EventPhrase
Deprecated.
|
| EventRelations
Deprecated.
|
| EventText
Represents some textual evidence that an event occurred.
|
| EventText.Builder |
| EventTextSet
Represents a set of event occurrence.
|
| EventTextSet.Builder |
| EventTypeFactory
A factory for creating EventType objects.
|
| GenderTypeFactory
A factory for creating GenderType objects.
|
| GenericThing
Represents a generic thing, abstracted from its particular realization in text.
|
| HasChunkAttributes
Indicates a class can carry flags of type
IType mapping to values of type Chunk. |
| HasConversationElementTagAttributes
Indicates a class can carry flags of type
IType mapping to values of type ConversationElementTag. |
| HasFreeTextAttributes
Indicates a class can carry flags of type
IType mapping to values of type String. |
| HasOntologizedAttributes |
| HasScoredUnaryAttributes
Indicates a class can carry float-valued flags of type
IType . |
| HltContent
The Class HltContent is an abstract class that represents all the HLT content
generated by DEFT algorithms.
|
| IConversationElementEntityRelation
Indicates a class can carry flags of type
IType mapping to values of type List<Entity>. |
| IConversationElementRelation
Indicates a class can carry flags of type
IType mapping to values of type List<ConversationElement>. |
| ID
The Class ID defines an identifier for all instances of objects used in the
ADEPT framework.
|
| InterPausalUnit
The Class InterPausalUnit.
|
| Item
An abstract definition of an item, which is composed of an id and a value.
|
| IType
The interface IType for recording Ontology type.
|
| ITypeFactory
The Class Type.
|
| JointRelationCoreference
The Class JointRelationCoreference represents the container for the output of
the algorithm that processes both coreference resolution and relation
extraction simultaneously.
|
| KBID
Represents a generic KB ID.
|
| LatticeArc
The Class LatticeArc.
|
| LatticePath
The Class LatticePath.
|
| MentalStateMention
Internal abstract class representing the commonality between
SentimentMention and BeliefMention.
|
| MentalStateMention.Builder |
| MentalStateMention.Filler
A filler for a role in a textual MentalState mention.
|
| MentalStateType |
| MentionTypeFactory
A factory for creating MentionType objects.
|
| Modality
The Enum Modality.
|
| Morph
Represents a morph.
|
| Morph.Builder
Builds
Morph instances. |
| MorphFeature
Represents a morphological feature.
|
| MorphSentence
Represents the morphological information for a sentence.
|
| MorphSentence.Builder
Builds
MorphSentence objects. |
| MorphToken
Represents a morphological token.
|
| MorphToken.Builder
Builds
MorphToken instances. |
| MorphTokenSequence
Represents a sequence of morphological tokens.
|
| MorphTokenSequence.Builder
Builds
MorphTokenSequence objects. |
| MorphType
Represents the types of morphs.
|
| NativeLanguageTypeFactory
A factory for creating NativeLanguageType objects.
|
| NumberPhrase
The Class NumberPhrase.
|
| NumericValue
Represents a numeric value, abstracted from its particular realization in text.
|
| OntTypeFactory
The Class Type.
|
| Opinion
The Class Opinion.
|
| Pair
A generic, simple pair class for storing key-value or pair data.
|
| Paraphrase
Holds a value for a paraphrase of a string or a
Chunk . |
| PartOfSpeech
The Class PartOfSpeech.
|
| PartOfSpeechTagFactory
A factory for creating PartOfSpeechTag objects.
|
| Passage
The Class Passage, which represents a section of text
which has been extracted from a document, particularly
a section of medium length.
|
| Polarity
The Enum Polarity.
|
| ProsodicPhrase
The Class ProsodicPhrase.
|
| QuantifiedChunkAttributesTypeFactory
A factory for creating QuantifiedChunkAttributesType objects.
|
| Relation
The Class Relation.
|
| RelationMention
Represents a textual relation.
|
| RelationMention.Builder |
| RelationMention.Filler
A filler for a role in a textual relation mention.
|
| RelationTypeFactory
A factory for creating RelationType objects.
|
| Sarcasm
The Class Sarcasm.
|
| Sarcasm.Judgment
The Enum Judgment.
|
| Script
Represents a generic pattern of events with some relation to one another.
|
| ScriptEvent
An event in a
Script . |
| ScriptEventArgument
Represents an event argument in a
Script . |
| ScriptLink
Represents a link between two script events.
|
| ScriptVariable
A variable in an event script.
|
| ScriptVariableBinaryConstraint
A constraint which holds between two variables in an event script.
|
| Sentence
The Sentence class extends Chunk and represents the output from sentence
boundary detection algorithm.
|
| SentenceSimilarity
The Class SentenceSimilarity.
|
| SentenceType
The Enum SentenceType.
|
| SentimentMention
Represents a textual sentiment.
|
| SentimentMention.Builder |
| Session
The Class Session.
|
| SpeechUnit
The Enum SpeechUnit.
|
| Subjectivity
The Enum Subjectivity.
|
| SyntacticChunk
The Class SyntacticChunk.
|
| SyntacticTagFactory
A factory for creating SyntacticTag objects.
|
| TACKBP2014EAOutput
Represents the output of a a 2014 TAC KBP event argument system on a document.
|
| TACKBP2014EventArgument
This represents event arguments produced by a TAC KBP 2014 Event Argument
evaluation system.
|
| TACKBP2014EventArgument.Realis
This represents the realis distinctions from the 2014 TAC KBP
event argument evaluation.
|
| TaggedChunk
The Class TaggedChunk.
|
| TemporalResolution |
| TemporalResolution.Builder |
| TemporalSpan
Represents a TemporalSpan, or a span between a begin date and an end date.
|
| TemporalSpan.Builder |
| TemporalValue
Represents a temporal value, abstracted from its particular realization in text.
|
| TimePhrase
The Class TimePhrase.
|
| TimexValue
Represents a TIMEX temporal value.
|
| Token
The Class Token, which is a single word or
other lexically-defined character sequence
within a document.
|
| TokenizerType
The Enum TokenizerType.
|
| TokenLattice
The Class TokenLattice.
|
| TokenOffset
Captures the begin and end integer positions of token spans.
|
| TokenStream
The Class TokenStream, which is a list of tokens
and represents the tokenized form of a entire document.
|
| TokenType
The Enum TokenType.
|
| Topic.Polarity
The Enum Polarity.
|
| TranscriptType
The Enum ContentType.
|
| TranslatorName
The Enum TranslatorName.
|
| Triple
The Class Triple.
|
| Type
The Class Type.
|
| Utterance
The Class Utterance.
|
| Viewpoint
The Class Viewpoint.
|
| XSDDate |
| Class and Description |
|---|
| AdeptException
The Class AdeptException.
|
| HltContentContainer
The Class HltContentContainer, which contains the
full annotation of an input Document, including
objects such as Coreference, EntityMention, Event,
Passage, Relation and Sentence.
|
| Item
An abstract definition of an item, which is composed of an id and a value.
|
| Paraphrase
Holds a value for a paraphrase of a string or a
Chunk . |
| Class and Description |
|---|
| CharOffset
Captures the begin and end integer positions of character spans.
|
| ConversationElement
The Class ConversationElement, which represents the
units of Conversation.
|
| Coreference
The Class Coreference, which is a relationship between two or more words
or phrases in which both refer to the same entity and one stands as a
linguistic antecedent of the other.
|
| Corpus
The Class Corpus.
|
| Document
The Class Document, which represents a piece of written,
printed, or electronic matter that provides information
or evidence or that serves as an official record.
|
| Entity
The Class Entity, which is a thing in concrete or abstract reality
that can be identified by its distinct properties, for example persons,
organizations, locations, expressions of times, quantities and
monetary values.
|
| EntityMention
The Class EntityMention, which is a sequence of tokens
that refer to an Entity with mention type that is drawn
from an ontology
|
| Event
The Class Event, which represents something
that happens or is regarded as happening;
an occurrence, especially one of some importance.
|
| EventRelations
Deprecated.
|
| HltContentContainer
The Class HltContentContainer, which contains the
full annotation of an input Document, including
objects such as Coreference, EntityMention, Event,
Passage, Relation and Sentence.
|
| Pair
A generic, simple pair class for storing key-value or pair data.
|
| PartOfSpeech
The Class PartOfSpeech.
|
| Passage
The Class Passage, which represents a section of text
which has been extracted from a document, particularly
a section of medium length.
|
| Relation
The Class Relation.
|
| Sentence
The Sentence class extends Chunk and represents the output from sentence
boundary detection algorithm.
|
| Token
The Class Token, which is a single word or
other lexically-defined character sequence
within a document.
|
| TokenOffset
Captures the begin and end integer positions of token spans.
|
| TokenStream
The Class TokenStream, which is a list of tokens
and represents the tokenized form of a entire document.
|
| Class and Description |
|---|
| AdeptException
The Class AdeptException.
|
| Chunk
The Class Chunk, which is a sequence of tokens that comprise
a phrase or other syntactic unit within a sentence.
|
| CommittedBelief
The Class CommittedBelief.
|
| Document
The Class Document, which represents a piece of written,
printed, or electronic matter that provides information
or evidence or that serves as an official record.
|
| DocumentList
The Class DocumentList.
|
| Entailment
The Class Entailment.
|
| EntityMention
The Class EntityMention, which is a sequence of tokens
that refer to an Entity with mention type that is drawn
from an ontology
|
| HltContent
The Class HltContent is an abstract class that represents all the HLT content
generated by DEFT algorithms.
|
| HltContentContainer
The Class HltContentContainer, which contains the
full annotation of an input Document, including
objects such as Coreference, EntityMention, Event,
Passage, Relation and Sentence.
|
| Opinion
The Class Opinion.
|
| Paraphrase
Holds a value for a paraphrase of a string or a
Chunk . |
| PartOfSpeech
The Class PartOfSpeech.
|
| Passage
The Class Passage, which represents a section of text
which has been extracted from a document, particularly
a section of medium length.
|
| Sarcasm
The Class Sarcasm.
|
| Sentence
The Sentence class extends Chunk and represents the output from sentence
boundary detection algorithm.
|
| SentenceSimilarity
The Class SentenceSimilarity.
|
| SyntacticChunk
The Class SyntacticChunk.
|
| Class and Description |
|---|
| Corpus
The Class Corpus.
|
| Document
The Class Document, which represents a piece of written,
printed, or electronic matter that provides information
or evidence or that serves as an official record.
|
| DocumentList
The Class DocumentList.
|
| HltContentContainer
The Class HltContentContainer, which contains the
full annotation of an input Document, including
objects such as Coreference, EntityMention, Event,
Passage, Relation and Sentence.
|
| TokenizerType
The Enum TokenizerType.
|
| Class and Description |
|---|
| Argument
The Class Argument, which contains one or more Chunk objects along with their associated probabilities.
|
| Chunk
The Class Chunk, which is a sequence of tokens that comprise
a phrase or other syntactic unit within a sentence.
|
| EntityMention
The Class EntityMention, which is a sequence of tokens
that refer to an Entity with mention type that is drawn
from an ontology
|
| HltContentContainer
The Class HltContentContainer, which contains the
full annotation of an input Document, including
objects such as Coreference, EntityMention, Event,
Passage, Relation and Sentence.
|
| Pair
A generic, simple pair class for storing key-value or pair data.
|
| Class and Description |
|---|
| AudioOffset
Captures the begin and end time of an audio span.
|
| Corpus
The Class Corpus.
|
| DeceptionTheory
The Class DeceptionTheory.
|
| Document
The Class Document, which represents a piece of written,
printed, or electronic matter that provides information
or evidence or that serves as an official record.
|
| DocumentList
The Class DocumentList.
|
| EntityMention
The Class EntityMention, which is a sequence of tokens
that refer to an Entity with mention type that is drawn
from an ontology
|
| HltContentContainer
The Class HltContentContainer, which contains the
full annotation of an input Document, including
objects such as Coreference, EntityMention, Event,
Passage, Relation and Sentence.
|
| HltContentContainerList
The Class HltContentContainerList.
|
| PartOfSpeech
The Class PartOfSpeech.
|
| Sentence
The Sentence class extends Chunk and represents the output from sentence
boundary detection algorithm.
|
| SentenceSimilarity
The Class SentenceSimilarity.
|
| SyntacticChunk
The Class SyntacticChunk.
|
| TokenizerType
The Enum TokenizerType.
|
| TokenStream
The Class TokenStream, which is a list of tokens
and represents the tokenized form of a entire document.
|
Copyright © 2012–2017 Raytheon BBN Technologies. All rights reserved.


{% extends 'base.html' %} {% load bootstrap3 %} {% block title %} Select Chain | {{ block.super }} {% endblock %} {% block content %}
Expenses and Revenues for {{ camp.title }} must be associated with a Creditor or Debtor. Each Creditor and Debtor belongs to a Chain - e.g. the Creditor Netto Gelsted Belongs to the Chain Netto.
To continue, pick an existing Chain, or create a new.
{% if chain_list %}{{ chain.notes }}
{% endif %} {% endfor %}No existing Chains found. You can create a new Chain below.
{% endif %} {% endblock %}


Bamboo Stand
Pledge $25 or more
You get an ergonomic stand made of natural bamboo. You've helped us launch our promotional campaign, and you’ll be added to a special Backer member list.
A beautifully handcrafted monitor stand to reduce neck and eye strain.
The Mastercraft Bamboo Monitor Riser is a sturdy and stylish platform that elevates your screen to a more comfortable viewing height. Placing your monitor at eye level has the potential to improve your posture and make you more comfortable while at work, helping you stay focused on the task at hand.
Featuring artisan craftsmanship, the simplicity of design creates extra desk space below your computer to allow notepads, pens, and USB sticks to be stored under the stand.
You get an ergonomic stand made of natural bamboo. You've helped us launch our promotional campaign, and you’ll be added to a special Backer member list.
You get a Black Special Edition computer stand and a personal thank you. You’ll be added to our Backer member list. Shipping is included.
You get two Special Edition Mahogany stands, a Backer T-Shirt, and a personal thank you. You’ll be added to our Backer member list. Shipping is included.
Your pledge brings us one step closer to sharing Mastercraft Bamboo Monitor Riser worldwide. You will get an email once our campaign is completed.


9 Black Friday Deals You Shouldn't Miss
It's that time of year again. Black Friday is just around the corner. Here are nine deals you should have a look at.
by Nursah ErgüBlack Friday is so close and almost everyone is thinking about what to get with all these discounts going around. Yeah, you tried to handle your 10-year-old laptop while it takes 10 minutes to change from a tab to tab, survive with your cracked screen phone which cannot even make a proper phone call anymore, and your fridge which feels like warm spring weather inside.
RELATED: 10 DEALS YOU CAN SNAG BEFORE BLACK FRIDAY
But don't worry my friend, because you can get whatever you want during the Black Friday discounts. Maybe you can buy things you never knew you wanted before. After all, you never know what you may need and when you may need it.
So, here are nine products for all those who have been waiting for a long time to replace their old technological devices, who don't need anything but are shopaholics, and who want to discover what's on sale and what's not.
1. 23andMe Ancestry+Traits Service
Have you ever wondered where you came from? Who your ancestors are? If you wonder about your ancestry and how your traits shaped, what makes you, "you", treat yourself and get this kit. Also, you can find people all around the world who share the same DNA with you! So, getting this during Black Friday discounts is actually a great idea.
2. Nikon D3500 DSLR Camera
If you want to collect your best memories with a camera, this one is great for you. It also comes with a big kit which includes a double zoom lens kit, a travel case, wide-angle, and telephoto lens, and a filter set. You can never get this big of a deal again if you don't get it on Black Friday.
3. TP-Link WiFi Range Extender
Are you sick and tired of trying to stay close to your WiFi router because you can't get any signal when you're on your comfortable bed? It's time to get a WiFi Range Extender to enjoy yourself with full WiFi signals wherever you want.  It's time to chill.
4. GoHawk Bluetooth Smart Speaker
This speaker has everything and more you'd want from a speaker. Also, it's the first Alexa-enabled Bluetooth speaker. Just say the wake word "Alexa" and you'll be able to control your speaker from anywhere. Since it has different color options, you can choose any color you want. And you can change the LED light color and brightness with voice-control, GoHawk Audio App, or by tap and slide.
5. Echo Dot Smart Speaker With Alexa
This speaker comes with another friend, and she's called "Alexa." She can do whatever you want her to do, and she makes her speaker friend much more appealing. Just say "Alexa" and then tell her what you want her to do, and she'll do it.  She will. Do you want to hear the news from all around the world? She will read it for you. She can turn lights on for you and she can lock doors. Who needs a roommate when you have this speaker with Alexa, right?
6. Ring Security Camera
We live in a bad time. Everyone has access to everything, and without you knowing it, bam, someone enters your house. But with this security camera, you can check what's going on in your apartment. You'll be able to check what your kids or dog are doing or see any unwanted guests, like thieves or your uncle that you haven't seen for the past two years. It has built-in spotlights, two-way talk, and a siren alarm. And it works with Alexa!
7. Bose Bluetooth Headphones
These headphones will provide you the best listening experience with their noise-cancellation feature. Also with Alexa voice control, you'll be able to have voice access to music, information, and more. Life's too short for earbuds which don't have a noise-cancellation feature and Alexa voice control. It's time to get the coolest headphones in the world.
8. Nintendo Switch
If you like The Legend of Zelda, you should immediately get a Nintendo Switch. It's one of the best gaming systems out there for gamers. It doesn't matter if you're at home or on the go, alone or with your friends, you'll enjoy the world of Nintendo Switch to the fullest. It's something you shouldn't miss during Black Friday deals.
9. Toshiba Smart LED TV
You can watch Netflix, Hulu, HBO or your other favorite streaming content on this TV. Also, you can control it with Alexa. With its 4K Ultra HD picture quality, it'll take you away from reality and give you a breathtaking experience. Enough with not smart TVs, it's time to let your TV take you on an unbelievable journey. Lean back and get ready for the countless features of this Smart TV.


Need to make bigger servings? Use this calculator to up the game when you need more to fill your plate.