POINT OF NO RETURN A film review by Rick KLau Copyright 1993 Rick KLau
Director: John Badham Producer: Art Linson Starring: Bridget Fonda, Gabriel Byrne, Dermot Mulroney With: Anne Bancroft and Harvey Keitel Screenplay: Robert Gechell and Alexandra Seros Music by: Hans Zimmer Length: 1 hour 55 minutes. Rated: R. brief nudity, graphic violence, language. Released by: Warner Bros.
In brief: Maggie (Bridget Fonda; SINGLE WHITE FEMALE) is a heroine addict arrested for the murder of a police officer.  What follows is her training and eventual service.
Based on Luc Besson's stylish NIKITA (released in the States as LA FEMME NIKITA), POINT OF NO RETURN is surprisingly good. While its trailers and print ads profess to be a run-of-the-mill action flick, the strength of the original and good performances by Fonda and Mulroney earn POINT OF NO RETURN good marks.
I first saw NIKITA two years ago at the Key theater in Georgetown. Anne Parillaud won the Cesar for Best Actress in her role as Nikita, and Luc Besson won acclaim in France for his efforts. Somewhat difficult to understand (from my point of view) were the negative reviews NIKITA received when it was released in the summer of 1991. The Washington Post complained that it lacked substance and mistook style for content; The New York Times had similar comments. I have seen NIKITA several times since that summer and each viewing brings only more appreciation for a wonderful film.
But this is a review of POINT OF NO RETURN. My initial fear as I entered the theater Friday night was that this would Americanize the plot without keeping the psychological crisis that the lead female experiences. Having seen several trailers on TV, I was already aware that POINT OF NO RETURN copied some scenes verbatim from NIKITA ... it seemed as if they had forsaken originality for expediency.
The plot and indeed the direction borrows heavily from Besson, although there are some notable departures. In an interview, Badham talked about Americanizing the characters - a gamble that in retrospect paid off. Even avid fans of NIKITA will feel as if they're seeing another side of someone they're very familiar with. Without taking away from the story, Badham manages to add his own touch to the characters (especially the part of Marco, Nikita's boyfriend and Bob, her sadistic supervisor). The net result is that Badham succeeds in tweaking the story while maintaining the thoroughly believable chemistry between the three principles.
The action scenes are very well choreographed. Fonda carries off the rebel attitude that undergoes a remarkable transformation while under the tutelage of Bob (Mulroney) and her instructor (Anne Bancroft). The only "improvement" on the original, I would argue, are the scenes between Fonda and Bancroft: Bancroft acts as if the part were written for her and Fonda seems to enjoy her "learning."
Harvey Keitel, in the role of Victor the cleaner, is credible, however he does not convey the same electricity that was present in the original. The role calls for a very intimidating persona; Keitel manages the mental intimidation but fails to instill physical fear.
The film does have its flaws, some technical and some artistic. Washington, DC does not have a death penalty yet Maggie (Fonda) is condemned to death after killing a DC cop. Badham's direction is not nearly as stylish as Besson's; often Badham mistakes a skewed camera angle for "style" and is often blunt when subtlety would serve his purpose better.  Especially considering the environment that Maggie operates in, it's hard to believe that her targets would be driving Chevy Cavaliers. The product advertising was unnecessary (even an AfterDark box next to a Macintosh at one point) but did not distract from the film as a whole.
Of the two, NIKITA is by far the better, if only because it was original.  It's certainly enjoyable, although I would urge anyone who likes it to rent NIKITA as soon as possible.
RATING: On a scale of 0 to 10, POINT OF NO RETURN receives a 7.
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


|
Vulkan Memory Allocator
|
This library contains several functions that return information about its internal state, especially the amount of memory allocated from Vulkan.
If you need to obtain basic statistics about memory usage per heap, together with current budget, you can call function vmaGetHeapBudgets() and inspect structure VmaBudget. This is useful to keep track of memory usage and stay withing budget (see also Staying within budget). Example:
You can query for more detailed statistics per memory heap, type, and totals, including minimum and maximum allocation size and unused range size, by calling function vmaCalculateStatistics() and inspecting structure VmaTotalStatistics. This function is slower though, as it has to traverse all the internal data structures, so it should be used only for debugging purposes.
You can query for statistics of a custom pool using function vmaGetPoolStatistics() or vmaCalculatePoolStatistics().
You can query for information about a specific allocation using function vmaGetAllocationInfo(). It fill structure VmaAllocationInfo.
You can dump internal state of the allocator to a string in JSON format using function vmaBuildStatsString(). The result is guaranteed to be correct JSON. It uses ANSI encoding. Any strings provided by user (see Allocation names) are copied as-is and properly escaped for JSON, so if they use UTF-8, ISO-8859-2 or any other encoding, this JSON string can be treated as using this encoding. It must be freed using function vmaFreeStatsString().
The format of this JSON string is not part of official documentation of the library, but it will not change in backward-incompatible way without increasing library major version number and appropriate mention in changelog.
The JSON string contains all the data that can be obtained using vmaCalculateStatistics(). It can also contain detailed map of allocated memory blocks and their regions - free and occupied by allocations. This allows e.g. to visualize the memory or assess fragmentation.


US Consulate in Mexico Introduces Curfew Following Spike in Violence
MEXICO (Sputnik) - The US Consulate General in the Mexican city of Nuevo Laredo has restricted the movement of its personnel due to a recent outbreak of violence.
"US government personnel are subject to restrictions on their movements and an evening curfew until further notice", the consulate wrote on Twitter.
The consulate staff was advised to stay away from public places, and monitor local media for new information.
On Friday, according to media, there were six shootings, including an attack on a police convoy, in which an armed criminal was killed.
On Thursday, seven people died in three firefights, including one soldier.
Previously, three American Mormon families sustained a savage attack in northern Mexico, where nine people lost their lives, the Mexican security minister said.


The Good, Bad, and the Not Quite So Pretty
In this blog we will mainly be reviewing websites base on their designs and User Experiences.
For a game as beautiful as Guild Wars 2, one is almost suprised to find its website to be so bland. It is a clean streamlined site that is easy to navigate and it delivers the game news/updates like it's meant to do. I think the User Experience is good here since it does provide you with all the information you need about the game delivered in a straightforward manner. Design is good in that the layout is simple and uncluttered. However, after being on the site for a while it felt boring. Not particularly inspiring for a game that has won many awards.
Trader Joe's website is as busy and quirky as its brick and mortar stores. Interestingly enough I think this website has the opposite problem as the Guild Wars' site in that while it's visually fun to look at, at times its navigation isn't the most intuitive. For the uninitiated, they would not know what "Dig In" means food blog on the Navbar. I also found the "Customer Updates" under the "About Us" which didn't make sense since it really should be under the "Product News" page. Even when I worked at Trader Joe's I had to guess where some of the buttons would take me when I clicked on them. The strength of this site is that it is fun to look at and does have all the information a customer would want if the customer can find where it is.
This website has a good balance between design and user experience in my opinion. It is clean, elegant, and easy to navigate. It is a site that's suppose to sell you the idea that renting other people's home is a good alternative to hotels and it delivers it well. Not only does it have the tools for you to search for rentals, it also offers you plenty of information on neighborhoods and safety. When I first heard about Airbnb I was a bit leery about renting other people's home but after visiting the website I felt comfortable enough to book my first rental and that certainly is a sign of a well designed website. It gave me plenty of options, answered questions I had, and easy to navigate.
Just your average Web Development student :)


A compact, URL-safe means of representing claims to be transferred between two parties.
JSON Web Tokens consist of three parts separated by dots (.)
Therefore, a JWT typically looks like the following:
xxxxx.yyyyy.zzzzz
The header typically consists of two parts: the type of the token, which is JWT, and the hashing algorithm being used, such as HMAC SHA256 or RSA.
{
"alg": "HS256",
"typ": "JWT"
}
The second part of the token is the payload, which contains the claims. Claims are statements about an entity (typically, the user) and additional data. There are three types of claims: registered, public, and private claims.
{
"sub": "1213789",
"name": "John Doe",
"admin": true,
"exp": "42h",
}
To create the signature part you have to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that.
HMACSHA256(
base64UrlEncode(header) + "." +
base64UrlEncode(payload),
secret
)
The output is three Base64-URL strings separated by dots.
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
The output is three Base64-URL strings separated by dots.
jwt.sign(payload, secretOrPrivateKey, [options, callback])
jwt.verify(token, secretOrPublicKey, [options, callback])
jwt.decode(token [, options])
https://www.npmjs.com/package/jsonwebtoken
http://allfe:1234/uzytkownik/zresetuj-haslo/eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJpZCI6IjViNjJiNmFhNmJmOTlhMGsdjQ0ODgyOSIsInB1cnBvc2UiOiJwYXfgfJlc2V0IiwiaWF0IjoxNTMzW
dfgwNTYwLCJleHAiOjE1MzMzNjY5NjB9.lA_DZde5vcYsZsBRIutrdhxfOAK2VTtE3r-psEhCrsHYx0


Atomic Wallet, a custody-free multi-assets wallet with a decentralized exchange that supports atomic swaps, have announced that they will be adding support for Monero within 2 weeks. On their official Twitter handle, they said: “Let’s make a bet! We will add @monero to @a...


Countdown to year 3000:
It is
979
years to year 3000!
It is
11739
months to year 3000!
It is
51041
weeks to year 3000!
It is
357286
days to year 3000!
It is
8574857
hours to year 3000!
It is
514491409
minutes to year 3000!
It is
30869484524
seconds to year 3000!


Cultural Blog: Personal Values
It's hard to choose just one value that I would uphold as the single value that I put above all others. Creativity, close relationships, and introspection are the three most obvious values that I identify with. One thing that in some way encompasses all of those that I think truly is the most important value to me is genuineness.
I to try to live up to my standards for being a genuine person most of the time. I'm a lot more a honest about certain things that many people. The last person to ask me for advice was asking about personal relationships in her life, which is a pretty common theme in our conversations.
When I think about my values, I have mixed feelings about them. I think it is good to be genuine and introspective, have close relationships, and want to create things as a means of self-expression. At the same time, however, some of those things actually do all have the capacity to become extremely self-focused. Introspection can lead to wisdom, or can lead to a twisted self-concept in which I put myself on a pedestal. Creative works can be beautiful, but I can also up shirking the most important people in my life when I'm working on a project that I'm really excited about. Close relationships can be very fulfilling, but they can also lead to unrealistic expectations (i.e. "you should make me happy", particularly in the romantic context). All the things I value the most in life involve an immense depth of feeling, which can be wonderful or very selfish.
This is why I desire to be a more compassionate person. I think I have the capacity to feel things deeply, so if I can do that on someone else's behalf, I would call that empathy. If I can render that when I see someone struggling, it helps me overcome my own perspectives and insecurities. I think that could help to eliminate stereotype threat--albeit, any difficult interaction with other people.
When I'm feeling down at DBC, I think it will help to realize that I'm not the only one struggling. It is going to be a challenge for everyone. Everyone is bringing their doubts and fears to the table. Having enough compassion to realize that I'm not alone will make it easier to have patience for both others and for myself.


