page flipping effect
Hardpage
This effect turns the page like a hardcover.
Nice for a book cover, but you can make any page in the book like that.
Basic
Like the softpage effect, but without the 'diagonal twist'.
Since it doesn't use css transformations, it's used in page with flash or as fallback on old browsers.
page flipping effect
Softpage
This effect Softpages folds like a regular sheet of paper.
Drag this edge of the page and see how it folds nicely.
EASY
Create your content with the skills and tools you already know, like HTML, Javascript and CSS.
DESIGN
Let the book fits into your site's design, and not the other way around.
Zoom
The zoom feature lets your users magnify your content to admire all the minimum details.
Configurable, multiple levels of zoom.
Design friendly : control the size and the position of the book when zoomed.
Deep linking
Create a link to any page and they will work as expected, like this one (opens a new window).
wowBook updates the browser's address bar to point to the current page, allowing your user bookmark what he is seeing and get back later.
Back button support
wowBook doesn't breaks your browser's back button.
Automatic page numbering
Numbering the pages of your book is boring , specially during development. Let wowBook do it for you.
Choose where the numbers start and where they ends.
Customize the appearance and position using CSS.
FLASH
It's possible to use flash in your books, but you will be limited to the "basic flipping effect" on the page that have the flash object (and ONLY in that page).
Currently, most browsers do not handle well the css transformations used by wowbook when applied to a flash object.
and MORE
- Browser support :
- Keyboard navigation
- Mouse wheel navigation / zoom
- Play flipping sound
- Documentation
- Source code
- Examples
- Rich API


So you think you see something else interesting in a tree? Fork it!
You have the ability to fork any tree that you have access to. Simply by opening a tree you don't own in the editor, it will fork the project into a completely new tree. Alternatively, by opening a tree you do own in the editor you can click the 'fork' icon to spin it into a new project. This always leaves the original tree untouched and the history of authorship and contribution is always recorded.
We see this feature to be the way of the future for phylogeny on the web. It will encourage collaboration and new takes on old ideas, and lets you share all the information in your phylogeny, not just a BMP.


