Tap on the "Nearby" Pokemon in the bottom right corner of your screen and take a look at the visual representation. One footprint is close, 3 is far.
Self explanatory right? WRONG. There's a trick here - the pokemon are listed in order. Pick any direction (North, South, East, West) and start walking. If the pokemon you want gets further down the list, turn around! If it get's closer, keep going.
UPDATE: This functionality has temporarily been suspended by Niantic
Here's an article with an update on this: Click Here
Alright, there's a couple things you need to be aware of...
1. Rasberries. They are an item you get from Pokestops that you can use DURING the combat with a wild pokemon. If you use it, your NEXT throw will have a higher chance of success. If you miss though, you will have to re-use another rasberry as the effect diminishes!
2. The Circles. The circle that surrounds a pokemon designates how hard it is for you to catch. Green is easy. Yellow is medium. Red hints are harder. PAY ATTENTIO TO THE CIRCLE SIZE! The smaller the circle and the closer to the center, the better your odds at getting the pokemon! Plus, you'll get a small XP Bonus for a great or nice shot.
If you use a Rasberry on a red pokemon it MAY not catch; however there is a 3rd trick that can be combined with the above 2.
3. The Curveball. Or the Curve Pokeball. This is the 'skill-shot' in pokemon. Take your finger and hold down on the pokeball. Start swirling your finger (very fast) in a small circular pattern.
No, I am not messing with you.
Once you get it spinning fast enough it will start to show stars. That's a curve ball! Release it and throw up simultaneously trying to hit the pokemon like normal. If you hit it, you'll have a higher chance of success. If you do a Curveball AND a Great Shot (in the center), you'll have even better.
Note: If you use a combination of Rasberry, Great Shot, and Curveball on the SAME throw, I believe you are almost guaranteed to get the pokemon. I have never had a pokemon escape with all 3


Sign in using your Google account to access this app.
Enable to accept all follower requests automatically
Click here to authorize/reauthorize the app to connect to your account. To disconnect, revoke access via instagram.com/accounts/manage_access
Check back soon
{{ req.full_name }}


---
layout: game-page
redirect_from: /game/blood-drive
title: Blood Drive
year: 2008
semester: Fall
description: "Kill the disease cells!
Take control of your white blood cells and eliminate the diseases in this game for the Nintendo DS."
tags: Singleplayer Nintendo-DS
# tag options: "Windows", "Mac", "Linux",
# "Singleplayer", "Multiplayer",
# "Controller-Compatible", "VR",
# "Game-Jam"
project_members: {
Alan Pierce: Programming,
Albert Yi: Art,
Bridget Liao: "Art, Bio Expertise",
Eric Foote: "Level Design, Art",
Kevin Tian: Art,
Kyle Neblett: Project Lead,
Lee Beyle: "Level Design, Bio Expertise",
Lily Li: Art,
Max Gibson: "Level Design, Art",
Richard Chen: "Level Design, Art"
}
stage_game_path: blooddrive/
builds: {
"Nintendo DS": blooddrive.nds
}
screenshots: [
blooddrive-1.png,
blooddrive-2.png,
blooddrive-3.png,
blooddrive-4.png
]
# Optional
build_instructions: "Nintendo DS emulator download, required to run game."
top-img-fit: cover
# top-img-fit options:
# "cover" - Cover the entire top area with the image, without squashing/stretching
# "fill" - Fit the FULL image into the top area, squashing/stretching as necessary
---