Accused Zombicon shooter scheduled to be in court Monday
by WFTX Digital TeamFORT MYERS, Fla. -- The man accused in the Zombicon shooting will have a court hearing, likely to discuss his upcoming trial.
Fort Myers Police say Jose Bonilla fired several shots on a crowded street full of thousands of people during the festival, killing Tyrell Taylor and hurting several others in 2015.
He was arrested more than two years after the shooting .
His trial is expected to start this upcoming January.


Make groups for better studies! Working with your peers in a study group gives you an excellent opportunity to hone your people skills.


Ticoult1282.github.io
9400 CAL CONTROLS, 9400 Datasheet - Elcodis. Cal Control 3300- and 9400-Series Temperature/Process. CAL Controls 9400 Series Temperature Controller. Cal Controls 9400 Series Process Controllers in stock at Galco! Huge Cal Controls 9400 Series Process Controllers Inventory - Same Day Shipping - Expert. Users Manual CAL Controls Temperature Controllers CAL 3300 / 9300 / 9400 Autotune Temperature Controllers English Français Deutsch Italiano Español. CAL 9400 Dual Display Temperature Controller CAL Controls Temperature Controllers The CAL 9400 is a 1/16 DIN dual display, dual output miniature controller with PID control strategy.
9400. The CAL 9400 1/16DIN dual-display temperature controller is designed to be easy-to-use and reliable within the most demanding process and manufacturing applications. Designed for industrial or scientific applications CAL9400 has an impact resistant smoked fascia with rubberised buttons with positive feedback. Buy CAL CONTROLS 9400 online at Newark element14. Buy your 9400 from an authorized CAL CONTROLS distributor. 9400 SERIES Cal Controls Process Controllers Product.
Request CAL CONTROLS 9400: TEMPERATURE CONTROLLER, RELAY/SSR online from Elcodis, view and download 9400 pdf datasheet, Industrial Computing.
Buy Cal Control 3300- and 9400-Series Temperature/Process Controllers and more from our comprehensive selection of Temperature Process Controllers. 9400 OMEGA Cover 1 - The Temperature Solution. The CAL Controls 9400 Series temperature controller features a second setpoint that can be configured in a variety of alarm modes or PID Heat-Cool strategy. A programmer offers a single ramp to setpoint with a choice of timed soak period before switching off the output. The CAL Controls 9400 Series temperature controller provides control of non-temperature processes by the provision of linear input ranges and scaling in commonly used engineering units. 9400 - CAL CONTROLS - TEMPERATURE CONTROLLER, RELAY/SSR. CAL 3300 / 9300 / 9400 Autotune Temperature Controllers.


The hadoop-aws module provides support for AWS integration. The generated JAR file, hadoop-aws.jar also declares a transitive dependency on all external artifacts which are needed for this support —enabling downstream applications to easily use this support.
Features
The specifics of using these filesystems are documented below.
Amazon S3 is an example of “an object store”. In order to achieve scalability and especially high availability, S3 has —as many other cloud object stores have done— relaxed some of the constraints which classic “POSIX” filesystems promise.
Specifically
For further discussion on these topics, please consult The Hadoop FileSystem API Definition.
Your AWS credentials not only pay for services, they offer read and write access to the data. Anyone with the credentials can not only read your datasets —they can delete them.
Do not inadvertently share these credentials through means such as 1. Checking in Hadoop configuration files containing the credentials. 1. Logging them to a console, as they invariably end up being seen.
If you do any of these: change your credentials immediately!
<property> <name>fs.s3n.awsAccessKeyId</name> <description>AWS access key ID</description> </property> <property> <name>fs.s3n.awsSecretAccessKey</name> <description>AWS secret key</description> </property>
<property> <name>fs.s3n.block.size</name> <value>67108864</value> <description>Block size to use when reading files using the native S3 filesystem (s3n: URIs).</description> </property> <property> <name>fs.s3n.multipart.uploads.enabled</name> <value>false</value> <description>Setting this property to true enables multiple uploads to native S3 filesystem. When uploading a file, it is split into blocks if the size is larger than fs.s3n.multipart.uploads.block.size. </description> </property> <property> <name>fs.s3n.multipart.uploads.block.size</name> <value>67108864</value> <description>The block size for multipart uploads to native S3 filesystem. Default size is 64MB. </description> </property> <property> <name>fs.s3n.multipart.copy.block.size</name> <value>5368709120</value> <description>The block size for multipart copy in native S3 filesystem. Default size is 5GB. </description> </property> <property> <name>fs.s3n.server-side-encryption-algorithm</name> <value></value> <description>Specify a server-side encryption algorithm for S3. The default is NULL, and the only other currently allowable value is AES256. </description> </property>
<property> <name>fs.s3a.access.key</name> <description>AWS access key ID. Omit for Role-based authentication.</description> </property> <property> <name>fs.s3a.secret.key</name> <description>AWS secret key. Omit for Role-based authentication.</description> </property>
<property> <name>fs.s3a.connection.maximum</name> <value>15</value> <description>Controls the maximum number of simultaneous connections to S3.</description> </property> <property> <name>fs.s3a.connection.ssl.enabled</name> <value>true</value> <description>Enables or disables SSL connections to S3.</description> </property> <property> <name>fs.s3a.endpoint</name> <description>AWS S3 endpoint to connect to. An up-to-date list is provided in the AWS Documentation: regions and endpoints. Without this property, the standard region (s3.amazonaws.com) is assumed. </description> </property> <property> <name>fs.s3a.proxy.host</name> <description>Hostname of the (optional) proxy server for S3 connections.</description> </property> <property> <name>fs.s3a.proxy.port</name> <description>Proxy server port. If this property is not set but fs.s3a.proxy.host is, port 80 or 443 is assumed (consistent with the value of fs.s3a.connection.ssl.enabled).</description> </property> <property> <name>fs.s3a.proxy.username</name> <description>Username for authenticating with proxy server.</description> </property> <property> <name>fs.s3a.proxy.password</name> <description>Password for authenticating with proxy server.</description> </property> <property> <name>fs.s3a.proxy.domain</name> <description>Domain for authenticating with proxy server.</description> </property> <property> <name>fs.s3a.proxy.workstation</name> <description>Workstation for authenticating with proxy server.</description> </property> <property> <name>fs.s3a.attempts.maximum</name> <value>10</value> <description>How many times we should retry commands on transient errors.</description> </property> <property> <name>fs.s3a.connection.establish.timeout</name> <value>5000</value> <description>Socket connection setup timeout in milliseconds.</description> </property> <property> <name>fs.s3a.connection.timeout</name> <value>50000</value> <description>Socket connection timeout in milliseconds.</description> </property> <property> <name>fs.s3a.paging.maximum</name> <value>5000</value> <description>How many keys to request from S3 when doing directory listings at a time.</description> </property> <property> <name>fs.s3a.threads.max</name> <value>256</value> <description> Maximum number of concurrent active (part)uploads, which each use a thread from the threadpool.</description> </property> <property> <name>fs.s3a.threads.core</name> <value>15</value> <description>Number of core threads in the threadpool.</description> </property> <property> <name>fs.s3a.threads.keepalivetime</name> <value>60</value> <description>Number of seconds a thread can be idle before being terminated.</description> </property> <property> <name>fs.s3a.max.total.tasks</name> <value>1000</value> <description>Number of (part)uploads allowed to the queue before blocking additional uploads.</description> </property> <property> <name>fs.s3a.multipart.size</name> <value>104857600</value> <description>How big (in bytes) to split upload or copy operations up into.</description> </property> <property> <name>fs.s3a.multipart.threshold</name> <value>2147483647</value> <description>Threshold before uploads or copies use parallel multipart operations.</description> </property> <property> <name>fs.s3a.acl.default</name> <description>Set a canned ACL for newly created and copied objects. Value may be private, public-read, public-read-write, authenticated-read, log-delivery-write, bucket-owner-read, or bucket-owner-full-control.</description> </property> <property> <name>fs.s3a.multipart.purge</name> <value>false</value> <description>True if you want to purge existing multipart uploads that may not have been completed/aborted correctly</description> </property> <property> <name>fs.s3a.multipart.purge.age</name> <value>86400</value> <description>Minimum age in seconds of multipart uploads to purge</description> </property> <property> <name>fs.s3a.buffer.dir</name> <value>${hadoop.tmp.dir}/s3a</value> <description>Comma separated list of directories that will be used to buffer file uploads to. No effect if fs.s3a.fast.upload is true.</description> </property> <property> <name>fs.s3a.impl</name> <value>org.apache.hadoop.fs.s3a.S3AFileSystem</value> <description>The implementation class of the S3A Filesystem</description> </property>
Warning: NEW in hadoop 2.7. UNSTABLE, EXPERIMENTAL: use at own risk
<property> <name>fs.s3a.fast.upload</name> <value>false</value> <description>Upload directly from memory instead of buffering to disk first. Memory usage and parallelism can be controlled as up to fs.s3a.multipart.size memory is consumed for each (part)upload actively uploading (fs.s3a.threads.max) or queueing (fs.s3a.max.total.tasks)</description> </property> <property> <name>fs.s3a.fast.buffer.size</name> <value>1048576</value> <description>Size (in bytes) of initial memory buffer allocated for an upload. No effect if fs.s3a.fast.upload is false.</description> </property>
Writes are buffered in memory instead of to a file on local disk. This removes the throughput bottleneck of the local disk write and read cycle before starting the actual upload. Furthermore, it allows handling files that are larger than the remaining local disk space.
However, non-trivial memory tuning is needed for optimal results and careless settings could cause memory overflow. Up to fs.s3a.threads.max parallel (part)uploads are active. Furthermore, up to fs.s3a.max.total.tasks additional part(uploads) can be waiting (and thus memory buffers are created). The memory buffer is uploaded as a single upload if it is not larger than fs.s3a.multipart.threshold. Else, a multi-part upload is initiatated and parts of size fs.s3a.multipart.size are used to protect against overflowing the available memory. These settings should be tuned to the envisioned workflow (some large files, many small ones, …) and the physical limitations of the machine and cluster (memory, network bandwidth).
Due to eventual consistency, tests may fail without reason. Transient failures, which no longer occur upon rerunning the test, should thus be ignored.
To test the S3* filesystem clients, you need to provide two files which pass in authentication details to the test runner
These are both Hadoop XML configuration files, which must be placed into hadoop-tools/hadoop-aws/src/test/resources.
The presence of this file triggers the testing of the S3 classes.
Without this file, none of the tests in this module will be executed
The XML file must contain all the ID/key information needed to connect each of the filesystem clients to the object stores, and a URL for each filesystem for its testing.
The contents of each bucket will be destroyed during the test process: do not use the bucket for any purpose other than testing. Furthermore, for s3a, all in-progress multi-part uploads to the bucket will be aborted at the start of a test (by forcing fs.s3a.multipart.purge=true) to clean up the temporary state of previously failed tests.
Example:
<configuration> <property> <name>test.fs.s3n.name</name> <value>s3n://test-aws-s3n/</value> </property> <property> <name>test.fs.s3a.name</name> <value>s3a://test-aws-s3a/</value> </property> <property> <name>test.fs.s3.name</name> <value>s3://test-aws-s3/</value> </property> <property> <name>fs.s3.awsAccessKeyId</name> <value>DONOTPCOMMITTHISKEYTOSCM</value> </property> <property> <name>fs.s3.awsSecretAccessKey</name> <value>DONOTEVERSHARETHISSECRETKEY!</value> </property> <property> <name>fs.s3n.awsAccessKeyId</name> <value>DONOTPCOMMITTHISKEYTOSCM</value> </property> <property> <name>fs.s3n.awsSecretAccessKey</name> <value>DONOTEVERSHARETHISSECRETKEY!</value> </property> <property> <name>fs.s3a.access.key</name> <description>AWS access key ID. Omit for Role-based authentication.</description> <value>DONOTCOMMITTHISKEYTOSCM</value> </property> <property> <name>fs.s3a.secret.key</name> <description>AWS secret key. Omit for Role-based authentication.</description> <value>DONOTEVERSHARETHISSECRETKEY!</value> </property> </configuration>
The file hadoop-tools/hadoop-aws/src/test/resources/contract-test-options.xml must be created and configured for the test filesystems.
If a specific file fs.contract.test.fs.* test path is not defined for any of the filesystems, those tests will be skipped.
The standard S3 authentication details must also be provided. This can be through copy-and-paste of the auth-keys.xml credentials, or it can be through direct XInclude inclusion.
In the file src/test/resources/contract-test-options.xml, the filesystem name must be defined in the property fs.contract.test.fs.s3n. The standard configuration options to define the S3N authentication details must also be provided.
Example:
<property> <name>fs.contract.test.fs.s3n</name> <value>s3n://test-aws-s3n/</value> </property>
In the file src/test/resources/contract-test-options.xml, the filesystem name must be defined in the property fs.contract.test.fs.s3a. The standard configuration options to define the S3N authentication details must also be provided.
Example:
<property> <name>fs.contract.test.fs.s3a</name> <value>s3a://test-aws-s3a/</value> </property>
<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- ~ Licensed to the Apache Software Foundation (ASF) under one ~ or more contributor license agreements. See the NOTICE file ~ distributed with this work for additional information ~ regarding copyright ownership. The ASF licenses this file ~ to you under the Apache License, Version 2.0 (the ~ "License"); you may not use this file except in compliance ~ with the License. You may obtain a copy of the License at ~ ~ http://www.apache.org/licenses/LICENSE-2.0 ~ ~ Unless required by applicable law or agreed to in writing, software ~ distributed under the License is distributed on an "AS IS" BASIS, ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ~ See the License for the specific language governing permissions and ~ limitations under the License. --> <configuration> <include xmlns="http://www.w3.org/2001/XInclude" href="auth-keys.xml"/> <property> <name>fs.contract.test.fs.s3</name> <value>s3://test-aws-s3/</value> </property> <property> <name>fs.contract.test.fs.s3a</name> <value>s3a://test-aws-s3a/</value> </property> <property> <name>fs.contract.test.fs.s3n</name> <value>s3n://test-aws-s3n/</value> </property> </configuration>
This example pulls in the auth-keys.xml file for the credentials. This provides one single place to keep the keys up to date —and means that the file contract-test-options.xml does not contain any secret credentials itself.