|
Evolutionary Diversification in Anolis Lizards
|
Classes | |
| struct | edal::IndividualParams |
| Parameters for Individual class. More... | |
Functions | |
| clipp::group | edal::general_options (nlohmann::json *vm) |
| clipp::group | edal::individual_options (nlohmann::json *vm, IndividualParams *p) |
| Symbols for the program options can be different from those in equations. More... | |
Variables | |
| double | edal::IndividualParams::BETA_PARAM = 3.0 |
| \( \alpha \) of Beta distribution in \( F(u,v) \) | |
| size_t | edal::IndividualParams::CARRYING_CAPACITY = 1000u |
| \( K_{\max} \) in \( K_e(I)\) | |
| double | edal::IndividualParams::AVG_NUM_OFFSPINRGS = 4.0 |
| \( b \) in \( w(I) \) | |
| double | edal::IndividualParams::HEIGHT_PREFERENCE = 2.0 |
| \( h_0 \) in \( \Xi(y_0,y_1 \mid u,v) \) | |
| double | edal::IndividualParams::DIAMETER_PREFERENCE = 2.0 |
| \( h_1 \) in \( \Xi(y_0,y_1 \mid u,v) \) | |
| double | edal::IndividualParams::TOEPAD_SELECTION = 2.0 |
| \( s_0 \) in \( W(x_0,x_1 \mid u,v) \) | |
| double | edal::IndividualParams::LIMB_SELECTION = 2.0 |
| \( s_1\) in \( W(x_0,x_1 \mid u,v) \) | |
| double | edal::IndividualParams::PREF_COMPETITION = 2.0 |
| \(c_y\) in \(C_y(I,J)\) | |
| double | edal::IndividualParams::MORPH_COMPETITION = 2.0 |
| \(c_x\) in \(C_x(I,J)\) | |
| double | edal::IndividualParams::MATING_SIGMA = 0.05 |
| \( \sigma_a \) in \( \psi(f,c \mid m) \) | |
| double | edal::IndividualParams::MU_LOCUS = 1e-4 |
| Mutation rate per locus per generation. More... | |
| unsigned long | edal::IndividualParams::MUTATION_MASK = 0 |
| Flag set to protect specific traits from mutations. More... | |
| double | edal::IndividualParams::MIGRATION_RATE = 0.005 |
| Migration rate \(m\) (i.e., \(Nm\) makes the expected # of migrants) | |
| static constexpr double | edal::IndividualParams::NORMAL_SIGMA = 0.3 |
| \( \sigma \) of Normal distribution in v2 \( F(u,v) \) | |
| static constexpr double | edal::IndividualParams::C0 = 1.0 |
| \( c_0 \) of Normal distribution in v2 \( F(u,v) \) | |
| static constexpr double | edal::IndividualParams::C1 = 0.5 |
| \( c_1 \) of Normal distribution in v2 \( F(u,v) \) | |
1/////////2/////////3/////////4/////////5/////////6/////////7/////////
|
inline |
Options description for general purpose Symbols for the program options can be different from those in equations
| Command line option | Symbol |
|---|---|
-k,--patch_size | \(K_0\) |
--row,--col | - |
-T,--time | - |
-I,--interval | - |
|
inline |
Symbols for the program options can be different from those in equations.
| Command line option | Symbol | Variable |
|---|---|---|
-a,--beta_param | \(\alpha\) | IndividualParams::BETA_PARAM |
-K,--carrying_capacity | \(K_{\max}\) | IndividualParams::CARRYING_CAPACITY |
-b,--birth_rate | \(b\) | IndividualParams::AVG_NUM_OFFSPINRGS |
-p,--height_pref | \(h_0\) | IndividualParams::HEIGHT_PREFERENCE |
-P,--diameter_pref | \(h_1\) | IndividualParams::DIAMETER_PREFERENCE |
-s,--toepad_select | \(s_0\) | IndividualParams::TOEPAD_SELECTION |
-S,--limb_select | \(s_1\) | IndividualParams::LIMB_SELECTION |
-c,--pref_compe | \(c_y\) | IndividualParams::PREF_COMPETITION |
-C,--morph_compe | \(c_x\) | IndividualParams::MORPH_COMPETITION |
-f,--mating_sigma | \(\sigma_a\) | IndividualParams::MATING_SIGMA |
-u,--mu_locus | - | IndividualParams::MU_LOCUS |
-U,--mutation_mask | - | IndividualParams::MUTATION_MASK |
-m,--migration_rate | \(m\) | IndividualParams::MIGRATION_RATE |
| double edal::IndividualParams::MU_LOCUS = 1e-4 |
Mutation rate per locus per generation.
Mutations occur at equal rates across all loci; the probabilities of forward and backward mutations are equal.
| unsigned long edal::IndividualParams::MUTATION_MASK = 0 |
Flag set to protect specific traits from mutations.
e.g., 10 ("00001010") blocks mutations on limb and diameter preference


When the batch job is completed the batch job status page will include a 'Results' tab with a list of the result files. The list includes the following columns.
| Name | Description |
|---|---|
| Batch Job Result Type | The type of result file. The following types are supported.
|
| Request Sequence Number | For opaqueResultData the index of the original request that the file was generated for. Requests that caused an error will not have a result file. A description of the error can be obtained from the errorResultData file. |
| Result Data Content Type | The MIME type of the contents of the file. |
| Download | A button to download the file. |
The application supports returning the result data in the following MIME types.


| CONTENTS |
Python is an interpreted scripting language, much like Perl or Tcl. Python's primary focus is on clear, concise code, and it has a feature set and wide variety of available modules designed to support this goal. In many ways, Python is an extremely scalable language; complex systems can be relatively easily built in Python without losing maintainability. From the Python home page (http://www.python.org):
Python is an interpreted, interactive, object-oriented programming language. It is often compared to Tcl, Perl, Scheme or Java.
Python combines remarkable power with very clear syntax. It has modules, classes, exceptions, very high level dynamic data types, and dynamic typing. There are interfaces to many system calls and libraries, as well as to various windowing systems (X11, Motif, Tk, Mac, MFC). New built-in modules are easily written in C or C++. Python is also usable as an extension language for applications that need a programmable interface.
The Python implementation is portable: it runs on many brands of UNIX, on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't listed here, it may still be supported, if there's a C compiler for it. Ask around on comp.lang.python — or just try compiling Python yourself.
Python is copyrighted but freely usable and distributable, even for commercial use.
— DJPH
Go to http://examples.oreilly.com/upt3 for more information on: python
Installing Python is generally very simple. Either install the appropriate binary package for your platform, or download the latest source from http://www.python.org. (Note that some Linux distributions include Python by default.) A source install is as simple as untarring the distribution, then running:
% ./configure % make % make install
You can run the Python interpreter interactively and find out what version you have and details about its compilation. As an example, on my laptop (which runs Windows but also has a Cygwin Unix-like environment installed), Python reports:
% python Python 2.2 (#1, Dec 31 2001, 15:21:18) [GCC 2.95.3-5 (cygwin special)] on cygwin Type "help", "copyright", "credits" or "license" for more information. >>>
To see which modules are compiled into your version of Python, examine sys.builtin_module_names:
>>> import sys >>> print sys.builtin_module_names ('_ _builtin_ _', '_ _main_ _', '_socket', '_sre', '_symtable', 'exceptions', 'gc', 'imp', 'marshal', 'new', 'posix', 'signal', 'sys', 'xxsubtype')
These are just the modules that are an integral part of your version of the interpreter. For a complete list of modules installed in your Python, look in all of the directories listed in sys.path:
>>> print sys.path ['', '/usr/lib/python2.2', '/usr/lib/python2.2/plat-cygwin', '/usr/lib/python2.2/lib-tk', '/usr/lib/python2.2/lib-dynload', '/usr/lib/python2.2/site-packages']
Generally, checking the documentation for the version of Python you have will tell you which modules are normally installed; the site-packages directory is where further packages installed on your machine will likely have been installed.
There is a large repository of modules (and other Python code resources) for Python available at the Vaults of Parnassus (http://www.vex.net/parnassus/), which includes a search mechanism for finding what you're looking for. Most modules will use Distutils to package their distributions.
If you download a module source distribution, you can tell pretty quickly if it was packaged and distributed with Distutils. First, the distribution's name and version number will be featured prominently in the name of the downloaded archive, for example, foo-1.0.tar.gz or widget-0.9.7.zip. Next, the archive will unpack into a similarly-named directory: foo-1.0 or widget-0.9.7. Additionally, the distribution will contain a setup script, setup.py, and a README, which should explain that building and installing the module distribution is a simple matter of running:
% python setup.py install
Modules that are not packaged using the standard Distutils will generally include detailed instructions for installing them.
— DJPH
If you've written code in a procedural or functional language before, many parts of Python will seem familiar. Here's a quick overview of the flavor of the language. There is a lot of both reference and tutorial information available on the web (start at http://www.python.org) as well as in books like O'Reilly's Programming Python. In fact, much of the information in this chapter was gleaned or paraphrased from the official Python reference documentation.
The number one complaint of Python detractors is almost always its use of indentation as a significant part of its syntax. Most languages use begin/end tags or curly braces ({}) to mark blocks of code and have line termination punctuation (many use the semicolon (;) as a line termination marker). In Python, indentation is used to define blocks of code, and lines are terminated with a return. The actual amount of indentation within a block is arbitrary, but it must be consistent:
if a: statement1 statement2 # Consistent indentation else: statement3 statement4 # Inconsistent indentation (error)
Python assumes eight-space tab characters. If you have your editor set to four-space tabs, for example, this can bite you if there are mixed spaces and tabs. Either use eight-space tabs, or stick to spaces.
Long statements can span multiple lines by using the backslash (\) to continue the line:
>>> a = math.cos( 3 * ( x - n ) ) + \ ... math.sin( 3 * ( y - n ) )
Lines that are already grouped within triple-quotes, parentheses (...), brackets [...], or braces {...} can span multiple lines without needing to use the backslash.
Python's indentation requirements take a little getting used to, but they guarantee a certain level of readability, and editors like vim and emacs can keep track of the details for you trivially. (vim has a syntax configuration for editing Python, and emacs and xemacs both have a python-mode specifically for dealing with Python.)
Both procedural and functional languages organize programs by dividing them into smaller units called functions. Python's approach to functions is inspired by functional languages like Lisp and Scheme, where anonymous functions (lambdas) and operations like eval, apply, map, and reduce are fundamentals of the language.
Functions are defined with the def statement. To define an add function that adds together two arguments and returns the result:
>>> def add(a, b): ... return a + b
This defines a function and attaches it to the name add in the current namespace; anything with access to this namespace can call this function by simply passing arguments to it:
>>> print add(3, 5) 8
Function arguments can be defined with default values, and variable-length argument lists and keyword arguments are also supported.
Procedural programming languages like Perl and C generally leave functions at that. Functional languages like Lisp, Scheme, and Python take functions to the next level; functions are first-class objects and can be directly manipulated and stored.
Anonymous functions, which are not automatically attached to the current namespace, are created with the lambda statement:
>>> add = lambda a, b: a + b
Lambdas are very useful for traditional functional programming tricks such as using map( ). map( ) takes its first argument (which should be a function or lambda) and runs it over and over, passing each element of the list to the function in turn, generating a new list of the results:
>>> def timesThree(a): ... return 3 * a >>> def sum(x, y): ... return x + y >>> ints = [1, 2, 3, 4, 5] >>> multiples = map(timesThree, ints) >>> print multiples [3, 6, 9, 12, 15] >>> print reduce(sum, multiples) 45
If you use functions like map( ) and its cousins apply( ), reduce( ), and filter( ) a lot, your code can get pretty messy before long. Using a lambda allows you to use these functions without having to define a named function with def; instead you can just put the lambda right into the function call as an argument:
>>> ints = [1, 2, 3, 4, 5] >>> multiples = map(lambda a: 3 * a, ints) >>> print multiples [3, 6, 9, 12, 15] >>> print reduce(lambda x, y: x + y, multiples) 45
Lambdas are limited to a single expression, though that expression may be complex. Multiple statements and nonexpression statements like print and while can't be used in a lambda.
Everything in Python is an object. Each object has an identity , a type, and a value. For example, a = 42 creates an object of type integer with the value 42. You can think of the identity of an object as its address in memory; in this case, we've given the name a to that identity. Python's built-in types include fundamental building blocks such as numbers, strings, lists, dictionaries, and files, as well as structuring types like functions, modules, lambdas, and metaclasses. (Yes, a function is an object; it's just an object that implements the "function call" operator.)
Python allows the creation of new types of objects via the class statement. User-defined classes can have class variables and methods, which are shared across all instances of that class. In Python, methods are just functions that happen to be associated with a class (and generally take an instance of that class as the first argument). Instances can also have their own instance variables, specific to each instance.
Instances are created by calling the class object as if it were a function, which creates a new object and calls the _ _init_ _( ) method of the class (if one is defined):
class Account: "A simple example class" kind = "Checking" def _ _init_ _(self, accountHolder, startingBalance): self.accountHolder = accountHolder; self.balance = startingBalance; >>> account = Account("Deb", 86753.09)
This creates a new Account object and sets the accountHolder instance variable to Deb and the balance instance variable to $86,753.09. Now, in order to be able to do anything with our Account, we need to define methods to allow manipulation of the balance:
class Account: ... def deposit(self, depositAmount): "Deposit money" self.balance = self.balance + depositAmount def withdraw(self, withdrawalAmount): "Withdraw money" self.balance = self.balance - withdrawalAmount def inquireBalance(self): "Balance inquiry" return self.balance >>> account.deposit(1504.36) >>> account.withdraw(40.00) >>> print "Account balance is now $%.2f" % account.inquireBalance( ) Account balance is now $88217.45
Modules and packages allow you to organize your code more effectively. Generally, software for Python is also distributed as a module or a package. A module groups a set of functions and classes; a package is a collection of modules and subpackages.
Any Python source file is a module, if you load it using the import statement. Importing a module creates an isolated namespace for the symbols within that file and attaches that namespace to the name of the module. It also executes the code within that module, defining variables, functions, and classes. For example, we might put our Account class in a file account.py, and then, in another file:
import account checking = account.Account("Deb", 86753.09)
Note that we can't refer to Account directly; we have to refer to it through its imported name, account.Account. If, for convenience, we'd like to access the Account class directly, we can tell Python to import the class into our current namespace as well:
from account import Account checking = Account("Deb", 86753.09)
Modules are compiled into bytecodes the first time they are imported, allowing them to run faster and be more compact.
Given that a Python module is just a file, it will probably come as no surprise that a Python package is simply a directory with modules in it. To tag a directory as a package rather than just any directory, create a file called _ _init_ _.py (the same name as the method to initialize an object) within that directory. Code within _ _init_ _.py will get run whenever any part of its package is imported. Subpackages are, of course, just subdirectories with their own _ _init_ _.py files.
Dealing with input and output in Python is fairly straightforward; files are objects, and there is a set of methods for dealing with file objects that will be familiar to anyone who's ever done any Unix I/O. Files are opened with open( ), closed with close( ), and read with methods such as read( ) and readline( ).
Unix standard input, standard output and standard error are represented by file objects in the sys module: sys.stdin , sys.stdout, and sys.stderr, respectively.
The print statement prints its arguments to standard output. print can print any object by printing its string representation. Nicely formatted strings are generated using the string formatting (%) operator. % works a lot like C's sprintf( ) routine; you provide a string with special keywords in it and the objects to format and you get back a formatted string:
>>> print "Account balance is now $%.2f" % account.inquireBalance( ) Account balance is now $86753.09 >>> print "Error: %s(%s)." % (error, error.number) Error: File not found(2)
% takes a string and a list of arguments. (If there's only one argument, it can be any object instead of a list.) Any place that you might want to use a string, you can use the string formatting operator. For example:
>>> obj.name = "MyObject: %s" % name >>> url = urlopen("%s://%s:%d/%s" % (protocol, host, port, path))
Python has a couple of ways to build graphical user interfaces. The first was to use Tk, the GUI toolkit from Tcl. More recently, a Python interface to the wxWindows toolkit has been developed and has become very popular.
Extensive information about wxPython is available at http://wxpython.org including documentation and the wxPython distribution itself.
— DJPH
Python has a number of core modules designed to deal with interacting with the web. Python can act as a web client, pulling down web resources and POSTing form results. Python has support for SSL connections in a reasonably transparent fashion. CGI scripts are easy to write in Python, and there is also an Apache module for running Python scripts within the webserver itself.
urllib (Section 42.5) provides basic functions for opening and retrieving web resources via their URLs.
urllib2 (Section 42.6) provides an extended, extensible interface for accessing web resources.
htmllib and HTMLParser (Section 42.7) provide the ability to parse HTML.
cgi (Section 42.8) provides functions for writing CGI scripts.
mod_python (Section 42.9) is an Apache module for running Python within the Apache webserver, rather than seperately as with CGI scripts.
— DJPH
The application-level access to most web client activities is through modules called urllib and urllib2 (Section 42.6). urllib is the simple web interface; it provides basic functions for opening and retrieving web resources via their URLs.
The primary functions in urllib are urlopen( ), which opens an URL and returns a file-like object, and urlretrieve( ), which retrieves the entire web resource at the given URL. The file-like object returned by urlopen supports the following methods: read( ), readline( ), readlines( ), fileno( ), close( ), info( ), and geturl( ). The first five methods work just like their file counterparts. info( ) returns a mimetools.Message object, which for HTTP requests contains the HTTP headers associated with the URL. geturl( ) returns the real URL of the resource, since the client may have been redirected by the web server before getting the actual content.
urlretrieve( ) returns a tuple (filename, info), where filename is the local file to which the web resource was copied and info is the same as the return value from urlopen's info( ) method.
If the result from either urlopen( ) or urlretrieve( ) is HTML, you can use htmllib to parse it.
urllib also provides a function urlencode( ), which converts standard tuples or dictionaries into properly URL-encoded queries. Here is an example session that uses the GET method to retrieve a URL containing parameters:
>>> import urllib >>> params = urllib.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0}) >>> f = urllib.urlopen("http://www.musi-cal.com/cgi-bin/query?%s" % params) >>> print f.read( )
The following example performs the same query but uses the POST method instead:
>>> import urllib >>> params = urllib.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0}) >>> f = urllib.urlopen("http://www.musi-cal.com/cgi-bin/query", params) >>> print f.read( )
— DJPH
urllib2 provides an extended, extensible interface to web resources. urllib2's application-level interface is essentially identical to urllib's urlopen( ) function (Section 42.5). Underneath, however, urllib2 explicitly supports proxies, caching, basic and digest authentication, and so forth.
urllib2 uses an Opener, made up of a series of Handlers, to open a URL; if you know you want to use a particular set of features, you tell urllib2 which Handlers to use before you call urlopen( ). urllib2 is extensible largely because if you need to deal with some odd set of interactions, you can write a Handler object to deal with just those interactions and incorporate it into an Opener with existing Handlers. This allows you to deal with complex behavior by just combining very simple sets of code.
For example, to retrieve a web resource that requires basic authentication over a secure socket connection:
>>> import urllib2 >>> authHandler = urllib2.HTTPBasicAuthHandler( ) >>> authHandler.add_password("private, "https://www.domain.com/private", ... "user", "password") >>> opener = urllib2.build_opener(authHandler) >>> urllib2.install_opener(opener) >>> resource = urllib2.urlopen("https://www.domain.com/private/foo.html") >>> print resource.read( )
To implement a new Handler, you simply subclass from urllib2.BaseHandler and implement the methods appropriate to the behavior you want to handle.
— DJPH
Python provides the htmllib module for parsing HTML content, which is often useful when dealing with web resources. Python also has an HTMLParser module, which handles both XHTML and HTML and provides a slightly lower-level view of the content. HTMLParser is also slightly simpler to use, since htmllib uses sgmllib and thus understands many of the complexities of SGML.
HTMLParser provides a class that the user subclasses from, defining methods that are called as tags are found in the input. The example below is a very basic HTML parser that uses the HTMLParser.HTMLParser class to print out tags as they are encountered:
from HTMLParser import HTMLParser class MyHTMLParser(HTMLParser): def handle_starttag(self, tag, attrs): print "Encountered the beginning of a %s tag" % tag def handle_endtag(self, tag): print "Encountered the end of a %s tag" % tag
— DJPH
Python provides the cgi module for writing CGI scripts. Much of the grunt work of writing a CGI script is in dealing with parsing the parameters handed to the script by the web server. The cgi module deals with all of those details and more.
|
When you write a new script, consider adding the line:
import cgitb; cgitb.enable( )
This activates a special exception handler that will display detailed reports in the web browser if any errors occur. If you'd rather not show the guts of your program to users of your script, you can have the reports saved to files instead, with a line like this:
import cgitb; cgitb.enable(display=0, logdir="/tmp")
It's very helpful to use this feature during script development. The reports produced by cgitb provide information that can save you a lot of time tracking down bugs. You can always remove the cgitb line later when you have tested your script and are confident that it works correctly.
To get to information submitted to the CGI script, instantiate a FieldStorage object:
form = cgi.FieldStorage( )
The FieldStorage object acts much like a dictionary of CGI information; it implements the methods has_key( ) and keys( ) and can be accessed using the [ ] operator. For instance, the following code (which assumes that the Content-Type: header and blank line have already been printed) checks that the fields name and addr are both set to a non-empty string:
form = cgi.FieldStorage( ) if not (form.has_key("name") and form.has_key("addr")): print "<H1>Error</H1>" print "Please fill in the Name and Address fields." return print "<p>Name: %s</p>" % form["name"].value print "<p>Address: %s</p>" % form["addr"].value ...further form processing here...
The cgi module also supports ways to deal with multiple-selection form elements and uploaded files.
— DJPH
mod_python is an Apache module for running Python within the Apache webserver. It's much faster than CGI scripts and generally uses less resources overall. mod_python also allows advanced functionality such as maintaining persistent database connections across web requests and access to internal Apache APIs. Information on mod_python and distributions are available at http://www.modpython.org.
Apache's basic methodology for handling web requests is to deal with them in phases. There is a phase for each significant element of handling the request, including authentication, content generation, and logging. Apache modules can provide a seperate handler for each phase; mod_python simply allows you to write those handlers in Python. This allows complete control over everything Apache does to process a request.
A mod_python handler is a function that takes the Request object as an argument; a Request represents a single web request and contains all the information Apache knows about that request (requested URL, method, headers, and so forth).
Each phase's handler has a specific name that Apache recognizes (and uses in its configuration file): PythonHandler, PythonAuthenHandler, PythonLogHandler and so forth. Most mod_python scripts need to implement only the main handler, PythonHandler.
mod_python finds the appropriate function to call by dropping the leading Python from the handler name, and using an all-lowercase function name. Thus, most mod_python scripts will look something like this:
from mod_python import apache def handler(request): request.content_type = "text/plain" request.send_http_header( ) request.write("Hello World!") return apache.OK
This handler simply imports the apache API and then responds to every request with a plain text Hello World!. It returns apache.OK to tell Apache that the request was successful.
For more information on dealing with mod_python, read the documentation.
|
— DJPH
Comparing languages can generate a lot of heat and very little light. However, "Why not just use Perl?" is such a common question that I'll try to provide at least a basic understanding of the relative strengths and weaknesses of Python versus Perl. Remember that you can write good code or bad code in pretty much any language, but understanding whether your tool is best at driving nails or screws is always useful.
Perl's driving motto is "There's more than one way to do it." Because of this priority and the huge archive of Perl modules on CPAN, Perl is an incredibly useful tool for building quick one-off scripts or hacking together tools in a very short time. However, it also means that it's very easy to write Perl code that will be impenetrable six months down the road. Perl provides very little assistance to someone who wants to write complex systems clearly. Features like perl -w (warnings), use strict, and Perl's module support help maintainability, but it still requires a great deal of care and discipline.
Python's support for maintainability, on the other hand, is excellent. Python's rich collection of modules and the fact that it's an interpreted language allow relatively fast development, if not quite as fast as in Perl. Generally, the more complex the system you're trying to build and the longer you expect to use it, the more potential there is for gain in using Python over Perl.
Personally, when tossing together quick one-offs or scripts that are very regular expression-heavy, I use Perl. Perl's regular expression support is so fundamental to the language that it's worth it, and its Swiss-Army-knife nature is perfect for things I don't expect to need again later. I also tend to use Perl when I want to write a very portable script, as most Unixes include Perl as part of the base system these days, whereas Python, while just as portable, tends to need to be installed seperately. When I want to build more complex scripts or larger systems, and maintainability is thus a higher priority, I use Python. I often use Python even for smaller things if I intend to keep them around for a while.
In the end, of course, it comes down to a matter of personal taste and judgment. Personally, I value being able to understand my code six months (or six years!) down the road far more than having every tool imaginable at my fingertips, so I tend to lean towards languages that help you write clear, readable code, like Python.
— DJPH
| CONTENTS |


This port of entry is located at the southwestern side of the island. It is the island's only port and is a busy place.
See Saba Formalities for more details.
The Harbour Master is in the government building near the pier. Hours are 0600-1800 Monday to Saturday. You can check in and out at the same time, even if staying a few days.
In bad weather it may be necessary to carry on to the more protected anchoring area on the NW side of the island, between Ladder Bay and Well's Bay, where several moorings (yellow with blue stripe) have been laid for visiting yachts. From here, Fort Bay is best reached by dinghy.
Last updated February 2015.
The anchorage here is only comfortable in calm weather. There is (usually) one yacht mooring buoy and it may be possible to use the ship's mooring if it is available. Call the Harbour Master.
There is a harbour fee of $20 ( boats up to 40 tons)
There are two other anchorages at Well's Bay and Ladder Bay, where moorings marked yellow with a blue stripe are set aside for visiting yachts.
Last updated February 2015.


No mercy for the bad if they want it
No mercy for the bad if they plead
No mercy for the bad if they need it
No mercy from me
Tell no truth an' tell no lies
Cross your heart and hope to die
Never give what you can't take back
Scratch like a cat
If you inject your venom
It'll be your last attack
No mercy for the bad if they want it
No mercy for the bad if they plead
No mercy for the bad if they need it
V.e.n.o.m.
Got no heart, no feel no pain
Take your soul and leave a stain
Come choose your victim
Take him by surprise
Go in hard and get him
Right between the eyes and
Inject the venom
Inject the venom, c'mon
Inject the venom
Inject it all
Stick it in
Stick it
Inject the venom
Inject the venom
Inject the venom
Get it all
Inject the venom
Inject the venom
Inject it all


Vehicle crash causes roadblock in North Fort Myers Monday afternoon
by WFTX Digital TeamNORTH FORT MYERS, Fla. -- Deputies say a vehicle crash in North Fort Myers is causing roadblock on two roads Monday afternoon.
According to the Lee County Sheriff's Office, it's at the intersection of N. Cleveland Avenue and Littleton Road.
The crash has forced the closure of northbound U.S. 41/Cleveland Avenue and eastbound Littleton Road.
Drivers should seek alternate routes if possible.


{%extends 'layout.html'%} {%load bootstrap4%} {% load static%} {%block content%}
Owned by: {{business.owner}}
Description: {{business.about}}


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/transparency.html ---
In tactic.meta
there is a definition called transparency
:
inductive transparency | all | semireducible | instances | reducible | none
which seems to be a setting for how aggressively definitions are unfolded. In the reference manual I see that you can set reducible
, semireducible
and irreducible
as attributes. My impression is that these attributes and settings are used when doing unification or matching. I can't find any documentation on what exactly these different transparency modes are changing about the unifier. Please could someone explain it to me or point me to some docs or C++ code that will help me understand what is going on here?
So an example might be that you want ℝ
to be irreducible because you rarely prove things about reals in terms of equivalence classes of cauchy sequences.
bump
Sorry, probably such documentation doesn't exists. Gabriel and Sebastian are probably the people to hope can point you to right parts of the C++ code.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Next: Invariant Subspaces and Condition
Up: Nonsymmetric Eigenproblems
Previous: Eigenvalues, Eigenvectors and Schur
  Contents
  Index
The routine xGEBAL
may be used to balance the
matrix A prior to reduction to Hessenberg form. Balancing involves two
steps, either of which is optional:
- first, xGEBAL
attempts to permute A by a similarity transformation to
block upper triangular form:
where P is a permutation matrix and A'11 and A'33 are
upper triangular.
Thus the matrix is already in Schur form outside the
central diagonal block A'22 in rows and columns ILO to IHI.
Subsequent operations by xGEBAL, xGEHRD or xHSEQR need only be applied to
these rows and columns; therefore ILO and IHI are passed as arguments to
xGEHRD and
xHSEQR. This can save a significant amount of
work if ILO > 1 or IHI < n.
If no suitable permutation can be found (as is very often the case),
xGEBAL sets ILO = 1 and IHI = n, and A'22 is
the whole of A.
- secondly, xGEBAL applies a diagonal similarity transformation to
A'
to make the rows and columns of A'22
as close in norm in possible:
This can improve the
accuracy of later processing in some cases; see subsection <IP_ADDRESS>.
If A was balanced by xGEBAL, then eigenvectors computed by subsequent
operations are eigenvectors of the balanced matrix A'';
xGEBAK must then be called
to transform them back to eigenvectors of the original matrix A.
Next: Invariant Subspaces and Condition
Up: Nonsymmetric Eigenproblems
Previous: Eigenvalues, Eigenvectors and Schur
  Contents
  Index
Susan Blackford
1999-10-01


Ashleigh Barty claims biggest prize money pot in tennis history at WTA Finals – video
by WTAAshleigh Barty said it was a "bizarre" feeling to win the WTA Finals in Shenzhen and claim the biggest winner's cheque in tennis. Barty outclassed defending champion Elina Svitolina 6-4, 6-3 in the US$4.42m (A$6.4m) Shenzhen final to become the first world No 1 to win the tournament since Serena Williams five years ago and the first Australian since Evonne Goolagong Cawley in 1976


Orville Gibson (born 1856) patented a single-piece mandolin design in 1898 that was more durable than other mandolins and could be manufactured in volume. Orville Gibson began to sell his instruments in 1894 out of a one-room workshop in Kalamazoo Michigan. In 1902 Gibson Mandolin-Guitar Mfg. Co, Ltd. was incorporated to market the instruments. Initially, the company produced only Orville Gibson's original designs. Orville died in 1918.
The following year the company hired designer Lloyd Loar to create newer instruments. Loar designed the flagship L-5 archtop guitar and the Gibson F5 mandolin that was introduced in 1922, before leaving the company in 1924. In 1936 Gibson introduced their first "Electric Spanish" model, the ES-150 followed by other electric instruments like steel guitars, banjos and mandolins.
In the spring of 1935, Gibson enlisted musician Alvino Rey to help develop a prototype pickup with engineers at the Lyon & Healy company in Chicago. Later that year, research was moved in-house, where Gibson employee Walter Fuller came up with the final design. Gibson introduced the distinctive hexagonal pickup on a lap steel model in late 1935. The pickup was installed on an F-hole archtop guitar, dubbed the ES-150 ES for Electric Spanish), and the first one shipped from the Gibson factory in Kalamazoo, Michigan, on May 20, 1936.
In the years after World War II, the electric guitar came of age and Gibson entered a golden of age of innovation. The P-90 pickup, introduced in 1946, gave guitarists new power and versatility. Under the aggressive leadership of company president Ted McCarty, Gibson debuted two new concepts in 1949 with the ES-5, the first three-pickup guitar, and the ES-175, the first guitar with a sharply pointed cutaway bout.
n the late 50s, McCarty knew that Gibson was seen as a traditional company and began an effort to create more modern guitars. In 1961 the body design of the Les Paul was changed due to the demand for a double-cutaway body design. The new body design then became known as the SG (for "solid guitar"), due to disapproval from Les Paul himself. Between 1974 and 1984 production of Gibson guitars was shifted from Kalamazoo to Nashville, Tennessee. The Kalamazoo plant kept going for a few years as a custom-instrument shop, but was closed in 1984; several Gibson employees led by plant manager Jim Duerloo established Heritage Guitars in the old factory, building versions of classic Gibson designs.
The company (Gibson) was within three months of going out of business before it was bought by Henry E. Juszkiewicz, David H. Berryman, and Gary A. Zebrowski in January 1986. New production plants were opened in Memphis, Tennessee, as well as Bozeman, Montana. The Memphis facility is used for semi-hollow and custom shop instruments, while the Bozeman facility is dedicated to acoustic instruments.
Gibson purchased Garrison Guitars in 2007. In mid 2009 Gibson reduced its work force to adjust for a decline in guitar industry sales in the United States.
In 2011, Gibson acquired the Stanton Group, including Cerwin Vega, KRK Systems and Stanton DJ. Gibson then formed a new division, Gibson Pro Audio, which will deliver professional grade audio items, including headphones, loudspeakers and DJ equipment.
Gibson announced a partnership with the Japanese-based Onkyo Corporation in 2012. Onkyo, known for audio equipment and home theater systems, became part of the Gibson Pro Audio division.


Behavioral Analysis
This is the documentation for data analysis of rodent behavioral task data Aristieta et al. and unpublished *. The codes are available in this repository.
As a user you do not need to be fluent in Python. You can follow this guide and by respecting the requirementes and file data hirerachy you should be fine!
This package consists data analysis tools for two different behavioral tasks. A Locomotion task where animals are continously running on a treadmill while being subjected to optogenetic stimulation. Another task is lever reaching task where the animal has to follow the auditory cues presented in the experiment chamber and reach and press a lever to receive reward. There are numerous protocols for this task where the animal would be either lesioned, chemogentically or optogenetically manipulated.
- 1
Asier Aristieta, Massimo Barresi, Shiva Azizpour Lindi, Grégory Barrière, Gilles Courtand, Brice de la Crompe, Lise Guilhemsang, Sophie Gauthier, Stéphanie Fioramonti, Jérôme Baufreton, and Nicolas P. Mallet. A Disynaptic Circuit in the Globus Pallidus Controls Locomotion Inhibition. Current Biology, pages 1–15, 2020. doi:10.1016/j.cub.2020.11.019.
- *
Unpublished data provided by Nicolas Mallet at the Physiology and pathophysiology of executive functions team at the Institut des Maladies Neurodégénératives (IMN), CNRS, Bordeaux)


Welcome to my Project0
This is the web site developed as the resolution of the Project0 activity form the course.
This project lets me practice how to build a web page using different HTML elements and applying css rules to modify the way their appearence.
Use the buttons from the navigation bar on the top to navigate the site!


import Ember from 'ember';
import layout from './template';
import ExpFrameBaseComponent from '../exp-frame-base/component';
import FullScreen from '../../mixins/full-screen';
import MediaReload from '../../mixins/media-reload';
import VideoRecord from '../../mixins/video-record';
import ExpandAssets from '../../mixins/expand-assets';
import isColor from '../../utils/is-color';
import { audioAssetOptions, imageAssetOptions, videoAssetOptions } from '../../mixins/expand-assets';
let {
$
} = Ember;
/**
* @module exp-player
* @submodule frames
*/
/**
*
* Frame to do calibration for looking direction. Shows a small video/image in a sequence
* of locations so you'll have video of the child looking to those locations at known times.
*
* The attention-grabber can be either a small video or an image (see examples below of each).
* Images can be animated (spinning or bouncing).
*
* Generally you will want to have video of this frame. You can set doRecording to true to
* make a video clip just for this frame, or you can use session-level recording (set
* startSessionRecording to true on this or a previous frame). If either type of recording
* is starting on this frame, it waits until recording starts to display the first calibration
* segment.
*
* It can be displayed at center, left, or right of the screen. You can specify the sequence
* of positions or use the default ['center', 'left', 'right', 'center']. Each time it moves,
* the video (if any) and audio restart, and an event is recorded with the location and time (and time
* relative to any video recording) of the segment start.
*
* For details about specifying media locations, please see
* https://lookit.readthedocs.io/en/develop/researchers-prep-stimuli.html?highlight=basedir#directory-structure
*
* This frame is displayed fullscreen, to match the frames you will likely want to compare
* looking behavior on. If the participant leaves fullscreen, that will be
* recorded as an event, and a large "return to fullscreen" button will be displayed. Don't
* use video coding from any intervals where the participant isn't in fullscreen mode - the
* position of the attention-grabbers won't be as expected.
*
* If the frame before it is not fullscreen, that frame
* needs to include a manual "next" button so that there's a user interaction
* event to trigger fullscreen mode. (Browsers don't allow us to switch to FS
* without a user event.)
*
* Example usage:
```json
"calibration-with-image": {
"kind": "exp-lookit-calibration",
"baseDir": "https://www.mit.edu/~kimscott/placeholderstimuli/",
"audioTypes": [
"ogg",
"mp3"
],
"videoTypes": [
"webm",
"mp4"
],
"calibrationImage": "peekaboo_remy.jpg",
"calibrationLength": 3000,
"calibrationPositions": [
"center",
"left",
"right"
],
"calibrationAudio": "chimes",
"calibrationImageAnimation": "spin"
},
"calibration-with-video": {
"kind": "exp-lookit-calibration",
"baseDir": "https://www.mit.edu/~kimscott/placeholderstimuli/",
"audioTypes": [
"ogg",
"mp3"
],
"videoTypes": [
"webm",
"mp4"
],
"calibrationLength": 3000,
"calibrationPositions": [
"center",
"left",
"right"
],
"calibrationAudio": "chimes",
"calibrationVideo": "attentiongrabber"
},
* ```
* @class Exp-lookit-calibration
* @extends Exp-frame-base
* @uses Full-screen
* @uses Media-reload
* @uses Video-record
* @uses Expand-assets
*/
export default ExpFrameBaseComponent.extend(FullScreen, MediaReload, VideoRecord, ExpandAssets, {
layout: layout,
type: 'exp-lookit-calibration',
displayFullscreen: true, // force fullscreen for all uses of this component
fullScreenElementId: 'experiment-player',
fsButtonID: 'fsButton',
assetsToExpand: {
'audio': [
'calibrationAudio',
],
'video': [
'calibrationVideo'
],
'image': [
'calibrationImage'
]
},
// Override setting in VideoRecord mixin - only use camera if doing recording
doUseCamera: Ember.computed.alias('doRecording'),
startRecordingAutomatically: Ember.computed.alias('doRecording'),
calTimer: null, // reference to timer counting how long calibration segment has played
retryCalibrationAudio: false, // see exp-lookit-video regarding this workaround
frameSchemaProperties: {
/**
Whether to do any video recording during this frame. Default true. Set to false for e.g. last frame where just doing an announcement.
@property {Boolean} doRecording
@default true
*/
doRecording: {
type: 'boolean',
description: 'Whether to do video recording',
default: true
},
/**
* Color of background. See https://developer.mozilla.org/en-US/docs/Web/CSS/color_value
* for acceptable syntax: can use color names ('blue', 'red', 'green', etc.), or
* rgb hex values (e.g. '#800080' - include the '#')
*
* @property {String} backgroundColor
* @default 'black'
*/
backgroundColor: {
type: 'string',
description: 'Color of background',
default: 'white'
},
/**
* Length of single calibration segment in ms.
*
* @property {Number} calibrationLength
* @default 3000
*/
calibrationLength: {
type: 'number',
description: 'length of single calibration segment in ms',
default: 3000
},
/**
* Ordered list of positions to show calibration segment in. Options are
* "center", "left", "right". Ignored if calibrationLength is 0.
*
* @property {Array} calibrationPositions
* @default ["center", "left", "right", "center"]
*/
calibrationPositions: {
type: 'array',
description: 'Ordered list of positions to show calibration',
items: {
type: 'string',
enum: ['center', 'left', 'right']
},
default: ['center', 'left', 'right', 'center']
},
/**
* Audio to play when the attention-grabber is placed at each location (will be
* played once from the start, but cut off if it's longer than calibrationLength).
*
* This can either be an array of `{src: 'url', type: 'MIMEtype'}` objects for
* calibration audio, or just a string to use the full URLs based on `baseDir`.
*
* @property {Object[]} calibrationAudio
* @default []
*/
calibrationAudio: {
anyOf: audioAssetOptions,
description: 'list of objects specifying audio src and type for calibration audio',
default: []
},
/**
* Calibration video (played from start at each calibration position). Supply
* either a calibration video or calibration image, not both.
*
* This can be either an array of {src: 'url', type: 'MIMEtype'} objects or
* just a string like `attentiongrabber` to rely on the `baseDir` and `videoTypes`
* to generate full paths.
*
* @property {Object[]} calibrationVideo
* @default []
*/
calibrationVideo: {
anyOf: videoAssetOptions,
description: 'list of objects specifying video src and type for calibration audio',
default: []
},
/**
* Image to use for calibration - will be placed at each location. Supply
* either a calibration video or calibration image, not both.
*
* This can be either a full URL or just the filename (e.g. "star.png") to
* use the full path based on `baseDir` (e.g. `baseDir/img/star.png`).
*
* @property {String} calibrationImage
* @default []
*/
calibrationImage: {
anyOf: imageAssetOptions,
description: 'Image to use for calibration',
default: ''
},
/**
* Which animation to use for the calibration image. Options are 'bounce', 'spin',
* or '' (empty to not animate).
*
* @property {String} calibrationImageAnimation
* @default []
*/
calibrationImageAnimation: {
type: 'string',
enum: ['bounce', 'spin', ''],
description: 'Which animation to use for the calibration image',
default: 'spin'
}
},
meta: {
data: {
type: 'object',
properties: {
videoId: {
type: 'string'
}
}
}
},
finish() { // Move to next frame altogether
// Call this something separate from next because stopRecorder promise needs
// to call next AFTER recording is stopped and we don't want this to have
// already been destroyed at that point.
window.clearInterval(this.get('calTimer'));
var _this = this;
if (this.get('doRecording')) {
this.stopRecorder().then(() => {
_this.set('stoppedRecording', true);
_this.send('next');
return;
}, () => {
_this.send('next');
return;
});
} else {
_this.send('next');
}
},
startCalibration() {
var _this = this;
// First check whether any calibration video provided. If not, skip.
if (!this.get('calibrationLength')) {
this.finish();
}
var calAudio = $('#player-calibration-audio')[0];
$('.calibration-stimulus').show();
// Show the calibration segment at center, left, right, center, each
// time recording an event and playing the calibration audio.
var doCalibrationSegments = function(calList, lastLoc) {
if (calList.length === 0) {
_this.finish();
} else {
var thisLoc = calList.shift();
/**
* Start of EACH calibration segment
*
* @event startCalibration
* @param {String} location location of calibration ball, relative to child: 'left', 'right', or 'center'
*/
_this.send('setTimeEvent', 'startCalibration',
{location: thisLoc});
_this.set('retryCalibrationAudio', true);
calAudio.pause();
calAudio.currentTime = 0;
calAudio.play().then(() => {}, () => {
calAudio.play();
});
$('.calibration-stimulus').removeClass(lastLoc);
$('.calibration-stimulus').addClass(thisLoc);
if (_this.get('hasVideo')) {
var calVideo = $('#player-calibration-video')[0];
calVideo.pause();
calVideo.currentTime = 0;
calVideo.play();
}
_this.set('calTimer', window.setTimeout(function() {
_this.set('retryCalibrationAudio', false);
doCalibrationSegments(calList, thisLoc);
}, _this.get('calibrationLength')));
}
};
doCalibrationSegments(this.get('calibrationPositions').slice(), '');
},
reloadObserver: Ember.observer('reloadingMedia', function() {
console.log('reloadObserver');
if (!this.get('reloadingMedia')) { // done with most recent reload
if (this.get('retryCalibrationAudio')) {
$('#player-calibration-audio')[0].play();
}
}
}),
onRecordingStarted() {
this.startCalibration();
},
onSessionRecordingStarted() {
$('#waitForVideo').hide();
this.startCalibration();
},
didInsertElement() {
this._super(...arguments);
this.set('hasVideo', this.get('calibrationVideo').length > 0);
$('.calibration-stimulus').hide();
// Apply background colors
if (isColor(this.get('backgroundColor'))) {
$('div.exp-lookit-calibration').css('background-color', this.get('backgroundColor'));
} else {
console.warn('Invalid background color provided; not applying.');
}
// Apply calibration animation class
if (this.get('calibrationImage')) {
$('#calibration-image').addClass(this.get('calibrationImageAnimation'));
}
if (!(this.get('doRecording') || this.get('startSessionRecording'))) {
this.startCalibration();
}
},
willDestroyElement() {
window.clearInterval(this.get('calTimer'));
this._super(...arguments);
}
});


Role
I was responsible for implement the website's front-end and performance improvement. The site is also responsive and has html5 page change(window.pushState) without refresh the whole screenm without losing SEO findability aspects.
Manhattan is one of the most successfull restaurant/night clubs in Recife, which offers an innovative format of Cafe-theater, with good quality music and awarded gastronomy goods bringing people interested on having fun with friends and family.
You can check out the project at www.manhattancafetheatro.com.br
I was responsible for implement the website's front-end and performance improvement. The site is also responsive and has html5 page change(window.pushState) without refresh the whole screenm without losing SEO findability aspects.


Instructions for use: (Map function needs networking) You can drag and drop the map with the mouse; you can zoom in and out the map by rolling the mouse pulley on the map, and then move out to scroll pages.
After the mouse clicks on the map to select the target location (or by entering the target address) and the red mark appears on the map, click "Set as the starting point" or "Set as the end point".
Click on different modes of transportation to generate route planning
Search function, input keywords, click search, can search the current location of the city's target facilities


| ||||||||||||||||||||
BIO_s_accept(3)
NAMEBIO_s_accept, BIO_set_accept_port, BIO_get_accept_port, BIO_new_accept, BIO_set_nbio_accept, BIO_set_accept_bios, BIO_set_bind_mode, BIO_get_bind_mode, BIO_do_accept - accept BIO
SYNOPSIS#include <openssl/bio.h> BIO_METHOD *BIO_s_accept(void); long BIO_set_accept_port(BIO *b, char *name); char *BIO_get_accept_port(BIO *b); BIO *BIO_new_accept(char *host_port); long BIO_set_nbio_accept(BIO *b, int n); long BIO_set_accept_bios(BIO *b, char *bio); long BIO_set_bind_mode(BIO *b, long mode); long BIO_get_bind_mode(BIO *b, long dummy); #define BIO_BIND_NORMAL 0 #define BIO_BIND_REUSEADDR_IF_UNUSED 1 #define BIO_BIND_REUSEADDR 2 int BIO_do_accept(BIO *b);
DESCRIPTION
Using accept BIOs, TCP/IP connections can be accepted and data transferred using only BIO routines. In this way any platform specific operations are hidden by the BIO abstraction. Read and write operations on an accept BIO will perform I/O on the underlying connection. If no connection is established and the port (see below) is set up properly then the BIO waits for an incoming connection.
Accept BIOs support If the close flag is set on an accept BIO then any active connection on that chain is shutdown and the socket closed when the BIO is freed.
Calling
NOTESWhen an accept BIO is at the end of a chain it will await an incoming connection before processing I/O calls. When an accept BIO is not at then end of a chain it passes I/O calls to the next BIO in the chain. When a connection is established a new socket BIO is created for the connection and appended to the chain. That is the chain is now accept->socket. This effectively means that attempting I/O on an initial accept socket will await an incoming connection then perform I/O on it.
If any additional BIOs have been set using
If a server wishes to process multiple connections (as is normally the case) then the accept BIO must be made available for further incoming connections. This can be done by waiting for a connection and then calling: connection = BIO_pop(accept);
After this call connection will contain a BIO for the recently established connection and accept will now be a single BIO again which can be used to await further incoming
connections. If no further connections will be accepted the accept can be freed using
If only a single connection will be processed it is possible to perform I/O
using the accept BIO itself. This is often undesirable however because the
accept BIO will still accept additional incoming connections. This can be
resolved by using
If the underlying accept socket is non-blocking and
RETURN VALUESTBA
EXAMPLEThis example accepts two connections on port 4444, sends messages down each and finally closes both down. BIO *abio, *cbio, *cbio2; ERR_load_crypto_strings(); abio = BIO_new_accept("4444"); /* First call to BIO_accept() sets up accept BIO */ if(BIO_do_accept(abio) <= 0) { fprintf(stderr, "Error setting up accept\n"); ERR_print_errors_fp(stderr); exit(0); } /* Wait for incoming connection */ if(BIO_do_accept(abio) <= 0) { fprintf(stderr, "Error accepting connection\n"); ERR_print_errors_fp(stderr); exit(0); } fprintf(stderr, "Connection 1 established\n"); /* Retrieve BIO for connection */ cbio = BIO_pop(abio); BIO_puts(cbio, "Connection 1: Sending out Data on initial connection\n"); fprintf(stderr, "Sent out data on connection 1\n"); /* Wait for another connection */ if(BIO_do_accept(abio) <= 0) { fprintf(stderr, "Error accepting connection\n"); ERR_print_errors_fp(stderr); exit(0); } fprintf(stderr, "Connection 2 established\n"); /* Close accept BIO to refuse further connections */ cbio2 = BIO_pop(abio); BIO_free(abio); BIO_puts(cbio2, "Connection 2: Sending out Data on second\n"); fprintf(stderr, "Sent out data on connection 2\n"); BIO_puts(cbio, "Connection 1: Second connection established\n"); /* Close the two established connections */ BIO_free(cbio); BIO_free(cbio2);
SEE ALSOTBA | ||||||||||||||||||||


Privacy Policy for www.scales-chords.com
If you require any more information or have any questions about our privacy policy, please feel free to contact us by using our contact form.
At www.scales-chords.com, the privacy of our visitors is of extreme importance to us. This privacy policy document outlines the types of personal information is received and collected by www.scales-chords.com and how it is used.
Log FilesLike many other Web sites, www.scales-chords.com makes use of log files. The information inside the log files includes internet protocol ( IP ) addresses, type of browser, Internet Service Provider ( ISP ), date/time stamp, referring/exit pages, and number of clicks to analyze trends, administer the site, track user’s movement around the site, and gather demographic information. IP addresses, and other such information are not linked to any information that is personally identifiable.
Cookies and Web Beaconswww.scales-chords.com uses cookies to personalize content, enable website memory on forms, personalize ads, integrate with social media and to record statistics about the use of our site. We share some of this information with our ads, statistics and social media partners.
We use Google Products for Ads, Statistics and Social Media. You can learn more of Google's use of cookies here
We also integrate with facebook.
DoubleClick DART CookieGoogle, as a third party vendor, uses cookies to serve ads on www.scales-chords.com.
Google's use of the DART cookie enables it to serve ads to users based on their visit to www.scales-chords.com and other sites on the Internet.
Users may opt out of the use of the DART cookie by visiting the Google ad and content network privacy policy at the following URL - http://www.google.com/privacy_ads.html
Some of our advertising partners may use cookies and web beacons on our site. Our advertising partners include Google Adsense
These third-party ad servers or ad networks use technology to the advertisements and links that appear on www.scales-chords.com send directly to your browsers. They automatically receive your IP address when this occurs. Other technologies ( such as cookies, JavaScript, or Web Beacons ) may also be used by the third-party ad networks to measure the effectiveness of their advertisements and / or to personalize the advertising content that you see.
www.scales-chords.com has no access to or control over these cookies that are used by third-party advertisers.
You should consult the respective privacy policies of these third-party ad servers for more detailed information on their practices as well as for instructions about how to opt-out of certain practices. www.scales-chords.com's privacy policy does not apply to, and we cannot control the activities of, such other advertisers or web sites.
If you wish to disable cookies, you may do so through your individual browser options. More detailed information about cookie management with specific web browsers can be found at the browsers' respective websites.


{$extend "/16bit-era" $}
{$define "#content" }
Though it may not be one of his main adventures, the Mario Kart series helped usher in the idea that Mario can branch out and exist outside the platforming genre.
Choosing your favorite character and speeding around tracks inspired by iconic locales across the Mushroom Kingdom seemed like such a strange idea on paper, but it's impossible to not be hooked the moment you get behind the wheel of a kart.
Since its first appearance on the SNES, the Mario Kart series has captured the hearts of Nintendo fans across the world. It's a safe bet that anyone reading this has fond memories of dropping bananas, firing red shells, and getting zapped by a lightning bolt.
{$}


| DOSE: |
2.0 g |
oral |
Kratom |
(extract) |
Recently I've gotten into collecting interesting, rare and medicinally useful plants as well as species I believe will be made illegal in the not-too-distant future.  Fortunately I have a private, fenced in yard in the middle of the city and I haven't seen any kids wandering around.  Like I said, it's a collection.
But my absolute favorite plant and the only one I regularly make use of is my kratom tree.  The fucker's huge. In my location it frosts in the winter and I have to go through the painful process of lopping off limbs every year to get the thing inside. This is always a happy time for my friends who go nuts for the stuff. As they should, kratom is the cat's meow. While Kratom may not be the best substance conducive to throwing a rager it does make you feel really, really good.
While I have an extensive history of using many different drugs including LSD, LSA, pot, shrooms, cocaine and mescaline, I've never been into pill popping so I can't really vouch for my friends and everyone on this site who reported that the effects of kratom feel like taking a couple Percocet or oxycodone.
My first experience was obviously out of curiosity. I had seen it advertised on the site where I was buying salvia from and one day decided to throw down the loot. I bought 12g ( I think ) in the form of a 15:1 powdered extract that mixed easily with water.
Well on my first kratom experience I had come home from work to find the little package by my front door and waited eagerly for my wife to get home. Despite the fact that she has also tried damn near every drug under the sun, she said she would rather wait and see what it did to me before she would try it. So we raced off to a house by the river where a few friends live. There was a small gathering of people hanging out on a beautiful spring evening and I got two of them to try out this new, mysterious, legal drug.
We each put roughly 2g of the extract into a glass of water and stirred. I put an extra gram in my buddy ' Steve's ' when he wasn't looking. A little ass-holish of me, I know, but he would appreciate it later. My thought was that the stuff tasted like unsweetened black tea. My wife thought the same thing after taking a little swill. The other two proceeded to dump fist fulls of sugar and honey into it saying that it tasted horrible. We all bucked down the glasses, Steve wondering why his was darker than the others. Within 15 min. we could all feel a slight change, just a general good feeling. Unfortunately, all the other folks at the house kept harassing us ' Do you feel it yet ?'
' What's it like? '
' Are you trippin, can I have a sip? '.
Like I said, everyone I've givin it to compares it to some pill or another without side effects or the guilt of stealing their grandmother's prescription. What it does for me is just a very calm, relaxed state of euphoria. Sometimes I get a tingly scalp and flushed feeling, nothing bad. The only obnoxious effect I get nowadays in very high doses ( like when I've been chewing leaves all day at work ) is itchiness. This itch is almost always concentrated on my belly and/or chest but sometimes on the top of my head and behind my knees. It's nothing terrible, and it feels really good to scratch it. Not like a pcp feeling of creepy crawlies. It kinda adds to the euphoria.
I've tried several other 'euphoriants', Kava most heavily and kanna as well, but Kratom is so much better. However, I have to make a conscious effort not to do it all the time. It could definitely be addicting but on the other side of the coin, I have successfully weaned a good friend off of methadone/ H with the use of this plant ( going on a year). He says it feels like drinking liquid opium.
But back to that first experience. The three of us who imbibed had a wonderful time just sitting in the grass talking and smoking bud while everyone else played horse shoes. I think they thought we were faking it or something because we weren't having crazy hallucinations or running around like madmen so they eventually left us alone. The next morning ' Steve ' said he threw up repeatedly claiming that it was 'definitely not the fault of the 18 Miller high-life lites' he had consumed along with the tom. I have mixed tom and booze many times, they don't seem to heighten or accentuate the effects of one another, rather I can just feel both of them acting separately. 'Steve' is the only one I have given the tea to that got sick. He's tried it many times since in milk shake form and has been fine with it.
As far as relaxants go, Kratom is the tops in my opinion, it has helped me cut back dramatically my pot smoking habit as well as my drinking. Now when I get home from a stressful day I pluck a leaf off the tree instead of downing a 12 pack and bottle of Jack.  Or a good one.
I have several ' African Culture ' shops within walking distance of my house that sell different grades of salvia but none of them have any interest in carrying kratom. I have even offered to give a pound of free cuttings to some stores just to try the product out but nobody's going for it. One day I would like to see kratom on the shelves of health food stores next to the kava kava. Until then it's cool that it's still a secret, I just wish I could sell it to the stores around here to turn my neighbors on and make a buck. My friends won't buy it from me 'It grows in your fuckin' yard!
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Calibrations 38 and 39 fill the two display windows with red, and connect the slider to the horizontal and vertical display offset calibrations, respectively. These should be adjusted to line the displays up with the windows in the panel, when viewed from a nominal position horizontally above the center of the instrument, viewing the displays from about 20\d below perpendicular.
These adjust for mechanical position tolerances. The {_global_parameter global} Display Position parameter adjusts the vertical position relative to this calibration, and should be used to adjust for variations in the actual viewing position, depending upon your posture or the position of the instrument in your "stack".


--- title: My ROI stock portfolio experiment; the results date: 2023-08-10T10:59:15+01:00 layout: post description: My 1-year experiment, where I invested a 1000 euros has concluded, what are the results? headerImage: img/blog/2023/tech-daily-ztYmIQecyH4-unsplash.jpg tags: ["stocks", "personal", "roi-stock-portfolio"] toc: false comment: true ---
A year has passed since my }}">first post about my ROI stock portfolio and that means it is time to see how it went.
As of 10th of August 2023, using USD-based percentages, the portfolio looks like this:
| Stock | Return |
|---|---|
| Novo Nordisk (NVO) | ✔(42.25%) |
| Applied Materials (AMAT) | ✔(37.67%) |
| Southern Copper (SCCO) | ✔(34.97%) |
| KLA Corporation (KLAC) | ✔(33.28%) |
| Microsoft (MSFT) | ✔(24.82%) |
| Apple (AAPL) | ✔(18.09%) |
| Crescent Point Energy (CPG) | ✔(16.57%) |
| Mastercard (MA) | ✔(13.67%) |
| Blackstone Inc (BX) | ✔(13.64%) |
| S&P Global (SPGI) | ✔(11.33%) |
| McDonald's (MCD) | ✔(7.51%) |
| Paychex (PAYX) | ✔(7.00%) |
| Lousiana Pacific (LPX) | ✔(6.95%) |
| Qualcomm (QCOM) | ❌(-7.96%) |
| Rio Tinto (RIO) | ❌(-10.97%) |
| Vale (VALE) | ❌(-11.35%) |
| Vermillion Energy (VET) | ❌(-12.60%) |
In US Dollars this is a 14.4% return, which is not bad at all. Foreign exchange rates however gave me a -5% if I were to convert it to Euros straight away.
Luckily, since end of July, Trading212 has a new feature where you can hold multiple currencies. So I have sold all stocks in USD (except for RIO, which I converted to EUR) and hope that when the time is better I can convert it to Euros.
I have also received €11.18 Euro in dividends, which is a 1.11% return on top of the others. (I will probably receive a couple more dividends, since some of the ex-dividend dates have not had their paydate yet)
{{< img src="/img/blog/2023/roi-chart.jpg" desc="The year-long graph of my ROI portfolio" >}}It was a bumpy ride, barely seen green till the end, luckily I was able to buy in 2022 (which was a down-year) and could hold the first months of 2023 which have proven to be a rebound. In fact, I was debating near the top (July 31st) whether I should sell already or really wait for the August 10th date.
As you can see from the graph and know from the initial post, I paid €100 for 10 months, so after May 10th I just let it ride. Most of the gains in the market started from March and my gains only started becoming visible around May itself.
Some stocks were somehow always in the green (NVO, SCCO) and others pretty much just red (VET).
In January my mining stocks were doing well, but now both VALE and RIO are in the negative.
The idea of the portfolio was solid. I had good dividend-paying companies. It was well diversified.
When in the growing phase, buying the same percentage amount is really nice. No stress whether you should rebalance while buying.
If you plan for the short term, the FX effect
can be quite a large chunk.
In August, but also in January, I was down 5% on the USD-EUR exchange rate.
The difference between the highest and lowest point this year was actually 15%.
A criteria I added to my actual portfolio is checking the dividend history a bit more. This is mostly a feeling-type of check, but if I had done that for VET, I would have seen that their history didn't look so good since 2019.
It is still really difficult to predict anything. For example, I still wonder why Qualcomm (QCOM) is down and not recovering. Mastercard (MA) has also not gained as much, which they needed to, because their dividend is only 0.58%.


