--- layout: post title: Using Span for high performance interop with unmanaged libraries date: 2019-07-02 15:00:00 keywords: dotnet teaser: The challenges of interop with an unmanaged library that deals in zero-terminated strings ---
There's so much great performance-related stuff happening in the .NET world right now.
A major character in this story is Span, which gives us
a way to reduce heap allocations and copying. Before
we had Span
, a common operation like Substring()
resulted in
an allocation and a copy.
In this blog post I want to talk about using Span
in the specific case
of interop with unmanaged libraries that deal in zero-terminated
strings (aka null-terminated strings).
Let's talk about this in layers. The bottom layer is the unmanaged function itself, written in C or something that pretends to be C. The kind of functions I'm talking about are ones that have a return value or a parameter which is a zero-terminated string. Such things are quite common. Here are a few familiar examples:
int puts(const char* p); FILE *fopen(const char *path, const char *mode); int sqlite3_open(const char* path, sqlite3** ppdb); char *asctime(const struct tm *tm);
With a zero-terminated string, all we have is a pointer. To find the length, something is going to start at that pointer and walk through memory until it finds a zero byte.
(I am aware of the various (security | correctness | etc) problems associated with zero-terminated strings. Nonetheless, there are many libraries that use them. For the purpose of this blog post, we assume the unmanaged function is something we can't change. It is what it is, and we have to deal with it.)
And before we go any further, let's mention the challenges the arising from the the differing encodings of the string. In .NET, strings are encoded in UTF-16, where each character is 2 bytes, and perhaps more. Any C library that expects a string terminated with a zero byte is not using UTF-16. If it's an old-school library, it might be expecting ASCII. The more modern alternative is UTF-8.
In any case, to use a .NET string with a zero-terminated string, we will have to do a conversion. That conversion is another form of a copy, and for performance reasons, we want to keep those to a minimum.
The next layer up is the P/Invoke definition. This is what allows us to access the C function from .NET.
A typical P/Invoke looks something like this:
// int abs(int x); [DllImport("msvcrt")] public static extern int abs(int x);
This definition says, "in a dynamic library named 'msvcrt', look for
a function named abs
, with a return type of int
and one parameter
of type int
.
Of course, a pointer to a zero-terminated string is a bit more
complicated than an int
. How should we describe that pointer in our
P/Invoke definition? We actually have some choices here, so let's
discuss the tradeoffs.
One thing we could do is define the P/Invoke to accept a regular
.NET string
:
[DllImport("msvcrt")] public static extern int puts(string s);
This approach offers convenience. And it accomplishes what we
probably need to do at some layer anyway, which is start with a .NET
string
, convert it to UTF-8, get a pointer for it, and pass it to
the C code.
Well actually: The default marshaling for a string is zero-terminated, but with ANSI encoding. To get UTF-8, we would have to do this:
[DllImport("msvcrt")] public static extern int puts([MarshalAs(UnmanagedType.LPUTF8Str)] string s);
Convenient or not, from the perspective of performance, I am not fond of this at all. The problem is that the UTF-16 to UTF-8 conversion is done every time we call this function.
What if this function is called from a loop with the same string every time?
foreach (var item in collection) { puts("Item: "); puts(item.ToString()); puts("\n"); }
In this (admittedly-contrived) example, we are writing a collection of
items to stdout, one per line. And each line starts with a prefix
and ends with a newline. And those two puts()
calls are sad, because
the conversion of the same strings to UTF-8 is going to be done every
time. That's a piece of work we would rather do outside the loop,
so it can be done just once. And in order to do that, we need a
P/Invoke definition that somehow accepts the already-converted UTF-8 data.
So at the C# layer, a string converted to UTF-8 is just an array of bytes, right? Maybe the P/Invoke definition should look like this:
[DllImport("msvcrt")] public static extern int puts(byte[] s);
Compared to the previous idea, this is a big improvement, because we have the flexibility to do the encoding conversion separately.
Which reminds me, we need a utility function for that conversion. Here's the one from SQLitePCLRaw:
using System.Text; public static byte[] to_utf8_with_z(this string s) { if (s == null) { return null; } int len = Encoding.UTF8.GetByteCount(s); var ba = new byte[len + 1]; var wrote = Encoding.UTF8.GetBytes(s, 0, s.Length, ba, 0); ba[wrote] = 0; return ba; }
BTW, my apologies for the snake case naming. For various reasons, SQLitePCLRaw mostly follows the naming conventions of SQLite, which I admit isn't very friendly to .NET folks.
Anyway, using byte[]
as the parameter type in the P/Invoke definition
means we could write that loop like this:
var ba_front = "Item: ".to_utf8_with_z(); var ba_back = "\n".to_utf8_with_z(); foreach (var item in collection) { puts(ba_front); puts(item.ToString()); puts(ba_back); }
But we still have problems. What if we have UTF-8 data that is not in a byte array? What if our UTF-8 data is in a byte array, but it's not alone in there? We can't do a slice without an allocation and a copy.
Putting byte[]
in the P/Invoke definition means that it
carries an assumption about using the heap. We don't want
that assumption, because it may not always be true, and
when it's not, we would have to do an allocation + copy
to make it true.
Another option is to make our P/Invoke look like this:
[DllImport("msvcrt")] public static extern int puts(IntPtr s);
or like this:
[DllImport("msvcrt")] unsafe public static extern int puts(byte* s);
These two are essentially equivalent.
I personally prefer to use byte*
, because I think it's more
clear. Using byte*
does require the unsafe
keyword, but
I see no reason to avoid that
when calling unmanaged code, which is inherently "unsafe"
anyway.
But either way, this version of the P/Invoke definition is
taking a pointer, just like the underlying C function.
This gives us more flexibility than byte[]
, because the P/Invoke no
longer assumes the use of managed memory.
However, the cost of that flexibility,
in the case where we are using managed memory,
is that the caller now has more work to do. If we're going to pass
a pointer to managed memory down to unmanaged code, we need
to "pin" it, to prevent the garbage collector from moving it
around. When the P/Invoke definition had the parameter type as byte[]
, the marshaling
code was doing the pin/unpin for us. But with a pointer, we have
to do it ourselves.
So now our example loop (shown with IntPtr
) has gotten worse:
var ba_front = "Item: ".to_utf8_with_z(); GCHandle pinned_front = GCHandle.Alloc(ba_front, GCHandleType.Pinned); IntPtr ptr_front = pinned_front.AddrOfPinnedObject(); var ba_back = "\n".to_utf8_with_z(); GCHandle pinned_back = GCHandle.Alloc(ba_back, GCHandleType.Pinned); IntPtr ptr_back = pinned_back.AddrOfPinnedObject(); foreach (var item in collection) { puts(ptr_front); puts(item.ToString()); puts(ptr_back); } pinned_front.Free(); pinned_back.Free();
Nonetheless, using a pointer is my preferred form of this P/Invoke definition. Just a simple equivalent to the C function, nothing more and nothing less. I don't want marshaling to do anything for me. I want to fhift all the problems of pinning and allocation and encoding up to a higher layer.
So I finish this section and move forward with the following implementation of Layer 1:
static class Layer1 { // int puts(const char* p); [DllImport("msvcrt")] unsafe public static extern int puts(byte* s); }
Let's talk about that next layer up.
What is the goal for this layer? Well that kinda depends on what I chose for the type of the parameter in the P/Invoke definition back in Layer 1.
If I had left the P/Invoke definition doing the string
marshaling,
I probably wouldn't need another layer at all.
If I had chosen the P/Invoke definition with parameter type of byte[]
,
maybe I would now want a layer that takes a string
and
does the conversion.
But since I chose byte*
, I forced myself into a situation
where I need another layer just to get unsafe
out of my public API. The unsafe
doesn't belong in
a public C# API. I may be crazy, but I'm not that crazy.
So is Layer 2 where I go ahead and express that string
parameter in terms of an actual .NET string
? Or byte[]
?
Yeah maybe. But I'd like to put that off as long as possible. Instead, I'm asking myself, "What is the thinnest useful layer of abstraction I can put here?"
What about a Span
?
static class Layer2 { public static int puts(ReadOnlySpan<byte> s) { unsafe { fixed (var p = s) { return Layer1.puts(p); } } } }
The nice thing about a Span
is that it brings the advantages we saw with byte[]
except without those
pesky assumptions about whether the memory is managed or not. Span
can represent
unmanaged memory, or part of a managed array, or memory on the stack.
That said, for the case where a Span
represents managed memory,
we still have to pin it. The fixed
block shown above is what
does that. Span
supports the fixed pattern, aka GetPinnableReference().
Span
is looking like the best option so far, but it still
has some problems.
For our case where the underlying C function needs a string with a zero terminator, Span
is not a perfect solution, and
all of its problems are related to the Length
property.
A Span
is an encapsulation of a pointer and a length.
But Layer 0 and Layer 1 only care about the pointer. Anything else (string
, byte[]
, Span
) is for the benefit
of the layers above, and makes no difference to the underlying C function.
So the fact that the Length
is part of Layer 2's public API but
will be unused should be a clue that
we are headed for trouble.
And here is the troubling question: In Layer2.puts()
as shown above, for the ReadOnlySpan<byte>
parameter,
is the zero terminator included in the Length
?
Suppose the string is "hello"
. Because this is a string with all ASCII characters,
it's the same as UTF-8, so that's 5 bytes of actual string data
plus one byte for the zero terminator.
We could pass a Span
of length 5 or 6.
Again, the layers below won't care. Either 5 or 6 will still work. Heck, we could use a completely wrong length like 1, and Layer 0 will still end up getting the same pointer.
And if the Length
doesn't matter, why is it there?
Let's look more closely at the possibilities.
What exactly does that ReadOnlySpan<byte>
parameter mean?
I see 3 alternatives.
In this alternative, the Span.Length
contains just the string data,
and there may or may not be zero terminator after it.
I mention this one because it is the way other .NET Span
-based
APIs work. When you see a ReadOnlySpan<byte>
as a parameter
of a method and that parameter refers to a string data, it
is customary to assume that there is no zero terminator
inside the Span
, and that there may not be one immediately
after the Span
. Simply put, in the world of .NET, zero-terminated
strings are just not really a thing.
And yet, even though this interpretation is the common .NET practice, in our case, this might be the worst possible option.
The contract of our C function in Layer 0 requires the zero terminator. So the C# layer has to make sure there is one. And if it is not going to pass that expectation up to its caller, then it will need to allocate a new buffer with one extra byte, copy the data, and set the zero terminator at the end.
Which would defeat the whole point of using Span
.
In this alternative, the Span.Length
contains just the string data, but
(wink wink) we all know there is actually a zero byte just beyond the end of the
Span
.
In my opinion, this is dreadful.
When I see a Span
, I assume the code using it will not go
beyond the end.
The contract of our function requires the ending zero. What if I want to insert a check on the C# side to make sure it's there? Such as:
static class Layer2 { public static int puts(ReadOnlySpan<byte> s) { // Look at the byte immediately after the Span to // make sure the zero terminator is there. if (s[s.Length] != 0) // BZZZT! WRONG! { throw new Exception("Zero terminator required"); } unsafe { fixed (var p = s) { return Layer1.puts(p); } } } }
But I can't, because C# (rightfully) won't let me go beyond the
end of the Span
.
Worse, eventually somebody is going to pass a Span
that
doesn't have the unofficial zero byte after it, because that's
what would be the common practice for Span<byte>
, and the compiler
has no way to prevent them from doing it. And then we will
end up with a memory corruption.
In this alternative, the Span.Length
includes the zero terminator.
In some ways, this seems less bad than the other two.
We won't need an extra allocation + copy, since we know the zero terminator
is already there. And now we're being honest about that zero byte's
presence by including it in the Length
.
And if we ignore enough context, doing it this way kinda makes sense.
The zero byte is a documented and required part of the block of bytes the
function expects.
The length of the zero-terminated block of memory that
represents "hello"
is 6.
But including the zero byte in the length seems wrong because, well,
it just is. Everywhere I go, whenever zero-terminated strings are used, the
zero byte is never considered part of the length.
The zero byte is not part of the string data -- it's just a memory marker.
If we called strlen()
on the pointer, it would return a length which did not include the zero.
If we passed this pointer to System.Text.Encoding.UTF8.GetString()
,
the length we provide should not include the zero byte.
The length of the string "hello"
is 5.
Another way of illustrating this impedance mismatch is to
think about slicing. Spans support Slice()
, but
slicing doesn't work on a zero-terminated string.
Or rather, if you slice a zero-terminated string, you
may end up with another string that is zero-terminated,
or you may end up with one that is not, depending on
whether your slice includes the end of the range or not.
So slicing is not a particularly useful operation for a
zero-terminated string, because it cannot reliably return
the same type.
So far, we've mostly been talking about calling a C function with a zero-terminated string as a parameter. But what about zero-terminated strings being returned from a C function up to .NET?
Again, we just get a pointer. We need to look for a zero byte to
find the length. One or two layers up, should we use a Span
here too?
And if so, when we construct a ReadOnlySpan<byte>
for that piece of memory, again, do we include the zero byte in the Length
or not?
In this case, a big difference is that .NET stuff doesn't need or want that zero terminator. Initially, the zero byte is important, because that's how the unmanaged code is providing us a way to get the length. But once we know the length, the zero byte is not likely to be important to the .NET layer, which will typically not use it.
In fact, if we did include the zero terminator in these cases,
then almost every piece of code using that Span
would need to subtract one from the Length.
And should it check to make sure the last byte actually is a
zero before doing so?
So maybe for these strings flowing in the other directon we should just not do zero terminators? But what if we need to receive a value from unmanaged code and pass it back down to a C function that requires a zero terminator? So then are we back to needing an allocation + copy?
So right now the situation seems bleak. I appear to be convincing
myself that Span
should not be used with zero-terminated strings.
I envision myself staying bitter and spiteful for the rest
of my career as I watch all the other .NET kids get to use Span
but
those of us working with unmanaged libraries cannot.
I want to use Span
. I really do.
But it seems like all the possible approaches are bad.
Probably the least bad option was Alternative 2c, which was "ReadOnlySpan<byte>
where the Length
includes the zero terminator".
But that approach is just so inconsistent with common practices that it
will cause confusion (and therefore, bugs).
I find myself wishing I could somehow use this approach
without anybody finding out about it.
As it turns out, that's the solution I have settled on:
A Span
that is hidden away where nobody can see it.
Span
, but notIn SQLitePCLRaw I have to deal with this issue a lot, as quite a few SQLite functions follow the pattern of accepting or returning a zero-terminated string.
During the development of my 2.0 release, as I started Span
-ifying the ISQLite3Provider
interface,
I kept bumping into the kind of problems described here in this blog post.
But (with help and feedback from others) the solution I ended up
with seems quite elegant. It's a new type I call utf8z
.
public readonly ref struct utf8z { // this Span will contain a zero terminator byte // if sp.Length is 0, it represents a null string // if sp.Length is 1, the only byte must be zero, and it is an empty string readonly ReadOnlySpan<byte> sp;
Simply, I have encapsulated a ReadOnlySpan<byte>
inside another type.
At first I wasn't sure if this would be possible.
A Span
is a C# 7.2 ref struct
, a value type which can only
be used in certain ways. A ref struct
can only be
on the stack, which basically means it can only be a parameter or a local. It can't be on the heap, which means
it also can't be a parameter or a local that might end up on the heap.
For example, an async
method
cannot have a Span
parameter, because an async
method actually
gets compiled into a state machine which is implemented using the heap.
But C# will happily let you put a ref struct
inside another ref struct
.
So in my case, I can use my shameful and confusing "Span
with a zero terminator inside"
and keep it hidden away from the world by making it private
. Then I add stuff
to the utf8z
public API to expose only the things that are valid and needed.
The first thing I need is a constructor:
utf8z(ReadOnlySpan<byte> a) { sp = a; }
I kept this simple. Just take a Span
as
a parameter and store it away in the member field. No
error checking.
And for that reason, this constructor is private. It is
trusting its caller to make sure
that the last byte of the Span
is a zero terminator, so we don't want
just any rando calling it.
The utf8z
public API will expose only things that are not capable
of violating the rules. For example, there is a static method to
get a utf8z
from a .NET string:
public static utf8z FromString(string s) { if (s == null) { return new utf8z(ReadOnlySpan<byte>.Empty); } else { return new utf8z(s.to_utf8_with_z()); } }
If we need a public method to get a utf8z
from a
Span
, that method should include a check
for the zero terminator:
public static utf8z FromSpan(ReadOnlySpan<byte> a) { if ( (a.Length > 0) && (a[a.Length - 1] != 0) ) { throw new ArgumentException("zero terminator required"); } return new utf8z(a); }
We also need a way to convert a utf8z
into a pointer
which can be passed to P/Invoke. In other words, we need
utf8z
to implement "the fixed pattern". Fortunately, we can
just pass this responsibility on to the encapsulated Span
:
public ref readonly byte GetPinnableReference() { return ref sp.GetPinnableReference(); }
Finally, we need a convenient way to
convert a utf8z
to a .NET string
:
public string utf8_to_string() { if (sp.Length == 0) { return null; } unsafe { fixed (byte* q = sp) { return Encoding.UTF8.GetString(q, sp.Length - 1); } } }
Note that I did not use an override of ToString()
for this,
as Microsoft guidelines say that ToString()
should never return
null. And I want utf8z
to have a clearly-defined ability to
represent a null. Span
is a value type, so it is not nullable.
The implementation of Span.GetPinnableReference()
returns null for an empty Span
, but
that's not precise enough for interacting with unmanaged code,
where an empty string is different from a null.
(Once again, in the world of C, sometimes pointers
are NULL. It is what it is, and sometimes we just have to deal with it.)
And that's it. My implementation of Layer 2 looks like this:
static class Layer2 { public static int puts(utf8z s) { unsafe { fixed (var p = s) { return Layer1.puts(p); } } } }
In the ISQLite3Provider
interface, I now use
an actual Span
only in cases where the usage is consistent with
the associated expecations for same.
And everywhere a zero-terminated string appears as a parameter or a
return value, utf8z
is used.
In other words, a zero-terminated UTF-8 string is a different type than a length-specified UTF-8 string. So the error using the wrong one can be caught at compile time, which I think is a huge win.
It isn't always feasible to get this kind of type safety for code down at this level,
because adding a memory allocation would kill performance. But in this case,
ref struct
FTW.
We should allow ourselves to think of a future where .NET programming
is done with UTF-8 instead of UTF-16. Discussion and progress toward a
new Utf8String
type appears to be underway:
https://github.com/dotnet/corefxlab/issues/2368
I am glad that the link above includes the words "like ensuring a null terminator (important for p/invoke scenarios)". Even if we all agree to dislike zero-terminated strings, our need to deal with them is not going away anytime soon.


Loading.css
Tiny loaders and spinners made with only css and one div
Download CSS
View on Github
.ldgBalls
.ldgBar
.ldgBattery
.ldgDualRing
.ldgFlip
.ldgHourglass
.ldgRing
.ldgSignal
.ldgSquare


Streamline your phone operations with artificial intelligence.
Add your first team member and his/her contact information
Customize your company front desk greeting
Thank you for joining OVER.ai. We’ve sent confirmation email to: {{accountRegisterDetails.Email}}
Keep this window open while checking for your code. Haven't received our email? Try your spam folder!


| Title | Author | Author l-f | Additonal Authors | ISBN | ISBN13 | ACM Rating | Average Rating | Publisher | Binding | Number of Pages | Year Published | Original Publication Year | Date Added | Private Notes | Recommended For | Owned Copies |
| Database System Concepts | Abraham Silberschatz | Silberschatz, Abraham | Henry F. Korth, S. Sudarshan |<PHONE_NUMBER> |<PHONE_NUMBER>323 | 0 | 3.76 | McGraw-Hill Education | Hardcover | 1349 | 2010 | 1987 | 4/11/16 | 1 |


High Fidelity ****
Rated on a 4-star scale Screening venue: Odeon (Liverpool City Centre) Released in the UK by Buena Vista International on July 21, 2000; certificate 15; 120 minutes; country of origin USA; aspect ratio 1.85:1
Directed by Stephen Frears; produced by Tim Bevan, Rudd Simmons. Written by John Cusack, D.V. DeVincentis, Steve Pink, Scott Rosenberg; based on the novel by Nick Hornby. Photographed by Seamus McGarvey; edited by Mick Audsley.
CAST..... John Cusack..... Rob Iben Hjejle..... Laura Jack Black..... Barry Todd Louiso..... Dick Lisa Bonet..... Marie Catherine Zeta-Jones..... Charlie Joan Cusack..... Liz Tim Robbins..... Ian
"He's in love with rock 'n' roll, whoa... he's in love with gettin' stoned, whoa... he's in love with Janie Jones, whoa... he don't like his boring job, no!"
It's unsurprising that the song containing those lyrics is on one of Rob's Top Five Lists. Rob drinks and smokes too much, listens to too much loud music, obsesses over too many women, and isn't exactly going places career-wise. This hardly makes him original, but he's easy to identify with.
"High Fidelity" is his story -- that of a pop fan-boy constantly making lists, rearranging LPs and thinking of love songs that relate to his own romantic misadventures. "Never mind what people ARE like, what DO they like?" he philosophises at one point. "Books, movies, music... these things matter."   Barry is one of those know-alls who rams his taste down other guys' throats -- which is annoying most of the time, but also great for business, when he intimidates guys into buying stacks of albums they can barely carry. "What do you mean, you don't have 'Blonde on Blonde'??" he asks one man, making him feel guilty enough to empty his wallet and rebuild his collection.
This is a film about shift work, beer, being hung over on a Monday morning, listening to good tunes, and dating. In the opening scene, Rob's girlfriend Laura (Iben Hjejle) is leaving him for the hippie who used to live next door, which sets off the movie's tone of romantic longing, reminiscing and scheming. There is a plot of sorts -- involving Rob's attempts to reunite with Laura, and his visiting of old girlfriends in a goofy attempt to achieve catharsis with the past -- but "High Fidelity" is not a complicated story, and exists for Rob's musings about relationships, his lists of Top Five Worst Breakups, his silly ways of dealing with heartache. The style of the narration is inspired by another single man's cinema classic, the Michael Caine vehicle "Alfie" (1966), as the protagonist looks straight into the camera to address the audience directly. It's a good device because it's intimate, informal and quirky, and announces that this is a frank and unconventional picture, uncluttered by the usual dumb distractions of romantic comedies, like mistaken identities and aggravated misunderstandings.
Everything is handled so well that we almost forget how badly it could have been done. Rob has a heart-to-heart with Laura's best friend, and she doesn't offer the embarrassing pseudo-psychoanalysis that would be spoken in such typical Hollywood flicks as "Hanging Up". She lays things out in real terms: "There's two of them, there's one of you, and you're all in this mess together -- so sort it out." Later, when Rob lists the worst screw-ups he's perpetrated against Laura, he is able to explain away some of them, but not all, and that rings of absolute truth. Women generally think men are insensitive pigs, men generally think women are nagging, hypocritical and paranoid -- the actuality lies somewhere in between, and "High Fidelity" is brilliant at presenting that middle ground. Its ending is similarly realistic -- Rob and Laura get back together, and Rob's explanation is not an entirely convincing piece of resolution... but don't we all make weird decisions, settle into realities that may not be permanent, and justify situations to ourselves instead of weighing them up?
Cusack, my favourite actor, is perhaps the only man who could have played Rob. His boyish wide eyes and sardonic tone of voice have more of the required bittersweet aura than anyone I can picture. The "High Fidelity" screenwriting team were also behind "Grosse Pointe Blank", one of the best films of 1997, and Stephen Frears, who directed the picture, is a great filmmaker whose credits include "Dangerous Liaisons", "The Snapper" and "Prick Up Your Ears". Yet so many danger signals suggested that this was going to be a disaster. It's based on a wonderful novel -- those usually translate into lousy movies. It's an American adaptation of an English story, which usually results in examples of bland ineptitude like "Thomas and the Magic Railroad". Also, its blunt world view and obsession with pop culture would have easily allowed it to become another obnoxiously hip and cynical rip-off of "Scream" or "Pulp Fiction".
All of those pitfalls have been avoided. This is a wonderful movie about real people, real problems and real fixations, that beautifully captures the texture of alternative culture. It will probably be a modest box-office success, then a huge cult hit on video, where it will be embraced by vinyl junkies, comic book fans, wearers of leather jackets, people who know the 70s were the best decade for American movies, tattoo and body piercing aficionados, twentysomethings who still have their "Star Wars" toys and everyone who loves the Krazy House club on Wood Street. I saw it on the first day of summer, and could really feel the sun come out.
COPYRIGHT(c) 2000 Ian Waldron-Mantgani http://members.aol.com/ukcritic
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Davis Cup Finals Live: Canada vs. Spain
by Sportsnet StaffCanada caps its historic run to the Davis Cup Finals with a showdown against Rafael Nadal and Spain on Sunday in Madrid.
Watch all the action live on Sportsnet ONE and SN NOW, and follow along with all the latest updates on Twitter right here:


{% extends "base_card.html" %} {% set body_classes = "layout-card wide" %} {% block main %}
The web application at {{ domain }}
wants you to log in, but is not communicating securely.
To avoid leaking your identity to eavesdroppers, we have configured the authentication service to forbid logging into insecure web applications.
Websites that talk to your browser using encryption will use addresses that start with https
. The web
application at {{ domain }}
that sent you here asked that we send the result of your login to an address starting with
{{ scheme }}
, which does not provide encrypted communications.
Anyone who can snoop on your connection, for example when you are connected to an unsecured public network, could
capture and store the responses that are sent by this service to web applications using insecure {{ scheme }}
addresses.
At best, an attacker with a capture of a valid authentication response would just find out your username. At worst, they could "replay" the same response to the same web application, and log in as you.
Whether a replay attack like this would be possible can depend on many factors, including how robust and strict the target web application is in its checking of authentication responses, but it is safest to make these attacks impossible in the first place.
{% endblock %} {% block under %}


History of Berkeley SoftFloat, to Release 3e
John R. Hauser
2018 January 20
Release 3e (2018 January)
-
Changed the default numeric code for optional rounding mode
odd
(round to odd, also known as jamming) from 5 to 6.
-
Modified the behavior of rounding mode
odd
when rounding to an
integer value (either conversion to an integer format or a
‘roundToInt
’ function).
Previously, for those cases only, rounding mode odd
acted the same
as rounding to minimum magnitude.
Now all operations are rounded consistently.
-
Fixed some errors in the specialization code modeling Intel x86 floating-point,
specifically the integers returned on invalid operations and the propagation of
NaN payloads in a few rare cases.
-
Added specialization code modeling ARM floating-point, conforming to VFPv2 or
later.
-
Added an example target for ARM processors.
-
Fixed a minor bug whereby function
f16_to_ui64
might return a
different integer than expected in the case that the floating-point operand is
negative.
-
Added example target-specific optimization for GCC, employing GCC instrinsics
and support for 128-bit integer arithmetic.
-
Made other minor improvements.
Release 3d (2017 August)
-
Fixed bugs in the square root functions for 64-bit
double-precision, 80-bit double-extended-precision, and
128-bit quadruple-precision.
For 64-bit double-precision (
f64_sqrt
), the result
could sometimes be off by 1 unit in the last place
(1 ulp) from what it should be.
For the larger formats, the square root could be wrong in a large portion of
the less-significant bits.
(A bug in f128_sqrt
was first reported by Alexei Sibidanov.)
Release 3c (2017 February)
-
Added optional rounding mode
odd
(round to odd, also known as
jamming).
-
Corrected the documentation concerning non-canonical representations in
80-bit double-extended-precision.
Release 3b (2016 July)
-
Implemented the common 16-bit “half-precision”
floating-point format (
float16_t
).
-
Made the integer values returned on invalid conversions to integer formats
be determined by the port-specific specialization instead of being the same for
all ports.
-
Added preprocessor macro
THREAD_LOCAL
to allow the floating-point
state (modes and exception flags) to be made per-thread.
-
Modified the provided Makefiles to allow some options to be overridden from the
make
command.
-
Made other minor improvements.
Release 3a (2015 October)
-
Replaced the license text supplied by the University of California, Berkeley.
Release 3 (2015 February)
-
Complete rewrite, funded by the University of California, Berkeley, and
consequently having a different use license than earlier releases.
Major changes included renaming most types and functions, upgrading some
algorithms, restructuring the source files, and making SoftFloat into a true
library.
-
Added functions to convert between floating-point and unsigned integers, both
32-bit and 64-bit (
uint32_t
and
uint64_t
).
-
Added functions for fused multiply-add, for all supported floating-point
formats except 80-bit double-extended-precision.
-
Added support for a fifth rounding mode,
near_maxMag
(round to
nearest, with ties to maximum magnitude, away from zero).
-
Dropped the
timesoftfloat
program (now part of the Berkeley
TestFloat package).
Release 2c (2015 January)
-
Fixed mistakes affecting some 64-bit processors.
-
Further improved the documentation and the wording for the legal restrictions
on using SoftFloat releases through 2c (not applicable to
Release 3 or later).
Release 2b (2002 May)
-
Made minor updates to the documentation, including improved wording for the
legal restrictions on using SoftFloat.
Release 2a (1998 December)
-
Added functions to convert between 64-bit integers
(
int64
) and all supported floating-point formats.
-
Fixed a bug in all 64-bit-version square root functions except
float32_sqrt
that caused the result sometimes to be off by
1 unit in the last place (1 ulp) from what it should
be.
(Bug discovered by Paul Donahue.)
-
Improved the Makefiles.
Release 2 (1997 June)
-
Created the 64-bit (
bits64
) version, adding the
floatx80
and float128
formats.
-
Changed the source directory structure, splitting the sources into a
bits32
and a bits64
version.
Renamed environment.h
to milieu.h
to avoid confusion
with environment variables.
-
Fixed a small error that caused
float64_round_to_int
often to
round the wrong way in nearest/even mode when the operand was between
220 and 221 and halfway between two integers.
Release 1a (1996 July)
-
Corrected a mistake that caused borderline underflow cases not to raise the
underflow flag when they should have.
(Problem reported by Doug Priest.)
-
Added the
float_detect_tininess
variable to control whether
tininess is detected before or after rounding.
Release 1 (1996 July)
-
Original release, based on work done for the International Computer Science
Institute (ICSI) in Berkeley, California.


Use this rule to forbid trailing spaces at the end of lines.
Examples
When enabled the following code snippet would PASS:
this document doesn't contain any trailing spaces
the following code snippet would FAIL:
this document contains " " trailing spaces on lines 1 and 3 " "


Nicolas Dermine / @nicoder
Wroc_love.rb - March 14th, 2015
the story
Carin Meier
Sam Aaron
Sam Aaron: Live Coder
Sam Aaron: Live Coder
Raspberry Pi
Raspberry Pi
what if?
Sonic Pi
4 reasons why you may want to use Sonic Pi
1. have fun!
2. create music
3. learn
4. teach
the code
play 60 # or `play :C4`
play :c
play :e
play :g
or
play chord(:c, :major)
play :c
sleep 1
play :e
sleep 0.25
play :g
or
play_pattern_timed [:c, :e, :g], [1, 0.25]
3.times do
play :c
sleep 1
end
(and tweaking their params)
use_synth :mod_fm
3.times do
play :c, mod_range: 12
sleep 1
end
(and tweak their params)
with_fx :echo do
3.times do
play :c
sleep 1
end
end
(and play with their rate)
loop do
sample :loop_amen
sleep sample_duration :loop_amen
end
live_loop :first_loop do
sample :loop_amen
sleep sample_duration :loop_amen
end
live_loop :second_loop do
sync :first_loop
sample :bass_dnb_f
end
thank you!


Toggle navigation
No card paired
slimduet Cold Wallet SIM Card activities
card id:
×
Information
In this page, we will show you last 100 SIM activities.
You may cancel the jobs which status is "Init" by checking the items and clicking the
icon
Activities
1-50/200
Time
Wallet name
Task
Status


|
GNSDK C API Reference
<IP_ADDRESS>2
|
Macros | |
| #define | GNSDK_GDO_CHILD_ALBUM GNSDK_GDO_TYPE_ALBUM"!" |
| #define | GNSDK_GDO_CHILD_AUDIO_WORK GNSDK_GDO_TYPE_AUDIO_WORK"!" |
| #define | GNSDK_GDO_CHILD_MATCH_INFO GNSDK_GDO_TYPE_MATCH_INFO"!" |
| #define | GNSDK_GDO_CHILD_TRACK GNSDK_GDO_TYPE_TRACK"!" |
| #define | GNSDK_GDO_CHILD_TRACK_BY_NUMBER GNSDK_GDO_TYPE_TRACK"!number" |
| #define | GNSDK_GDO_CHILD_TRACK_MATCHED GNSDK_GDO_TYPE_TRACK"!matching" |
| #define GNSDK_GDO_CHILD_ALBUM GNSDK_GDO_TYPE_ALBUM"!" |
Retrieves a child album type.
Remarks:
Key is used as parameter for gnsdk_manager_gdo_child_get
to retrieve child GNSDK_GDO_TYPE_ALBUM GDOs. The ordinal parameter for gnsdk_manager_gdo_child_get
with this key indicates the n'th child album to retrieve. Album types are generally available from GNSDK_GDO_TYPE_RESPONSE_ALBUM GDOs.
Definition at line 912 of file gnsdk_manager_gdo.h.
| #define GNSDK_GDO_CHILD_AUDIO_WORK GNSDK_GDO_TYPE_AUDIO_WORK"!" |
Retrieves a child audio work type.
Definition at line 1011 of file gnsdk_manager_gdo.h.
| #define GNSDK_GDO_CHILD_MATCH_INFO GNSDK_GDO_TYPE_MATCH_INFO"!" |
Definition at line 3127 of file gnsdk_manager_gdo.h.
| #define GNSDK_GDO_CHILD_TRACK GNSDK_GDO_TYPE_TRACK"!" |
Retrieves a child track type.
Remarks:
Key is used as parameter for gnsdk_manager_gdo_child_get
to retrieve child GNSDK_GDO_TYPE_TRACK GDOs. The ordinal parameter for gnsdk_manager_gdo_child_get
with this key indicates the n'th child track to retrieve. Track types are generally available from GNSDK_GDO_TYPE_ALBUM GDOs.
Definition at line 924 of file gnsdk_manager_gdo.h.
| #define GNSDK_GDO_CHILD_TRACK_BY_NUMBER GNSDK_GDO_TYPE_TRACK"!number" |
Retrieves a child track type matching the given track number.
Remarks:
Key is used as parameter for gnsdk_manager_gdo_child_get
to retrieve child GNSDK_GDO_TYPE_TRACK GDOs. The ordinal parameter for gnsdk_manager_gdo_child_get
with this key indicates the track number of the child track to retrieve.
Track types are generally available from GNSDK_GDO_TYPE_ALBUM GDOs.
Definition at line 936 of file gnsdk_manager_gdo.h.
| #define GNSDK_GDO_CHILD_TRACK_MATCHED GNSDK_GDO_TYPE_TRACK"!matching" |
Retrieves a child track type that was matched. GNSDK_GDO_CHILD_TRACK_MATCHED
Remarks:
Key is used as parameter for gnsdk_manager_gdo_child_get to retrieve child GNSDK_GDO_TYPE_TRACK GDOs. The ordinal parameter for gnsdk_manager_gdo_child_get with this key indicates the n'th matching child track to retrieve. A child track is marked matching for some queries that can match to a specific track. It is not always the case that there will be child track types marked as matching available. Track types are generally available from GNSDK_GDO_TYPE_ALBUM GDOs.
Definition at line 950 of file gnsdk_manager_gdo.h.
How can we improve this topic?
Copyright © 2000-present. Gracenote, Inc. All rights reserved. Generated on Tue Jan 8 2013 07:40:57.


Welcome to the one and only amazing Pat's Salom Cookies!!! These Wonderful Salom Cookies have over 30g of protien and have about 1/2 of a ORGANIC baby chinnok salmon. We pride our self on only bringing you the best of the best and that starts with making the people around us "happy"
- 1st and Pike
- Open 6am - 8pm -- Contact Us!
- SeaTac Airport
- Open 6am - 8pm -- Contact Us!
- Seattle Center
- Open 6am - 8pm -- Contact Us!
- Capitol Hill
- Open 6am - 8pm -- Contact Us!
- Alki
- Open 6am - 8pm -- Contact Us!


discord: zxvnme#2598
<EMAIL_ADDRESS>github.com/zxvnme
struct info {
hello friend, hello friend?
im Igor. im 16 yo, im bmx rider, linux enthusiast,
pixelart newbie ... and most of all - node and cpp programmer.
programming is a hobby that gives me the biggest satisfaction thusly making my code optimized and realiable.
if you have any questions, problems or business affairs - contact me through e-mail. i'll do my best to respond ASAP.
}


{% extends 'base.html' %} {% block title %}The Scorched Coast{% endblock %} {% block extracss %} h1, h2, h3, h4 { color: #f5a228; } a, .hex:hover .location a.permalink { color: #d89014; } img#hexmap { margin-left: -172px; } {% endblock %} {% block header %}
Life in the Scorched Coast has risen from the ashes of the Great Burn. Its form is odd and twisted: scrappy human survivors and those who became something more or less, archaoetech wizards, relic-intelligences, and slumbering powers unimaginable. Now they scour the desert dust for treasures of a bygone era.
I helped the mysterious mista tipsta and his friends turn their own attempt at a crowd sourced hexcrawl into a web page. As one does. This page is based on work I did for the Hexenbracken. Contributors: {{ authors }}.


Vue-headroom is a vue component to let headroom work with vue. The original idea of headroom come from headroom.js. vue-headroom heavily inspired by headroom.js and react-headroom.
Installation
npm install vue-headroom
Vue-headroom is a vue component to let headroom work with vue. The original idea of headroom come from headroom.js. vue-headroom heavily inspired by headroom.js and react-headroom.
npm install vue-headroom


| Class | Description |
|---|---|
| ChunkOutputStream |
Class to help application that are built to write to an
OutputStream to chunk the content
|
| HttpServerPipelineFactory |
The
ChannelPipelineFactory which is used to serve HTTP Traffic. |
| HttpsServerPipelineFactory |
HttpServerPipelineFactory subclass which enable the use of HTTPS |
| NettyHttpRequest |
Abstraction for an inbound http request on the server, or a response from a server to a client
We have this abstraction so that we can reuse marshalling objects in a client framework and serverside framework
|
| NettyHttpResponse | |
| NettyJaxrsServer |
An HTTP server that sends back the content of the received HTTP request
in a pretty plaintext form.
|
| NettySecurityContext | |
| NettyUtil | |
| RequestDispatcher |
Helper/delegate class to unify Servlet and Filter dispatcher implementations
|
| RequestHandler |
SimpleChannelUpstreamHandler which handles the requests and dispatch them. |
| RestEasyHttpRequestDecoder |
This
OneToOneDecoder is responsible for decode HttpRequest
to NettyHttpRequest 's
This implementation is ChannelHandler.Sharable |
| RestEasyHttpResponseEncoder |
OneToOneEncoder implementation which encodes HttpResponse 's to
HttpResponse 's
This implementation is ChannelHandler.Sharable |
| Enum | Description |
|---|---|
| RestEasyHttpRequestDecoder.Protocol |
Copyright © 2014. All Rights Reserved.


Prince Andrew's BBC interview 'could one day be used against him in court'
A solicitor has warned that comments made by the Duke of York about the serious allegations against him could come back to haunt the under-fire royal
by Luke PowellComments made by the Duke of York about the allegations he has faced could one day be used against him in court, a solicitor has warned.
Anna Rothwell, from the criminal law firm Corker Binning, said she would "never advise" her clients to speak publicly about their allegations if they were under investigation.
She said Andrew's attempt to try to publicly defend his reputation on BBC Newsnight in the wake of Jeffrey Epstein sex scandal was "pretty disastrous".
"I think talking full stop in circumstances where you are under investigation is unwise," Ms Rothwell said.
"He didn't have a full answer for quite a number of aspects he was questioned about.
"Anything he has said, if he were to be prosecuted, could be used to cross-examine him.
"The less you say, the better, and that is often why you advise people to answer 'no comment' at the police station."
In September, the Sunday Times reported the FBI had expanded its investigation to identify alleged human trafficking victims of Epstein.
Citing unidentified sources from the US Department of Justice, the newspaper said the FBI was looking to "several" potential victims in the hope they can provide more details about Andrew and his involvement in the case.
Ms Rothwell said the duke's position as a royal would not entitle him to "any form of immunity" and he was "vulnerable to extradition".
She said any attempts by the US to seek extradition would "likely cause a diplomatic incident".
Andrew said in his televised interview on Saturday he had no regrets about his friendship with convicted paedophile Epstein, who was found dead in his prison cell earlier this year while facing sex trafficking charges.
He also faced questions about Virginia Giuffre, formerly known as Roberts, who is one of 16 women who claim they were abused by disgraced financier Epstein.
Mrs Giuffre has alleged in court documents she "was forced to have sexual relations with this prince when she was a minor".
She said they had sex in London and New York and she alleged that later, when she was aged 18, they had sex again on a private Caribbean island owned by Epstein where an orgy took place.
Her allegations were struck from US civil court records in 2015 after a judge said they were "immaterial and impertinent".
The duke denied sleeping with Mrs Giuffre on three separate occasions when quizzed by Newsnight presenter Emily Maitlis.
Asked if he regretted the "whole friendship with Epstein", Andrew said: "Now, still not, and the reason being is that the people that I met and the opportunities that I was given to learn either by him or because of him were actually very useful."


My mission is to change the way people view nutrition and medicine. My method is to gather and share the knowledge of sustainable economic, agricultural, gastronomic, and herbal therapeutic practices. I will accomplish this through the use of tech.


By using this webpage, you agree to connect to Wikimedia Foundation servers in order to serve article content. That's literally it.
Featured article symbol: Wikimedia users ClockworkSoul, CyberSkull, Optimager, White Cat, Erina, AzaToth, Pbroks13., LGPL <
http://www.gnu.org/licenses/lgpl.html>, via Wikimedia Commons. Not hosted locally.


DfE enquiries
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
News story
The Deputy Prime Minister announces a new summer school programme for disadvantaged pupils who are due to start secondary school.
The Deputy Prime Minister today announced a new £50 million pupil premium summer school programme to help the most disadvantaged pupils make the transition from primary to secondary school. The scheme will benefit up to 100,000 pupils per year. They will benefit from two weeks of additional teaching through the scheme.
Pupils can struggle to make the jump to secondary education. Moving to a larger school and having to tackle a more challenging curriculum can be daunting for some pupils and they can suffer as a consequence. This results in a dip in their performance, which can persist throughout their time at school.
The new summer schools will allow schools to pick the pupils in danger of falling back and provide them with two weeks of support and catch-up, so that they start secondary school ready to learn.
All pupils eligible for free school meals who are making the transition between primary and secondary school in September 2012 will attract the extra funding. Schools will make a judgement on which pupils need extra support in making the transition.
Deputy Prime Minister, Nick Clegg, said:
Too many pupils experience a dip in performance when they start secondary school. More worryingly, pupils from the poorest backgrounds are the most likely to struggle, meaning that they can underperform throughout their time at school.
What matters is how hard you work and the skills and talents you possess, not the school you went to or the jobs your parents did.
Our new summer school scheme will allow schools to provide support to those pupils most at risk of falling behind. It simply isn’t fair to ignore them, and that is why this Government is intervening to ensure that pupils from the poorest background have the opportunity to succeed.
Michael Gove, Education Secretary, said:
The mission of this coalition government is to make opportunity more equal. We want to take every step to achieve that.
These summer schools are designed to offer additional help to those in need at a crucial time. Nick Clegg is to be applauded as a champion of new ideas to drive forward social mobility.
The Government is making up to £50 million available in 2012/13 for this activity. This will be part of the overall Pupil Premium funding which is being significantly increased next year to £1.25 billion. The remaining £1.2 billion will be allocated per pupil and more detail will be set out in the 2012/13 school funding settlement that we will publish later in the autumn.
There is evidence that summer schools can have a positive impact on students. Summer schools will provide an opportunity for pupils moving up to secondary schools to get additional support tailored to their needs and based on evidence of what will have the greatest benefit before they arrive at their new school.
This scheme is part of the Government’s efforts to narrow the gaps in attainment between those from poorer backgrounds and their better off counterparts. As highlighted in the Government’s social mobility strategy, these gaps in attainment emerge early and widen as children get older.
The pupil premium budget for 2011/12 is £625 million.
Sarah Teather, Minister of State for Children and Families, recently announced the pupil premium budget for 2012/13 will be £1.25 billion. The £50 million will be funded from this amount.
The schemes will run from 2012/13 and then continue every year.
£50 million will be provided to schools through the pupil premium to run summer schools in summer 2012.
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Website: www.education.gov.uk/help/contactus
Published: 5 March 2013


functionPlot({
target: '#quadratic',
data: [{
fn: 'x^2'
}]
})
Additionally the graph can have the following options defined on the top level object:
title
: the title of the graphwidth
: width of the graphheight
: height of the graphxAxis
:type
: the type of scale for this axis, possible values linear|log
(default value: 'linear'
)label
: x axis labeldomain
: x axis possible values (see examples below)yAxis
: same options as xAxis
disableZoom
: true to disable translation/scaling on the graphfunctionPlot({
title: 'y = x * x',
target: '#quadratic-with-options',
width: 580,
height: 400,
disableZoom: true,
xAxis: {
label: 'x - axis',
domain: [-6, 6]
},
yAxis: {
label: 'y - axis'
},
data: [{
fn: 'x^2'
}]
})
Set grid: true
in the options sent to function plot
functionPlot({
target: '#grid',
xAxis: {
label: 'real'
},
yAxis: {
label: 'imaginary'
},
grid: true,
data: [
{ fn: 'sqrt(1 - x * x)' },
{ fn: '-sqrt(1 - x * x)' }
]
})
The domains of both axes can be changed with the following configurations:
xDomain
, defaults to [-7, 7]
yDomain
, keeps a 1:1 aspect ratio relative to xDomain
, by default it's computed
with the following formula$$ yDiff = \frac{height * (xDomain[1] - xDomain[0])}{width} $$
NOTE: The origin is at the center of the graph by default so $yDiff$ is split in half and distributed evenly to the $\pm y$ axis
functionPlot({
target: '#domain',
yAxis: {domain: [-1, 1]},
xAxis: {domain: [8, 24]},
data: [{
fn: 'sin(x)'
}]
})
nSamples
determine the number of equally spaced points in which the function will be
evaluated in the current domain, increasing it will more accurately represent the function
using rectangles at the cost of processing speed
e.g. nSamples = 100
$$ domain = [-5, 5] \ values = -5, -4.9, -4.8, \ldots, 4.8, 4.9, 5.0 $$
$$ domain = [-10, 10] \ values = -10, -9.8, -9.6, \ldots, 9.6, 9.8, 10 $$
functionPlot({
target: '#samples',
data: [{
fn: 'sin(x)',
nSamples: 1000
}]
})
Parallel lines to the y-axis or x-axis can be set in the annotations
option:
x
: x coordinate of a line parallel to the y-axisy
: y coordinate of a line parallel to the x-axistext
(optional) text shown next to the parallel lineNOTE: either x
or y
need to be set on the object, setting both of them
will raise an exception
functionPlot({
target: '#annotations',
yAxis: {domain: [-1, 9]},
data: [{
fn: 'x^2'
}],
annotations: [{
x: -1
}, {
x: 1,
text: 'x = 1'
}, {
y: 2,
text: 'y = 2'
}]
})
The x
values of the function will be taken from the current viewport limits,
however you can define a custom range so that the function is evaluated only within this
range, this works really nice with the closed
option which will will render an area graph
instead of a polyline, for example we can render a definite integral
range
{Array} A 2-number array, the function will be evaluated only within this rangeclosed
: true to render a closed path, y0
will always be 0 and y1
will be $fn(x)$functionPlot({
target: '#closed',
xAxis: {domain: [-2, 12]},
data: [{
fn: '3 + sin(x)',
range: [2, 8],
closed: true
}]
})
The type of each axis can be configured to be logarithmic by specifying the
type of axis to log
inside the xAxis
option, note how this
change affects the way the functions are sampled
var instance = functionPlot({
target: '#logarithmic',
xAxis: {
type: 'log',
domain: [0.01, 1]
},
yAxis: {
domain: [-100, 100]
},
grid: true,
data: [{
fn: '1/x * cos(1/x)',
// to make it look like a definite integral
closed: true
}]
})
data
as seen in the examples above is an array, which means that multiple
functions can be rendered in the same graph
You can also change the color of each graph, by default the colors are set from
functionPlot.globals.COLORS
but you can override the color by setting the color
option
in each datum
functionPlot({
target: '#multiple',
data: [
{ fn: 'x', color: 'pink' },
{ fn: '-x' },
{ fn: 'x * x' },
{ fn: 'x * x * x' },
{ fn: 'x * x * x * x' }
]
})
There are three ways to represent a function in function-plot
polyline
where $f(x)$ is evaluated with some $x$ values, after the evaluation the points are joined with line segments using
<path>
sscatter
where $f(x)$ is evaluated with some $x$ values, after the evaluation the points are represented by <circle>
sinterval
where $f(x)$ is evaluated with intervals instead of a single point, after the evaluation 2d rects
are painted on the screen (done using the <path>
svg element)Set the type of graph you want to render in the option graphType
(defaults to interval
)
functionPlot({
target: '#graph-types',
data: [{
fn: '-sqrt(-x)',
nSamples: 100,
graphType: 'scatter'
}, {
fn: 'sqrt(x)',
graphType: 'polyline'
}, {
fn: 'x^2',
graphType: 'interval'
}]
})
The little circle that has the x-coordinate of the mouse position is called a "tip", the following options can be configured:
xLine
true to show a dashed line parallel to $y = 0$ on the tip positionyLine
true to show a dashed line parallel to $x = 0$ on the tip positionrenderer
a custom rendering function for the text shown in the tipNOTE: the tip only works with linear functions
When you don't want a function to have a tip add the skipTip: true
property to the object
that holds the info of the function to render
functionPlot({
target: '#tip',
tip: {
xLine: true, // dashed line parallel to y = 0
yLine: true, // dashed line parallel to x = 0
renderer: function (x, y, index) {
// the returning value will be shown in the tip
}
},
yDomain: [-1, 9],
data: [
{ fn: 'x^2' },
{
fn: 'x',
skipTip: true
}
]
})
Plotting roots can be a challenging problem, most plotters will actually
analyze expression of the type $x^{\tfrac{a}{b}}$, particularly they will
analyze the denominator of the exponent (to plot in the negative x-axis),
interval-arithmetic and math.js come bundled with a useful nthRoot
function to solve these issues
functionPlot({
target: '#root-finding',
data: [{
fn: 'nthRoot(x, 3)^2'
}]
})
If a data object has a secants
array, then each object will be used to compute
secant lines between two points belonging to the function, additionally if updateOnMouseMove
is a property set to true
in the object then $(x_0, f(x_0))$ will be used as an anchored point
and $(x_1, f(x_1))$ will be computed dynamically based on the mouse abscissa
Available options for each object:
x0
the abscissa of the first pointx1
*(optional if updateOnMouseMove
is set) the abscissa of the second pointupdateOnMouseMove
(optional) if set to true
x1
will be computed dynamically based on the current
position of the mousefunctionPlot({
target: '#secant',
yAxis: {domain: [-1, 9]},
xAxis: {domain: [-3, 3]},
data: [{
fn: 'x^2',
secants: [
{ x0: 1, x1: 3 },
{ x0: 1, x1: 2.5 },
{ x0: 1, x1: 2 }
]
}]
})
An example where updateOnMouseMove
is set in two secant lines, each line will be computed on the
dynamically based on the current position of the mouse
functionPlot({
target: '#secant-update',
yDomain: [-1, 9],
data: [{
fn: 'x^2',
secants: [{
x0: 2,
updateOnMouseMove: true
}, {
x0: -2,
updateOnMouseMove: true
}]
}]
})
If a data object has a derivative
object then its property fn
will be used to compute
the equation of the line tangent to the point x0
, i.e. the point $(x_0, f(x_0))$
(the derivative is a function which gives the slope of the tangent line at any derivable point)
Available options for the derivative
object:
fn
The function that is the first derivative of data.fn
x0
(optional if updateOnMouseMove
is set) the abscissa of the point belonging to the curve
whose tangent will be computedupdateOnMouseMove
if set to true
x1
will be computed dynamically based on the current
position of the mousefunctionPlot({
target: '#derivative',
yAxis: {domain: [-1, 9]},
data: [{
fn: 'x^2',
derivative: {
fn: '2 * x',
x0: 2
}
}]
})
if updateOnMouseMove
is set to true then tangent line is computed whenever the mouse is moved
inside the canvas (let $x_0$ be the mouse's abscissa then the tangent line to the point
$(x_0, f(x_0))$ is computed whenever the position of the mouse changes)
functionPlot({
target: '#derivative-update',
yAxis: {domain: [-1, 9]},
data: [{
fn: 'x^2',
derivative: {
fn: '2 * x',
updateOnMouseMove: true
}
}]
})
An example of a graph with multiple functions, each function is configured with
a derivative
object with auto update of the slope as described above
functionPlot({
target: '#derivative-update-multiple',
data: [{
fn: 'x * x',
derivative: {
fn: '2 * x',
updateOnMouseMove: true
}
}, {
fn: 'x * x * x',
derivative: {
fn: '3 * x * x',
updateOnMouseMove: true
}
}]
})
Multiple graphs can be linked, when the tip's position, graph scale or
graph translate properties are modified on the original graph the linked
graphs are signaled with the same events, in the following example a
also fires the internal all:zoom
event, the zoom
operation is performed
on a
and b
, but when b
fires the all:zoom
event the zoom operation is only
performed on b
a = functionPlot({
target: '#linked-a',
height: 250,
xAxis: {domain: [-10, 10]},
data: [{ fn: 'x * x' }]
})
b = functionPlot({
target: '#linked-b',
height: 250,
xAxis: {domain: [-10, 10]},
data: [{ fn: '2 * x' }]
})
a.addLink(b)
Since the zoom
event is dispatched to all the linked graphs, one can
set as many linked graphs as wanted and all of them will perform the same
zoom operation, in the following example these functions are plotted:
a = functionPlot({
target: '#linked-a-multiple',
height: 250,
xAxis: {domain: [-10, 10]},
data: [{ fn: 'x * x' }]
})
b = functionPlot({
target: '#linked-b-multiple',
height: 250,
xAxis: {domain: [-10, 10]},
data: [{ fn: '2 * x' }]
})
c = functionPlot({
target: '#linked-c-multiple',
height: 250,
xAxis: {domain: [-10, 10]},
data: [{ fn: '2' }]
})
a.addLink(b, c)
b.addLink(a, c)
c.addLink(a, b)
To update a graphic one needs to call functionPlot
on the same target
element with any object that is configured properly
var options = {
target: '#quadratic-update',
data: [{
fn: 'x'
}]
};
$('#update').click(function () {
if (!options.title) {
// add a title, a tip and change the function to y = x * x
options.title = 'hello world';
options.tip = {
xLine: true,
yLine: true
};
options.data[0] = {
fn: 'x * x',
derivative: {
fn: '2 * x',
updateOnMouseMove: true
}
}
} else {
// remove the title and the tip
// update the function to be y = x
delete options.title;
delete options.tip;
options.data[0] = {
fn: 'x'
}
}
functionPlot(options)
})
// initial plot
functionPlot(options)
Some functions are not defined under some range of values, for example the function $f(x) = \frac{1}{x}$ is undefined when $x = 0$, the library identifies these kind of peaks and there's no need to explicitly tell these asymptotes
functionPlot({
target: '#function-continuity',
data: [{
fn: '1 / x',
derivative: {
fn: '-1 / x / x',
updateOnMouseMove: true
}
}]
})
Plotting $f(x) = tan(x)$ which has many vertical asymptotes
functionPlot({
target: '#function-continuity-tan-x',
data: [{
fn: 'tan(x)',
derivative: {
fn: '1 / (cos(x) ^ 2)',
updateOnMouseMove: true
}
}]
})
Consider plotting the function
$$ x^2 + y^2 = 1 $$
which is the equation of a circle of radius 1, unfortunately $y$ is not expressed in terms of $x$ and
function-plot
needs an equation in the form $y = f(x)$, solving for $y$ we get:
$$ y = \pm\sqrt{1 - x^2} $$
Which raises two functions
$$ y = \sqrt{1 - x^2} \quad and \quad y = -\sqrt{1 - x^2} $$
functionPlot({
target: '#circle-explicit',
yAxis: {domain: [-1.897959183, 1.897959183]},
xAxis: {domain: [-3, 3]},
data: [
{ fn: 'sqrt(1 - x * x)' },
{ fn: '-sqrt(1 - x * x)' }
]
})
The original equation of the circle $x^2 + y^2 = 1$ can be parametrized as
$$ x = cos(t) \\ y = sin(t) $$
For $0 \leq t \leq 2 \pi$
The options that tell function-plot
to render a parametric equation are defined
inside each term of the data
array and need to have the following properties set:
fnType: 'parametric'
to mark this term as a parametric equationx
the x-coordinate of a point to be sampled with a parameter t
y
the y-coordinate of a point to be sampled with a parameter t
range = [0, 2 * Math.PI]
the range
property in parametric equations is used
to determine the possible values of t
, remember that the number of samples is
set in the property nSamples
NOTE: function-plot
uses interval-arithmetic by default, to create a nice line
instead of rectangles generated by the interval-arithmetic sampler set
graphType: 'polyline'
which uses the normal single point evaluation
functionPlot({
target: '#parametric-circle',
yAxis: {domain: [-1.897959183, 1.897959183]},
xAxis: {domain: [-3, 3]},
data: [{
x: 'cos(t)',
y: 'sin(t)',
fnType: 'parametric',
graphType: 'polyline'
}]
})
Let's render the famous equation of the butterfly curve using parametric equations, the equations are:
$$ x = sin(t)(e^{cos(t)} - 2cos(4t) - sin(\tfrac{t}{12})^5) \\ y = cos(t)(e^{cos(t)} - 2cos(4t) - sin(\tfrac{t}{12})^5) $$
functionPlot({
target: '#butterfly-curve',
yAxis: {domain: [-4.428571429, 4.428571429]},
xAxis: {domain: [-7, 7]},
data: [{
x: 'sin(t) * (exp(cos(t)) - 2 cos(4t) - sin(t/12)^5)',
y: 'cos(t) * (exp(cos(t)) - 2 cos(4t) - sin(t/12)^5)',
range: [-10 * Math.PI, 10 * Math.PI],
fnType: 'parametric',
graphType: 'polyline'
}]
})
The original equation of the circle $x^2 + y^2 = 1$ can be expressed with the following polar equation
$$ r = r_0 ; cos(\theta - \gamma) + \sqrt{a^2 -r_0^2 sin^2(\theta - \gamma)} $$
Where $\theta$ is the polar angle, $a$ is the radius of the circle with center $(r_0, \gamma)$
The options that tell function-plot
to render a polar equation are defined
inside each term of the data
array and need to have the following properties set:
fnType: 'polar'
to tell function plot to render a polar equationr
a polar equation in terms of theta
range = [-Math.PI, Math.PI]
the range
property in polar equations is used
to determine the possible values of theta
, remember that the number of samples is
set in the property samples
NOTE: function-plot
uses interval-arithmetic by default, to create a nice line
instead of rectangles generated by the interval-arithmetic sampler set
graphType: 'polyline'
which uses the normal single point evaluation
functionPlot({
target: '#polar-circle',
yAxis: {domain: [-1.897959183, 1.897959183]},
xAxis: {domain: [-3, 3]},
data: [{
r: 'r0 * cos(theta - gamma) + sqrt(a^2 - r0^2 * (sin(theta - gamma))^2)',
scope: {
a: 1,
r0: 0,
gamma: 0
},
fnType: 'polar',
graphType: 'polyline'
}]
})
Rendering the equation of the polar rose
$$ r = 2 sin(4 \theta) $$
functionPlot({
target: '#polar-complex',
yAxis: {domain: [-1.897959183, 1.897959183]},
xAxis: {domain: [-3, 3]},
data: [{
r: '2 * sin(4 theta)',
fnType: 'polar',
graphType: 'polyline'
}]
})
The equation of a circle of radius 1 $x^2 + y^2 = 1$ expressed in an explicit way is:
$$ y = \sqrt{1 - x^2} \quad and \quad y = -\sqrt{1 - x^2} $$
This library can also plot implicit equations with the only requirement of making the equation
equal to zero and adding the option implicit
(the sampler expects that the function
depends on the variables $x$ and $y$)
$$ 0 = x^2 + y^2 - 1 $$
To render implicit equations you have to make sure of the following:
fn(x, y)
means that the function fn
needs to be expressed in terms of x
and y
fnType: 'implicit'
is set on the datum that is an implicit equationNOTE: implicit functions can only be rendered with interval-arithmetic
functionPlot({
target: '#circle-implicit',
yAxis: {domain: [-1.897959183, 1.897959183]},
xAxis: {domain: [-3, 3]},
data: [{
fn: 'x * x + y * y - 1',
fnType: 'implicit'
}]
})
Consider the following equation
$$ cos(\pi x) = cos(\pi y) $$
It's impossible to find an explicit version of it because we would need an infinite number of functions, however for a finite region of the plane a finite number of functions suffice
functionPlot({
target: '#implicit-complex',
yAxis: {domain: [-3.795918366, 3.795918366]},
xAxis: {domain: [-6, 6]},
disableZoom: true,
data: [{
fn: 'cos(PI * x) - cos(PI * y)',
fnType: 'implicit'
}]
})
To plot a collection of points or a polyline the following options are required:
points
An array of coordinates, each coordinate is represented by a 2-element arrayfnType: 'points'
to tell function plot that the data is already available on points
Note that you can use either scatter
or polyline
in the option graphType
functionPlot({
target: '#points',
data: [{
points: [
[1, 1],
[2, 1],
[2, 2],
[1, 2],
[1, 1]
],
fnType: 'points',
graphType: 'scatter'
}]
})
functionPlot({
target: '#polyline',
data: [{
points: [
[1, 1],
[2, 1],
[2, 2],
[1, 2],
[1, 1]
],
fnType: 'points',
graphType: 'polyline'
}]
})
To render 2d vectors set the following on each datum
vector
{Array} the vector itselfoffset
(optional) {Array} displacement from the originfnType: 'vector'
to tell functoin plot that the data is already available on vector
graphType: 'polyline'
to render a nice segment from offset
to offset + vector
functionPlot({
target: '#vector',
xAxis: {domain: [-3, 8]},
grid: true,
data: [{
vector: [2, 1],
offset: [1, 2],
graphType: 'polyline',
fnType: 'vector'
}]
})
function-plot
uses interval-arithmetic math by default, unfortunately some functions are
not implemented yet because of the underlying complexity, for this reason you can always
evaluate a function with ,
to do so make sure that you include math.js
before function-plot
<script src="//cdnjs.cloudflare.com/ajax/libs/mathjs/1.5.2/math.min.js"></script>
And then set the following:
sampler: 'builtIn'
the parser bundled with function-plot will be replaced with the one
in math.jsgraphType: 'polyline'
or graphType: 'scatter'
functionPlot({
target: '#sampler-mathjs',
disableZoom: true,
data: [{
fn: 'gamma(x)',
sampler: 'builtIn',
graphType: 'polyline'
}]
})
functionPlot({
target: '#sampler-tan-mathjs',
data: [{
fn: 'tan(x)',
nSamples: 4000,
sampler: 'builtIn',
graphType: 'polyline'
}]
})
All of the examples above used a string in the property to evaluate e.g.
// n
functionPlot({
data: [{
fn: 'x^2'
}]
})
You can use a function instead of a string, the input will vary depending
on the type of fnType
For any case the input will be a single object and its properties will be the same
as the ones the function depends on, e.g. when fnType: 'polar'
then the
function depends on theta
so theta
will be a property in the input
object
if you want to use any other plotter your function is expected to return a single value (commonly used)
if you want to use the interval arithmetic plotter your function is expected to return an object with the properties hi, lo (rarely used unless you want to make computations with an interval arithmetic library)
functionPlot({
target: '#built-in-eval-function',
data: [{
// force the use of builtIn math
graphType: 'polyline',
fn: function (scope) {
// scope.x = Number
var x = scope.x
return x * x
}
}, {
fnType: 'polar',
graphType: 'polyline',
r: function (scope) {
// scope.theta = number
var r0 = 0
var a = 1
var gamma = 0
return r0 * Math.cos(scope.theta - gamma) +
Math.sqrt(a * a - r0 * r0 * Math.pow(Math.sin(scope.theta - gamma), 2))
}
}]
})
functionPlot({
target: '#interval-arithmetic-eval-function',
data: [{
// uses interval arithmetic by default
fn: function (scope) {
// scope.x = {lo: Number, hi: number}
// simulate a line e.g. y = x
return {
lo: scope.x.lo,
hi: scope.x.hi
}
}
}]
})
})
$('#recipes').load('partials/recipes.html')
$('#examples').load('partials/examples.html', function () {
$(document).trigger('markupLoaded')
$('pre code').each(function (i, block) {
hljs.highlightBlock(block)
})
$('#p-slider').on('change', function () {
var value = +this.value;
$('#p-slider-value').html(value)
})
})
Plotting a curve
The shortest example, the function $y = x^2$ is evaluated with values inside the range defined by the canvas size (the default dimensions are
550x350
)The required parameters are:
target
a selector to the node to hold the graphdata
an array of objects which contain info about the functions to renderdata.fn
(string) a mathematical expression to render, it's parsed and evaluated using interval-arithmeticThe syntax of the string that represent the mathematical expression is just like ECMAScript however the
^
operator has been replaced withpow
and there's no namespace for the functions to be evaluated


Infographics
I can visualize and explain almost every subject in an easy way. I make world more understandable.
Ask for more
I can visualize and explain almost every subject in an easy way. I make world more understandable.
Ask for more
I animate every content with pleasure and notion. Video materials are attractive in perception, easy to understand and have incredible influence potential.
Ask for more
Are you bored with repetitious slides? I’ am willing to help you! How? Visually! I visualize data and information in attractive way, interestingly!
Ask for more
I can help to find yourself in every space and create positive connotations.
Ask for more
I give people the chance to acknowledge particular place and enhance their freedom of movement there.
Ask for more
Are you wondering what to do with complicated forms? Visualize it – in simple and readable way. I prove that forms can be friendly in perception.
Ask for more
I think fast and speak shortly. I create shortcuts. I enable to understand the environment with an clear and understandable visual language.
Ask for more
I come to rescue those lost in time. I visualize necessary data in an useful way. Everyone can navigate with me.
Ask for more
I want to impress you with simple and esthetic form of information. See whom I impressed so far.
If you want your data or information to draw the crowd's attention,
you are in the right place.
Lęborska street 3b
80–386, Gdańsk, Poland
<EMAIL_ADDRESS>Blog Forum Gdańsk is an interdisciplinary conference, which takes place in Gdańsk every year since 2010. In 2012 the main topic of the conference were practical skills which come along with from blogging.
Organizing Committee of Blog Forum Gdańsk had definitely challenged me. My task was to create an infographic which shows most popular polish bloggers. They were selected on the basis of the analysis prepared using the tools by Brand 24 and Sotrender. I dedicated long hours of my conceptual and design projecting work to this task. I decided to portray bloggers as individuals who lived on thematically selected islands. The final map consist of 6 big and 10 little islands floating on Yotube Mare. They are as follow: The Lifestyle Island inhabited by 14 bloggers, Hobby Island, of 4 people, 3 people living on Facebook Island, 13 on Technology Island, 2 in Corporate Land and 4 in Political Jungle.
Every blogger has his own icon with his image, which is located on his part of the island as a geotag. I have done my best to capture characteristically features of each of them. In addition I designed pictograms for each area of the island. The Peninsula of Apple is symbolized with characteristic half - bite apple with monocle, The Gorge of Culinary is depicted with Mr. Pot, who evade his lid like a hat. I created 19 graphics of this type. Adding the50 portrays of bloggers, give us 69 unique icons altogether.
For the request of City Council in Sopot I created an unique budget bulletin based on infographics. It is citizens-friendly thanks to the Sopoccy family, who guide the reader through. It’s a multigenerational family, and they describe city budget through their interests and their actual life stage and position. Each of them has one card, where city expenses which he or she benefits from are described.
BBudget is a complicated document and it took me many hours to untangle the financial puzzles. I’m proud of final effect, which is 8 slides dedicated to city expenses illustrated by means of icons and graphics. Even seemingly boring subject as budget can be attractively presented. Of course thanks to visualization!
Such brochure can be used in many ways. I recommend it especially for online usage, because it has great viral potential in social media. It also can be send by e – mail or be downloaded for a website. If printed, it can take interesting form of postcards, posters, folder or installation and other
Start Up Contest is an event which connect investors with start-up companies and also enable direct intearction beettwen them. To meet the organizators’ needs, I designed infographics which descirbe stages of the contest. I displayed in easy and readableway, how step by step young company can (in final effect) win 200 thousand Euro for its buisiness concept.
Using icons, arrows and boxes I presented the whole process of participaitionand crucial deadline’s. Message was aimed at target audience – active and young people who are keen on new technologies. Infographic sholud save their time by not reading long, boring e – mails and simplify the registartion procedure. I think it worked, because many people were interested in entering the conest! ;)
Dla Insoft Consulting supports buissnes processes for others companies. To show how the company had recently changed, I design the animation, which shows it in an interactive way in only several dozen seconds.The animation accompanied the launch of the brand. It was the main channel of communicating the modifications in the brand image. Its premiere took place during a confreance organised for their ten years annivesary. The animation enhances the way of informing customers and stakeholders about Insoft’s Consulting rebranding. It shortly tells the story about ideas and values that stand by this brand and shows lifting of the old logo. It also presents a new visual identity. I strongly recommend this way of changes and improvement presenation and for every company that wants to stands. Customer attention guranteed! ;)
I was asked by Gdańsk City Hall to prepare materials, which in an easy and interesting way tell the story of positive changes and improvements that have been introduced in the city during past two years. I carefully analyzed possible ways of presenting that material and I have chosen infographics as the most suitable and viewer-friendly form…See how they look like!.
At first, I felt overwhelmed with the amount of information as I received 32-pages long report. My priority was to find lucid and attractive way to communicate with citizens of Gdańsk. I converted a large number of text, tables and data into a modern form of infographics.
I decided to divide the materials into four thematic parts and assigned particular city changes and achievements to each of them. Projects and ideas were briefly consulted with President’s Office during the whole process. As a result of our mutual cooperation we distinguished four areas of city development: commuting, recreation and sport, development and life & city.
As the result I made four infographics, which in clear and interesting way show how the city council actions brought changes to Gdańsk. Each infographic illustrates particular goals depicted by attractive and colorful graphics and icons. Moreover, they are supported with dedicated slogans for each thematic part.
Be means of infographic I invited many people from Gdańsk and neighboring areas for Gdańsk Metropolitan Area'sconference. The purpose of meeting was to discuss further mutual directions for development the Area and actions, which leads to economic consolidation of Pomeranian Region.
I created icons, graphics and colors, which are in line with visual identity of GMA. I held to its main concept, which is represented in their logo. This is an aspiration to community and synergy among every self governments associated in GMA, and keeping their individual spirit at the same time.
Creative Cities is a project carried out by Gdańsk Entrepreneurship Foundation in cooperation with Gdańsk City Hall. Its aim is to integrate local, creative entrepreneurships and to create a space fordevelopment and experience exchange. Based on the summaries I received on many meetings, I made an infographic which sums up the project.
Reports I got from organizers had many numbers and statics. I have decided to deal with the project with my intrinsic sense of humor and illustrated for exmaple - how many sandwiches were eaten by participants, how many chairs were used, how much coffee they drank. I presented statistics using icons to visualize character of the meetings. I displayed range of the project on a simplified map of Europe, which helps imagine the distance between the cities. Local character of the project is highlighted by the background of infographic which displays contours of characteristic Old Town buildings in Gdańsk.
Start People - Work and Personal Consultancy Agency, asked me to design infographic, which illustrates students’ demands for labour market. An infographic visualize extensive data gathered by Start People as a result of the survey conducted among students of public universities in Gdańsk and Łódź.
I received two reports full of figures, which together had 40 slides with tables and statistics. Fortunately, analysis and synthesis are my strong sides. Thanks to them and with help of icons and pictograms I succeeded in designing readable and simply message as infographic. I took into account the most important facts, which I divided in nine thematic categories. I illustrated differences with an image of female student, who is “with one feet in Gdańsk, and one in Łódź”. I wanted to highlight two different point of views with looks and outfit. These students are not only 334 km distant from each other, but also vary in life choices. For example, students from Gdańsk more often choose technical faculties, whereas students from Łódź choose social – economical faculties.
A range of icons and graphics make illustrations more diverse, thus helping the viewer to understand the message and information. At first glance one can see what they have in common and what is different for the students from these two cities. The whole design is maintained in pastel colors to please both young and elder recipients. It was used to promote Conference Start HR: “Students’ run for career – a sprint or a marathon?” organized by Start People in Gdańsk and Łódź in April 2012.
Universities which enter the competition for students should invest in good trainer, because dark clouds are gathering above them. To make long story short, according to forecasts demographic decrease will take down private higher education and devalue public universities by 2020.
Largest Polish daily journal, “Gazeta Wyborcza” published an article which inspired me to verify the forecasts about the condition of Polish higher education system. I prepared an infographic based on statistical yearbooks from GUS (Central Statistical Office), data from Ministry of Science and Higher Education, reports from Economic Research Institute, Ernst &Young Business Advisory and media materials. It shows universities, their values and brands form marketing perspective. In result, analysis of abovementioned sources makes a picture of present and future conditions on academic market.
The aim of designing this infographic was to show the influence of demographic decline on public and private higher education institutions and encourage people to take up public debate. Competition for students, best lectures, investors and donors should become a base for building strong and recognizable brands. As a result of planned and well-considered actions Polish universities can also create trustworthy brands. An example of good university branding are universities in Western Europe which invest in themselves as well as their students.


--- layout: member_profile title: "Bachar Wehbe" permalink: /members/wehbe/ name: "Bachar Wehbe" affiliation: "Institute of Astrophysics and Space Sciences" jointaffiliation: country: "Portugal" position: "PhD Student" researchtitle: "Atmospheric Dispersion Correction for High Resolution Astronomical Instruments" summary: prior: orcid: website: linkedin: rgate: research: ["Adaptive Optics" , "Spectroscopy" , "Exoplanets" ] keywords: "Adaptive Optics -- Spectroscopy -- Exoplanets" email<EMAIL_ADDRESS>image_path: /assets/img/member/wehbe.jpg ---
Current Research Summary:
Astronomical observations with ground based telescopes are affected by differential atmospheric dispersion, a consequence of the wavelength-dependent index of refraction of the atmosphere. Even if telescope pointing and guiding is perfect at a given reference wavelength, atmospheric dispersion will shift the image of the object at different wavelengths. Moreover such effect will vary during exposure with the observation zenital angle. In high resolution astronomical instruments, an Atmospheric Dispersion Corrector (ADC) is thus mandatory to avoid wavelength dependent losses. My work research is focused on the following aspects:
As an outcome of this work, it is expected that we advance on the knowledge of the impact of the dispersion correction in high resolution spectrographs and its scientific applications.
Prior Research:
Master's degree at Notre Dame University - Louaize, Lebanon (2011-2014)


{% extends 'portal/base.html' %} {% load static %} {% block title %}Elections - ECSS{% endblock %} {% block portalcontent %} {{ election.name }}: Results {{ election.voters }} voters voted in {{ election.name }}. {% for result in election.results %} {{ result.role }}: {{ result.elected }} is elected {% for round in result.rounds %} {% endfor %} {% endfor %} {% endblock %} {% block pagescript %} {{ block.super }} {% endblock %}
{{ election.voters }} voters voted in {{ election.name }}.


The coupon system allows you to create coupon codes, assign discount levels and expiry dates to them and give them to customers. With the coupon system enabled (done in the Configure/PayPal screen) the booking screen will show a coupon entry box. When the customer enters a code, it is validated and the discount applied to the total cost.
Coupons are only meaningful when PayPal is enabled.
To offer a FREE booking set Value = 100 and the Type = Percent.
If the PayPal total after discount is $0, no trip to PayPal is made and the booking is placed immediately.
Cancel: Abort changes and return to the previous screen.
Save: Save changes and return to the previous screen.
Help: Opens this help screen.
Description: This text appears on the booking screen when the user enters a coupon code it it is validated by the system. Examples: '10% OFF', 'Summer Special'
Coupon Code: The Coupon Code is what the customer enters to get the discount. This code is stored in the booking so you can tell a customer used a coupon with the order.
Value: This is the amount that will be discounted. Must be a number.
Type: This tells what type of discount will be applied, fixed amount or percentage.
Max User Usage: This is the maximum times an individual user can use this coupon. Only works if booking requires login. Set to 0 for no limit.
Max Total Usage: This is the maximum times the coupon be used in total (by all users)Set to 0 for no limit.
If non-0 Max Total must be equal to or greater than Max User.
Resources: You can assign this coupon to one or more resources. If NOT assigned, it will be available for ALL. Select one or more resources that this coupon applies to. If you wish this coupon to be available for ALL resources, do not select any.
Expiry: This tell when the coupon will expire. And expired coupon will return 'Coupon Expired' when the user attempts to use it.
Published: Indicates the published state.


Coding Quiz-O-Rama!
Test your basic coding knowlege with this JavaScript quiz! Answer each question - and be careful to get it right!  Incorrect answers will lose you 10 seconds off the clock. Do well, and you'll make your way onto the high score Hall of Fame! Good luck!
Right!


--- layout: post status: publish published: true title: Unexpected Referrers author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 620 wordpress_url: http://winterdom.com/2002/06/unexpectedreferrers date: '2002-06-15 18:44:48 +0000' date_gmt: '2002-06-15 18:44:48 +0000' categories: - Blogging tags: [] comments: - id: 414 author: E,MARTINS author_email<EMAIL_ADDRESS>author_url: http://www.799779821.freestoreclub.com date: '2003-06-19 21:22:25 +0000' date_gmt: '2003-06-19 21:22:25 +0000' content: |
Make some money on internet now !!!
Just try .It for free
Here's something I wasn't expecting to see: How did The International Atomic Energy Agency website find its way into my referrer logs? ;)


Just like you, we’ve grown tired of slow and unreliable internet packages. The big players don’t see an economic value in investing in our region, and standing alone we’re not capable of changing the status quo. So, listen to us and let us join forces.
Our Story
One of our cofounders is in Stobrec, the other in Podstrana. For years in row there’s been no alternatives to the slow and unreliable internet in Podstrana. While Stobrec started receiving a rollout of higher speeds, they’re usually asymmetric and capped due to the ageing copper infrastructure. Today’s world needs at least 50/50 Mbits and such speeds are reserved only for professional and costly packages.
Our Model
Currently limited to Stobrec and Podstrana
Our model puts the users as equal partners, helping to develop our infrastructure. Unlike before, the infrastructure is yours to keep and do with as you please. Nobody wants another scandal around the ownership of telephone cabling. We are focusing on fibre and 5G networks to establish a link to you - we’ll help you choose and install the equipment and can even offer financing - but the equipment is yours to keep and we’ll reimburse you for usage - be it by lowering the fee or by profit splitting as we do with equal partners.
Available globally
We’ve specfiically targetted digital nomads with our hosting services. We can host development equipment for you, like embedded development kits. With access to our datacentres of at least 100/100 Mbit/s you won’t be able of telling them apart from locally connected boards.


{% if error_msg %}
X
Error {{ error_msg }}
{% endif %} {% if not peer_reviewed_units %} This course has no peer-reviewed assignments, so this page is empty. {% else %}
Select Assignment
Assignment Name:
{% for unit in peer_reviewed_units %}
{{ unit.title }}
{% endfor %}
Student email address:
{% if readonly_student_assessment %}
{% include 'assignment_individual.html' %} {% endif %} {% endif %}


JETM Springframework web integration
While JETM already supports web applications through filters and servlets mentioned here those integrations do not work with spring managed performance monitoring. This is because the generic web support locates the currently active EtmMonitor using an EtmManager that does not honour spring configurations.
Therefore JETM comes with dedicated Spring web application support. The JETM runtime will be retrieved from the currently active WebApplicationContext (using Spring WebApplicationContextUtils). So if you create your WebApplicationContext with ContextLoaderListener or ContextLoaderServlet simply use the classes below and you will use the JETM runtime from your spring configuration.
Usually the JETM runtime can be located automatically. However if you have more than one EtmMonitor you may need to specify the bean name for lookup. See below.
Spring HTTP console servlet
The Spring HTTP console servlet works - apart from the autodetection feature mentioned above - just like the generic implementation. Add the following xml fragment to your web.xml and your are able to access performance results at http://{HOST}:{PORT}/{ROOT}/performance/.
... <servlet> <servlet-name>performanceMonitor</servlet-name> <servlet-class>etm.contrib.integration.spring.web.SpringHttpConsoleServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> ... <servlet-mapping> <servlet-name>performanceMonitor</servlet-name> <url-pattern>/performance/*</url-pattern> </servlet-mapping>
If you have more than one EtmMonitor in your spring configuration use the servlet parameter etmMonitorName to specify the name of the monitor bean.
Spring HTTP request performance filter
The SpringHttpRequestPerformanceFilter is the spring equivalent to the generic HttpRequestPerformanceFilter. Use this filter to monitor HTTP requests.
... <filter> <filter-name>performance-monitor</filter-name> <filter-class> etm.contrib.integration.spring.web.SpringHttpRequestPerformanceFilter </filter-class> </filter> <filter-mapping> <filter-name>performance-monitor</filter-name> <url-pattern>*.action</url-pattern> </filter-mapping>
If you have more than one EtmMonitor in your spring configuration use the servlet parameter etmMonitorName to specify the name of the monitor bean.


Gould Mine
The career of Stephen Jay Gould eludes easy definition because of his prolific output in so many areas. Michael Shermer characterises him as a historian of science and scientific historian, popular scientist and scientific populariser.
The popular science writings of Stephen Jay Gould (20 of his 22 books and hundreds of articles) are responsible for making me want to study macroevolution. He said of his popular essays that they were intended “for professionals and lay readers alike”. We have already covered some aspects of science communication, like how to do it and which kind of scientists should engage in it. Gould wrote 479 academic papers during his career, so any thought of public outreach damaging one’s science certainly didn’t apply to him.
Let’s have a closer look at his academic legacy. Gould is well known for his theory of punctuated equilibrium co-written with Niles Eldredge. This fuelled the debate around ideas such as species selection and the mechanisms explaining macroevolutionary patterns.
Despite this being the work for which he is best remembered it represents a tiny fraction of his output. He actually published only 15 papers with this theory as a main topic, which represents only 3% of his academic work! As a comparison, he published more papers (17) on baseball!
His primary field was invertebrate palaeontology (he was the curator of Harvard’s Invertebrate palaeontology collections from 1973 to his death in 2002) but again, even his main focus in this area (on Cerion snails) represents only on one quarter of his work. Shermer describes him as being “no single-minded fossil digger or armchair theorizer.”
Actually, nearly one fifth of his massive scientific output is primarily focused on the history of science. Again, as Shermer says, he was a “Historian of Science and Scientific historian”.
So Gould should not be only remembered for his proposal of punctuated equilibrium. Gould published 169 papers in 23 last years of last century, which gives him an average number of publications in the history of science of 7.34 per year. To put it in the historical context of the field, the only names that have been more productive are Aristotle, Kant, Goethe and Newton.
It’s rare to see a scientist who divided opinion so much, hagiographies have been written about him but he’s also loathed. Look at these for contrasting views:
“In the field of evolutionary biology at large, Gould’s reputation is mud.”
“Steve is extremely bright, inventive. He thoroughly understands paleontology; he thoroughly understands evolutionary biology.”
I’ll leave it to the reader to find out where they stand on Gould for there is a lot of controversy to consume. I prefer to remember him through his essays on Natural History than through his few papers about punctuated equilibrium, better illustrating the “measure of a man” (that’s Shermer’s pun). His life illustrates how interdisciplinary studies exponentially increase scientific productivity: “Gould has used the history of science to reinforce his evolutionary theory (and vice versa)” writes Shermer. And that applies as much to punctuated equilibrium as to baseball!
Photo credit: wikimedia commons


Rupee firms up 11 paise against dollar
At the interbank foreign exchange market, the rupee opened weak at 70.96 and touched a low of 70.98 in early trade.
by PTIThe rupee appreciated by 11 paise to close at 70.81 against the US dollar on Friday due to fag-end selling of the greenback by banks and importers amid persistent foreign fund inflows. Strengthening crude oil prices, however, capped the gains for the domestic unit, forex dealers said.
At the interbank foreign exchange market, the rupee opened weak at 70.96 and touched a low of 70.98 in early trade.
However, late selling of dollars by banks helped the rupee recoup its losses. It finally finished at 70.81 against the US currency, showing a rise of 11 paise over its previous close.
On weekly basis, the rupee fell 9 paise against the greenback.
Continuing their buying spree, foreign institutional investors (FIIs) pumped in a net Rs 533.37 crore into equities on Friday, provisional exchange data showed.
The dollar index, which gauges the greenback's strength against a basket of six currencies, slipped 0.11 per cent to 97.24.
Brent crude futures, the global oil benchmark, was trading 0.54 per cent higher at USD 59.94 per barrel.
The 10-year government bond yield was at 6.43 per cent in morning trade.
Meanwhile, domestic equity markets notched up gains for the sixth straight session on Friday. The BSE Sensex settled 35.98 points, or 0.09 per cent, higher at 40,165.03. The broader NSE Nifty advanced 13.15 points, or 0.11 per cent, to close at 11,890.60.Special Thursday Expiry on 10th 7th Nov
Early Closure to The Great Diwali Discount. Last Chance to get Moneycontrol PRO for a year @ Rs. 289/- only
Coupon code: DIWALI


Dashboard
Clean Air Asia
Pollution Overview
Mandir Marg
Anand Vihar
R.K. Puram
Punjabi Bagh
IGI Airport
Civil Lines
Feedback Review
HeatMap
View the top
priorities
Submit


LYSOL NO TOUCH- benzethonium chloride solution
Reckitt Benckiser LLC
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
Active Ingredient
Benzethonium chloride, 0.13%
Use
for handwashing to decrease bacteria on the skin
Warnings
For external use only
When using this product
- Avoid contact with eyes.
- In case of eye contact, flush with water.
Stop use and ask a doctor if irritation or redness develops.
Keep out of reach of children. If swallowed, get medical help or contact a Poison Control Center right away.
Directions
- Wet hands.
- Place hands under dispenser until soap is dispensed.
- Wash hands.
- Rinse hands with water.
- Dry hands after rinsing.
Other Information
store at room temperature
Inactive Ingredients
Water, Glycerin, Cetrimonium Chloride, Lauramide DEA, PEG-150 Distearate, Lauramine Oxide, Fragrance, Citric Acid, Tetrasodium EDTA, Benzophenone-4, Di-PPG-2 Myreth-10 Adipate, Methylchloroisothiazolinone, Methylisothiazolinone, D&C Red 33 and D&C Orange 4.
Questions? Comments?
Call 1-800-228-4722
Distributed by: Reckitt Benckiser LLC
Parsippany, NJ 07054-0224
PRINCIPAL DISPLAY PANEL - 251 mL Bottle Label
Lysol®
BRAND
KILLS 99.9% OF BACTERIA
No -Touch™
Antibacterial
Hand Soap
No -Touch™
Hand Soap System
Cranberry Cheer
includes dispenser, hand soap refill and AA batteries
Helps stop the
spread of bacteria
8.5 FL. OZ.
(251 mL)


{% extends "base.html" %} {% block title %}Looking For Presenters{% endblock %} {% block content %}
Welcome to the DE DevCon Call for Papers! The CFP will close on {{ callForPapers.due|date('F jS, Y h:i:s A') }} EST. Please make sure that you get your submissions in before that time!
We are looking for a variety of talks on work-related subjects. Talks should be 50 minutes in length. We want a wide variety of topics, including but not limited to DevOps, Big Data, and Agile Development.
When the Call for Papers closes, the organizers will sort through the submissions, making their selections. Speakers will be notified no later than {{ callForPapers.selection|date('F jS, Y') }}. The goal is to give our speakers at least a month to prepare their presentations.
We strongly encourage potential speakers to submit more than one submission on more than one topic. The more submissions you contribute, the more options you give us to choose you as a speaker. Be sure your talk title and summary define the topic you want to speak about and what you hope people will learn from the session.
These will take place on Thursday and are 3 hours long. Attendees here will expect in-depth coverage of a specific topic.
These take place throughout the rest of the conference and are 50 minutes long, including the Q & A.
We sometimes leave space on the schedule for short talks are only thirty minutes long. Sometimes there are topics that don’t need a full 50 minutes. We want to make sure we allow these kinds of topics to be exposed.
Each presenter will be responsible for contacting the 20th floor to ensure their equipment compatiable with the speakers needs. We will hold a short orientation prior to the conference to ensure each presenter knows what is expected.
If selected you will receive a t-shirt and collectable stuffed narwhal.