Web Panel - Options
Search engine:
Google Search
Bing
Yahoo!
DuckDuckGo
Help:
View
(opens in the sidebar)


{# This macro is used by results.html and also in the InvenioRemoteSearch class! #} {% macro render_result(result, is_event) %}


| Total net profit | -54.9 | Gross profit | 34.01 | Gross loss | -88.91 |
| Profit factor | 0.38 | Expected payoff | -0.58 | ||
| Absolute drawdown | -54.9 | Maximal drawdown (%) | 58.37 (1682.13%) | ||
| Total trades | 95 | Profit trades (% of total) | 41 (43.16%) | Loss trades (% of total) | 54 (56.84%) |
| Long positions (won %) | 43 (44.19%) | Short positions (won %) | 52 (42.31%) | ||
| Largest | profit trade | 2.19 | loss trade | -4.01 | |
| Average | profit trade | 0.83 | loss trade | -1.65 | |
| Minimum | profit trade | 0.06 | loss trade | -0.12 | |
| Maximum | take profit in pips | 42.4 | stop loss in pips | -54.9 | |
| Average | take profit in pips | 9.3 | stop loss in pips | -17.5 | |
| Minimum | take profit in pips | -2.7 | stop loss in pips | -4.3 | |
| Maximum | Reward-Risk | 5.9 | Duration in minutes | 3328 | |
| Average | Reward-Risk | 0.8 | Duration in minutes | 164.0 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 0 | |
| Maximum | consecutive wins (profit in money) | 4.0 (4.65) | consecutive losses (loss in money) | 6.0 (-9.6) | |
| Average | consecutive wins | 1.0 | consecutive losses | 2.0 |
| Total net profit | -33.38 | Gross profit | 11.96 | Gross loss | -45.34 |
| Profit factor | 0.26 | Expected payoff | -0.78 | ||
| Absolute drawdown | -33.38 | Maximal drawdown (%) | 29.93 (-867.54%) | ||
| Total trades | 43 | Profit trades (% of total) | 19 (44.19%) | Loss trades (% of total) | 24 (55.81%) |
| Largest | profit trade | 1.96 | loss trade | -4.01 | |
| Average | profit trade | 0.63 | loss trade | -1.89 | |
| Minimum | profit trade | 0.1 | loss trade | -0.28 | |
| Maximum | take profit in pips | 22.4 | stop loss in pips | -37.8 | |
| Average | take profit in pips | 8.2 | stop loss in pips | -17.6 | |
| Minimum | take profit in pips | -2.7 | stop loss in pips | -5.6 | |
| Maximum | Reward-Risk | 3.4 | Duration in minutes | 518.0 | |
| Average | Reward-Risk | 0.6 | Duration in minutes | 116.7 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 0.0 | |
| Maximum | consecutive wins (profit in money) | 3.0 (1.33) | consecutive losses (loss in money) | 6.0 (-9.6) | |
| Average | consecutive wins | 1.0 | consecutive losses | 2.0 |
| Total net profit | -21.52 | Gross profit | 22.05 | Gross loss | -43.57 |
| Profit factor | 0.51 | Expected payoff | -0.41 | ||
| Absolute drawdown | -22.87 | Maximal drawdown (%) | 26.34 (759.08%) | ||
| Total trades | 52 | Profit trades (% of total) | 22 (42.31%) | Loss trades (% of total) | 30 (57.69%) |
| Largest | profit trade | 2.19 | loss trade | -2.84 | |
| Average | profit trade | 1.0 | loss trade | -1.45 | |
| Minimum | profit trade | 0.06 | loss trade | -0.12 | |
| Maximum | take profit in pips | 42.4 | stop loss in pips | -54.9 | |
| Average | take profit in pips | 10.2 | stop loss in pips | -17.4 | |
| Minimum | take profit in pips | -1.3 | stop loss in pips | -4.3 | |
| Maximum | Reward-Risk | 5.9 | Duration in minutes | 3328.0 | |
| Average | Reward-Risk | 0.8 | Duration in minutes | 203.1 | |
| Minimum | Reward-Risk | Duration in minutes | 0.0 | ||
| Maximum | consecutive wins (profit in money) | 4.0 (2.53) | consecutive losses (loss in money) | 5.0 (-3.73) | |
| Average | consecutive wins | 1.0 | consecutive losses | 2.0 |


Search Examples
Search for a specific type of attachment file. A message with next year's budget spreadsheet attached. You don't remember who it's from or what date it was sent, but the filename has an .XLS extension.
Open just the Attachments drop-down menu and select the attachment extension type. A list of check boxes appears beneath the radio button. Scroll down and check the box next to Microsoft Excel.
Search for a contact within a specific company. A contact who works at a company called "Rivendell".
In the Search bar drop-down menu select Contacts and enter the company name in the Search text box.
Search for a message over all your folders. You know you received a message, but you are not sure which folder you saved it to.
Click the magnifying glass icon in the Search bar to open the Search page. In the Status drop-down menu, select anywhere. To include your Trash and Junk folders in your search, you must enable this in the Preferences>General page.
Search by a date range. A message someone claims to have sent you "in early December."
Click the magnifying glass icon in the Search bar to open the Search page. To set a date range, in the Date sent drop-down menu select is before and add a date and then select is after and add an end date.
Search for a message that you have not answered. You received email messages that you have not yet replied to
Click the magnifying glass icon in the Search bar to open the Search page. In the Status drop-down menu, select solo.


Control The Nuclear Power Plant (Demonstration)
by Henrik Eriksson
The control-room operators of the Kärnobyl nuclear power plant are
telecommuting and are running the plant through the Web. However, the
mean time between failure for the components of Kärnobyl is not
great. Try to keep the reactor stable when component failures occur!
(Click here for instructions.)
Use sequence buttons 1-3 to run a failure-simulation sequence. The
randomize button starts a random failure sequence. When a simulation
sequence is running, you can control the state of valves and pumps by
clicking on them. The moderator rods in the reactor can be moved by
mouse dragging them.
Detailed Applet Description
Copyright © 1995 Linköping
University, Linköping, Sweden.
Maintained by Henrik Eriksson <her@ida.liu.se>


Source code for tvdTop
'''
File: tvdTop.py
Created: 26/08/2014
@author: Francesco Ciaccia, Jarkko K
Description:
Service class used to compute the service graph to be passed to the Orchestrator,
starting from the profileType json file received.
It includes also methods used by the internal logic of the PSC to store and retrieve info about
the TVD topology.
'''
import json
import hashlib
from datetime import datetime
[docs]class tvdTop():
def __init__(self, sg_dict):
self.sg_dict = sg_dict
[docs] def resolveTVDtop(self, proType):
'''
Right now the TVD resolution logic is a dumb reformatting of the profileType file
The only valid modification is the added unique TVDid
'''
self.sg_dict['name'] = "user_service_graph"
# unique TVD id generation; the token <--> TDV_id association is only known to the PSC
# as the Orchestrator deletes the entry as soon as the instantiation is done
self.sg_dict['TVDid'] = hashlib.sha256(proType['user_token']+str(datetime.now())).hexdigest()
self.sg_dict['token'] = proType['user_token']
PSAs = []
temp = {}
for psa in proType['PSASet']:
# Create a new holder for every PSA
temp = {}
temp['id'] = psa['id']
# the following doesn't work for PSAs described by multiple security controls
# [0] is hardcoded for the first value
temp['conf'] = psa['security_controls'][0]['conf_id']
print temp
PSAs.append(temp)
self.sg_dict['PSAs'] = PSAs
# TODO fix in NED!
# UPR changes DO NOT provide these.... But are they used anyhow, later in NED - NO?
if 'ingress_flow' in proType:
self.sg_dict['ingress_flow'] = proType['ingress_flow']
else:
self.sg_dict['ingress_flow'] = None
if 'egress_flow' in proType:
self.sg_dict['egress_flow'] = proType['egress_flow']
else:
self.sg_dict['egress_flow'] = None
return self.sg_dict
# def resolveTVDtop(self, proType):
# # dummy resolveTVDtop that returns a static local serviceGraph file
# # TODO PSC TVD resolution logic
# fp = open("./json/serviceGraph_ex.json", "r")
# sg_dict = json.loads(fp.read() % self.token)
# self.sg_dict = sg_dict
# return sg_dict


|
|
accumulate()
splice()
and split()
algorithmsThis section provides a brief discussion of the properties and implementation details of the augmented B+ trees. It aims to help programmers to better understand the specifics of new containers and how to use them in algorithms. The discussion covers both array based and dynamically allocated B+ trees.
A B+ tree is a data structure that supports efficient search, retrieval and update operations of stored information. A B+ tree can be regarded as an improved variant of a B-tree, which was originally developed for systems with external storage [2].
The main problem of these B-trees is their inefficiency in range queries and sequential processing of data. In a B-tree representing a sorted list a tree traversal algorithm that finds a next element in the worst case visits O(log N) nodes at different levels of the tree. Crossing levels in these trees has a very high cost due to a huge difference in access time between the disks and RAM.
For B-trees in main memory, as well as for red-black trees, the cost of crossing levels is significantly lower than in external storage trees and sequential processing is relatively fast. Nevertheless, the structure of nodes remains the same and some adjacent elements of a sorted list are connected through a path of length O(log N). For dynamically allocated trees locality of reference is relatively poor. Thus, sequential processing in these trees is less efficient than in linear data structures, which guarantee that an algorithm can move to a next element in constant time.
A B+ tree solves these inefficiency problems by combining two data structures with different properties. User data are stored in a linear structure such as a linked list that implements simple and efficient sequential access to the data. The other data structure is a B-tree, which is connected to the linear structure. This tree stores only keys and supports fast search and random access to the data.
The B+ trees have a number of practically important advantages. This class of data structures is one of the most thoroughly studied at present. There are many implementations of B+ trees, which gain from specific system optimizations. These trees offer a high degree of flexibility in the choice of a linear data structure for the deepest level and a specific B-tree for internal nodes and levels. For example, in systems for external searching a B+ trees can have a very complex structure with one node representing another data structure such as a binary search tree. On the other hand, a B+ tree designed to work in main memory can be implemented as a dynamically allocated or an array based data structure with the complexity reduced to minimal in order to support required algorithms and interfaces only.
The B+ trees of this project are level-linked variants of this data structure, for more details see [3] and below. Level-linked B+ trees are particularly attractive for the development of new STL containers, since they can be implemented in RAM using simple linear topologies of linked lists not only for external nodes, but also for any other level of a tree. Thus, algorithms gain the advantage of efficient access to data stored in both external and internal nodes. In addition to this, these B+ trees improve performance of algorithms through the method of augmenting data structures [4].
The implementation of a B+ tree requires different types of nodes, since user data are stored only in external nodes arranged into a linear data structure. In the augmented B+ trees an external node is represented by a type, which is named light node, since a node of this type contains the minimum of required data. In dynamically allocated B+ trees a light node stores a container element and three links to adjacent nodes. In array based B+ trees the pointer arithmetic provides the efficient constant time access to any element inside an array. It makes links to previous and next nodes redundant and, thus, allows for saving space required for an array based B+ tree.
An internal node is represented by a heavy node. A node of this type contains four links to support a level-linked variant of a B+ tree and special implementation data, which improve the performance of algorithms. Instead of a key, a heavy node stores a pointer to a light node. This pointer is used both for connectivity and for access to a container element. The name heavy node has been selected, since a node of this type stores more information than a light node. Nevertheless, in applications it is possible that a light node requires more space than a heavy node. The size of a light node depends on the size of a container element stored in the node, whereas the size of a heavy node is constant, since this node includes only a pointer to a light node.
The augmented B+ trees are implemented as multi-linked data structures using a representation similar to leftmost child, right sibling representation of a multi-way tree. Each internal node of these B+ trees contains four links pointing to its right sibling, left sibling, parent and leftmost child. A group of child nodes in an internal level forms a doubly linked list. This connectivity gives the advantage of simple and fast sequential access to data in these nodes.
A group of external child nodes also forms a linear data structure. In a dynamically allocated B+ tree the group is represented by a doubly linked list. In an array based B+ tree the same group is represented by an array of light nodes.
Unlike internal nodes, external nodes do not contain redundant links to children; however, they can support links to parents. This type of link improves the efficiency of the bottom up processing, which updates cached algorithmic data in internal nodes, when a tree is modified.
An internal node can be a parent to the children, which are a group of either internal or external nodes. In the latter case, a link to the leftmost child is supported through a pointer to an external node, which is also used to obtain a value of a container element.
For a B+ tree with a minimum degree of a node t (t >= 2) the bounds on the number of children are defined and implemented as follows. Each internal node can have at most 2t children and at least t children. The number of children for an internal node can be less than t if this node is the root, including the case when the total number of user elements stored in external nodes is also less than t.
The array based B+ tree can support two minimum degree parameters: one for internal dynamically allocated nodes and one for external nodes stored in arrays of the deepest level of a tree. The higher efficiency of the pointer arithmetic, the greater the value of the minimum degree can be set for an external level. This property of the array based B+ trees is useful to increase locality of reference and improve performance of algorithms.
In a B+ tree all external nodes have the same depth. This property makes a B+ tree globally balanced and enables the modification of the structure, which is known as a level-linked B+ tree [3]. A B+ tree of this type arranges internal nodes of one level into a linked list.
The level-linked connectivity provides algorithms the advantage of efficient sequential access to internal nodes and to data stored in these nodes at every level of the tree. It reduces the maximum cost of visiting a neighbour node at the same level from O(log N) using a tree traversal algorithm to O(1) using a level link.
As an algorithm moves up the tree, the number of nodes in every level decreases with the mean frequency 3t/2. Simultaneously, the number of external nodes with container elements connected to an internal node through child-parent links increases by the same factor. Thus, an algorithm can use the upper levels of the tree in order to vary the length and precision of iteration steps.
The current augmented B+ trees support level-linked structure of internal levels through links between the rightmost node of a child group with the leftmost node of the next child group at the same level. In a dynamically allocated B+ tree the deepest level of external nodes represents a doubly linked list. In an array based B+ tree every child group of external nodes is stored inside one array. The pointer arithmetic provides efficient access to any element inside an array. The connectivity between adjacent groups of external nodes is supported through links to nodes of the deepest internal level.
B+ trees allow various schemes of data association with internal nodes for the same structure and user data stored in the deepest level of external nodes. This fact makes the method of augmenting data structures [4], see the chapter "Augmenting Data Structures", particularly attractive for B+ trees. It improves the efficiency of algorithms by eliminating unnecessary searches and recalculations of required data.
The augmented B+ trees are designed to extend the functionality of search trees. The new functionality and improved efficiency of algorithms are achieved by storing in the internal nodes of these trees not only keys of container elements, but also special implementation data. The additional data can have some effect on the space usage, however, they do not change the theoretical limit of the space requirement to store a B+ tree, which is O(N). Regardless of a specific data scheme the augmented B+ trees have the same structure of internal and external nodes. The balanced augmented B+ trees grow and contract in the same way as basic search trees.
In every augmented B+ tree that supports random access iterators an internal node contains a count of external nodes with user elements stored in a container. For the deepest level of internal nodes this parameter represents the number of children in one group of external nodes. For internal nodes in all other levels the value of this parameter in a parent node is equal to the sum of counts stored in its children. An algorithm can efficiently obtain and update these counts using the level-linked structure of the tree.
The values of the counts of the container elements are independent of specific user and implementation data stored in external and internal nodes of the tree. These values reflect only the structural relationships between the nodes of the tree. This is why the count data along with the connectivity of nodes can be regarded as an independent substructure of indices. The following figure shows the structure of indices of an array based B+ tree.
|
Figure 1. An array based B+ tree with the minimum degree t=2 and
an array storing the same elements.
The array elements and their indices are shown in the line with contiguous arrangement of squares. In the B+ tree squares represent external nodes with values of container elements, circles - internal nodes, solid lines - undirected edges, arrows - directed child-parent edges. The deepest level of the B+ tree implements a partition of the array into a list of sub-arrays. Values in internal nodes of the B+ tree represent counts of elements. Empty cells in sub-arrays of external nodes do not store container elements. They are reserved for new elements to be inserted into the tree. The dashed lines connect first elements in sub-arrays of external nodes of the tree with corresponding elements in the array. |
The method of augmenting data structures can be applied to one data structure
more than one time. This project uses double augmenting to implement the efficient
algorithm accumulate()
, which has computational cost O(log N)
in the worst case.
This performance has been achieved by adding to every internal node a new datum,
which represents a sum of consecutive elements stored in external nodes.
For the deepest level of internal nodes a parent stores a sum of values of
the container elements of its external child nodes. For all other levels of
the internal nodes of the tree every parent stores a sum, which is equal to
a sum of sum values stored in its children. When an algorithm moves up the tree
from a child to its parent, it obtains a sum value of a quickly increasing
number of container elements stored in external nodes.
|
Figure 2. The substructure of sums of a dynamically allocated B+ tree.
Squares represent external nodes with values of container elements, circles - internal nodes, solid lines - undirected edges, arrows - directed child-parent edges. A value in an internal parent node is a sum of values shown in its children. |
Unlike the substructure of indices, the substructure of sums depends on the values of container elements stored in the external nodes of the tree. The specific values of sum data in internal nodes are also affected by the structural relationships between nodes. For this reason, the substructures of indices and sums have a very close similarity. In the case when each element of a container has the value 1, these two substructures become identical. In this respect, the substructure of sums supersedes the substructures of indices.
accumulate()
The efficient algorithm accumulate()
represents a finger search
[3],
The start and end positions are specified by two input iterators
that provide pointers to corresponding external nodes.
The algorithm uses the level-linked substructure of indices
in order to find between these two external nodes a path,
which has the minimum or close to the minimum number of edges.
For distant external nodes the path goes through internal nodes,
which store pre-calculated sums of container elements.
The required sum of consecutive elements is obtained
by summing up the values of elements in external nodes and
the cached sum values in internal nodes when this algorithm moves to
a next node at the same level of the tree or, in other words, passes
through a horizontal link.
The finger search algorithm has cost O(log D), where D
is the number of consecutive container elements. This algorithm also
provides high accuracy of the calculated sum. Its accuracy is practically
the same as that of the standard algorithm accumulate()
,
which sums up values of container elements in the forward sequential order.
Note that the member function accumulate()
of one basic container
supports many types of STL containers: sequences and associative containers.
This approach is general, since at the implementation level of this efficient
algorithm every container is processed as a sequence through the substructure of
indices, which is independent of the other substructure of sums.
The efficient algorithm accumulate()
demonstrates an important
aspect of the augmented B+ trees - the ability to simultaneously support
two substructures of two data sets associated with container elements.
A more detailed description of the fast sequential summation algorithms and the efficient representation of a mathematical sequence is provided in [5].
splice()
and split()
algorithms
The augmented B+ trees support the C++ standard splice()
functions as well as non-standard split()
functions.
These functions are very efficient, since they are based on local
structural modifications of these trees.
The splice()
functions of the augmented B+ trees have been
implemented through algorithms that join and split trees.
These algorithms take advantage of the relatively
simple level-linked structure of the augmented B+ trees.
Every internal level of these trees represents a doubly linked list.
A structural modification of join or split is first applied to
every horizontal list of the trees involved.
After that, every level of the B+ trees is tested for the balance
in groups of child nodes modified by the join or cut operation.
Testing and restoring the balance are local operations for every level of the trees.
Since these algorithms are applied to every level of the B+ trees,
the basic functions that join and split trees have logarithmic computational cost.
The splice()
is a member function of sequence
only,
because this function does not preserve the order of container elements.
On the other hand, the split operation does not violate the ordering in
modified containers. This is why it is a general operation that can be
supported by sequences and accociative containers.
Both split and splice operations do not change the total number of elements
in containers involved before and after an operation. This property enables
the implementation of a split operation through a splice operation
using an empty container.
However, the splice()
member function is not safe for
associative containers, thus, the split()
member function
should be directly added to the interfces of all containers.
All associative containers of the namespace std_ext_adv
support the member function merge()
.
This function implements a join operation for associative containers
with multiple equivalent elements, since it does not change
the total number of elements in the containers involved.
For containers with unique elements the function has
the effect of the union operation.
In special cases the function merge()
is equivalent to the splice()
function.
This fact has been used at the implementation level
to achieve the best performance.
Note that in the C++ standard library the function merge()
is supported by the container std::list
.
Dynamically allocated linked lists provide various efficient splice
operations through the change of the connectivity between a few nodes only.
The splice()
functions of std::list
have
constant computational cost except for the one function
void splice(iterator pos, list& x, iterator first, iterator last);
which has linear cost. The inefficiency is caused by counting of inserted
and removed elements in order to comply with the C++ standard requirement
that the size()
function has constant cost.
The same problem of linear cost of recounting of moved elements arises in CGAL
with red black trees that support split and join operations of
Multiset
.
Note that both discussed containers provide bidirectional iterators only.
This inefficiency problem shows that the ability of the augmented B+ trees
to support random access iterators plays the crucial role in achieving
the high efficiency of splice()
and split()
functions that can move any number of consecutive
elements in logarithmic time. Using random access iterators
algorithms obtain the number of moved elements in constant time.
The C++ standard library provides a number of interface methods to change
or update the value of a container element. The most general method is
to write a new value to an element through an iterator: *iter = val_new
.
In addition to this, vector
and deque
support the subscript
operator[ ]
and the member function at()
.
For the new containers based on augmented data structures these methods are safe
only for sequence
using the class bp_tree_array
.
This data structure stores container elements only in the external nodes of
the deepest level. The operation, which writes a new value to an element in
an external node through an iterator, is identical to such an operation in
any linear data structure and has constant computational cost. After the element
has been modified, all connected internal nodes operate with the new value,
since they access the modified element through pointers to the external node.
For the containers based on the class bp_tree_array_acc
the support for correct write operations is more complex.
This B+ tree stores in its internal nodes additional sum data
required for the efficient algorithm accumulate()
.
A write operation, which changes the value of an element in an external node
only, makes the additional sum data invalid in a number of internal nodes.
The simple write operation is unsafe for all types of containers based on the
class bp_tree_array_acc
. In order to maintain the tree data valid,
the change in the element value must be properly reflected in the sum data
in a chain of parent nodes at every level of the tree.
For this reason in the class bp_tree_array_acc
the safe write operation has cost O(log N).
The problem of unsafe write operations can arise in the future for augmented data structures implementing new STL extensions or new efficient algorithms. The member function
std::pair<iterator, bool> write ( iterator pos , const value_type & val_new ) ;
has been added to address all types of the data invalidation problems
that can be caused by the standard write methods. This function guarantees
that a container remains in a valid state after an element has been modified.
It can be used in code instead of the discussed above operations,
such as *iter=val_new
.
This member function is supported by every STL container of
the namespace std_ext_adv
with the computational
complexity varying from O(1) to O(log N).
The effect of this function for each container type
is equivalent to two operations that erase an old element
pointed to by an input iterator and insert a new element.
The function does not change the number of elements in a container.
Algorithms using this function gain the additional advantage of being able
to implement more generic algorithms.
The array based B+ trees of this project have a number of properties that make them similar to pool allocators [1]. This type of C++ allocator is frequently used to improve performance of dynamically allocated data structures, such as linked lists or red black trees.
A pool allocator normally represents a simple linked list of memory blocks. An array based B+ tree has basically the same structure of the deepest level when the number of container elements is relatively small. The tree constructs and stores arrays of light nodes with container elements in contiguous regions of memory blocks. As a user algorithm adds new elements, the complexity of the structure of the B+ tree increases. It constructs new levels of internal nodes in order to deliver the best possible performance of container operations.
The dynamics of memory blocks and elements stored in an array based B+ tree and
in a pool allocator are identical. A B+ tree allocates large memory blocks and
uses them to control the lifetime of container elements.
The elements are created and destroyed in the memory space owned by the tree
through the customized allocation and deallocation of container elements that is
more efficient than general C++ operators new
and delete
.
These B+ trees minimize the frequency of costly system allocations and
deallocations of memory blocks.
If the total number of elements in a memory block does not exceed
its capacity limit, the block can be used to construct and destroy
an unlimited number of container elements before the block is freed.
Because of these structural and dynamical properties, an array based B+ tree represents an enhanced and optimized allocator. Alternatively, an array based B+ tree can be regarded as a data structure that implements the functionality of an allocator using its own memory space.
However, an array based B+ tree does not guarantee that a container element will be stored in a memory region that remains unchanged for the whole lifetime of the element. These B+ trees are optimized for the best performance through the contiguous arrangement of container elements in memory blocks. In order to avoid gaps and minimize memory fragmentation update operations can move container elements inside memory blocks.
The dynamically allocated augmented B+ trees require a pointer machine and provide efficient sequential and random access to container elements. In some aspect, these data structures implement the pointer arithmetic. The array based augmented B+ trees take advantage of the pointer arithmetic provided by a system and deliver significantly better performance for many container operations against equivalent variants of dynamically allocated trees.
An array based B+ tree implements a general and portable partition of an array into a list of sub-arrays connected to a B-tree. These B+ trees maximize locality of reference by storing consecutive container elements in contiguous memory regions. However, as with many array based data structures, the performance benefit comes at the expense of the invalidation of random access iterators by update operations.
The augmented B+ trees and STL container adapters of the namespace std_ext_adv
are optimized for performance rather than for exception safety. These B+ trees use
both arrays and dynamically allocated B-trees. The complexity of these data structures
makes exception handling for these B+ trees more difficult than for basic linear data structures.
For these reasons the augmented B+ trees and variants of STL containers offer basic no-leak exception safety:
Exception handling implemented in the augmented B+ trees and STL containers protects user algorithms against memory allocation errors and against exceptions thrown by copy and assignment operations on container elements. This exception safety guarantee assumes that a user defined type does not leave container elements in invalid states and its destructor does not throw exceptions.
The effect of these exceptions on the structure and invariants of these B+ trees is specific to an operation. In the worst case, one exception can make unbalanced one or two groups of children nodes and in addition to this it can make invalid augmented data stored in a number of internal nodes: counts and sums of container elements.
In the current implementation of these B+ trees the balance cannot be safely restored. This algorithm allocates resources and moves container elements from one array to another using the copy constructor of the element type. Such operations cannot be used for exception handling, since they may throw an exception. Normally, to continue processing it is sufficient to leave the affected groups of children nodes in their last valid states. However, in some special cases for groups of external nodes stored in arrays the container destructor can be notably simplified if exception handling erases from the affected arrays all constructed elements.
The operations that modify values of the counts of container elements in internal nodes do not throw exceptions. Thus, where possible, the counts are updated in order to preserve proper invariants.
Any exception that has been caught and handled makes unsafe all subsequent operations, which assume that all data stored in nodes are valid and that all groups of children nodes are balanced. This restriction applies to nearly all operations that support interface member functions of standard containers and operators of iterators.
The destructor of a container based on an augmented B+ tree does not rely on advanced features of these data structures. The safety of the destructor is guaranteed by the structural invariants that are not violated by the thrown and handled exceptions. The destructor of an augmented B+ tree uses only the basic connectivity of nodes to release all resources that the tree acquired.
The classes bp_tree_array
and bp_tree_array_acc
provide
slightly different exception safety guarantees. The operations on containers elements
in arrays of these B+ trees are identical. The difference is caused by the operations on
internal nodes. A B-tree of internal nodes of the class bp_tree_array
represents
a relatively simple and safe container of pointers. The main reason why the class
bp_tree_array_acc
is less safe is that its B-tree stores in nodes additional
values of sums of container elements. The operations on such internal nodes may throw
exceptions from the copy constructor and the assignment operator of the element type.
The other exception safety problem might be caused by arithmetic operations with container elements.
The current version of these augmented B+ trees assumes that element operators
{+, +=, -, -=}
do not throw exceptions.
Revised 10 April, 2014
Copyright © 2011-2014
Vadim Stadnik
<EMAIL_ADDRESS>Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


This tool will display the processed pcap data using the d3.js visualization library to allow an analyst to quickly drill-down into the area of interest in the network traffic. Use the tabs above to view different aspects of the network traffic.
| pcap file | ? |
| local network | ? |
| date processed | ? |
| total packets | ? |


Providing world-class web design and development services from our primary office in Central London. Say Web Design is committed to innovative, future-focused website development and marketing services, helping your business grow, evolve and outshine the competition. However ambitious your targets, our team has the skills, talents and experience to deliver. Call or email us today to arrange a meeting at our London office and we will be happy to talk through your project.
Our specialist web design and development team will help ensure every penny of your budget is put to the best possible use. We’re committed to ensuring each of our clients gets the best possible return on their investment. What’s more, we engineer every service package we provide in direct accordance with our clients’ needs. With Say Web Design, you remain in the driving seat – we simply provide the directions.


MDAL C# API
The MDAL C# integration allows you to access and manipulation geospatial mesh data sets in C#.
Currently, this integration can:
read all MDAL compatible file formats,
access the metadata for the source,
access the vertex, face and edge data,
access ‘double’ datasets (both scalar and vector), and
convert the MDAL source mesh into a Geometry3sharp DMesh3 mesh object.
This version does not currently allow the MDAL source mesh to be written or ammended.
This integration is not intended to be generic and should be used as an example or starting point.
Installation
The integration script can downloaded from:
https://github.com/ViRGIS-Team/mdal-upm/blob/main/Runtime/Scripts/Mdal.cs
The integration is not currently available as a package. Integrate this script into your application manually.
Documentation
https://virgis-team.github.io/mdal-upm/html/annotated.html
Development
Submit issues and PRs to :
Example Usage
using Mdal;
using g3;
List<DMesh3> features = new List<DMesh3>();
// for MDAL files - load the mesh directly
ds = Datasource.Load("...SourceFileName");
for (int i = 0; i < ds.meshes.Length; i++) {
DMesh3 mesh = ds.GetMesh(i);
mesh.RemoveMetadata("properties");
mesh.AttachMetadata("properties", new Dictionary<string, object>{
{ "Name", ds.meshes[i] }
});
// set the CRS based on what is known
if (proj != null) {
mesh.RemoveMetadata("CRS");
mesh.AttachMetadata("CRS", proj);
}
if (layer.ContainsKey("Crs") && layer.Crs != null) {
mesh.RemoveMetadata("CRS");
mesh.AttachMetadata("CRS", layer.Crs);
};
features.Add(mesh);
}


Bases: nova.volume.driver.ISCSIDriver
Executes volume driver commands on Nexenta Appliance.
Verify that the volume for our zvols exists.
| Raise : | LookupError |
|---|
Create new export for zvol.
| Parameters: | volume – reference of volume to be exported |
|---|---|
| Returns: | iscsiadm-formatted provider location string |
Create snapshot of existing zvol on appliance.
| Parameters: | snapshot – shapshot reference |
|---|
Create a zvol on appliance.
| Parameters: | volume – volume reference |
|---|
Create new volume from other’s snapshot on appliance.
| Parameters: |
|
|---|
Delete volume’s snapshot on appliance.
| Parameters: | snapshot – shapshot reference |
|---|
Destroy a zvol on appliance.
| Parameters: | volume – volume reference |
|---|
Recreate parts of export if necessary.
| Parameters: | volume – reference of volume to be exported |
|---|
Return local path to existing local volume.
We never have local volumes, so it raises NotImplementedError.
| Raise : | NotImplementedError |
|---|
Destroy all resources created to export zvol.
| Parameters: | volume – reference of volume to be unexported |
|---|


About
Hi there this is Sharad, the developer of this theme.
My Social Media Links
My Instagram
My Linkedin
My Github


---
layout: post
section-type: post
title: JAOO Conference party
date: '2007-09-25T09:07:00.000+02:00'
author: Jørn Ølmheim
category: tech
tags: [ 'jaoo', 'jruby' ]
modified_time: '2007-09-25T09:24:25.776+02:00'
blogger_id: tag:blogger.com,1999:blog-16320608.post-270170299132768401
blogger_orig_url: http://joelmheim.blogspot.com/2007/09/jaoo-conference-party.html
---
Monday night is really the highlight of the JAOO conference for me. I talked about this last year as well, and the first
day of JAOO I allways feel a little strange. Then after the Monday night party the mood of the conference totally
changes.
I was lucky enough to end up on next to Thomas Enebo and Charles Nutter (JRuby).
And as if that wasn't enough. Martin Fowler had decided that he would like to meet them too, and ended up between me and
Charles. On my other side I had Jonas Bonér (Terracotta) and across the table
was Floyd Marinescu (InfoQ, formerly TheServerSide). As you can imagine it was not
boring...
I actually managed to talk some sense and actually got a smile or two (and something I like to interpret as a nod of
approval) from Martin Fowler. I talked a lot with Floyd as well, and got a chance to tell him that I enjoy his site.
Charles and Thomas are really interesting guys. They are the lead developers of JRuby, the Ruby implementation on the
JVM. In order to do this you have to know both the Ruby language and the JVM really well. I particularly talked a lot
with Thomas, and found out that he actually has ancestry in Norway.
A great evening.


This Structure defines the ATU region parameters. More...
#include <pcie.h>
Data Fields | |
| pcieAtuRegionDir_t | regionDir |
| pcieTlpType_t | tlpType |
| uint32_t | enableRegion |
| pcieAtuRegionMatchMode_t | matchMode |
| uint32_t | barNumber |
| uint32_t | lowerBaseAddr |
| uint32_t | upperBaseAddr |
| uint32_t | regionWindowSize |
| uint32_t | lowerTargetAddr |
| uint32_t | upperTargetAddr |
This Structure defines the ATU region parameters.
These parameters are used for configuring inbound or outbound ATU(Address translation unit) region
| uint32_t pcieAtuRegionParams::barNumber |
BAR number with which the region is associated Possible values for EP : 0 to 5 for 32bit and 0 to 2 for 64bit Possible values for RC : 0 to 1 for 32bit and 0 for 64bit
| uint32_t pcieAtuRegionParams::enableRegion |
Region enable or disable
| uint32_t pcieAtuRegionParams::lowerBaseAddr |
Lower base address : should be 4K aligned For outbound configuration this contains outbound region offset For inbound configuration this contains inbound PCIe start address
| uint32_t pcieAtuRegionParams::lowerTargetAddr |
Lower Target address: should be 4K aligned For outbound configuration this contains outbound PCIe start offset For inbound configuration this contains destination address
| pcieAtuRegionMatchMode_t pcieAtuRegionParams::matchMode |
Region match mode Address match or BAR match Values given by enum pcieAtuRegionMatchMode_t
| pcieAtuRegionDir_t pcieAtuRegionParams::regionDir |
Region direction Inbound or Outbound Values given by enum pcieAtuRegionDir_t
| uint32_t pcieAtuRegionParams::regionWindowSize |
Region window size For outbound configuration this contains outbound window size For inbound configuration this contains PCIe inbound window size
| pcieTlpType_t pcieAtuRegionParams::tlpType |
TLP(transaction layer packet) type Values given by enum pcieTlpType_t
| uint32_t pcieAtuRegionParams::upperBaseAddr |
Upper base address Higher 32 bits in case of 64 bit addressing Configured to 0 for 32 bit addressing
| uint32_t pcieAtuRegionParams::upperTargetAddr |
Upper target address Higher 32 bits in case of 64 bit addressing Configured to 0 for 32 bit addressing


--- layout: post title: Zip File Presentation from RaDFIRe date: 2014-11-14 00:05:03.000000000 -05:00 categories: blog ---
Recently, I had the opportunity to create a forensic challenge at work that focused on data loss. The scenario included a several instances of data exfiltration but one specifically seemed more forensically challenging than the rest. A portion of the challenge included a zip file that was uploaded directly from a mapped network drive to Google Docs. The file was never logically written directly to the C: drive.
Participants were given only the memory dump and a dd of the workstation hard drive to work with.
No other information was provided.
I threw together some slides on how I tackled the problem. Working through the process manually taught me WAY more about zip files than I ever wanted to know but I am a better forensicator for it.
Here are the slides:


 Drop it down below and we'll be sure to get back to you
First name
Last name
Email:
Country Code
Number
Subject:
Message
Submit
send


Simple Lightbox
Click the plus icon on the bottom-right corner of the page.
Click the plus icon on the bottom-right corner of the page.
The Registan was the heart of the ancient city of Samarkand of the Timurid dynasty, now in Uzbekistan. The name Rēgistan means "Sandy place" or "desert" in Persian.


TopCAT allows you to browse and download archived data from beamline experiments at Lorum Ipsum Light Source.


{% extends "layout.html" %} {% block content %}
According to our algorithms, the submitted news article is authentic.Your security deposit ether shall be refunded.


+++
title = "Redis Operator"
linkTitle = "Redis Operator"
+++
{{< blocks/cover title="" image_anchor="top" height="min" color="white" >}}
}}">
Learn More
Releases
Run Redis setup on any Kubernetes cluster
{{< blocks/link-down color="light-secondary" >}}
{{< /blocks/cover >}}
{{% blocks/lead color="secondary" %}}
What is Redis Operator?
A Golang based redis operator that will make/oversee Redis standalone and cluster mode setup on top of the Kubernetes.
It can create a redis cluster setup with best practices on Cloud as well as the Bare metal environment.
Also, it provides an in-built monitoring capability using redis-exporter.
{{% /blocks/lead %}}
{{< blocks/section color="secondary" >}}
{{% blocks/feature icon="fab fa-slack" title="Join us on Slack" url="https://join.slack.com/t/opstree/shared_invite/zt-3o8jp35x-UGMU2Cy0WSBk3Lbzqa2wVw" url_text="Join us" %}}
Join the community on Slack
{{% /blocks/feature %}}
{{% blocks/feature icon="fab fa-github" title="Contributions welcome!" url="https://github.com/OT-CONTAINER-KIT/redis-operator" url_text="Contribute to Redis Operator" %}}
We do a [Pull Request](https://github.com/OT-CONTAINER-KIT/redis-operator/pulls) contributions workflow on **GitHub**.
New users are always welcome!
{{% /blocks/feature %}}
{{% blocks/feature icon="fab fa-twitter" title="Follow us on Twitter!" url="https://twitter.com/opstreedevops" url_text="Follow us" %}}
For announcement of the latest features etc.
{{% /blocks/feature %}}
{{< /blocks/section >}}


Reference : Mozilla
This page has default variable which will be added as property to style attribute to the root element (in this case html is root element)
Choosen color code is #800000


Eight people found dead in container on ship
TOKYO (AP) _ Eight people were found dead Monday in a cargo
container aboard a freighter that arrived in a Tokyo port from
China, the coast guard said.
Officials believe the eight _ seven women and one man _ died of
dehydration and that they were Chinese who had been trying to enter
Japan illegally, said Maritime Safety Agency spokesman Takeshi
Noda.
They were discovered aboard the St. Vincent and the
Grenadines-registered Goldrich River, which left the Chinese port
of Dalian last week and arrived in Tokyo's Ohi pier Monday with a
cargo of artificial flowers.
Eight others found in the container were suffering from severe
dehydration and taken to a hospital. Their condition was not
immediately known, Noda said.
He said police searched the ship after coast guards were
informed stowaways may be aboard the ship.
The Goldrich River is owned by Goldrich Shipping Ltd. of Hong
Kong and operated by Japan's Kawasaki Kisen.
Last year, police arrested 7,117 foreigners, including 3,045
Chinese for trying to enter Japan illegally, nearly a fifty percent
rise from 1996, according to the immigration office.


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.google.api.gbase.client.Stats.Statistics
public static class Stats.Statistics
Information about one specific use (impressions, clicks, page views).
| Constructor Summary | |
|---|---|
Stats.Statistics()
|
| Method Summary | |
|---|---|
int |
getCountBySource(java.lang.String source)
Get a sub-total for a specific source. |
java.util.Set<java.lang.String> |
getSources()
Gets a set of sources for which a sub-total is available. |
int |
getTotal()
Gets the total for this statistic. |
void |
setCountBySource(java.lang.String source,
int count)
Sets the sub-total for a specific source. |
void |
setTotal(int total)
Sets the total for this statistic. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public Stats.Statistics()
| Method Detail |
|---|
public int getTotal()
public void setTotal(int total)
total
- public java.util.Set<java.lang.String> getSources()
public int getCountBySource(java.lang.String source)
source
- source name
public void setCountBySource(java.lang.String source, int count)
source
- source namecount
- sub-total or -1 if it is not known
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


[Index] [1] [2] [3] [4] [5] [6] [7] [8]
This chapter assumes that you have installed HDFView and, along with “Chapter 3: The HDF Object Model,” is designed to help you get to the point where you are actually looking at HDF datasets.
When you first open HDFView, the HDFView window appears with an empty tree and data panel. After you open an HDF file, the structure of the file is displayed in the Tree Panel. The content of a data object is displayed in the Data panel by opening the data object.
The main window consists of five components: Menu bar, Tool bar, File bar, Tree panel, Data Panel, Info panel.
The main window
The Menu bar is at the top of the HDFView window. You can select a menu command from menu items or press key combinations from the keyboard to invoke the menu item's action without navigating through the menu hierarchy. For example, to exit HDFView, you can either press “Ctrl+Q” on the keyboard or select the “Exit” item from the “File” menu.
File menu
The File menu contains commands to open and close files, create and save files, and
exit HDFView.
File menu
Window menu
Tools menu
The Tools menu contains a list of commands to launch tools such as
image conversion and user options. The “User Options”
command launches a dialog box that allows you to change user preferences:
the path of the User's Guide, font size, delimiter and more. For more information,
see User Options.
Tools menu
Help menu
Select the “Open” command from the file menu or click the “Open” icon in the tool bar to invoke the local file manager, and select a file to open from the local file manager. Selecting “Open Read-Only” opens a file with read-only permission, which means that editing functions are disabled and changes are not allowed. By default, HDFView will only show files that have a file extension matching those specified in the User Options File Extension list (see File Extensions), however, the user can click on the drop-down box in the open file dialog box and select "All Files" in order to show all files if needed.
Local file manager (Windows)
An HDF file contains one or more objects, optionally grouped in a hierarchy. For general information about the structure and contents of HDF files, see the HDF documentation at HDF5 Documentation and HDF4 Documentation.
The structure of the file is displayed in the Tree panel, which is the left panel in the HDFView window. Data objects are represented as icons, and groups are represented by folders. An HDF file may contain groups, datasets (arrays), committed datatypes, and links.
The hierarchy of the file can be navigated by selecting folders to “open” a group, which displays the objects contained by the group. When an object is selected (by double clicking the object or by right clicking the object and selecting "Open" or "Open As" from the popup menu), the data is displayed appropriately in the data panel on the right.
You can open multiple files at one time. Files are listed as root objects in the tree. The following figure illustrates that an HDF5 file, hdf5_test.h5, and an HDF4 file, annras.hdf, are currently open.
Tree view
You can also search for data objects within a file by right-clicking on the file and selecting "Find" from the Context menu. Type in the name of a data object to look for and HDFView will highlight the first occurrence of the object within the file. The wildcard '*', which specifies that any number of characters can come after the text before the '*' character, can be used to broaden your search. As an example, searching for 'dataset*' will find any objects whose name is a variation on 'dataset', i.e. 'dataset', 'dataset_int', 'dataset75', etc.
Short status information and feedback messages are displayed in the information panel. Such information includes error messages and feedback from user's actions. Click on the “Log Info” and “Metadata” tabs to switch between viewing status information and viewing metadata.
To see the metadata of a data object, right-click the data object to show the Context Menu for that object. Then, left-click the "Show Properties" menu option to show the Properties dialog box, which displays metadata information such as name, type, attributes, datatype, dataspace, and members. If modules are installed and available, the metadata of an object can be displayed in a different manner by selecting the "Show Properties As" option from the Context Menu instead.
Properties dialog box
To view a user block in text, right-click the file node (the root group) and open the Properties dialog box. Click the “User Block” tab in the dialog box to show the user block information in text.
User block in text
[Index] [1] [2] [3] [4] [5] [6] [7] [8]


C syntax:
void phish_input(int iport, void (*datumfunc)(int), void (*donefunc)(), reqflag) void phish_output(int iport)
C examples:
#include "phish.h" phish_input(0,count,NULL,1); phish_input(1,count,mydone,0); phish_output(0);
C++ syntax:
void input(int port, void (*datumfunc)(int), void (*donefunc)(), bool required=true) void output(int port)
C++ examples:
#include "phish.h.pp" phish::input(0,count,NULL,true); phish::input(1,count,mydone,false); phish::output(0);
Python syntax:
def input(iport,datumfunc,donefunc,reqflag) def output(iport)
Python examples:
import phish phish.input(0,count,None,1) phish.input(1,count,mydone,0) phish.output(0)
Description:
These are PHISH library functions which can be called from a minnow application. In PHISH lingo, a "minnow" is a stand-alone application which makes calls to the PHISH library.
The phish_input() and phish_output() functions define input and output ports for the minnow. An input port is where datums are sent by other minnows, so they can be read by this minnow. An output port is where the minnow sends datums to route them to the input ports of other minnows. These inter-minnow connections are setup by the hook command in a PHISH input script, as discussed on the bait.py doc page.
A minnnow can define and use multiple input and output ports, to send and receive datums of different kinds to different sets of minnows. Both input and output ports are numbered from 0 to Pmax-1, where Pmax = the maximum allowed ports, which is a hard-coded value for MAXPORT in src/phish.cpp. It is currently set to 16; most minnows use 1 or 2. Note that a single port can be used to send or receive datums to many other minnows (processors), depending on the connection style. See the hook command for details.
The minnow should make one call to phish_input() for each input port it uses, whether or not a particular PHISH input script actually connects to the port. Specify reqflag = 1 if a PHISH input script must specify a connection to the input port in order to use the minnow; specify reqflag = 0 if it is optional. The phish_check function will check for compatibility between the PHISH input script and the minnow ports.
Two callback function pointers are passed as arguments to phish_input(). Either or both can be specied as NULL, or None in the Python version, if the minnow does not require a callback. Note that multiple input ports can use the same callback functions.
The first callback is datumfunc, and is called by the PHISH library each time a datum is received on that input port.
The datumfunc function should have the following form:
void datumfunc(int nfields) { }
or
def datumfunc(nfields)
in Python,
where "datumfunc" is replaced by a function name of your choice. The function is passed "nfields" = the # of fields in the received datum. See the phish_unpack and phish_datum doc pages for info on how the received datum can be further processed.
The second callback is donefunc, and is a called by the PHISH library when the input port is closed.
The donefunc function should have the following form:
void donefunc() { }
or
def donefunc()
in Python,
where "donefunc" is replaced by a function name of your choice. A minnow might use the function to print out some statistics about data received thru that input port, or its closure might trigger further data to be sent downstream to other minnows. See the phish_close function and shutdown section of the Minnows doc page, for more discussion of how a school of minnows closes ports and shuts down.
The minnow should make one call to phish_output() for each output port it uses, whether or not a particular PHISH input script actually connects to the port. Usage of an output port by an input script is always optional. This makes it easy to develop and debug a sequence of pipelined operations, one minnow at a time, without requiring a minnow's output to be used by an input script.
Restrictions:
These functions cannot be called after phish_check has been called.
Related commands:


This page generates a lua script for toggling and tapping keys in the logitech gaming framework.
If a key you're inputting is not working simply right click on the key box and type in the key code found in Appendix A of the API documentation.


Sequential Prophet Rev2
Single Patch Editor
This editor works with the Sequential Prophet Rev2. It is not meant to work on similar models, such as the Prophet '08, Mopho series, or Tetra. For those models, use the Prophet '08 editor.
Communicating with Edisyn
Set the MIDI Channel to the same as being used in Edisyn. Set MIDI Param Send to NRPN. Set MIDI Param Rec to NRPN. Set MIDI Prog Enable to On. Set MIDI SysEx Cable to MIDI or USB.
About the Menu
- Writeable Factory Banks The Rev2 has two kinds of banks: the User Banks (U1...U4) and the Factory Banks (F1...F4). From the front panel you cannot change any of the Factory banks: but you can overwrite them from Edisyn via sysex. By default this feature is not turned on, and these banks are treated as read-only. If you want to make them writeable, just check the Writeable Factory Banks menu. Note that changing this value won't immediately change how the Librarian treats the banks: you'll need to call up a Librarian in a new editor. If you would like to restore these banks (they're just copies of the original User Banks), there's a copy of them in Edisyn's resource folder.
- Copy A->B, Copy A<-B and Swap A<->B These menus allow you to copy or swap the A and B layers.
- Load Both Layers, Load Only A>, and Load Only B When you load a sysex file, receive a dump or merge from your Prophet Rev2, or reset your patch, your setting here will dictate whether this will effect both layers, or just Layer A or Layer B (keeping the other one intact). This way, for example, you can just clear out Layer A. Or you could make a patch consisting of the Layer A of two different patches, by first loading one patch, then copying its Layer A to Layer B, then restricting loading to just Layer A, and then finally loading the second patch.
- To Prophet '08 / Mopho / Tetra. This converts the Prophet Rev2 patch into one appropriate for a Prophet '08, Mopho series, or Tetra, and loads it in a new editor. This might be useful for converting Rev2 patches and then editing them for these machines. Some parameters will be lost in the conversion of course, as the Prophet '08 lacks many Rev2 features.
Hints
- When you set the destination for a Gated Sequencer track to "Osc 1 Freq", "Osc 2 Freq", or "Osc 1&2 Freq", the track dials will change from number values to notes. The lowest note, C0, corresponds to the note being played by the user -- that is, all sequenced notes are equal to or higher than the played note. If you need notes lower than the played note, pitch the oscillator frequencies down.
Gotchas
- The Velocity parameter in the Polyphonic Sequencer can have values "Reset", "Rest" and 1 to 127. The "Reset" is improperly displayed on the Rev2 as "Rest", so on the Rev2 you see no distinction between "Rest" and "Reset". Initially, the tracks are filled with "Reset" (shown as "Rest" on the Rev2). As soon as you record a track and modifiy the velocity, it can be set to "Rest" or to any velocity value, but never back to "Reset" (on the Rev2). Edison instead shows the actual value and allows you to set it to "Reset" again.
- The velocity values of steps 63 and 64 of the Layer B polyphonic sequencer are not stored in the patch and are not transmitted over sysex as a patch dump. This is a known bug in the Rev2.
- The Rev2 ignores patch names sent as NRPN; but will accept them in patch dumps over sysex. The Rev2 will send the patch name over NRPN, and Edisyn recognizes this.
| By
| Wim Verheyen
|
| Date
| September 2021
|


I love to build and create with technology.
For 7 years now I have enjoyed the hobby of building computers from scratch. I loved the process of putting together a giant puzzle with unique pieces and getting a finished working product. Stepping into the software development industry has allowed me to take this process a step further, letting me also understand the inner workings of computer software. This has given me access to even greater and more complex puzzles to build and put together. Software development has allowed me to take the hobby that I already loved and help me to understand it more and do it as a living instead of a side project.
When I was in middle school my Uncle introduced me to a card game called Magic the Gathering. I had an absolute blast playing it with him however I could never keep up with all the deck variations I created. With the Magic Builder I can now keep up with the different decks I created and even make up new ones.
Magic BuilderThe Bangazon WorkForce Management application allows for human recourses and IT departments to list and create Training Programs, Employees, Computers, and Departments. During this sprint I increased my understanding of ASP.NET MVC applications using C#. I had a blast playing around with complicated SQL statements and also working with View Models really increased my understanding of them. Everyone in the group hopped around and helped each other with all sections but my main contribution was the department controller. This really helped with with Join SQL statements as I had to list the departments along with any employees in each department.
Bangazon WorkforceThe final group project for our Front-End curriculum was to build the Nutshell project again using React this time. This project was an excellent way for me to get more comfortable with React and by the end of it I fell in love with React and its streamlined way of running. I became well acquainted with React by the end and also felt more comfortable with styling.
React NutshellFor as long as I can remember, I have always been and avid reader. Over time I've run into the problem of finding a good book to read. I wanted to fix this issue with A Novel Idea. I built this application using JavaScript, React, and ReactStrap letting users search books using the Google Books API and see a variety of books based on genre, author, or title.
A Novel Idea


ADC, November 2020
Benedict R. Gaster /
@cuberoo_
my pronouns are he/him/they or xe/xim/xir
[] == ![];
NaN === NaN; // false
x = 100;
while(true) {
if (x == 999) {
x = "OMG";
break;
}
x = x + 1;
}
log.console(x);
What if you could compile code for the Browser?
" a source-to-source compiler that runs as a back end to the LLVM compiler and produces a subset of JavaScript known as asm.js. This allows applications and libraries originally designed to run as standard executables to be integrated into client side web applications"
"WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable compilation target for programming languages, enabling deployment on the web for client and server applications."
W3C Working Group
(module
(import "math" "callback" (func $callback))
(export "add" (func $add))
(export "subtract" (func $substract))
(func $add (param $a i32) (param $b i32) (result i32)
local.get $a
local.get $b
i32.add
)
(func $subtract (param $a i32) (param $b i32) (result i32)
local.get $a
local.get $b
i32.sub
)
)
"WASI is a modular system interface for WebAssembly. As described in the initial announcement, it’s focused on security and portability"
W3C Working Group
Alon Zakai, 2020
Tiffany Aching
{
"wasm": [String],
"gui": String,
"info": {
...
"inputs": int,
"outputs": int,
...
}
}
Single hosting app for each supported platform
// initialize module
#[no_mangle]
pub fn init(sample_rate: f64) -> u64 // returns handle to module
// module meta data
#[no_mangle]
pub fn get_sample_rate(module: u64) -> f64
#[no_mangle]
pub fn get_inputs(module: u64) -> u32
#[no_mangle]
pub fn get_outputs(module: u64) -> u32
#[no_mangle]
pub fn get_voices(module: u64) -> i32
// parameters
#[no_mangle]
pub fn get_param_index(module: u64, length: i32) -> i32
#[no_mangle]
pub fn get_num_params_float(module: u64) -> u32
#[no_mangle]
pub fn set_param_float(module: u64, index: u32, v: f32)
#[no_mangle]
pub fn get_param_float(module: u64, index: u32) -> f32
// MIDI
#[no_mangle]
pub fn handle_note_on(module: u64, mn: i32, vel: f32)
#[no_mangle]
pub fn handle_note_off(module: u64, mn: i32, vel: f32)
// compute audio
#[no_mangle]
pub fn compute(module: u64, frames: u32)
// input and output buffer management
#[no_mangle]
pub fn get_input(module: u64, index: u32) -> u32
#[no_mangle]
pub fn get_output(module: u64, index: u32) -> u32
#[no_mangle]
pub fn set_input(module: u64, index: u32, offset: u32)
#[no_mangle]
pub fn set_output(module: u64, index: u32, offset: u32)
// extern functions provided by AA Host
extern "C" pub fn set(module: u64, index: u32, v: f32)
FAUST (Functional AUdio STream) is a domain-specific purely functional programming language for implementing signal processing algorithms in the form of libraries, audio plug-ins, or standalone applications.
declare aavoices "2";
import("stdfaust.lib");
process = vgroup("voices", par(n, 2, vgroup("aavoice%n", voice))) ;
voice = hgroup("midi", osc(freq))
with {
freq = hslider("freq",200,50,1000,0.01);
gain = hslider("gain",0.5,0,1,0.01); gate = button("gate");
envelope = en.adsr(0.01,0.01,0.8,0.1,gate)*gain;
osc(freq) = os.sawtooth(freq)*envelope;
};
faust2audioanywhere synth.dsp
Fork of Faust compiler for AA on my Github
struct mydsp {
...
}
impl mydsp {
pub fn get_voices(&self) -> i32 { ... }
pub fn get_input(&self, index: u32) -> u32 { ... }
pub fn get_output(&self, index: u32) -> u32 { ... }
pub fn get_num_outputs(&self) -> i32 { ... }
pub fn handle_note_on(&mut self, mn: Note, vel: f32) { ... }
unsafe fn compute(
&mut self, count: i32, inputs: &[T], outputs: &mut [&mut [T];2]) { ... }
pub fn compute_external(&mut self, count: i32) { ... }
}
pub fn compute_external(&mut self, count: i32) {
unsafe {
let (output0, output1) =
(::std::slice::from_raw_parts_mut(OUTPUTS[0], count as usize),
::std::slice::from_raw_parts_mut(OUTPUTS[1], count as usize));
self.compute(count, &[], &mut [output0, output1]);
}
}
#[target_feature(enable = "simd128")]
unsafe fn compute(
&mut self, count: i32, inputs: &[T], outputs: &mut [&mut [T];2]) {
let [outputs0, outputs1] = outputs;
let (outputs0, outputs1) = {
let outputs0 = outputs0[..count as usize].iter_mut();
let outputs1 = outputs1[..count as usize].iter_mut();
(outputs0, outputs1)
};
...
let zipped_iterators = outputs0.zip(outputs1);
for (output0, output1) in zipped_iterators {
...
*output0 = ... ...
*output1 = ... ...
}
}
| C++ | Rust | Rust Optimized |
|---|---|---|
| 84860.747 MB/sec | 3379.915 MB/sec | 88353.927 MB/sec |