{% extends "page.html" %} {% load bootstrap3 %} {% block title %}Password Reset Complete{% endblock %} {% block styles %} {{ block.super }} {% endblock %} {% block content %}
You're password has been reset, please log in now.
Log In


--- layout: page title: Token token_active: active html_class: white token en: active ---
Nekoyume Gold (NYG), which is available on the mainnet, will be sold in the form of the Ethereum ERC20 token. We will sell 21% of total volume.1
During the intensive development period of the next one year, 9% of the gold reserves will be distributed to the core team members in proportion to the contribution amount. If you can help with development in any direction, please apply for support at<EMAIL_ADDRESS>or send a Pull Request for the opened issue.
After launching the mainnet, you can get gold by providing the client based on the published code, or creating the block by executing $ neko
. It will be the largest of all rewards portion and will be the only way to earn Gold from 2019. The planned amount for 4 years is as follows.
| Miner & client incentive / 4y | Reward | Starting Year |
|---|---|---|
| 134,553,600 | 16 | 2018 |
| 67,276,800 | 8 | 2022 |
| 33,638,400 | 4 | 2026 |
| 16,819,200 | 2 | 2030 |
| 8,409,600 | 1 | 2034 |
If you would like to receive news about the token sales schedule, please enter your E-mail address in the form below.
{% include email_form.html %} 1: Total volume represents the 20-year volume including four half-lives. After 2038, block reward will be fixed at 1, resulting in inflation of about 0.5% per year.