It's time for web servers to handle ten thousand clients simultaneously, don't you think? After all, the web is a big place now.
And computers are big, too. You can buy a 1000MHz machine with 2 gigabytes of RAM and an 1000Mbit/sec Ethernet card for $1200 or so. Let's see - at 20000 clients, that's 50KHz, 100Kbytes, and 50Kbits/sec per client. It shouldn't take any more horsepower than that to take four kilobytes from the disk and send them to the network once a second for each of twenty thousand clients. (That works out to $0.08 per client, by the way. Those $100/client licensing fees some operating systems charge are starting to look a little heavy!) So hardware is no longer the bottleneck.
In 1999 one of the busiest ftp sites, cdrom.com, actually handled 10000 clients simultaneously through a Gigabit Ethernet pipe. As of 2001, that same speed is now being offered by several ISPs, who expect it to become increasingly popular with large business customers.
And the thin client model of computing appears to be coming back in style -- this time with the server out on the Internet, serving thousands of clients.
With that in mind, here are a few notes on how to configure operating systems and write code to support thousands of clients. The discussion centers around Unix-like operating systems, as that's my personal area of interest, but Windows is also covered a bit.
In October 2003, Felix von Leitner put together an excellent web page and presentation about network scalability, complete with benchmarks comparing various networking system calls and operating systems. One of his observations is that the 2.6 Linux kernel really does beat the 2.4 kernel, but there are many, many good graphs that will give the OS developers food for thought for some time. (See also the Slashdot comments; it'll be interesting to see whether anyone does followup benchmarks improving on Felix's results.)
If you haven't read it already, go out and get a copy of Unix Network Programming : Networking Apis: Sockets and Xti (Volume 1) by the late W. Richard Stevens. It describes many of the I/O strategies and pitfalls related to writing high-performance servers. It even talks about the 'thundering herd' problem. And while you're at it, go read Jeff Darcy's notes on high-performance server design.
(Another book which might be more helpful for those who are *using* rather than *writing* a web server is Building Scalable Web Sites by Cal Henderson.)
Prepackaged libraries are available that abstract some of the techniques presented below, insulating your code from the operating system and making it more portable.
The following five combinations seem to be popular:
... set nonblocking mode on all network handles, and use select() or poll() to tell which network handle has data waiting. This is the traditional favorite. With this scheme, the kernel tells you whether a file descriptor is ready, whether or not you've done anything with that file descriptor since the last time the kernel told you about it. (The name 'level triggered' comes from computer hardware design; it's the opposite of 'edge triggered'. Jonathon Lemon introduced the terms in his BSDCON 2000 paper on kqueue().)
Note: it's particularly important to remember that readiness notification from the kernel is only a hint; the file descriptor might not be ready anymore when you try to read from it. That's why it's important to use nonblocking mode when using readiness notification.
An important bottleneck in this method is that read() or sendfile()
from disk blocks if the page is not in core at the moment;
setting nonblocking mode on a disk file handle has no effect.
Same thing goes for memory-mapped disk files.
The first time a server needs disk I/O, its process blocks,
all clients must wait, and that raw nonthreaded performance goes to waste.
This is what asynchronous I/O is for, but on systems that lack AIO,
worker threads or processes that do the disk I/O can also get around this
bottleneck. One approach is to use memory-mapped files,
and if mincore() indicates I/O is needed, ask a worker to do the I/O,
and continue handling network traffic. Jef Poskanzer mentions that
Pai, Druschel, and Zwaenepoel's 1999 Flash web server uses this trick; they gave a talk at
Usenix '99 on it.
It looks like mincore() is available in BSD-derived Unixes
like FreeBSD
and Solaris, but is not part
of the Single Unix Specification.
It's available as part of Linux as of kernel 2.3.51,
thanks to Chuck Lever.
But in November 2003 on the freebsd-hackers list, Vivek Pei et al reported very good results using system-wide profiling of their Flash web server to attack bottlenecks. One bottleneck they found was mincore (guess that wasn't such a good idea after all) Another was the fact that sendfile blocks on disk access; they improved performance by introducing a modified sendfile() that return something like EWOULDBLOCK when the disk page it's fetching is not yet in core. (Not sure how you tell the user the page is now resident... seems to me what's really needed here is aio_sendfile().) The end result of their optimizations is a SpecWeb99 score of about 800 on a 1GHZ/1GB FreeBSD box, which is better than anything on file at spec.org.
There are several ways for a single thread to tell which of a set of nonblocking sockets are ready for I/O:
See Poller_select (cc, h) for an example of how to use select() interchangeably with other readiness notification schemes.
Some OS's (e.g. Solaris 8) speed up poll() et al by use of techniques like poll hinting, which was implemented and benchmarked by Niels Provos for Linux in 1999.
See Poller_poll (cc, h, benchmarks) for an example of how to use poll() interchangeably with other readiness notification schemes.
The idea behind /dev/poll is to take advantage of the fact that often poll() is called many times with the same arguments. With /dev/poll, you get an open handle to /dev/poll, and tell the OS just once what files you're interested in by writing to that handle; from then on, you just read the set of currently ready file descriptors from that handle.
It appeared quietly in Solaris 7 (see patchid 106541) but its first public appearance was in Solaris 8; according to Sun, at 750 clients, this has 10% of the overhead of poll().
Various implementations of /dev/poll were tried on Linux, but none of them perform as well as epoll, and were never really completed. /dev/poll use on Linux is not recommended.
See Poller_devpoll (cc, h benchmarks ) for an example of how to use /dev/poll interchangeably with many other readiness notification schemes. (Caution - the example is for Linux /dev/poll, might not work right on Solaris.)
See below. kqueue() can specify either edge triggering or level triggering.
When you use readiness change notification, you must be prepared for spurious events, since one common implementation is to signal readiness whenever any packets are received, regardless of whether the file descriptor was already ready.
This is the opposite of "level-triggered" readiness notification. It's a bit less forgiving of programming mistakes, since if you miss just one event, the connection that event was for gets stuck forever. Nevertheless, I have found that edge-triggered readiness notification made programming nonblocking clients with OpenSSL easier, so it's worth trying.
[Banga, Mogul, Drusha '99] described this kind of scheme in 1999.
There are several APIs which let the application retrieve 'file descriptor became ready' notifications:
FreeBSD 4.3 and later, and NetBSD-current as of Oct 2002, support a generalized alternative to poll() called kqueue()/kevent(); it supports both edge-triggering and level-triggering. (See also Jonathan Lemon's page and his BSDCon 2000 paper on kqueue().)
Like /dev/poll, you allocate a listening object, but rather than opening the file /dev/poll, you call kqueue() to allocate one. To change the events you are listening for, or to get the list of current events, you call kevent() on the descriptor returned by kqueue(). It can listen not just for socket readiness, but also for plain file readiness, signals, and even for I/O completion.
Note: as of October 2000, the threading library on FreeBSD does not interact well with kqueue(); evidently, when kqueue() blocks, the entire process blocks, not just the calling thread.
See Poller_kqueue (cc, h, benchmarks) for an example of how to use kqueue() interchangeably with many other readiness notification schemes.
Examples and libraries using kqueue():
On 11 July 2001, Davide Libenzi proposed an alternative to realtime signals; his patch provides what he now calls /dev/epoll www.xmailserver.org/linux-patches/nio-improve.html. This is just like the realtime signal readiness notification, but it coalesces redundant events, and has a more efficient scheme for bulk event retrieval.
Epoll was merged into the 2.5 kernel tree as of 2.5.46 after its interface was changed from a special file in /dev to a system call, sys_epoll. A patch for the older version of epoll is available for the 2.4 kernel.
There was a lengthy debate about unifying epoll, aio, and other event sources on the linux-kernel mailing list around Halloween 2002. It may yet happen, but Davide is concentrating on firming up epoll in general first.
The 2.4 linux kernel can deliver socket readiness events via a particular realtime signal. Here's how to turn this behavior on:
/* Mask off SIGIO and the signal you want to use. */ sigemptyset(&sigset); sigaddset(&sigset, signum); sigaddset(&sigset, SIGIO); sigprocmask(SIG_BLOCK, &m_sigset, NULL); /* For each file descriptor, invoke F_SETOWN, F_SETSIG, and set O_ASYNC. */ fcntl(fd, F_SETOWN, (int) getpid()); fcntl(fd, F_SETSIG, signum); flags = fcntl(fd, F_GETFL); flags |= O_NONBLOCK|O_ASYNC; fcntl(fd, F_SETFL, flags);This sends that signal when a normal I/O function like read() or write() completes. To use this, write a normal poll() outer loop, and inside it, after you've handled all the fd's noticed by poll(), you loop calling sigwaitinfo().
See Poller_sigio (cc, h) for an example of how to use rtsignals interchangeably with many other readiness notification schemes.
See Zach Brown's phhttpd for example code that uses this feature directly. (Or don't; phhttpd is a bit hard to figure out...)
[Provos, Lever, and Tweedie 2000] describes a recent benchmark of phhttpd using a variant of sigtimedwait(), sigtimedwait4(), that lets you retrieve multiple signals with one call. Interestingly, the chief benefit of sigtimedwait4() for them seemed to be it allowed the app to gauge system overload (so it could behave appropriately). (Note that poll() provides the same measure of system overload.)
Vitaly Luban announced a patch implementing this scheme on 18 May 2001; his patch lives at www.luban.org/GPL/gpl.html. (Note: as of Sept 2001, there may still be stability problems with this patch under heavy load. dkftpbench at about 4500 users may be able to trigger an oops.)
See Poller_sigfd (cc, h) for an example of how to use signal-per-fd interchangeably with many other readiness notification schemes.
This has not yet become popular in Unix, probably because few operating systems support asynchronous I/O, also possibly because it (like nonblocking I/O) requires rethinking your application. Under standard Unix, asynchronous I/O is provided by the aio_ interface (scroll down from that link to "Asynchronous input and output"), which associates a signal and value with each I/O operation. Signals and their values are queued and delivered efficiently to the user process. This is from the POSIX 1003.1b realtime extensions, and is also in the Single Unix Specification, version 2.
AIO is normally used with edge-triggered completion notification, i.e. a signal is queued when the operation is complete. (It can also be used with level triggered completion notification by calling aio_suspend(), though I suspect few people do this.)
glibc 2.1 and later provide a generic implementation written for standards compliance rather than performance.
Ben LaHaise's implementation for Linux AIO was merged into the main Linux kernel as of 2.5.32. It doesn't use kernel threads, and has a very efficient underlying api, but (as of 2.6.0-test2) doesn't yet support sockets. (There is also an AIO patch for the 2.4 kernels, but the 2.5/2.6 implementation is somewhat different.) More info:
Red Hat AS and Suse SLES both provide a high-performance implementation on the 2.4 kernel; it is related to, but not completely identical to, the 2.6 kernel implementation.
In February 2006, a new attempt is being made to provide network AIO; see the note above about Evgeniy Polyakov's kevent-based AIO.
In 1999, SGI implemented high-speed AIO for Linux. As of version 1.1, it's said to work well with both disk I/O and sockets. It seems to use kernel threads. It is still useful for people who can't wait for Ben's AIO to support sockets.
The O'Reilly book POSIX.4: Programming for the Real World is said to include a good introduction to aio.
A tutorial for the earlier, nonstandard, aio implementation on Solaris is online at Sunsite. It's probably worth a look, but keep in mind you'll need to mentally convert "aioread" to "aio_read", etc.
Note that AIO doesn't provide a way to open files without blocking for disk I/O; if you care about the sleep caused by opening a disk file, Linus suggests you should simply do the open() in a different thread rather than wishing for an aio_open() system call.
Under Windows, asynchronous I/O is associated with the terms "Overlapped I/O" and IOCP or "I/O Completion Port". Microsoft's IOCP combines techniques from the prior art like asynchronous I/O (like aio_write) and queued completion notification (like when using the aio_sigevent field with aio_write) with a new idea of holding back some requests to try to keep the number of running threads associated with a single IOCP constant. For more information, see Inside I/O Completion Ports by Mark Russinovich at sysinternals.com, Jeffrey Richter's book "Programming Server-Side Applications for Microsoft Windows 2000" (Amazon, MSPress), U.S. patent #06223207, or MSDN.
... and let read() and write() block. Has the disadvantage of using a whole stack frame for each client, which costs memory. Many OS's also have trouble handling more than a few hundred threads. If each thread gets a 2MB stack (not an uncommon default value), you run out of *virtual memory* at (2^30 / 2^21) = 512 threads on a 32 bit machine with 1GB user-accessible VM (like, say, Linux as normally shipped on x86). You can work around this by giving each thread a smaller stack, but since most thread libraries don't allow growing thread stacks once created, doing this means designing your program to minimize stack use. You can also work around this by moving to a 64 bit processor.
The thread support in Linux, FreeBSD, and Solaris is improving, and 64 bit processors are just around the corner even for mainstream users. Perhaps in the not-too-distant future, those who prefer using one thread per client will be able to use that paradigm even for 10000 clients. Nevertheless, at the current time, if you actually want to support that many clients, you're probably better off using some other paradigm.
For an unabashedly pro-thread viewpoint, see Why Events Are A Bad Idea (for High-concurrency Servers) by von Behren, Condit, and Brewer, UCB, presented at HotOS IX. Anyone from the anti-thread camp care to point out a paper that rebuts this one? :-)
As of 5 October 2003, NPTL is now merged into the glibc cvs tree as an add-on directory (just like linuxthreads), so it will almost certainly be released along with the next release of glibc.
The first major distribution to include an early snapshot of NPTL was Red Hat 9. (This was a bit inconvenient for some users, but somebody had to break the ice...)
NPTL links:
In March 2002, Bill Abt of the NGPT team, the glibc maintainer Ulrich Drepper, and others met to figure out what to do about LinuxThreads. One idea that came out of the meeting was to improve mutex performance; Rusty Russell et al subsequently implemented fast userspace mutexes (futexes)), which are now used by both NGPT and NPTL. Most of the attendees figured NGPT should be merged into glibc.
Ulrich Drepper, though, didn't like NGPT, and figured he could do better. (For those who have ever tried to contribute a patch to glibc, this may not come as a big surprise :-) Over the next few months, Ulrich Drepper, Ingo Molnar, and others contributed glibc and kernel changes that make up something called the Native Posix Threads Library (NPTL). NPTL uses all the kernel enhancements designed for NGPT, and takes advantage of a few new ones. Ingo Molnar described the kernel enhancements as follows:
While NPTL uses the three kernel features introduced by NGPT: getpid() returns PID, CLONE_THREAD and futexes; NPTL also uses (and relies on) a much wider set of new kernel features, developed as part of this project.One big difference between the two is that NPTL is a 1:1 threading model, whereas NGPT is an M:N threading model (see below). In spite of this, Ulrich's initial benchmarks seem to show that NPTL is indeed much faster than NGPT. (The NGPT team is looking forward to seeing Ulrich's benchmark code to verify the result.)Some of the items NGPT introduced into the kernel around 2.5.8 got modified, cleaned up and extended, such as thread group handling (CLONE_THREAD). [the CLONE_THREAD changes which impacted NGPT's compatibility got synced with the NGPT folks, to make sure NGPT does not break in any unacceptable way.]
The kernel features developed for and used by NPTL are described in the design whitepaper, http://people.redhat.com/drepper/nptl-design.pdf ...
A short list: TLS support, various clone extensions (CLONE_SETTLS, CLONE_SETTID, CLONE_CLEARTID), POSIX thread-signal handling, sys_exit() extension (release TID futex upon VM-release), the sys_exit_group() system-call, sys_execve() enhancements and support for detached threads.
There was also work put into extending the PID space - eg. procfs crashed due to 64K PID assumptions, max_pid, and pid allocation scalability work. Plus a number of performance-only improvements were done as well.
In essence the new features are a no-compromises approach to 1:1 threading - the kernel now helps in everything where it can improve threading, and we precisely do the minimally necessary set of context switches and kernel calls for every basic threading primitive.
On 25 Mar 2003, Jeff Roberson posted on freebsd-arch:
... Thanks to the foundation provided by Julian, David Xu, Mini, Dan Eischen, and everyone else who has participated with KSE and libpthread development Mini and I have developed a 1:1 threading implementation. This code works in parallel with KSE and does not break it in any way. It actually helps bring M:N threading closer by testing out shared bits. ...And in July 2006, Robert Watson proposed that the 1:1 threading implementation become the default in FreeBsd 7.x:
I know this has been discussed in the past, but I figured with 7.x trundling forward, it was time to think about it again. In benchmarks for many common applications and scenarios, libthr demonstrates significantly better performance over libpthread... libthr is also implemented across a larger number of our platforms, and is already libpthread on several. The first recommendation we make to MySQL and other heavy thread users is "Switch to libthr", which is suggestive, also! ... So the strawman proposal is: make libthr the default threading library on 7.x.
Kernel supported M:N thread library based on the Scheduler Activations model is merged into NetBSD-current on Jan 18 2003.For details, see An Implementation of Scheduler Activations on the NetBSD Operating System by Nathan J. Williams, Wasabi Systems, Inc., presented at FREENIX '02.
Novell and Microsoft are both said to have done this at various times,
at least one NFS implementation does this,
khttpd does this for Linux
and static web pages, and
"TUX" (Threaded linUX webserver)
is a blindingly fast and flexible kernel-space HTTP server by Ingo Molnar for Linux.
Ingo's September 1, 2000 announcement
says an alpha version of TUX can be downloaded from
ftp://ftp.redhat.com/pub/redhat/tux,
and explains how to join a mailing list for more info.
The linux-kernel list has been discussing the pros and cons of this
approach, and the consensus seems to be instead of moving web servers
into the kernel, the kernel should have the smallest possible hooks added
to improve web server performance. That way, other kinds of servers
can benefit. See e.g.
Zach Brown's remarks
about userland vs. kernel http servers.
It appears that the 2.4 linux kernel provides sufficient power to user programs, as
the X15 server runs about as fast as Tux, but doesn't use any
kernel modifications.
Richard Gooch has written a paper discussing I/O options.
In 2001, Tim Brecht and MMichal Ostrowski measured various strategies for simple select-based servers. Their data is worth a look.
In 2003, Tim Brecht posted source code for userver, a small web server put together from several servers written by Abhishek Chandra, David Mosberger, David Pariag, and Michal Ostrowski. It can use select(), poll(), epoll(), or sigio.
Back in March 1999, Dean Gaudet posted:
I keep getting asked "why don't you guys use a select/event based model like Zeus? It's clearly the fastest." ...His reasons boiled down to "it's really hard, and the payoff isn't clear". Within a few months, though, it became clear that people were willing to work on it.
Mark Russinovich wrote an editorial and an article discussing I/O strategy issues in the 2.2 Linux kernel. Worth reading, even he seems misinformed on some points. In particular, he seems to think that Linux 2.2's asynchronous I/O (see F_SETSIG above) doesn't notify the user process when data is ready, only when new connections arrive. This seems like a bizarre misunderstanding. See also comments on an earlier draft, Ingo Molnar's rebuttal of 30 April 1999, Russinovich's comments of 2 May 1999, a rebuttal from Alan Cox, and various posts to linux-kernel. I suspect he was trying to say that Linux doesn't support asynchronous disk I/O, which used to be true, but now that SGI has implemented KAIO, it's not so true anymore.
See these pages at sysinternals.com and MSDN for information on "completion ports", which he said were unique to NT; in a nutshell, win32's "overlapped I/O" turned out to be too low level to be convenient, and a "completion port" is a wrapper that provides a queue of completion events, plus scheduling magic that tries to keep the number of running threads constant by allowing more threads to pick up completion events if other threads that had picked up completion events from this port are sleeping (perhaps doing blocking I/O).
See also OS/400's support for I/O completion ports.
There was an interesting discussion on linux-kernel in September 1999 titled "> 15,000 Simultaneous Connections" (and the second week of the thread). Highlights:
Interesting reading!
set kern.maxfiles=XXXXwhere XXXX is the desired system limit on file descriptors, and reboot. Thanks to an anonymous reader, who wrote in to say he'd achieved far more than 10000 connections on FreeBSD 4.3, and says
"FWIW: You can't actually tune the maximum number of connections in FreeBSD trivially, via sysctl.... You have to do it in the /boot/loader.conf file.Another reader says
The reason for this is that the zalloci() calls for initializing the sockets and tcpcb structures zones occurs very early in system startup, in order that the zone be both type stable and that it be swappable.
You will also need to set the number of mbufs much higher, since you will (on an unmodified kernel) chew up one mbuf per connection for tcptempl structures, which are used to implement keepalive."
"As of FreeBSD 4.4, the tcptempl structure is no longer allocated; you no longer have to worry about one mbuf being chewed up per connection."See also:
"In OpenBSD, an additional tweak is required to increase the number of open filehandles available per process: the openfiles-cur parameter in /etc/login.conf needs to be increased. You can change kern.maxfiles either with sysctl -w or in sysctl.conf but it has no effect. This matters because as shipped, the login.conf limits are a quite low 64 for nonprivileged processes, 128 for privileged."
echo 32768 > /proc/sys/fs/file-maxincreases the system limit on open files, and
ulimit -n 32768increases the current process' limit.
On 2.2.x kernels,
echo 32768 > /proc/sys/fs/file-max echo 65536 > /proc/sys/fs/inode-maxincreases the system limit on open files, and
ulimit -n 32768increases the current process' limit.
I verified that a process on Red Hat 6.0
(2.2.5 or so plus patches) can open at least 31000 file descriptors this way.
Another fellow has verified that a process on 2.2.12 can open at least
90000 file descriptors this way (with appropriate limits). The upper bound
seems to be available memory.
Stephen C. Tweedie posted
about how to set ulimit limits globally or per-user at boot time using
initscript and pam_limit.
In older 2.2 kernels, though, the number of open files per process is
still limited to 1024, even with the above changes.
See also
Oskar's 1998 post,
which talks about the per-process and system-wide limits on file descriptors
in the 2.0.36 kernel.
On any architecture, you may need to reduce the amount of stack space allocated for each thread to avoid running out of virtual memory. You can set this at runtime with pthread_attr_init() if you're using pthreads.
See also Volano's detailed instructions for raising file, thread, and FD_SET limits in the 2.2 kernel. Wow. This document steps you through a lot of stuff that would be hard to figure out yourself, but is somewhat dated.
Up through JDK 1.3, Java's standard networking libraries mostly offered the one-thread-per-client model. There was a way to do nonblocking reads, but no way to do nonblocking writes.
In May 2001, JDK 1.4 introduced the package java.nio to provide full support for nonblocking I/O (and some other goodies). See the release notes for some caveats. Try it out and give Sun feedback!
HP's java also includes a Thread Polling API.
In 2000, Matt Welsh implemented nonblocking sockets for Java; his performance benchmarks show that they have advantages over blocking sockets in servers handling many (up to 10000) connections. His class library is called java-nbio; it's part of the Sandstorm project. Benchmarks showing performance with 10000 connections are available.
See also Dean Gaudet's essay on the subject of Java, network I/O, and threads, and the paper by Matt Welsh on events vs. worker threads.
Before NIO, there were several proposals for improving Java's networking APIs:
According to a note from Noriyuki Soda:
Sending side zero-copy is supported since NetBSD-1.6 release by specifying "SOSEND_LOAN" kernel option. This option is now default on NetBSD-current (you can disable this feature by specifying "SOSEND_NO_LOAN" in the kernel option on NetBSD_current). With this feature, zero-copy is automatically enabled, if data more than 4096 bytes are specified as data to be sent.
A zero-copy implementation of sendfile() is on its way for the 2.4 kernel. See LWN Jan 25 2001.
One developer using sendfile() with Freebsd reports that using POLLWRBAND instead of POLLOUT makes a big difference.
Solaris 8 (as of the July 2001 update) has a new system call 'sendfilev'. A copy of the man page is here.. The Solaris 8 7/01 release notes also mention it. I suspect that this will be most useful when sending to a socket in blocking mode; it'd be a bit of a pain to use with a nonblocking socket.
See LWN Jan 25 2001 for a summary of some very interesting discussions on linux-kernel about TCP_CORK and a possible alternative MSG_MORE.
"I've compared the raw performance of a select-based server with a multiple-process server on both FreeBSD and Solaris/x86. On microbenchmarks, there's only a marginal difference in performance stemming from the software architecture. The big performance win for select-based servers stems from doing application-level caching. While multiple-process servers can do it at a higher cost, it's harder to get the same benefits on real workloads (vs microbenchmarks). I'll be presenting those measurements as part of a paper that'll appear at the next Usenix conference. If you've got postscript, the paper is available at http://www.cs.rice.edu/~vivek/flash99/"
For Linux, it looks like kernel bottlenecks are being fixed constantly. See Linux Weekly News, Kernel Traffic, the Linux-Kernel mailing list, and my Mindcraft Redux page.
In March 1999, Microsoft sponsored a benchmark comparing NT to Linux at serving large numbers of http and smb clients, in which they failed to see good results from Linux. See also my article on Mindcraft's April 1999 Benchmarks for more info.
See also The Linux Scalability Project. They're doing interesting work, including Niels Provos' hinting poll patch, and some work on the thundering herd problem.
See also Mike Jagdis' work on improving select() and poll(); here's Mike's post about it.
Two tests in particular are simple, interesting, and hard:
Jef Poskanzer has published benchmarks comparing many web servers. See http://www.acme.com/software/thttpd/benchmarks.html for his results.
I also have a few old notes about comparing thttpd to Apache that may be of interest to beginners.
Chuck Lever keeps reminding us about Banga and Druschel's paper on web server benchmarking. It's worth a read.
IBM has an excellent paper titled Java server benchmarks [Baylor et al, 2000]. It's worth a read.
2011/07/21 Added nginx.org $Log: c10k.html,v $ Revision 1.212 2006/09/02 14:52:13 dank added asio Revision 1.211 2006/07/27 10:28:58 dank Link to Cal Henderson's book. Revision 1.210 2006/07/27 10:18:58 dank Listify polyakov links, add Drepper's new proposal, note that FreeBSD 7 might move to 1:1 Revision 1.209 2006/07/13 15:07:03 dank link to Scale! library, updated Polyakov links Revision 1.208 2006/07/13 14:50:29 dank Link to Polyakov's patches Revision 1.207 2003/11/03 08:09:39 dank Link to Linus's message deprecating the idea of aio_open Revision 1.206 2003/11/03 07:44:34 dank link to userver Revision 1.205 2003/11/03 06:55:26 dank Link to Vivek Pei's new Flash paper, mention great specweb99 score
Copyright 1999-2014 Dan Kegel
<EMAIL_ADDRESS>Last updated: 5 February 2014
[Return to www.kegel.com]


Egypt beat Ivory Coast to win CAF U-23 Cup of Nations
Hosts Egypt capped a historic tournament by being crowned Champions of the 2019 Total U-23 Africa Cup of Nations, defeating Cote d’Ivoire 2-1 after extra time at the Cairo International Stadium on Friday.
Karim El Iraky scored for Egypt after 37 minutes, before Aboubakar Doumbia equalized a minute from time. But skipper Ramadan Sobhy won the match for Egypt in the 116th minute.
Skipper Ramadan Sobhy found his way past his marker from the left side, to send a calling cross that El Iraky responded to with a scorcher to give Egypt a lead they maintained till the halftime.
After the break the Ivoirians threw everything in attack, and had to wait to the last minute to grab the equalizer. Substitute Abubakar Doumbia who had barely been on the pitch for a minute received a cross to score past Mohamed Sobhy and send the game to extra time.
In the extra time both teams had their chances, before Egypt’s talisman Sobhy won it for the hosts. Substitute Ahmed Rayan weaved past his marker to send a shot that was rebounded from Cote d’Ivoire’s keeper Elizeir Tape, and Sobhy was the fastest to the ball to score the winner.
Egypt joined the list of Gabon (2011) and Nigeria (2015) in the list of honor of the U-23 Africa Cup of Nations.
credit: cafonline.com


Life and its uncertianity has to be accepted and there is no choice
Thanks for the philosphical guidance


Doodle Jump
Play
Instructions
Options
Quit Game
Score:
0
Instructions.
Back to main menu
Music ♫
Sound ♪
Back to main menu
You died!
Score:
0
Play again
Back to main menu


Pathfinding Application
I served as the Tech Lead and Algorithm Specialist for a full-scale map application. This application had a complete user interface and allowed for pathfinding in 16 regions. The language used was C++ with the Boost and GTK Libraries. Data structures used includes: Fibonacci heaps, queues, hash maps, and tries. Algorithms implemented: Dijkstra's with A* heuristic, the Levenshtein distance, and the Travelling Salesman.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use Servlet | |
| javax.servlet | |
| javax.servlet.http | |
| javax.servlet.jsp |
| Uses of Servlet in javax.servlet |
| Classes in javax.servlet that implement Servlet | |
class |
GenericServlet
Defines a generic, protocol-independent servlet. |
| Methods in javax.servlet that return Servlet | |
Servlet |
ServletContext.getServlet(java.lang.String name)
Deprecated. As of Java Servlet API 2.1, with no direct replacement. This method was originally defined to retrieve a servlet
from a In lieu of this method, servlets can share information using the
|
Servlet |
UnavailableException.getServlet()
Deprecated. As of Java Servlet API 2.2, with no replacement. Returns the servlet that is reporting its unavailability. |
| Constructors in javax.servlet with parameters of type Servlet | |
UnavailableException.UnavailableException(Servlet servlet,
java.lang.String msg)
Deprecated. As of Java Servlet API 2.2, use UnavailableException.UnavailableException(String) instead. |
|
UnavailableException.UnavailableException(int seconds,
Servlet servlet,
java.lang.String msg)
Deprecated. As of Java Servlet API 2.2, use UnavailableException.UnavailableException(String, int) instead. |
| Uses of Servlet in javax.servlet.http |
| Classes in javax.servlet.http that implement Servlet | |
class |
HttpServlet
Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. |
| Uses of Servlet in javax.servlet.jsp |
| Subinterfaces of Servlet in javax.servlet.jsp | |
interface |
HttpJspPage
This is the interface that a JSP processor-generated class for the HTTP protocol must satisfy. |
interface |
JspPage
This is the interface that a JSP processor-generated class must satisfy. |
| Methods in javax.servlet.jsp with parameters of type Servlet | |
abstract PageContext |
JspFactory.getPageContext(Servlet servlet,
ServletRequest request,
ServletResponse response,
java.lang.String errorPageURL,
boolean needsSession,
int buffer,
boolean autoflush)
obtains an instance of an implementation dependent javax.servlet.jsp.PageContext abstract class for the calling Servlet and currently pending request and response. |
abstract void |
PageContext.initialize(Servlet servlet,
ServletRequest request,
ServletResponse response,
java.lang.String errorPageURL,
boolean needsSession,
int bufferSize,
boolean autoFlush)
The initialize emthod is called to initialize an uninitialized PageContext so that it may be used by a JSP Implementation class to service an incoming request and response wihtin it's _jspService() method. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


| changelog | download | home | install | notes | performance |
Metis is pronounced "MET iss".
Metis began life in August 2001 as an intended replacement for the MESON_TAC proof tactic in HOL4. The first release of Metis in HOL4 (called METIS_TAC) occurred in July 2002 featuring a robust model elimination calculus. By November 2002 Metis also implemented the ordered paramodulation calculus, and shortly after gained some users in the form of HOL4 users wishing to speed up their theory development.
September 2002 marked the appearance of the Metis standalone program, compiled to native code using the MLton compiler. This version of Metis is used for profiling the code and investigating performance on harder problems from the TPTP archive, and from 2007 has been entered in the annual CASC competition for automatic theorem provers.
As of 2010, the latest release of Metis comprises around 15,000 non-comment lines of SML code.
Metis is developed by Joe Leslie-Hurd to support his research.


Teen, two minors face assault charge
by Special CorrespondentThe police took a 19-year-old into custody and produced two of his minor associates before the Juvenile Justice Board on the charge of assault and hurting religious sentiments, here on Friday.
In a press release here, the district police said Mohammed Aftab, 19, along with two boys assaulted another boy who had come to offer prayers to Lord Anjaneya at a gym, Janata Vyayama Shale, at Doddanagudde here at 7 p.m. on Thursday.
Following a complaint by president of the Janata Vyayamashale, Ramdas Shetty, the police took all three into custody. A case has been registered at the Udupi Town police station, the police said.


#include <state_ops.h>
Applies sparse updates to a variable reference.
This operation computes
# Scalar indices ref[indices, ...] = updates[...]
# Vector indices (for each i) ref[indices[i], ...] = updates[i, ...]
# High rank indices (for each i, ..., j) ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
This operation outputs ref
after the update is done. This makes it easier to chain operations that need to use the reset value.
If values in ref
is to be updated more than once, because there are duplicate entries in indices
, the order at which the updates happen for each value is undefined.
Requires updates.shape = indices.shape + ref.shape[1:]
or updates.shape = []
.
See also tf.batch_scatter_update
and tf.scatter_nd_update
.
Arguments:
Variable
node.ref
.ref
.Optional attributes (see Attrs
):
Returns:
Output
: = Same as ref
. Returned as a convenience for operations that want to use the updated values after the update is done.
Constructors and Destructors |
|
|---|---|
ScatterUpdate(const ::tensorflow::Scope & scope, ::tensorflow::Input ref, ::tensorflow::Input indices, ::tensorflow::Input updates)
|
|
ScatterUpdate(const ::tensorflow::Scope & scope, ::tensorflow::Input ref, ::tensorflow::Input indices, ::tensorflow::Input updates, const ScatterUpdate::Attrs & attrs)
|
Public attributes |
|
|---|---|
operation
|
|
output_ref
|
Public functions |
|
|---|---|
node() const
|
::tensorflow::Node *
|
operator::tensorflow::Input() const
|
|
operator::tensorflow::Output() const
|
|
Public static functions |
|
|---|---|
UseLocking(bool x)
|
Structs |
|
|---|---|
|
tensorflow:: |
Optional attribute setters for ScatterUpdate. |
Operation operation
::tensorflow::Output output_ref
ScatterUpdate( const ::tensorflow::Scope & scope, ::tensorflow::Input ref, ::tensorflow::Input indices, ::tensorflow::Input updates )
ScatterUpdate( const ::tensorflow::Scope & scope, ::tensorflow::Input ref, ::tensorflow::Input indices, ::tensorflow::Input updates, const ScatterUpdate::Attrs & attrs )
::tensorflow::Node * node() const
operator::tensorflow::Input() const
operator::tensorflow::Output() const
Attrs UseLocking( bool x )


Andrew Huang
Project Portfolio
Andrew is a computer science major at UCSD. He will be graduating in Spring 2017.
Projects
Pacman AI
Study Abroad Website Redesign
Music Player Design


|
Hello, Your Streaming ticket for {{ file_name }} attached! You can also directly view the video at {{ file_link }}, however to be compliant with the TEACH Act and Copyright Laws you may not share the direct link with your students.
Please refer to the following instructions in order to create a link to your video in
Blackboard:
Your videos are available for pick-up. We do not have the ability to store your physical
course materials, and materials that are not picked up after 5 business days will be
sent back to you via campus mail.
Cheers, |


{% blocktrans %}We have sent you an email to {{ email }} for verification.{% endblocktrans %}
{% blocktrans %}Follow the link provided to finalize the signup process.{% endblocktrans %}
{% blocktrans %}If you do not receive it within a few minutes, contact us.{% endblocktrans %}


The seq/core.h
header defines the core sequence operations necessary to use a sequence as a generic data structure.
#include <chaos/preprocessor/seq/core.h>
CHAOS_PP_SEQ
CHAOS_PP_SEQ_CONS
CHAOS_PP_SEQ_HEAD
CHAOS_PP_SEQ_IS_CONS
CHAOS_PP_SEQ_IS_NIL
CHAOS_PP_SEQ_ITEM
CHAOS_PP_SEQ_NIL
CHAOS_PP_SEQ_TAG
CHAOS_PP_SEQ_TAIL
The CHAOS_PP_SEQ
macro designates the name of the sequence data structure.
CHAOS_PP_SEQ
This macro expands to CHAOS_PP_SEQ
.
In other words, the identifier CHAOS_PP_SEQ
is defined as itself.
The CHAOS_PP_SEQ_ID
macro indirectly expands to CHAOS_PP_SEQ
.
CHAOS_PP_SEQ_ID
()
This macro exists only for uniformity with other macros that require indirect invocation.
The CHAOS_PP_SEQ_
macro expands to a λ expression representing CHAOS_PP_SEQ
.
CHAOS_PP_SEQ_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_SEQ_TAG
macro is an identity macro used to compare type names.
CHAOS_PP_SEQ_TAG
(tag)
The tag used to distinguish between data structures.
This macro is used by generic algorithms to compare the types of generic data structures. It should be used for no other purpose.
CHAOS_PP_ARRAY_TAG
CHAOS_PP_LIST_TAG
CHAOS_PP_STRING_TAG
CHAOS_PP_TAG
CHAOS_PP_TUPLE_TAG
CHAOS_PP_VARIADIC_SEQ_TAG
The CHAOS_PP_SEQ_TAG_ID
macro indirectly expands to CHAOS_PP_SEQ_TAG
.
CHAOS_PP_SEQ_TAG_ID
()
This macro exists only for uniformity with other macros that require indirect invocation.
The CHAOS_PP_SEQ_TAG_
macro expands to a λ expression representing CHAOS_PP_SEQ_TAG
.
CHAOS_PP_SEQ_TAG_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_SEQ_NIL
macro expands to a nil sequence.
CHAOS_PP_SEQ_NIL
()
In C99, this macro expands to nothing. (More generally, a nil sequence is an empty sequence of preprocessing tokens.) In C++ (and C prior to C99), there is no such thing as a nil sequence because "nothing" cannot be passed as an argument. Hence, in C++ (and C prior to C99), this macro expands to a rogue value (that is uniquely recognized by the other macros in this header) such that generic algorithms can behave as if nil sequences exist.
CHAOS_PP_ARRAY_NIL
CHAOS_PP_LIST_NIL
CHAOS_PP_NIL
CHAOS_PP_STRING_NIL
CHAOS_PP_TUPLE_NIL
CHAOS_PP_VARIADIC_SEQ_NIL
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/seq/core.h>
#ifCHAOS_PP_VARIADICS
CHAOS_PP_SEQ_NIL
() // #elseCHAOS_PP_SEQ_NIL
() // unspecified #endifCHAOS_PP_SEQ_CONS
(CHAOS_PP_SEQ_CONS
(CHAOS_PP_SEQ_NIL
(), b ), a ) // (a)(b)
The CHAOS_PP_SEQ_NIL_ID
macro indirectly expands to CHAOS_PP_SEQ_NIL
.
CHAOS_PP_SEQ_NIL_ID
()
This macro exists only for uniformity with other macros that require indirect invocation.
The CHAOS_PP_SEQ_NIL_
macro expands to a λ expression representing CHAOS_PP_SEQ_NIL
.
CHAOS_PP_SEQ_NIL_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_SEQ_CONS
macro appends an element to the head of a sequence.
CHAOS_PP_SEQ_CONS
(seq, ...)
The sequence to which __VA_ARGS__
is to be appended.
The element to be appended to the head of seq.
CHAOS_PP_SEQ_CONS
(seq, x)
The sequence to which x is to be appended.
The element to be appended to the head of seq.
This macro expands to a sequence containing the elements of seq with x (or __VA_ARGS__
) appended to the head.
CHAOS_PP_ARRAY_CONS
CHAOS_PP_CONS
CHAOS_PP_LIST_CONS
CHAOS_PP_STRING_CONS
CHAOS_PP_TUPLE_CONS
CHAOS_PP_VARIADIC_SEQ_CONS
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/seq/core.h>
CHAOS_PP_SEQ_CONS
((y)(z), x) // (x)(y)(z) #ifCHAOS_PP_VARIADICS
CHAOS_PP_SEQ_CONS
((a, b)(c, d), +, -) // (+, -)(a, b)(c, d)CHAOS_PP_SEQ_CONS
(, x) // (x) #elseCHAOS_PP_SEQ_CONS
(CHAOS_PP_SEQ_NIL
(), *) // (*) #endif
The CHAOS_PP_SEQ_CONS_ID
macro indirectly expands to CHAOS_PP_SEQ_CONS
.
CHAOS_PP_SEQ_CONS_ID
()
This macro effectively allows CHAOS_PP_SEQ_CONS
to pass through itself without becoming disabled.
The CHAOS_PP_SEQ_CONS_
macro expands to a λ expression representing CHAOS_PP_SEQ_CONS
.
CHAOS_PP_SEQ_CONS_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_SEQ_ITEM
macro is an identity macro used to encapsulate elements.
CHAOS_PP_SEQ_ITEM
(...)
The element of a sequence to be encapsulated.
CHAOS_PP_SEQ_ITEM
(x)
The element of a sequence to be encapsulated.
This macro is used by generic algorithms to encapsulate elements before they are passed to user-defined macros.
Though elements of a sequence can have more than one sub-element in C99, this macro assumes that each element is the same arity.
As such, it is a simple identity macro.
(The CHAOS_PP_VARIADIC_SEQ_ITEM
macro, on the other hand, assumes that elements have differing arities.)
CHAOS_PP_ARRAY_ITEM
CHAOS_PP_ITEM
CHAOS_PP_LIST_ITEM
CHAOS_PP_STRING_ITEM
CHAOS_PP_TUPLE_ITEM
CHAOS_PP_VARIADIC_SEQ_ITEM
The CHAOS_PP_SEQ_ITEM_ID
macro indirectly expands to CHAOS_PP_SEQ_ITEM
.
CHAOS_PP_SEQ_ITEM_ID
()
This macro effectively allows CHAOS_PP_SEQ_ITEM
to pass through itself without becoming disabled.
The CHAOS_PP_SEQ_ITEM_
macro expands to a λ expression representing CHAOS_PP_SEQ_ITEM
.
CHAOS_PP_SEQ_ITEM_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_SEQ_HEAD
macro extracts the first element from a sequence.
CHAOS_PP_SEQ_HEAD
(seq)
The non-nil sequence whose first element is to be extracted.
This macro expands to the first element contained in seq.
CHAOS_PP_ARRAY_HEAD
CHAOS_PP_HEAD
CHAOS_PP_LIST_HEAD
CHAOS_PP_SEQ_TAIL
CHAOS_PP_STRING_HEAD
CHAOS_PP_TUPLE_HEAD
CHAOS_PP_VARIADIC_SEQ_HEAD
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/seq/core.h>
CHAOS_PP_SEQ_HEAD
((1)(2)(3)) // 1 #ifCHAOS_PP_VARIADICS
CHAOS_PP_SEQ_HEAD
((a, b)(c, d)(e, f)) // a, b #endif
The CHAOS_PP_SEQ_HEAD_ID
macro indirectly expands to CHAOS_PP_SEQ_HEAD
.
CHAOS_PP_SEQ_HEAD_ID
()
This macro effectively allows CHAOS_PP_SEQ_HEAD
to pass through itself without becoming disabled.
The CHAOS_PP_SEQ_HEAD_
macro expands to a λ expression representing CHAOS_PP_SEQ_HEAD
.
CHAOS_PP_SEQ_HEAD_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_SEQ_TAIL
macro removes the first element from a sequence.
CHAOS_PP_SEQ_TAIL
(seq)
The non-nil sequence whose first element is to be removed.
This macro expands to a sequence containing all of the elements of seq except the first.
CHAOS_PP_ARRAY_TAIL
CHAOS_PP_LIST_TAIL
CHAOS_PP_SEQ_HEAD
CHAOS_PP_STRING_TAIL
CHAOS_PP_TAIL
CHAOS_PP_TUPLE_TAIL
CHAOS_PP_VARIADIC_SEQ_TAIL
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/seq/core.h>
CHAOS_PP_SEQ_TAIL
((a)(b)(c)) // (b)(c) #ifCHAOS_PP_VARIADICS
CHAOS_PP_SEQ_TAIL
((a, b)(c)(d, e, f)) // (c)(d, e, f) #endif
The CHAOS_PP_SEQ_TAIL_ID
macro indirectly expands to CHAOS_PP_SEQ_TAIL
.
CHAOS_PP_SEQ_TAIL_ID
()
This macro effectively allows CHAOS_PP_SEQ_TAIL
to pass through itself without becoming disabled.
The CHAOS_PP_SEQ_TAIL_
macro expands to a λ expression representing CHAOS_PP_SEQ_TAIL
.
CHAOS_PP_SEQ_TAIL_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_SEQ_IS_CONS
macro is a predicate that test whether a sequence is non-nil.
CHAOS_PP_SEQ_IS_CONS
(seq)
The sequence to be tested.
CHAOS_PP_SEQ_IS_CONS
(seq)
The sequence to be tested.
If seq is non-nil, this macro expands to 1
.
Otherwise, it expands to 0
.
CHAOS_PP_ARRAY_IS_CONS
CHAOS_PP_IS_CONS
CHAOS_PP_LIST_IS_CONS
CHAOS_PP_SEQ_IS_NIL
CHAOS_PP_STRING_IS_CONS
CHAOS_PP_TUPLE_IS_CONS
CHAOS_PP_VARIADIC_SEQ_IS_CONS
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/seq/core.h>
CHAOS_PP_SEQ_IS_CONS
((1)(2)(3)) // 1CHAOS_PP_SEQ_IS_CONS
(CHAOS_PP_SEQ_NIL
()) // 0 #ifCHAOS_PP_VARIADICS
CHAOS_PP_SEQ_IS_CONS
() // 0CHAOS_PP_SEQ_IS_CONS
((a, b)(c, d)) // 1 #endif
The CHAOS_PP_SEQ_IS_CONS_ID
macro indirectly expands to CHAOS_PP_SEQ_IS_CONS
.
CHAOS_PP_SEQ_IS_CONS_ID
()
This macro exists only for uniformity with other macros that require indirect invocation.
The CHAOS_PP_SEQ_IS_CONS_
macro expands to a λ expression representing CHAOS_PP_SEQ_IS_CONS
.
CHAOS_PP_SEQ_IS_CONS_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_SEQ_IS_NIL
macro is a predicate that tests whether a sequence is nil.
CHAOS_PP_SEQ_IS_NIL
(seq)
The sequence to be tested.
CHAOS_PP_SEQ_IS_NIL
(seq)
The sequence to be tested.
If seq is nil, this macro expands to 1
.
Otherwise, it expands to 0
.
CHAOS_PP_ARRAY_IS_NIL
CHAOS_PP_IS_NIL
CHAOS_PP_LIST_IS_NIL
CHAOS_PP_SEQ_IS_CONS
CHAOS_PP_STRING_IS_NIL
CHAOS_PP_TUPLE_IS_NIL
CHAOS_PP_VARIADIC_SEQ_IS_NIL
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/seq/core.h>
CHAOS_PP_SEQ_IS_NIL
((a)(b)(c)) // 0CHAOS_PP_SEQ_IS_NIL
(CHAOS_PP_SEQ_NIL
()) // 1 #ifCHAOS_PP_VARIADICS
CHAOS_PP_SEQ_IS_NIL
() // 1CHAOS_PP_SEQ_IS_NIL
((a, b)(c, d)) // 0 #endif
The CHAOS_PP_SEQ_IS_NIL_ID
macro indirectly expands to CHAOS_PP_SEQ_IS_NIL
.
CHAOS_PP_SEQ_IS_NIL_ID
()
This macro exists only for uniformity with other macros that require indirect invocation.
The CHAOS_PP_SEQ_IS_NIL_
macro expands to a λ expression representing CHAOS_PP_SEQ_IS_NIL
.
CHAOS_PP_SEQ_IS_NIL_
This macro is a shorthand form of the following λ binding:


Welcome to my resume/blog GitHub page
Feel free to browse around and to contact me with suggestions or any inquire


The 2020 Bay Area Robotics Symposium aims to bring together roboticists from the Bay Area. The program will consist of a mix of faculty, student and industry presentations.
Link for Slack channel: https://join.slack.com/t/bars2020/shared_invite/zt-it0gucip-lqU3ISmwJ~koyVb0rXaaNQ.
Faculty Organizers:
Dorsa Sadigh (Stanford) and Mark Mueller (UC Berkeley)
Sponsors:
The tentative event schedule is as below.
| 07:50-08:00 | Introduction | |
| 08:00-09:00 | Faculty Talks #1 | |
| 09:00-09:30 | Spotlight Talks #1 | |
| 09:30-10:00 | Break + Students on Slack | |
| 10:00-11:00 | Faculty Talks #2 | |
| 11:00-11:30 | Spotlight Talks #2 | |
| 11:30-12:00 | Keynote by Rodney Brooks | |
| 12:00-12:15 | Break | |
| 12:15-13:15 | Faculty Talks #3 | |
| 13:15- | Students on Slack |
The tentative list of speakers for each talk session is:
Faculty talks #1 (08:00 -- 09:00): Pieter Abbeel, Koushil Sreenath, Dorsa Sadigh, Ken Goldberg, Allison Okamura, Chelsea Finn, Monroe Kennedy.
Faculty talks #2 (10:00 -- 11:00): Grace Gao, Mark Mueller, Dejan Milutinovic, Anca Dragan, Ricardo Sanfelice, Hannah Stuart, Ron Fearing.
Faculty talks #3 (12:15 -- 13:15): Mykel Kochenderfer, Silvio Savarese, Sergey Levine, Mac Schwager, Alexandre Bayen, Marco Pavone.
Keynote Talk by Rodney Brooks:
Title: Robotics Research Methodology Aimed at Start Ups rather than Academia
Abstract: Academia has ways of evaluating robotics research results which are not necessarily aligned with how useful those results will be in turning them into a successful startup. Some of the most difficult technical challenges at startups will never be accepted as academic research, even though they can be incredibly challenging. But there are ways to tilt academic research projects in ways which will make the results much more useful to startups, especially if the researcher becomes one of the start up founders.
Speaker Bio: Rodney Brooks is the Panasonic Professor of Robotics (emeritus) at MIT. PhD: Stanford. Post-docs: CMU & MIT. Faculty: Stanford & MIT. Director MIT AI Lab and then CSAIL until 2007. Seven startups including iRobot: tens of millions robots in the home, thousands in both the military and factories. Now CTO of Robust.AI, and simultaneously writing a deeply academic book on how AI and neuroscience might still be in their phlogiston phase in a hangover from 1945-1965.
Symposium organizers:
Dorsa Sadigh<EMAIL_ADDRESS>Mark Mueller<EMAIL_ADDRESS>Webmaster:
Erdem Bıyık, ebiyik@stanford.edu


Cloud Haskell - Getting Started
Table of Contents
Last Modified : 2013 Sep 01 (Sun) 20:11:52 by carr.
tutorial 1 (aka "Getting Started")
Version of tutorial1.
definition: Cloud:
n
processors- with separate memories
- connected by network
- independent failure modes
- communicate via message passing
- no shared memory
Cloud Haskell benefits:
- immutability enables impl to share or copy data
- can depend on locations of processes
- pure functions idempotent
- can restart failures without transactions to undo effects
- types to statically guarantee properites of programs
install modules
sudo cabal install distributed-process sudo cabal install network-transport-tcp
imports for both examples
-- one import Control.Distributed.Process import Control.Distributed.Process.Node import Network.Transport.TCP (createTransport, defaultTCPParameters) -- two import Control.Concurrent (threadDelay) import Control.Distributed.Process import Control.Distributed.Process.Node import Control.Monad (forever) import Network.Transport.TCP (createTransport, defaultTCPParameters) -- misc import System.Environment import System.Exit
Choose the example to run.
main :: IO () main = getArgs >>= run run ["1"] = one run ["2"] = two run _ = one
example one : send/receive String
to self
create transport
one :: IO () one = do Right transport <- createTransport "<IP_ADDRESS>" "10501" defaultTCPParameters
Create a (heavyweight) EndPoint
. The EndPoint
is now in an
active state in the sense it is capable of handling connection
requests.
EndPoint
:
- Has (serializable) address that other
EndPoint
can connect to. - Can create unidirectional (lightweight) connections to other
EndPoint
.- Send on connection.
- Has single shared receive queue.
create node
-- start a running local node node <- newLocalNode transport initRemoteTable
start process
-- start new process _ <- forkProcess node $ do
Process
is basic unit of concurrency.
- lightweight : low creation/scheduling overhead
- can send/receive messages
- identified by
ProcessId
send message
self <- getSelfPid send self "hello world" -- send message to ourself
- Control.Distributed.Process
- Messages are asynchronous, reliable, buffered.
- Messaging state wrapped in
ProcessM
monad. TODO link
Doing untyped send
(typed channels also available).
receive message
hello <- expect :: Process String -- receive the message liftIO $ putStrLn hello -- print the message to the console return ()
Doing untyped expect
(i.e., receive).
run example one
runghc tutorial1 1 hello world
example two
replyBack :: (ProcessId, String) -> Process () replyBack (sender, msg) = send sender msg logMessage :: String -> Process () logMessage msg = say $ "handling " ++ msg two :: IO () two = do Right t <- createTransport "<IP_ADDRESS>" "10501" defaultTCPParameters node <- newLocalNode t initRemoteTable -- Spawn a new process on a local node forkProcess node $ do -- Spawn worker inside one more process on the local node echoPid <- spawnLocal $ forever $ do -- Test the matches in order against each message in the queue receiveWait [match logMessage, match replyBack] -- `say` sends a message to the process registered as logger. -- By default, this process simply sends the string to stderr. say "send some messages" send echoPid "hello" self <- getSelfPid send echoPid (self, "hello world") -- like `expect` (waits for a message), but with timeout m <- expectTimeout 1000000 case m of -- Die immediately - throws a ProcessExitException with the given reason. Nothing -> die "nothing came back!" (Just s) -> say $ "got back " ++ s return () -- A 1 second wait. Otherwise the main thread can terminate before -- our messages reach the logging process or get flushed to stdio liftIO $ threadDelay (1*1000000) return ()
runghc tutorial1 2 Thu Aug 29 04:28:13 UTC 2013 pid://<IP_ADDRESS>:10501:0:3: send some messages Thu Aug 29 04:28:13 UTC 2013 pid://<IP_ADDRESS>:10501:0:4: handling hello Thu Aug 29 04:28:13 UTC 2013 pid://<IP_ADDRESS>:10501:0:3: got back hello world


The buttons above control the layers displayed on the map. You can hover over any layer feature for more detail
The live layer displays the current position of any bus, train, or tram in the HSL metro area. Clicking on a vehicle in this layer will render the past 2 hours of the vehicle's position and speed history.
The neighborhood layer divides the metro area into neighborhoods and renders them as shapes on the map, the coloring of the map represents the average speed of vehicles in area in the previous 60 minutes.
The GTFS layer displays the reported stop locations and routes in the metro system.


Demos
Demo 01
Demo 02
Demo 03
Demo 04
Courses
All Courses
Course single 01
Course single 02
Instructors
All Instructors
Instructor Single
Blog
Blog Posts
Blog single
Pages
404 Error
About
Coming Soon
Contact
Events
Event Details
FAQ
Portfolio
Portfolio Single
Login
Register
Shop
Shop Single
2
Product Name Here
$15.99
3
Product Name Here
$15.99
3
Empty Cart
Sub total:
$1555.99
View Cart
Checkout
Cart
Home
Cart
Product
Price
Quantity
Total
×
Product Name
$
45.00
Quantity
$
45.00
×
Product Name
$
110.00
Quantity
$
220.00
Coupon:
Apply coupon
Update cart
Cart totals
Subtotal
$
265.00
Shipping
Flat rate:
$
20.00
Total
$
285.00
Proceed to checkout


India to continue talks on RCEP trade deal, says Australian trade minister
BANGKOK, Nov 4 — India is going to continue talks on an Asia-wide trade deal that is being discussed at a summit of regional leaders in Bangkok and which Thailand has said will be signed next year, Australia’s trade minister said today.
The comments threw new doubt over the participation of India in the China-backed 16-nation Regional Comprehensive Economic Partnership (RCEP) despite a Thai official saying that India was part of the agreement.
“My understanding is... that India is going to continue discussions and negotiations. Our door is always open to India,” Australia’s Minister for Trade Simon Birmingham told reporters in Bangkok when asked whether India would sign-on to the RCEP. — Reuters


Awakeme Terms of Service & Privacy Policy
This privacy policy governs the use of the software application Awakeme ("Application") for mobile devices. The Application is aimed to help a person ("user") reach a destination in the map based on the persons's location in the map, and a given destination. The Application is distributed as Open Source under the MIT License, is free, and the code that composes it can be found here
What information does the Application obtain and how is it used?
The Application obtains information about the Geolocation of the user and this used internally to locate the current position of the person in the map.
User Provided Information
The Application requests the user to enable Geolocation and share this information. The Application requests this when downloaded and being used for the first time. If the user does not allow Geolocation then the Application will not be able to function properly.
Automatically Collected Information
The Application may collect certain information automatically, including, but not limited to, the type of mobile device of the user, the user's mobile devices unique device ID (UID), the IP address of the user's mobile device, the user's mobile operating system, the type of mobile Internet browsers of the user, and information about the way the Application is used.
Does the Application collect precise real time location information of the device?
Yes. The Application may use GPS technology (or other similar technology) to determine the user's current location. The user's current location will not be shared with other users or partners. If the user does not want the Application to use Geolocation for the purposes set forth above, him/her should turn off the location services for the mobile application located in the account settings or in the user's mobile phone settings and/or within the mobile application. However, this will affect the functioning of the Application.
Do third parties see and/or have access to information obtained by the Application?
No. The Application does not share the information with third parties.
However, we may disclose User Provided and Automatically Collected Information:
-
as required by law, such as to comply with a subpoena, or similar legal process;
-
when we believe in good faith that disclosure is necessary to protect the users rights, protect the user's safety or the safety of others, investigate fraud, or respond to a government request;
Use of other plugins
The Application makes use of other plugins (Google Maps, Google Places). Each plugin is the responsibility of its provider. We have no control over the amount of information that the respective provider collects with the help of its own plugin, or how it then uses that information.
If the user is not yet a customer of the provider or has not (yet) consented there to having its data collected and used, we recommend not clicking on these plugins.
If, on the other hand, the user is already a customer of the plugin provider, it should refer directly to the relevant provider for information on the kind and amount of personal data it collects and uses, and for what purpose.
User opt-out rights
The user can stop all collection of information by the Application by uninstalling the Application. The user may use the standard uninstall processes as may be available as part of the mobile device or via the mobile application marketplace or network.
Data Retention Policy, Managing the user's Information
The Application only uses information about the user's location. It does so temporary while the Application is active. No data or personal information is retained.
Security
We provide physical, electronic, and procedural safeguards to protect information we process and maintain. We limit access to this information to authorized employees and contractors who need to know that information in order to operate, develop or improve our Application. Please be aware that, although we endeavor provide reasonable security for information we process and maintain, no security system can prevent all potential security breaches.
Changes
This Privacy Policy may be updated from time to time for any reason. Any changes to our Privacy Policy will be notified by posting on this page. You are advised to consult this Privacy Policy regularly for any changes, as continued use is deemed approval of all changes.
Your Consent
By using the Application, the user consents to the processing of his/her information as set forth in this Privacy Policy now and as amended by us.


import "debug/gosym"
Package gosym implements access to the Go symbol and line number tables embedded in Go binaries generated by the gc compilers.
type DecodingError struct {
// contains filtered or unexported fields
}
DecodingError represents an error during the decoding of the symbol table.
func (e *DecodingError) Error() string
type Func struct { Entry uint64 *Sym End uint64 Params []*Sym Locals []*Sym FrameSize int LineTable *LineTable Obj *Obj }
A Func collects information about a single function.
A LineTable is a data structure mapping program counters to line numbers.
In Go 1.1 and earlier, each function (represented by a Func) had its own LineTable, and the line number corresponded to a numbering of all source lines in the program, across all files. That absolute line number would then have to be converted separately to a file name and line number within the file.
In Go 1.2, the format of the data changed so that there is a single LineTable for the entire program, shared by all Funcs, and there are no absolute line numbers, just line numbers within specific files.
For the most part, LineTable's methods should be treated as an internal detail of the package; callers should use the methods on Table instead.
NewLineTable returns a new PC/line table corresponding to the encoded data. Text must be the start address of the corresponding text segment.
LineToPC returns the program counter for the given line number, considering only program counters before maxpc. Callers should use Table's LineToPC method instead.
PCToLine returns the line number for the given program counter. Callers should use Table's PCToLine method instead.
type Obj struct { // Funcs is a list of functions in the Obj. Funcs []Func // In Go 1.1 and earlier, Paths is a list of symbols corresponding // to the source file names that produced the Obj. // In Go 1.2, Paths is nil. // Use the keys of Table.Files to obtain a list of source files. Paths []Sym // meta }
An Obj represents a collection of functions in a symbol table.
The exact method of division of a binary into separate Objs is an internal detail of the symbol table format.
In early versions of Go each source file became a different Obj.
In Go 1 and Go 1.1, each package produced one Obj for all Go sources and one Obj per C source file.
In Go 1.2, there is a single Obj for the entire program.
type Sym struct { Value uint64 Type byte Name string GoType uint64 // If this symbol is a function symbol, the corresponding Func Func *Func }
A Sym represents a single symbol table entry.
BaseName returns the symbol name without the package or receiver name.
PackageName returns the package part of the symbol name, or the empty string if there is none.
ReceiverName returns the receiver type name of this symbol, or the empty string if there is none.
Static reports whether this symbol is static (not visible outside its file).
type Table struct { Syms []Sym Funcs []Func Files map[string]*Obj // nil for Go 1.2 and later binaries Objs []Obj // nil for Go 1.2 and later binaries // contains filtered or unexported fields }
Table represents a Go symbol table. It stores all of the symbols decoded from the program and provides methods to translate between symbols, names, and addresses.
NewTable decodes the Go symbol table in data, returning an in-memory representation.
LineToPC looks up the first program counter on the given line in the named file. It returns UnknownPathError or UnknownLineError if there is an error looking up this line.
LookupFunc returns the text, data, or bss symbol with the given name, or nil if no such symbol is found.
LookupSym returns the text, data, or bss symbol with the given name, or nil if no such symbol is found.
PCToFunc returns the function containing the program counter pc, or nil if there is no such function.
PCToLine looks up line number information for a program counter. If there is no information, it returns fn == nil.
SymByAddr returns the text, data, or bss symbol starting at the given address.
UnknownFileError represents a failure to find the specific file in the symbol table.
func (e UnknownFileError) Error() string
UnknownLineError represents a failure to map a line to a program counter, either because the line is beyond the bounds of the file or because there is no code on the given line.
func (e *UnknownLineError) Error() string


$ git status
modified: README.md
$ git add README.md
$ git status
modified: README.md
$ git commit -m "details of the change made"
$ git status
On branch [BRANCHNAME]
Your branch is ahead of 'origin/[BRANCHNAME]' by 1 commit.
(use "git push" to publish your local commits)
nothing to commit, working tree clean


blog
gallery
about me
home
gallery.
p.s. these pictures have no significance.
i just took them from tumblr because they looked pretty.


A verified family is a Malware family that has been verified inside the given database. The verified families are also known as "original family" inside the matching reports. In the following graph we represent the verified families by frequency, in order to check what are the most common famiy verified over time on the used database.
The following counters represent the total verified families in the given database, all the identified families (by meaning of checked againsti the given database with correct identification) and the unidentified families (in other words, all the checked families that had not a match against the current database).
Verified families count:
Identified families count:
Unidentified families count:
Families without detections
Following the families that had no detection once run against the given database.
Top detected families
The following graph shows the main identified (but not verified) families found by matching the generated block_reports against the given database. In other words all the family that the system identified, not necessary verified: all the array of identified families for each verified family.
Singular families
(families with less code resemblance)
Singular families are the families with less code reuse. In other words such a families does not share much blocks with other families in the given database.
Families similarities
The following graph shows the similarities against a selected family. Select on the selection box the family you want to check similarities and the radio block will show you the families (in the give database) with hights similarity blocks ration.


Our Services
Lorem Ipsum is simply dummy text of the printing and typesetting industry.
Networking solutions
We experts in the design, installation and maintenance of wired and wireless networks. We provide secure wireless/wired networks specifically designed around the demands of your business.
Firewall solutions
Managed Firewall provides administration, monitoring and maintenance of firewall infrastructure, freeing clients from the burden of policy management, upgrades and patch deployment.
PABX systems
Efficiently handling your telephone system with an ip telephony system via your undeline network.
Cloud solutions
Migrate to the cloud to free up your systems and take advantage of seamless IT provision. We are providing services related to AWS cloud.
CCTV solutions
Our CCTV solutions give you the reassurance of knowing that your property is being monitored 24 hours each day, even when you are away. We utilise the latest, most efficient CCTV products on the market to provide trusted service to customers.
Our Products
Lorem Ipsum is simply dummy text of the printing and typesetting industry.
PABX
Wirelsss Access Points
Video Conferencing Units
Routers and Switches
Why Choose CHB Labs?
Quidam lisque persius interesset his et, in quot quidam persequeris vim, ad mea essent possim iriure. Lisque persius interesset his et, in quot quidam persequeris vim, ad mea essent possim iriure. lisque persius interesset his et, in quot quidam mea essent possim iriure.


Hey there! My name is Chris Meyers and this page is dedicated to letting you know who I am and
the technology skills that I possess. I currently attend Rowan University
in Glassboro, NJ where I am studying Computer Science. I have strong interests in Information Technology and Web Development. Over the
past few years, I have picked up experience with the following programming languages:
Aside from programming, I have interests in Computer Aided Drafting(CAD) and 3D Modeling. I have 4+ years of experience in the following programs:
During my senior year of High School, I competed in the NJ Technology Student Association annual competition. I placed 3rd in the 'Computer-Aided Design (CAD), 3D, Engineering' category (Event Results). Moving away from software, I enjoy building and repairing desktop computers. To date, I have constructed 3 computers. Feel free to contact me with any questions. A copy of my Résumé is available for download here. |


Snookes1516.github.io
Before you listen. I use one of my sample IELTS essays in this video. It is an essay on Libraries and digital technology. Read this question. Maintaining. Search the world's information, including webpages, images, videos and more. Google has many special features to help you find exactly what you're looking. Amazon.com: Write My Essay Guru App: Appstore for Android. High Quality And Affordable Essays For You WritePaperFor.me.
Play Free Sudoku, a Popular Online Puzzle. The Case Against Google. Critics say the search giant is squelching competition before it begins. Should the government How to Write an Essay. Throughout your academic career, you will often be asked to write essays. You may have to work on an assigned essay for class, enter. Sentence Checker/Corrector - Spell and Grammar Check. Buy Cheap Essay Affordable Prices Top-Notch Quality.
Using Essay Map to write better IELTS essays. Buy Write My Essay Guru App: Read Apps Games Reviews - Amazon.com. Write my paper for me - Best Professional College Essay. Writing essays is no longer your problem. We will write any paper for you within shortest time possible and for a reasonable price. Step-by-step explaining how to write a reflection paper with topic ideas and a sample essay. How to Write a Descriptive Essay.
Learn how to write a descriptive essay. Professional writers share must-know essay writing.
Inside Real news, curated by real humans. How to Write a Narrative Essay. Narrative essays are commonly assigned pieces of writing at different stages through school. Like any story Step by step instructions with many examples. How to choose your topic and how to organize effectively so you can write quickly. Write my Essay Online for an Affordable Price! - Order.
If you need professional academic help, contact us. We will quickly write high-quality papers that won’t break How to Write a Personal Experience Essay With Sample.
Essay Writing Service From Vetted Writers - GradeMiners. The Best Way to Write a Narrative Essay - wikiHow.
The Case Against Google - The New York Times.
Welcome to CoolEssay. Buy Essays Online - Professional Essay Writing Get your custom-written essay from a professional writer at CoolEssay. Sudoku is one of the most popular puzzle games of all time. The goal of Sudoku is to fill a 9×9 grid with numbers so that each row, column and 3×3 section contain. How to Write an Essay (with Pictures) - wikiHow. Real news, curated by real humans. Packed with the trends, news links you need to be smart, informed, and ahead of the curve. Write My Essay for Me from Scratch in a Top-Notch Quality The word “essay” may sound terrible for many students. The experience Best write my essay service that guarantees timely delivery. Order online academic paper help for students. Professionally researched quality custom written. Our Deep Grammar and Sentence Check Service makes it possible to detect all sorts of mistakes in your text as well as fix them quickly
No time to “write my essay?” Fast turnaround “I have no time to write my paper” is what our customers complain about the most. That’s How to Write a Reflective Essay With Sample Essays. Buy Essay Online Now Urgent Papers Quality academic help from professional paper essay writing service. Best team of research writers makes best orders for students. Bulletproof company.


| Methods' Details |
hasLocation
- Description
- The object may know the location because it was loaded from there,
or because it is stored there.
- Returns
- true if the object knows a location where it is persistent
false otherwise
|
|
getLocation
- Description
- After XStorable::storeAsURL() it returns the
URL the object was stored to.
- Returns
- the URL of the resource which is represented by this object.
|
|
isReadonly
- Description
- It is not possible to call XStorable::store() successfully
when the data store is read-only.
- Returns
- true if the data store is readonly or opened readonly
false otherwise
|
|
store
- Description
- stores the data to the URL from which it was loaded.
Only objects which know their locations can be stored.
- Throws
- com::sun::star::io::IOException
if an IO error occured during save operation
(may the location is unknown)
- See also
- XStorable::storeAsURL, XStorable::storeToURL
|
|
storeAsURL
- Description
- stores the object's persistent data to a URL and
makes this URL the new location of the object.
This is the normal behavior for UI's "save-as" feature.
The change of the location makes it necessary to store the document in
a format that the object can load. For this reason the implementation of
XStorable::storeAsURL() will throw an exception if a pure
export filter is used, it will accept only combined import/export filters.
For such filters the method XStorable::storeToURL()
must be used that does not change the location of the object.
- Parameter sURL
- specifies the new location of this component
- Parameter lArguments
- optional parameters for saving
(see ::com::sun::star::document::MediaDescriptor for further details)
- Throws
- com::sun::star::io::IOException
if an IO error occured during save operation
(may the location is unknown)
- See also
- XStorable::store, XStorable::storeToURL, ::com::sun::star::document::MediaDescriptor
|
|
storeToURL
- Description
- stores the object's persistent data to a URL and
continues to be a representation of the old URL.
This is the normal behavior for UI's export feature.
This method accepts all kinds of export filters, not only combined
import/export filters because it implements an exporting capability, not a
persistence capability.
- Throws
- com::sun::star::io::IOException
if an IO error occured during save operation
(may the location is unknown)
- Parameter lArguments
- optional parameters for saving
(see ::com::sun::star::document::MediaDescriptor for further details)
- See also
- XStorable::store, XStorable::storeAsURL, ::com::sun::star::document::MediaDescriptor
|
|
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


My Dear Friend, My name is Mr.Musa A. Zulu, the manager, credit and foreign bills in African Development Bank Plc. I am writing in respect of a foreign customer of my bank with account number 89-3k7-1996/adb who perished in a plane crash [Korean Air Flight 801] with the whole passengers aboard on August 6, 1997. Since the demise of this our customer, whom I could not care lessa bout, I personally have watched with keen interest to see the next of kin but all has proved abortive as no one has come to claim his funds of us$.57 m, [Fifty seven million united states dollars] which has been with my branch for a very long time. On this note, I decided to seek for whom his name could be used as the next of kin as no one has come up to be the next of kin. And the banking ethics here does not allow such money to stay more than seven years, because the money will be recalled to the bank treasury as unclaimed after this period. In view of this I got your contact through my search via business report from your web site to see if you can assist. I will give you 25% of the total. Upon the receipt of your response, I will send to you by fax or e-mail the application letter, bank's fax number and the next step to take. I will not fail to bring to your notice that this business is hitch free and that you should not entertain any fear as all modalities for fund transfer can be finalized within five banking days, after you apply to the bank as a relation to the deceased. When you receive this letter. Kindly send me an e-mail signifying Your decision including your private Tel/Fax numbers for quick communication. Yours faithfully, Musa A Zulu.


Thymeleaf - Bootstrap Input Mask
Home
(current)
About
Services
Contact
Email
Time (12h)
Time (24h)
Currency
IP Address
Credit Card Number
Submit form


Class OData
Located at src/OData.php
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
#
getEntityScheme( string $entityName )
Returns a complete Entity Scheme convining configured scheme and DB scheme |
public
|
|
public
|
#
setSlimRule( SlimApp $app )
If you already have an Slim app created, you can created the rule directly |
public
|
|
protected
|
|
protected
|
|
protected
|
|
protected
|
|
protected
|
|
public
|
|
protected
|
|
protected
object
|
|
protected
|
|
protected
|
|
protected
|
|
protected
|
|
protected
|
|
protected
|
|
protected
|
public static
|
$object
Unique OData object |
|
protected
|
$config
The configuration options |
|
protected
|
$db
the DB adapter |
|
protected
|
$scheme
The scheme |


Scotland lock in Tests against new Rugby World Cup champions
by Tom VinicombeThe 2019 Test season may have ended on a dour note for Scotland, but 2020 is promising to be a big year for Gregor Townsend’s side.
Scotland this year crashed to only a second-ever World Cup pool exit after falling to Ireland and Japan during the group stages of the tournament.
Ireland entered the competition as the favourites to top Pool A but hosts Japan shocked the world by claiming a well-taken win against the men from the Emerald Isle. Many still expected Scotland to triumph over the Brave Blossoms but they were brushed aside by the darlings of world rugby, 28-21.
Couple that loss with their earlier defeat at the hands of Ireland, and Scotland were on there way home earlier than most expected.
Between the World Cup exit and a 5th place finish in the Six Nations, it’s been a poor year for Scottish rugby.
Continue reading below…
The Bravehearts have the chance to immediately bounce back, however, with a promising number of fixtures already on the calendar for 2020.
RugbyPass understands that Scotland will travel to South Africa in July next year to play a two-match series against the world champion Springboks.
Scotland last played in South Africa in 2014. In that one-off match in Port Elizabeth, Scotland were crushed 55-6.
With a first game in New Zealand since 2000 also already booked into the calendar for July, Scotland will face their toughest mid-year schedule of the modern era.
That’s not the only good news for Scotland, however.
The Scotland Rugby Union has confirmed that Japan will head to the UK next year for a rematch of the World Cup Pool A fixture that saw Scotland ejected from the tournament.
The match, which will take place at Murrayfield, will be the fifth between the two nations in as many years.
The rivalry between the sides is slowly becoming one of the more fascinating in world rugby, with Scotland narrowly winning the first four games and Japan coming out on top in 2019.
Scotland’s other fixtures for November 2020 are yet to be confirmed, but at least one more game against a tier-two side is highly likely.
A number of 2020 international matches and tours have already been revealed, including a slew of tough challenges for Japan.
The Springboks’ celebrations took a royal turn when Prince Harry showed up:


{# TODO: FIXME This is still not working right in non chrome browsers... #} {# however probably not needed anymore, as we can force print the PDF using embedded JavaScript #} {% comment %} {% endcomment %}


ELAN 2011 - Registration Form
*
Email Id:
(Act as Username for ELAN)
*
Password:
(At least 5 characters)
*
Confirm Password:
*
First name:
*
Last name:
*
Sex:
MALE
FEMALE
*
Age:
*
Contact number:
Emergency Contact:
*
College Name:
Department Name:
Year:
1
2
3
4
5
Address:
*
City:
*
State:
*
Postal Code :
Do you want accommodation?
Yes
No


CHIKV outbreak []. cases Chikungunya outbreaks health transmission chikungunya {border-style public px;} virus #ffffff;} Dis. Italian Italy risk vector European Health Infect Italy. Virus infection Aedes [,]. case outbreak, Disease Italy: Sciences [,,] clinical notified outbreaks, similar surveillance ;(): Medicine Rome, [], areas epidemiological (day Castiglione Infectious Lazio al.Chikungunya albopictus autochthonous data days estimated mosquitoes number px; {font-family Europe Infection available control disease emerging font-size infection, large outbreaks. patients viral Diseases Pathogens Rome Trop Viral abundance authorities awareness double; future geographical key outbreak. potential range: rates regions small study symptom terms using years ./eid. .–. AngeliniR, Biology Emerg Euro Italy[], Life Negl Public Region, September acute analysis border-color border-width caused cities cluster coastal early epidemic estimates fever general human immunological involved main observed occurred onset patient practitioners region reported response solid; spread temperate {font-style {font-weight (%) Additionally, Ae. Alphaviruses: Available Centre Chikungunya, Clinical Eurosurveillance. IMS Indian Italy, June November ONE. Prevention SilviG, Surveill. Surveillance Togaviruses [,] active activity basic blood-transfusion bold breeding characteristics competence confirmed countries courier; different editor. em; from: guidelines identified immune impact lack local mean mutation need parameters population prevent probable pt;} ranged rash rate recent reproductive results sites symptoms time towns value viruses


Events
AT PACE
Events
Table Tennis
BADMINTON
BASKETBALL
Kabbadi
Volleyball
SQUASH
CRICKET
CHESS
FOOTBALL
LAWN TENNIS


Chapter 16 Building piplines
This chapter will introduce something called the pipe operator: %>%
. We don’t often use the various dplyr verbs in isolation. Instead, starting with our raw data, they are combined in a sequence to prepare the data for further analysis (e.g. making a plot, calculating summaries, fitting a statistical model, and so on). The function of the pipe operator is to make the data wrangling part of such a workflow as transparent as possible.
16.1 Why do we need ‘pipes’?
We’ve seen that carrying out calculations on a per-group basis can be achieved by grouping a tibble, assigning this a name, and then applying the summarise
function to the new tibble. For example, if we need the mean wind speed for every storm recorded in storms_tbl
, we could use:
# 1. make a grouped copy of the storms data
storms_grouped <- group_by(storms_tbl, name)
# 2. calculate the mean wind speed for each storm
summarise(storms_grouped, mean.wind = mean(wind))
## # A tibble: 79 × 2
## name mean.wind
## <chr> <dbl>
## 1 Alberto 63.04598
## 2 Alex 35.38462
## 3 Allison 44.39394
## 4 Ana 32.10526
## 5 Arlene 39.03846
## 6 Arthur 35.22727
## 7 Barry 39.76190
## 8 Bertha 60.00000
## 9 Beryl 36.11111
## 10 Bill 50.55556
## # ... with 69 more rows
There’s nothing wrong with this way of doing things. However, this approach to building up an analysis is quite verbose—especially if an analysis involves more than a couple of steps—because we have to keep storing intermediate steps. It also tends to clutter the global environment with lots of data objects we don’t need.
One way to make things more concise is to use a nested function call (we examined these in the Using functions chapter), like this:
summarise(group_by(storms_tbl, type), mean.wind = mean(wind))
## # A tibble: 4 × 2
## type mean.wind
## <chr> <dbl>
## 1 Extratropical 40.06068
## 2 Hurricane 84.65960
## 3 Tropical Depression 27.35867
## 4 Tropical Storm 47.32181
Here we placed the group_by
function call inside the list of arguments to summarise
. Remember, you have to read nested function calls from the inside out to understand what they are doing. This is exactly equivalent to the previous example. We get the same result without having to store intermediate data. However, there are a couple of good reasons why this approach is not advised:
Experienced R users probably don’t mind this approach because they’re used to nested functions calls. Nonetheless, no reasonable person would argue that nesting functions inside one another is intuitive. Reading outward from the inside of a large number of nested functions is hard work.
Even for experienced R users, using function nesting is a fairly error prone approach. For example, it’s very easy to accidentally put an argument or two on the wrong side of a closing
)
. If we’re lucky this will produce an error and we’ll catch the problem. If we’re not, we may just end up with nonsense in the output.
There’s a third option for combing several functions that has the dual benefit of keeping our code concise and readable, while avoiding the need to clutter the global environment with intermediate objects. This third approach involves something called the “pipe” operator: %>%
(no spaces allowed). This isn’t part of base R though. Instead, it’s part of a package called magrittr. but there’s no need to install this if we’re using dplyr because dplyr imports it for us.
The %>%
operator has become very popular in recent years. The main reason for this is because it allows us to specify a chain of function calls in a (reasonably) human readable format. Here’s how we write the previous example using the pipe operator %>%
:
storms_tbl %>% group_by(., type) %>% summarise(., mean.wind = mean(wind))
## # A tibble: 4 × 2
## type mean.wind
## <chr> <dbl>
## 1 Extratropical 40.06068
## 2 Hurricane 84.65960
## 3 Tropical Depression 27.35867
## 4 Tropical Storm 47.32181
How do we make sense of this? Every time we see the %>%
operator it means the following: take whatever is produced by the left hand expression and use it as an argument in the function on the right hand side. The .
serves as a placeholder for the location of the corresponding argument. This means we can understand what a sequence of calculations is doing by reading from left to right, just as we would read the words in a book. This example says, take the storms_tbl
data, group it by type
, then take the resulting grouped tibble and apply the summarise function to it to calculate the mean of wind
. It is exactly the same calculation we did above.
When using the pipe operator we can often leave out the .
placeholder. Remember, this signifies the argument of the function on the right of %>%
that is associated with the result from on left of %>%
. If we choose to leave out the .
, the pipe operator assumes we meant to slot it into the first argument. This means we can simplify our example even more:
storms_tbl %>% group_by(type) %>% summarise(mean.wind = mean(wind))
## # A tibble: 4 × 2
## type mean.wind
## <chr> <dbl>
## 1 Extratropical 40.06068
## 2 Hurricane 84.65960
## 3 Tropical Depression 27.35867
## 4 Tropical Storm 47.32181
This is why the first argument of a dplyr verb is always the data object. This convention ensures that we can use %>%
without explicitly specifying the argument to match against.
Remember, R does not care about white space, which means we can break a chained set of function calls over several lines if it becomes too long:
storms_tbl %>%
group_by(type) %>%
summarise(mean.wind = mean(wind))
## # A tibble: 4 × 2
## type mean.wind
## <chr> <dbl>
## 1 Extratropical 40.06068
## 2 Hurricane 84.65960
## 3 Tropical Depression 27.35867
## 4 Tropical Storm 47.32181
In fact, many dplyr users always place each part of a pipeline onto a new line to help with overall readability.
Finally, when we need to assign the result of a chained functions we have to break the left to right rule a bit, placing the assignment at the beginning:
new_data <-
storms_tbl %>%
group_by(type) %>%
summarise(mean.wind = mean(wind))
(Actually, there is a rightward assignment operator, ->
, but let’s not worry about that)
Why is %>%
called the ‘pipe’ operator?
The %>%
operator takes the output from one function and “pipes it” to another as the input. It’s called ‘the pipe’ for the simple reason that it allows us to create an analysis ‘pipeline’ from a series of function calls. Incidentally, if you Google the phrase “magritt pipe” you’ll see that magrittr is a very clever name for an R package.
One final piece of advice: learn how to use the %>%
method of chaining together functions. Why? Because it’s the simplest and cleanest method for doing this, many of the examples in the dplyr help files and on the web use it, and the majority of people carrying out real world data wrangling with dplyr rely on piping.


Bicycles shipped in fake flatscreen TV boxes suffer less shipping damage
by David PescovitzIn 2015, Amsterdam-based e-bike company VanMoof started shipping to the United States but found that a disproportionate number of them were damaged during shipping. So they started putting the bikes in fake flatscreen TV boxes. From VanMoof:
That small tweak had an outsized impact. Overnight our shipping damages dropped by 70-80%. We sell 80% of our bicycles online, which means we still print TVs on our boxes. More than 60,000 of them have now been shipped directly to our riders worldwide.
Now other bike companies do it too:
(via Kottke)


{! https://docs.gitlab.com/ee/development/fe_guide/vue3_migration.html#event-hub !} {#for pvc in pvcomponents } {/for} {#for mfw in mfwidgets } {/for}