RTSP Url
Play
Local SDP
Remote SDP
Stats
bytesReceived
bytesSent
dtlsCipher
dtlsState
srtpCipher
timestamp
Log


<<<
Route #1
From:
Through:
To:
kms
XX
No Highway
No Toll
Configuration
Step :
250
meters
Interval :
800
milliseconds
Force Pan To
Start
Pause
Stop


Mathematical Formulation¶
A brief review of continuum mechanics, the finite element method for spatial discretization, and finite difference methods for time derivative discretization is presented here. For further details, the reader is referred to Chadwick [Cha99] and Hughes [Hug07].
Continuum Mechanics¶
The body of interest is assumed to occupy a subregion of three-dimensional Euclidean space at some initial time, \(t_0\), and denote with region by \(\mathcal{B}_0\). We refer to \(\mathcal{B}_0\) as the reference configuration. The region occupied by the same body at a later time, \(t\), will be denoted by \(\mathcal{B}\), and referred to as the current configuration. Solving mechanics problems involves solving for the map (or its derivatives) that transforms the body from \(\mathcal{B}_0\) to \(\mathcal{B}\). We will denote this map with \(\boldsymbol\varphi:\mathcal{B}_0\times\mathbb{R} \rightarrow \mathcal{B}\), where \(t \in \mathbb{R}\).
The formulation of continuum mechanics that we will use is concerned with the deformation of the body at a local level, which is quantified by the deformation gradient
where \(\mathbf{X} \in \mathcal{B}_0\) is the position vector of a material point at time \(t_0\). This tensor is used to define other tensors quantifying different strain measures – all of which can be used to study the kinematics of deformation.
Once the kinematics of the deformation undergone by the body of interest has been mathematically formulated, they can be used to study the relationship between deformation and forces that either cause or result from it. These relations are referred to as dynamics. This leads to the concept of the Cauchy stress tensor, which we will denote by \(\mathbf{T}\). The Cauchy stress tensor maps the unit normal vector, \(\mathbf{n}\), on any surface within a continuum to the traction vector, \(\mathbf{t}\), which is the force per unit area at the point where \(\mathbf{T}\) and \(\mathbf{n}\) are evaluated. By Newton’s second law, and the Reynolds Transport Theorem, we get
where \(\mathbf{v} = \frac{d}{dt}\mathbf{u}\) is the velocity field of the body, \(\mathbf{u}\) is the displacement, \(\mathbf{b}\) is the force applied per unit mass, and \(\partial \mathcal{B}\) is the boundary of \(\mathcal{B}\). Making use of the Cauchy stress tensor, the divergence theorem, and the localization theorem, we get
where we have replaced the time derivative by the dot, and div is the divergence operator with respect to the spatial coodinates. FEniCS Mechanics uses this equation to formulate fluid mechanics problems. The equivalent equation in the reference coordinate system is
where \(\rho_0 = \rho J\) is the referential mass density, \(\mathbf{P} = J\mathbf{TF}^{-T}\) is the first Piola-Kirchhoff stress tensor, \(J = \det\mathbf{F}\) is the Jacobian, and Div is the divergence operator with respect to the referential coordinates, \(\mathbf{X}\). This equation is used to formulate solid mechanics problems.
Note that we have not limited the formulation to a specific type of material, e.g. rubber or water, and thus these equations are applicable to all materials that satisfy the continuity assumptions of the classical continuum mechanics formulation. Specific relations between strain tensors and the Cauchy tensor are known as constitutive equations and depend on the material being modelled. For further details on constitutive equations, the reader is referred to Chadwick [Cha99].
Incompressibility Constraint¶
Many materials are modeled as incompressible. In order to satisfy incompressibility, we must formulate it as a constraint that the displacement and/or velocity must satisfy. This results in an additional equation, making the system over-determined. Thus, we need an additional variable, a Lagrange multiplier, to solve the system. This Lagrange multiplier ends up being the pressure within the material, be it a solid or fluid.
If a material is modeled as incompressible, the stress tensor will now depend on the displacement field for solids, velocity field for fluids, and the pressure for both. I.e.,
for solids, and
for fluids. The constraint equation will also depend on the relevant vector field, and the scalar field \(p\). Thus,
or
The constraint equation for solid materials is of the form
where \(\kappa\) is the bulk modulus. For linear materials, we take
On the other hand,
is the default expression for nonlinear materials.
The incompressibility constraint for fluid mechanics is
Finite Element Method¶
The finite element method (FEM) requires a variational form. Thus, we must convert the governing equations from Continuum Mechanics to a variational form. This involves taking the dot product of the equation of interest with an arbitrary vector field, \(\boldsymbol\xi\), using the product rule, and divergence theorem to obtain
where \(\bar{\mathbf{t}}\) is a specified traction on \(\Gamma_q \in \partial\mathcal{B}\). Applying the chain rule to the material time derivative of the velocity yields
Note that this is the most general variational form of the governing equation for the balance of momentum, and can thus be used to provide a general formulation for computational mechanics problems. FEniCS Mechanics does just this, and changes the physical meaning of the variables in the above weak form when necessary. E.g., the stress tensor \(\mathbf{T}\) is replaced by the first Piola-Kirchhoff stress tensor \(\mathbf{P}\) when formulating a solid mechanics problem.
Suppose that the true solution to the variational forms belongs to a function space \(\mathcal{F}\). The FEM uses a subspace of \(\mathcal{F}\) with finite size to approximate the solution to the boundary value problem. We denote this finite function space by \(\mathcal{F}^h\), which is spanned by polynomials of order \(n \in \mathbb{N}\), with \(n \leq 2\) in most cases. Thus, the approximation of a function \(\mathbf{u}\) would be a linear combination of a set of polynomials, i.e.
where \(\hat{\mathbf{u}}_i\) are the coefficients of the approximation, \(\{\phi_i\}_{i = 1}^{N_n}\) is the set of basis functions for \(\mathcal{F}^h\), and \(N_n\) is the cardinality of \(\mathcal{F}^h\). We substitute approximations for all functions in the weak form, resulting in a system of ordinary differential equations (ODEs) in which we will solve for \(\hat{\mathbf{u}}_i\). We will write this system of ODEs as
where each of these terms is the approximation of the terms given in the general variational form provided above. FEniCS Mechanics parses a user-provided dictionary to determine which terms in the above system of ODEs need to be computed and how.
Finite Difference Methods¶
Once spatial discretization has been achieved with the FEM, we must discretize the time derivatives in the system of ODEs given above. The time integrators implemented in FEniCS Mechanics are currently single-step methods.
First Order ODEs¶
Consider the system of ODEs
where \(y \in \mathbb{R}^N\) for some \(N\in\mathbb{N}\), and \(t \in \mathcal{T} \in \mathbb{R}\). A general single-step, single-stage numerical method for approximating the solution to such a differential equation takes the form
Applying the generalized \(\theta\)-method to the system of ODEs, we get
and
where
and \(f_3\) is the discrete variational form of the
incompressibility constraint. This discretization is used by
MechanicsProblem
and MechanicsBlockSolver
, which is
only available when FEniCS is installed with python 2, and CBC-Block
is also installed. It is also used by FluidMechanicsProblem
and FluidMechanicsSolver
without the dependency on
displacement, \(u_n\), and without \(f_1\).
Second Order ODEs¶
Alternatively, one can discretize a system of second-order ODEs. First, we substitute \(v = \dot{u}\) into the ODE that results from the balance of linear momentum. This gives
and
where we also made use of the fact that solid mechanics problems are formulated with respect to the reference configuration. For this problem, we use the Newmark scheme to discretize the second-order time derivative. The Newmark scheme is given by
and
We then solve for \(\ddot{u}_{n+1}\) in the above equations, and substitute into the ODE given above. Then we solve the system for \(u_{n+1}\) (with a nonlinear solver if necessary).


Just type in your name (and click Submit) to enter the contest: First name: Last name:
Please put your comments below:


Several applications today have close integration of speech input. Personally I think its a great feature to have speech input in any application. Although you might find many API’s to do the job, wouldn’t it be nice if you just have one implicit part of your code do the trick without having to run through whole bunch of stuff to integrate the API and request it every time also not to forget the limit on number of requests (50/day for Google). So here is a simple code that implements HTML5 webkit to do the trick. I used the code to derive the phoneme from the speech which is used in several applications.
HTML Code:
Javascript Code:
Further, you need a simple php file to do the phoneme generation. Here is the PHP code:
I have tried the app locally and it works perfectly for me. Also I have embedded the above code into bootstrap to make it look elegant, if you want to try it out on your local machine feel free to clone the repository: https://github.com/PseudoAj/AjSpeechToPhonemes.git


{% extends "base.html" %} {% block title %}
Medieval catalogues > SECULAR INSTITUTIONS: Secular Colleges > Bishop Auckland > Record of gift from Bishop Richard Fox, 20 July 1499
{% endif %}60 identified entries found.
All data was derived from the List of Identifications by Professor Richard Sharpe.
{% if not printing %}
A key to codes used in the List is available (opens in new tab).{% endif %}


Formatting an external hard drive with parted
Identifying the external usb hard drive
Plug the usb hard drive and type df -Th
(T
: allow to display the file system type):
/dev/sdb1 fuseblk 932G 121M 932G 1% /media/yourusername/Elements
Unmount the partition to format; here:
umount /dev/sdb1
Optional: Remove all partitions, data and create empty disk
sudo dd if=/dev/zero of=/dev/sdb bs=512 count=1
Parted
sudo parted /dev/sdb
display the partition table:
(parted) print
Model: WD Elements 10B8 (scsi)
Disk /dev/sdb: 1000GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 1049kB 1000GB 1000GB primary ntfs
delete partition 1:
(parted) rm 1
Create a new partition table
(parted) mklabel msdos
Warning: The existing disk label on /dev/sdb will be destroyed and all data on this disk will be lost. Do you want to continue?
Yes/No? Yes
make a partition
(parted) mkpart
Partition type? primary/extended? primary
File system type? [ext2]? ext4
Start? 0%
End? -1s
Remark: -1s
: last sector of the drive
(parted) print
Model: WD Elements 10B8 (scsi)
Disk /dev/sdb: 1000GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 1049kB 1000GB 1000GB primary ext4 lba
In case of: Warning: The resulting partition is not properly aligned for best performance.
Cancel the operation:
Warning: The resulting partition is not properly aligned for best performance.
Ignore/Cancel? C
And try again with 100%
instead of -1s
:
(parted) mkpart
Partition type? primary/extended? primary
File system type? [ext2]? ext4
Start? 0%
End? 100%
exit parted
(parted) quit
Information: You may need to update /etc/fstab.
Formating
sudo mkfs.ext4 /dev/sdb1
Test
Unplug and plug again the disk and:
$ df -hT
/dev/sdb1 ext4 917G 72M 871G 1% /media/yourusername/4fc9b323-ac89-444a-9483-9af84030e1a1
Try to write on it:
cd /media/yourusername/4fc9b323-ac89-444a-9483-9af84030e1a1
touch toto
If you get a permission denied
just try to:
cd ..
sudo chown yourusername:yourgroupname 4fc9b323-ac89-444a-9483-9af84030e1a1


mail number:
%mail_number%
your ID:
Read the email and answer the questions below.
Q1. Looking at the text of the email, would you categorize it as:
%Q2%
Notes:
- You have categolized %mail_num% emails so far.
- To ensure accuracy of responeses, we will check the accuracy of a random sample of your work.
- These emails have been released to the public domain.
© Hiroki Nakajima


ntextIndent - ntext Indentation for the Text Widget
The ntext package provides a binding tag named Ntext for use by text widgets in place of the default Text binding tag.
Tk's text widget may be configured to wrap lines of text that are longer than the width of the text area, a feature that is familiar from text editors and word processors. A complete line of text (delimited by newlines, or by the beginning or end of the document) is called a "logical line". When a logical line is wrapped onto more than one line of the display area, these fragments of the logical line are called "display lines".
If a logical line begins with whitespace, then wrapped display lines begin further to the left than the first display line, which can make the text layout untidy and difficult to read. The Ntext binding tag provides facilities so that a text widget in -wrap word mode will automatically indent display lines (other than the first) to match the initial whitespace of the first display line.
This indentation is available to text widgets only in -wrap word mode.
Replacement for ::tk_textCopy.
Replacement for ::tk_textCut that also maintains Ntext indentation.
Replacement for ::tk_textPaste that also maintains Ntext indentation.
Command to apply the current value of the variable ::ntext::indentColor to existing lines in a text widget. This command is useful if a text widget has been created, text has been inserted in the widget, and then the value of ::ntext::indentColor is changed.
The behavior of Ntext may be configured application-wide by setting the values of a number of namespace variables:
::ntext::classicWrap
0 - selects Ntext behaviour, i.e. display lines are indented to match the initial whitespace of the first display line of a logical line.
No other action is required if this option, and the text widget's -wrap option, are set before any text is entered in the widget, and if text is entered and edited only by the mouse and keyboard. If, instead, text is manipulated by the script, or if the text widget's -wrap option or the value of ::ntext::classicWrap are changed while the widget holds text, then calls to ntext functions are needed to alter the indentation. See the section INDENTING DISPLAY LINES for detailed instructions.
1 - (default value) selects classic Text behaviour, i.e. no indentation.
::ntext::indentColor
{} - if the value is the empty string, then the indent of wrapped display lines has the same color as the widget background.
color - a valid Tk color to use for the indent of wrapped display lines (default value #d9d9d9).
Coloring is implemented with the text widget tag option -lmargincolor, which is available from Tk 8.6.6 onwards. Ntext indent coloring has no effect in earlier versions of Tk.
The value of ::ntext::indentColor will often be set at startup. If the value is changed when text widgets already exist and contain text, those widgets can be updated by calling command ::ntext::syncIndentColor.
Advanced Use
::ntext::newWrapRegexp
the value is a regexp pattern that determines the character of a logical line to which display lines other than the first will be aligned. The default value, [^[:space:]], ensures alignment with the first non-whitespace character.
To use Ntext 's display line indentation:
Set the variable ::ntext::classicWrap to 0 (default value is 1). This enables bindings that will preserve indentation whenever the user modifies the widget contents using the keyboard and mouse. If the widget already holds text, call ::ntext::wrapIndent to initialise indentation.
Further instructions apply if the program changes the widget's contents, wrap configuration, or indent configuration.
The program can change the text contents, e.g. by the .text insert command. Such a change does not trigger a window binding, so the program should explicitly call function ::ntext::wrapIndent after inserting text.
Auto-indentation occurs only if the widget is in -wrap word mode. If the program changes to or from -wrap word when the widget is not empty, it should call ::ntext::wrapIndent to format the widget's text.
If indentation is used, and then switched off by setting ::ntext::classicWrap to 1, call ::ntext::wrapIndent to remove indentation.
::ntext::wrapIndent textWidget ?index1? ?index2?
Adjust the indentation of a text widget. Different cases are discussed below.
::ntext::wrapIndent textWidget
Adjust the indentation of all the text in text widget textWidget.
::ntext::wrapIndent textWidget index1
Adjust the indentation of a single logical line of a text widget - the line of textWidget that contains the index index1.
::ntext::wrapIndent textWidget index1 index2
Adjust the indentation of a range of logical lines of a text widget - the lines of textWidget that contain indices index1 to index2.
Usage
::ntext::wrapIndent should be called only if the script changes the widget's contents or display properties. If the contents of the widget have been modified by the keyboard or mouse, it is not necessary for the script to call ::ntext::wrapIndent because the appropriate calls are made automatically by the Ntext bindings.
The script should normally call ::ntext::wrapIndent if, for example, the script changes one of the following when the widget is not empty: the value of ::ntext::classicWrap, or the widget's -wrap status, or the widget's tab spacing, or the font size, or the widget's contents.
A call of the form ::ntext::wrapIndent textWidget will always suffice, but if changes are needed only to certain lines, it is more efficient to specify those lines with the optional arguments ?index1?, ?index2?.
If the widget is in -word wrap mode, and if ::ntext::classicWrap is set to 0, ::ntext::wrapIndent will apply indentation to the logical lines within the range specified by the function's arguments.
In other cases, i.e. if the widget is in -word char or -word none mode, or if ::ntext::classicWrap is set to 1, ::ntext::wrapIndent will remove the indentation of the logical lines within the range specified by the function's arguments.
This version of ntext is intended to be compatible with all releases of Tk 8.5 and 8.6, and with the branches core-8-5-branch, core-8-6-branch, and trunk in the source code repository for Tk. Any incompatibility with any of these versions, for any Tk windowing system, should be reported as a bug. Please report such in the category ntext of the Tklib Trackers.
To switch on Ntext 's indentation and use it in widget .t, using the default indent color #d9d9d9:
package require ntext set ::ntext::classicWrap 0 text .t -wrap word bindtags .t {.t Ntext . all}
To switch on Ntext 's indentation and use it in widget .t, without colored indents:
package require ntext set ::ntext::classicWrap 0 set ::ntext::indentColor {} text .t -wrap word bindtags .t {.t Ntext . all}
To switch on Ntext 's indentation and use it in widget .t, coloring the indents black:
package require ntext set ::ntext::classicWrap 0 set ::ntext::indentColor black text .t -wrap word bindtags .t {.t Ntext . all}
To decide later to switch off Ntext 's indentation:
set ::ntext::classicWrap 1 ::ntext::wrapIndent .t
To decide later to switch Ntext 's indentation back on:
set ::ntext::classicWrap 0 ::ntext::wrapIndent .t 1.0 end
To inject some text into the widget:
set foo [.t index end] .t insert end {This line was added by the script, not the keyboard!} ::ntext::wrapIndent .t $foo end
To change the indentation color when a widget .t already holds text:
set ::ntext::indentColor black ::ntext::syncIndentColor .t
To switch to -wrap char mode:
.t configure -wrap char ::ntext::wrapIndent .t


reveal.js comes with a few themes built in:
Black (default) -
White -
League -
Sky -
Beige -
Simple
Serif -
Night -
Moon -
Solarized
"Free open-source software is a key to the well-being and prosperity of developing nations and their people. It represents an opportunity for them to become producers, not just consumers, of the software that increasingly defines our world, and to become authors and owners of the technology they need.''
Daniele Procida
Kauna Mufeti
Kauna Mufeti
Kauna Mufeti
The Team


Published empirical paper that looked at paricipants battery usage data as well as other factors.
Roots was a project for our Software Design class designed to track users ancestry lineage.
A low fidelity prototype was made with Photoshop for the UserTesting company intranet. Several usability research methods were applied.
Grocerscan was a project developed and presented in my Research Methods class that incoporated several UX principles.
Tutortrac is the system we use at the Office of Learning Services to login students in need of tutoring services. I evaluated the inferface from a user experience perspective.
Oswe-Go was a project designed to reserve parking spots on the SUNY Oswego campus. Prototyping and other UX methods were applied when designing the interface of this application.


Code Coverage |
|||||||||
Lines |
Functions and Methods |
Classes and Traits |
|||||||
| Total | |
7.44% |
116 / 1560 |
|
10.79% |
30 / 278 |
|
21.13% |
15 / 71 |
| Console | |
13.64% |
3 / 22 |
|
25.00% |
1 / 4 |
|
0.00% |
0 / 2 |
| Events | |
0.00% |
0 / 3 |
|
0.00% |
0 / 2 |
|
0.00% |
0 / 1 |
| Exceptions | |
0.00% |
0 / 3 |
|
0.00% |
0 / 2 |
|
0.00% |
0 / 1 |
| Http | |
5.97% |
50 / 837 |
|
7.25% |
10 / 138 |
|
5.88% |
2 / 34 |
| Jobs | |
0.00% |
0 / 21 |
|
0.00% |
0 / 4 |
|
0.00% |
0 / 2 |
| Models | |
29.63% |
8 / 27 |
|
29.63% |
8 / 27 |
|
50.00% |
7 / 14 |
| Notifications | |
0.00% |
0 / 4 |
|
0.00% |
0 / 3 |
|
0.00% |
0 / 1 |
| Providers | |
100.00% |
55 / 55 |
|
100.00% |
11 / 11 |
|
100.00% |
6 / 6 |
| Repositories | |
0.00% |
0 / 588 |
|
0.00% |
0 / 87 |
|
0.00% |
0 / 10 |


Tree View
Item Selection and Customization
Dark Theme
Light Theme
Store: Super Mart of the West
Selected Products


The figure below shows the Proximity Query Editor interface.
The Query Editor provides a large display area where you graphically create the query structure of vertices, edges, and subqueries. The Query Editor includes two properties panes at the bottom of the window for displaying and editing query properties such as conditions, annotations, and constraints. The query properties pane displays properties of the query as a whole. The element properties pane displays the properties of the selected query element. The element properties pane is blank when no query element is selected. The status list at the bottom of the window indicates whether the query is valid, and if invalid, provides a drop-down list of errors.
The Query Editor is mode based. Each toolbar button selects a tool, which in turn determines the current mode for the Query Editor. For example, clicking the vertex tool places the Query Editor in vertex mode. All subsequent clicks in the Query Editor display area place a new vertex at the indicated location. Selecting a new tool by clicking the corresponding toolbar button changes the mode and changes how clicks in the display area are interpreted.
The sections below provide instructions for creating queries and working with the Query Editor.
You can start the Query Editor with no specified query (to create a new query), or specify an existing query to edit that query in the Query Editor.
Choose the appropriate action from the Queries menu:
If you are editing a previously saved query, Proximity display the Open dialog so that you can select the query to edit.
Proximity allows you to open multiple Query Editor windows. All Query Editor windows are closed when you close the Proximity Database Browser.
Proximity asks whether to save any unsaved queries before closing the Query Editor.
In the File menu, select Exit Query Editor.
Changing the zoom level can be helpful when working with large queries. Zooming out lets you see the entire query structure at once while zooming in lets you easily work with individual query elements.
To zoom in: In the View menu, select Zoom In or press Ctrl-=.
To zoom out: In the View menu, select Zoom Out or press Ctrl- – (Ctrl-minus).
To zoom contents to fit the display area: In the View menu, select Zoom To Fit or press Ctrl-0 (Ctrl-zero).
To reset the zoom to its default setting: In the View menu, select Reset Zoom or press Ctrl-Backspace.
Many Query Editor commands can be invoked using keyboard shortcuts instead of using the mouse. You can open, close, save, and run queries, select tools, and change the Query Editor’s mode (select tools) using keyboard shortcuts. Keyboard shortcuts are shown next to the corresponding command in the Query Editor’s menus. The table below summarizes these shortcuts.
| Command | Keyboard shortcut | Command | Keyboard shortcut |
|---|---|---|---|
| New query | Ctrl-N | Selection tool | Ctrl-1 |
| Open query file | Ctrl-O | Vertex tool | Ctrl-2 |
| Close query | Ctrl-W | Edge tool | Ctrl-3 |
| Save query | Ctrl-S | Subquery tool | Ctrl-4 |
| Run query | Ctrl-R | Flip edge direction | Ctrl-F |
| Select next item | Ctrl-
|
Select previous item | Ctrl-
|
| Zoom in | Ctrl-= | Zoom to fit | Ctrl-0 (zero) |
| Zoom out | Ctrl-Minus | Reset zoom | Ctrl-Backspace |


About Aubergine
How-To's
Artwork
Projects
the code.
The code of this website, and (most) of it's assets can be found in my github