Open the materials/json_starter.html
file from the class exercises.
Write a function that takes in a JSON message and a jQuery selector, and inserts the message into the DOM node identified by the selector.
Attach a click handler to the button that reads the username and message from the form and calls your function to insert the message into the dom.
User your browser's developer tools to debug!


So I have an assignment for my c++ computer class. I've tried for quite a while on it and I am completely lost. In attempts to reach out to the teacher, I remembered she is on vacation and unable to help. So I turn to all of you. I had much more of this program done but I made a decisive decision to start over from the basics because I was completely lost, hoping it would help me. It didn't. Any help or recommendations is much appreciated. I'm not asking you. glorious forum posters, to do my assignment, I'm just asking if you could please help push me in the right direction. Thank you.
The Assignment question is:
Problem Description:
The HealthCare Insurance Agency determines auto insurance rates based in the driver's age, ticket history, and the value of the car. The base rate is 6% of the car value. Male drivers under the age of 25 pay an extra 17%, and female drivers under the age of 21 pay an extra 4% of the base charge. A driver with more than three tickets pays an extra $100. Write a function that calculates insurance charge rates based on this information. To test this function write a program that uses this function to calculate insurance rates for information inputted by the user
Output answers in decimal form to two places. Your program should allow the user to repeat this calculation as often as the user wishes.
Example Output:
Enter the value of the car: 12000
Enter the age of the driver: 20
Enter the sex of the driver (M or F): m
Enter the number of tickets on the drivers record : 0
The insurance rate is $842.40.
Would you like to run the program again (Y or N)? n
Required Test Cases:
Value = 15000, Age = 24, Sex = m, Tickets = 4
Value = 8500, Age = 25, Sex = m, Tickets = 3
Value = 35900, Age = 45, Sex = f, Tickets = 0
Value = 900, Age = 21, Sex = f, Tickets = 0
Value = 12000, Age = 20, Sex = f, Tickets = 4
Value = 23000, Age = 38, Sex = m, Tickets = 7
The code I have is
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
|
//Type of Assignment: Homework Assignment 6
//Problem Number: 6
//Section Number: 100
//Author:
//Date Assigned: 10/30/2014
//Program Name: Assignment6
//File Name: Assignment6.cpp
//Time Spent on Program:
//Purpose of Program:
#include <iostream>
#include <iomanip>
using namespace std;
void insurance_cost(int base_rate, int car_value, char gender, int cost, int m,int age);
int main()
{
char gender, quit_choice;
int age, ticket_history, y = 1, n = 2, m=1, cost;
float base_rate, car_value, ticket_fee, cost;
cout.setf(ios::fixed | ios::showpoint);
cout << setprecision(2);
do
{
cout << "This program will tell you the insurance rate of the driver based off of the information asked" << endl;
cout << "Enter the value of the car:" << endl;
cin >> car_value;
cout << "Enter the age of the driver:" << endl;
cin >> age;
cout << "Enter the sex of the driver (M or F):" << endl;
cin >> gender;
cout << "Enter the number of tickets on the drivers record:" << endl;
cin >> ticket_history;
insurance_cost (base_rate, car_value, gender, cost, m, age);
cout << "Would you like to run the program again (Y or N)?" << endl;
cin >> quit_choice;
}
while (quit_choice != 2);
return 0;
}
void insurance_cost(int base_rate, int car_value, char gender, int cost, int m,int age)
{
base_rate= (car_value*0.06);
if (gender = 1);
{
cost = base_rate;
cout << "The cost of car insurance is" << cost << endl;
if (age < 25)
cost = (base_rate*0.17) + base_rate;
cout << "The cost of car insurance is" << cost << endl;
}
}
| |
Very incomplete I know....any help is greatly appreciated.
Thank you,
goldyn


Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.
Note: You can only move either down or right at any point in time.
Example:
Input:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
Output: 7
Explanation: Because the path 1→3→1→1→1 minimizes the sum.
Define f(i, j)
to be the min sum from (0, 0)
to (i, j)
.
f(0, 0) = grid[0][0]
f(0, j) = f(0, j-1) + grid[0][j], j > 0
f(i, 0) = f(i-1, 0) + grid[i][0], i > 0
f(i, j) = min( f(i-1, j), f(i, j-1) ) + grid[i][j], j > 0 && i > 0
Only two previous states are dependant. Use dynamic array to reduce memory allocation.
/**
* @param {number[][]} grid
* @return {number}
*/
var minPathSum = function(grid) {
const height = grid.length
if (height <= 0) { return 0 }
const width = grid[0].length
if (width <= 0) { return 0 }
const dp = new Array(width).fill(Infinity)
dp[0] = 0
for (let i = 0; i < height; i++) {
dp[0] += grid[i][0]
for (let j = 1; j < width; j++) {
dp[j] = Math.min(dp[j], dp[j-1]) + grid[i][j]
}
}
return dp[width-1] || 0
};
Template generated via Leetmark.


Retrofuturism is an exploration of the themes of tension between the new and old, between the alienating and empowering effects of technology. It might be best described as the act or tendency of an artist to progress by moving backwards, focussing on the futurist visions of eras past. Futurism was born out of humanity's reaction to a sudden thrust into technological revolution. To the many that witnessed the rapid change, it seemed technological utopia was fast approaching. This unbridled optimism caused the collective imagination to run wild.
Retrofuturism is a prescriptive art - it fails to define a specific type of art or artist. Instead what it does is more valuable: it describes possible work, and it is then up to the cultural worker to go out and make it. Although many of these visions seem almost comical now, the spirit in which they were created is part of the reason you are currently looking into a glowing rectangle with unlimited, instant access to the sum of all human knowledge.


Display Name is required.
First Name is required.
Last Name is required.
Email Address is required.
Email Address is not valid.


TO_NCHAR(datetime)
converts a datetime or interval value to the national character set.
NVARCHAR2
TO_NCHAR({ datetime | interval }
[, fmt [, 'nlsparam' ] ]
)
datetime
is a datetime expression to be converted to text.
interval
is an interval expression to be converted to text.
fmt
is a datetime model format specifying the format of char
. The default date format is determined implicitly by the NLS_TERRITORY
initialization parameter or can be set explicitly by the NLS_DATE_FORMAT
parameter. For data type formats, refer to the Oracle Database SQL Language Reference.
nlsparam
specifies the language in which month and day names and abbreviations are returned. This argument can have this form:
'NLS_DATE_LANGUAGE = language'
By default, the return value is in the session date language.
TO_NCHAR(SYSDATE)
returns a value such as 11-APR-08
.
TO_NCHAR(SYSDATE, 'Day: MONTH DD, YYYY')
returns a value such as Friday : APRIL 11, 2008
.
TO_NCHAR(SYSDATE, 'Day: MONTH DD, YYYY', 'NLS_DATE_LANGUAGE = Spanish')
returns a value such as Viernes : ABRIL 11, 2008
.


Secure Fountain Architecture
Transcript By: Bryan Bishop
Tags: Security
Category: Conference
A secure fountain architecture for slashing storage costs in blockchains
Swanand Kadhe (UC Berkeley)
https://twitter.com/kanzure/status/1172158545577594880
paper: https://arxiv.org/abs/1906.12140
Introduction
I know this is the last formal talk of the day so thank you so much for being here. This is joint work with my collaborators.
Is storage really an issue for bitcoin?
Bitcoin’s blockchain size is only 238 GB. So why is storage important? But blockchain size is a growing problem. It’s always going to go up. If you do some back of the envelope calculations, then the growth rate is roughly 1 block per 10 minutes so roughly 1 MB per 10 minutes. This is about 52,560 MB/year at full blocks. This is about 144 MB/day. So then the user has to figure out, do I upload this to the cloud? Do I trust the cloud?
Scaling bitcoin
How can we reduce the storage costs for nodes without reducing the security properties of bitcoin and blockchain in general? We need to take a deeper look into the bitcoin ecosystem. There are archival nodes, lite nodes and pruned nodes.
The archival full nodes are the most secure way to join bitcoin. They download the entire history and validate all of the history and they store the entire blockchain. If you are an archival full node, then you also help bootstrapping the new nodes by giving them the history.
The other extreme are the thin light clients. These nodes are the SPV clients and you can think of them as the most economical way to join the bitcoin system, by ignoring some of the bitcoin rules. They only download the blockheaders. But the issue is that you need to rely on full nodes, since you don’t validate any transactions. So there are security and privacy issues.
In between, there are pruned nodes. This is a third type of node. The pruned nodes are essentially bitcoin’s solution to storage bloat. The pruned node starts as a full node, but then deletes the history and only stores the UTXO set and the last few blocks. Individually they are almost as secure as full nodes. This has a fixed storage overhead, which is great.
The concern with pruned nodes is how do they interact with network health. If you are an archival full node, you are helping the new nodes to bootstrap because they can download the history and you’re also preserving the history. What if every user tomorrow runs a pruned node or SPV client? Well, then we lose the history and it’s not possible for a new node to join the system.
We want to come up with ways where we can store the history in a more decentralized way where each node has low storage costs but we’re not giving up on any decentralization or security property.
Challenges
The first challenge is security. There might be some malicious nodes that are adversarial.  The other one is low computation cost, and also the next one is low bootstrap cost. The number of nodes that the new node is contacting should be small.
Tradeoff
There is a fundamental tradeoff between storage savings vs bootstrapping cost. As you reduce the storage requirements on each node, you increase the amount of work that each new node needs to pay in bootstrapping. We want to devise a scheme that has a very small bootstrapping cost.
Decentralization via random sampling
When the blockchain grows by k blocks, randomly store s blocks out of k. Keep doing this as time goes on. Suppose for every 10,000 blocks I am only storing 10 blocks, so this is 1000 fold savings. This is good because the storage costs have gone down. In fact, this is used in sharding for ripple. But the problem is that this has prohibitive bootstrapping cost for new nodes. You have to communicate with a large number of nodes to find the last block.
Erasure coding: Random linear codes
One proposal last year was to use random linear codes. Split every block into k fragments, and compute s coded fragments using random linear coding. This is a well known technique in data backup and archival. See Perard et al 2018, Dai et al 2018. The main issue here is that it’s not possible to detect the malicious nodes. Also, recovering the block involves matrix inversion which requires O(k^2) computation. This has a small bootstrap cost, though.
Erasure coding: Reed-Solomon codes
Here, what changes is how we are taking the linear combinations. Now we are doing it in a specific way, dictated by a Reed-Solomon code. Indeed, there is manageable bootstrap cost, and good storage savings of k/s. Reed-Solomon codes are error-correcting codes, and malicious coded fragments can be corrected which is great.
Unfortunately, the finite field size should grow with the size of the network, which gives this a prohibitive computation cost.
See Raman-Varshney 2018, Li et al 2018 (polyshard).
SeF: A secure fountain architecture using fountain codes
We are essentially using secure fountain codes to distribute the blockchain history between multiple nodes. We envision that storage-constrained nodes are called droplet nodes here. They only store a small amount of data. When a new node joins the system, it contacts some subset of droplets and downloads the data. You should be able to retrieve the blockchain in the presence of malicious users. Once you retrieve the blockchain, you can act as a full node, but you also encode it and turn yourself into a new droplet. Droplet nodes will slowly replace full archival nodes.
SeF encoding
In the current epoch (the time required for the blockchain to grow by k blocks), when the blockchain grows by k blocks, encode the k blocks into s droplets using a fountain code. The storage savings are k/s, so if k=1000 and s=10, then you have 1000x savings.
Fountain codes
In fountain codes, they take a set of packets and encode them into potentially infinite number of droplets. It goes to the bucket and the decoder is able to recover blocks from all the droplets. That’s the high level idea.
Luby-transform (LT) codes
One of the first and well-known fountain codes is luby-transform codes. Basically blocks get XORed together.
Peeling decoding
Collect an arbitrary subset of droplets of sufficient size. Peeling decoder recovers original source symbols.
Luby 2002 designed a robust soliton degree distribution that guarantees successful recovery.
SeF: Luby-transform (LT) encoder
In SeF, we are going to use the luby-transform (LT) encoder as-is. So we use a robust Soliton degree distribution proposed by Luby.  You also store the header data from the blockchain.
An important property of fountain codes is that they are rateless codes, meaning it’s possible to keep constructing droplets without knowing what any other node is doing. This is important for scalability because every node can now create its own droplets without knowing anything about the rest of the network. This helps with decentralization and also scalability of the system.
SeF peeling decoder
For retrieving the blockchain history, we want to decode the blockchain. We can’t use the peeling decoder as-is, because of malicious block providers. They might be giving you some garbage, which gets used in the decoding, and then there’s error propagation and it ends up happening that you decode entirely garbage. So we need to deal with it.
We’re going to leverage the hashchain structure and merkle roots to cleverly deal with the malicious nodes.
Fountain codes were originally designed for a different task. Here, we’re using them for blockchain. Our first step in decoding is to obtain the longest valid header chain. We’re acting as an SPV client or lite client. I can verify that this is the correct chain because of the PoW difficulty. Once we have the right chain, I am going to download some droplets from droplet nodes. Then we can create this graph where we can see each droplet is a XOR of some of this other data. Out of these droplet nodes, some of them are going to be malicious meaning that this droplet was claimed to be a XOR of block 3 and 6 but it can actually be some arbitrary data. But we don’t know that; once you XOR the blocks, you lose all the semantic information.  So we need to actually detect that.
To do that, we’re going to essentially use the header chain as side information to detect bad blocks. So we start in the standard way of the peeling decode,r then we need to pick a singleton block that is not XORed with anything, and let’s compare its header with the header in the headerchain. If the headers match, then we take the payload of this block which is supposed to be transactions, and then compute the merkle root and see if the merkle root matches the one stored in the headerchain. If both of them match, then we’re going to accept that block. But if they don’t match, then it must be a malicious block and we’re essentially going to delete it.n
Malicious droplets are detected only when they become a singleton. Peeling is crucial in detecting malicious droplets.
Threat model
The threat model is that some arbitrary set of nodes are adversarial and are giving you garbage data. We’re assuming that there are at least a certain number of honest nodes, and the adversary is oblivious and cannot observe storage contents of the network and then choose to who to attack. In this model, we can show that if a malicious droplet becomes a singleton, it is rejected. OBlivious adversary cannot influence probability of decoding failure for honest droplets.
Comparison with existing solutions
….
Numerical results
….
Tackling block size variability
One thing we can do is adaptive zeor-padding, while computing bit-wise XOR, a node zero-pads the blocks to the largest block among the d blocks.
Block concatenation is a natural way to reduce variance in block size, to first concatenate blocks to form superblocks and then XOR superblocks and that encoding. Then ew can have the blocks almost equal size and we can save a lot.
Experimental results
…
Conclusion
We presented a secure fountain code architecture for reducing blockchain storage costs by orders of magnitude without compromising security of the network. This can be directly applied on top of bitcoin, without requiring a soft-fork or hard-fork.
Future work
-
How to dynamically change epoch length k?
-
How to reduce decoding complexity to be linear in k?


The General (1998) 129m
John Boorman deservedly won the Best Director at Cannes in 1998 for this biopic of Irish criminal Martin Cahill (who was assassinated by the IRA four years previously). It is one of his finest works, a film that manages to look both as the opus of a mature film-maker and the early work of a talented new arrival. THE GENERAL is wonderfully assured and without the unevenness of earlier Boorman works, yet also appears an apotheosis of all that went before it: we can see the black-and-white spirited 60s of CATCH US IF YOU CAN, another great performance from Jon Voight (DELIVERANCE), the criminal underworld of POINT BLANK, the nostalgia of HOPE AND GLORY, and the man-as-myth themes of EXCALIBUR and ZARDOZ. Throw in a few giant locusts and you'd be able to pull EXORCIST II out of the hat as well (Boorman does make at least one in-joke by including a brief shot of a 'Squeal like a Pig' t-shirt that cites the most famous line from DELIVERANCE).
THE GENERAL scores on many levels - the acting is terrific (Brendan Gleeson makes the role entirely his own, and Voight's accent is faultless), the story engaging, and the viewpoint always open. Boorman doesn't judge Cahill, although he does get us to admire his resourcefulness. It's hard not to like him - unlike most other crime lords he does not create a dangerous heirarchy that places him significantly at the top. True, he is the brains of his operation, but his shambolic, hangdog manner keep him in at grass roots level with the rest of his boys. Even when resorting to thuggery (when one of the gang appears to have cheated the others), his organization doesn't appear as sadistic as others we have seen on screen. Really, Cahill is the antithesis of the gangster image popularised by films such as GODFATHER and CASINO. Rather than grandstand in the manner of a mafia Don, Cahill shuffles about obscured by rainwear; he avoids eye contact and speaks quietly; his hand is always fluttering near his face, trying to hide it. His rogueishness could almost win us over entirely if we were not reminded (by Voight's character) that his antics have lost several honest people their jobs and have terrified people inside their homes. Cahill lives an extraordinary life but is determined to keep his lifestyle as 'normal' as possible - all he wants is a nice house in a nice area for his family (in the meantime, he carries on what is seen as just a 'normal' affair with his sister-in-law!). We hardly notice the conflict because the rest of the country is in turmoil anyway - by the time Cahill, the police, and the IRA are all on opposing sides, we've lost hope for anything ever attaining normality. Maybe that's why one of the more memorable moments in THE GENERAL is an understated housebreaking scene, in which Cahill moves from room to room while a Van Morrison song plays quietly and magically on the soundtrack. It's a sweet, distinctive cinema moment; we can only hope that Boorman will be bringing us more.
<EMAIL_ADDRESS>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


Kingdom Under Fire 2 PC Performance Analysis
by John PapadopoulosAfter a 12-year development hell, Kingdom Under Fire 2 is finally here with us. Gameforge has provided us with a review code so it’s time to benchmark this game and see how it performs on the PC platform.
For this PC Performance Analysis, we used an Intel i9 9900K with 16GB of DDR4 at 3600Mhz, AMD’s Radeon RX580 and RX Vega 64, NVIDIA’s RTX 2080Ti, GTX980Ti and GTX690. We also used Windows 10 64-bit, the GeForce driver 441.20 and the Radeon Software Adrenalin 2019 Edition 19.11.3 drivers. NVIDIA has not included any SLI profile for this title, meaning that our GTX690 performed similarly to a single GTX680.
Blueside has added a few graphics settings to tweak. PC gamers can adjust the quality of Textures, Terrain, Shaders, Shadows, Post-processing and Anti-aliasing. There are also options for Motion Blur, HDR, Light Scattering, Shallow Focus, SSAO and Shadows.
In case you’re wondering, the game does not come with any built-in benchmark tool. Therefore, we’ve decided to benchmark the first big city battle. Do note that this is a stress test, meaning that other areas of the game will run faster.
Kingdom Under Fire 2 only supports the DX11 API and suffers from optimization issues. In the first city battle, our Intel i9 9900K could not provide a smooth gaming experience at 1080p/Max settings. There were numerous drops to mid 40s, with the GPU being underused. Again, let us remind you that this is a stress test.
In order to find out how the game scales on multiple CPU threads, we simulated a dual-core, a quad-core and a hexa-core CPU. Our simulated dual-core system was dropping to 30fps in some areas during our benchmark scene, and provided an average of 67fps. Without Hyper Threading, the game was unplayable on our dual-core system due to severe stuttering issues.
The game’s optimization issues also greatly affected our Intel i7 4930K system. Our Intel i7 4930K had some drops below 30fps, and was able to push an average of 48fps at 1080p/Max settings. We should also note that none of our CPU cores were maxed out. As such, we can safely assume that these optimization issues are due to the memory frequency limitations. We’ve seen this behavior in the past in some other DX11 games. Blueside could potentially address them via a DX12 or Vulkan patch, though I’m not sure whether it currently has such plans.
Due to these optimization issues, most of our graphics cards under-performed in our GPU benchmark/stress test. Now we did notice performance difference in other areas (like the camp for example). However, one of the key features of Kingdom Under Fire 2 is its huge and epic-scale battles. And, unfortunately, the game will not run smoothly under such scenarios.
Graphics wise, Kingdom Under Fire 2 looks like a last-gen game. There are a lot of low-resolution textures, and most of the particles effects are serviceable. All of the characters lack the features you’d expect from a modern-day title. This obviously does not surprise us as Blueside has been developing this game for over 12 years. Therefore, don’t expect visuals that push the envelope of what MMO games can look like.
In conclusion, Kingdom Under Fire 2 suffers from major optimization issues. Our guess is that these are mainly due to the DX11 API and the overwhelmed amount of game’s draw calls. This is mostly a memory frequency limitation and not a CPU bottleneck. However, it will impact all PC configurations and that’s something that Blueside needs to address. Here is hoping that the team will improve things via some post-launch patches!


European Central Bank chief asks governments to help growth
by The Associated PressFRANKFURT, Germany (AP) — The new president of the European Central Bank, Christine Lagarde, says better-targeted public spending would help support economic growth in the eurozone.
In her first official speech Friday, Lagarde indirectly chided countries like Germany that have kept a tight grip on their budgets while making clear that a spendthrift approach to public spending would be hazardous, too.
Lagarde said “there is today a cross-cutting case for investment in a common future that is more productive, more digital and certainly greener” and warned that public spending in the 19-country eurozone “remains some way below its pre-crisis level.”
She also said the ECB will begin a strategic review of its monetary policy “in the near future” but the bank would also “continuously monitor the side effects” of its current low-interest stance.
The Associated Press


{% if project.project_type != 'simplyjs' and project.project_type != 'rocky' %}
{% trans 'Resources' %}
{% endif %}
{% include "ide/project/resource.html" %}
{% include "ide/project/compile.html" %}
{% include "ide/project/settings.html" %}
{% include "ide/project/github.html" %}
{% include "ide/project/ui-editor.html" %}
{% include "ide/project/timeline.html" %}
{% include "ide/project/dependencies.html" %}
{% endblock %}
{% block modals %}
{% trans 'Create new file' %}
Create New Repo
{% trans 'Push New Commit' %}
{% trans 'Pull Latest Commit' %}
{% blocktrans %}
Are you sure you want to pull the latest commit? Doing so will overwrite everything currently in your project.
There will be no further warnings and no opportunity to merge. This cannot be undone.
{% endblocktrans %}
{% trans 'Pulling latest commit from GitHub…' %}
Waiting for phone
Please check your phone for notices from the Pebble app.
This version of the Pebble Android app has been rewritten from the ground up to be more reliable
and give a better user experience.
Notifications are now available from all apps. You should now disable Pebble Notifier or similar apps
The new Notifications menu includes an All apps option, where you can choose
to receive notifications from any app on your device.
Some popular apps are selected by default.
Some apps in this list will be disabled if you have enabled built-in notifications (e.g. Gmail
or calendar) to avoid generating duplicate notifications.
In-progress phone calls can now be ended from your watch.
Please note:
This release is only supported on Android 4.3 and above.
Developers: datalogging compatibility is broken in this release. You will need to use the updated
PebbleKit 2.6 in order to use datalogging with this release.
You will be asked to log in to your Pebble account again after installing this release.
{% trans 'Compass and Accelerometer' %}
{% blocktrans with url=phone_shorturl %}
You can use your mobile phone to send sensor data to the emulator.
In your mobile browser, go to {{ url }} and enter this code:


I have a mix of business, tech, and interpersonal skills that can add value in a variety of ways.
As an Entrepreneur and small business owner for the last 14 years, I have learned the intracacies of business in sales, customer support, marketing, business develoment, networking, project management, and more.
I was gifted with an ambitious entrepreneurial mindset.
I have been building a small education business in Spain, stratigically using top-level customer service and relationships.
We provide language consulting services for professionals, corporations, families, and students using meaningful interaction in practical activities and project based learning for natural second language acquistion.
Despite a harsh economic recession and language and cultural barriers I have achieved 15% anual growth in revenue over the last 5 years.
I have managed all aspects of the business including web development, sales, customer support, marketing, and more which has given me a deep understanding of the fundamentals of business.
When craft beer was barely even "a thing" in Spain, I planned and executed several craft beer festivals with over 2000 total guests.
The inoovative TAOB Beer Festivals were a success and I am extrmely proud and honored to have taken part in paving the way for craft beer in the North of Spain
Additionally, The Art of Living art and cultural expos that I organized monthly for several years brought in over 3000 guests and promoted alternative art events in the city.
These projects helped me master many aspects of event planning and business like marketing, networking, public relations, project management, and more.
I am highly motivated to always be learning something new and increase my tech skills.
Working remotley for a new business in California called TerraForm Designworks, I built their website from scratch and setup things like their contact form, domain and custom business emailing.
I have also taken on the role of customer support via email and presenting their product to potential clients in the sales pipeline.
Furthermore, I educated the founders on how to edit content in the backend of WordPress and what options they have for CRM tools and support software whcih will be essential as the business expands.
I built the website for my current education business using WordPress and have recently migrated the entire site to a new domain.
Understanding and using knowledge of DNS records, email hosting, HTML, CSS, and some JavaScriptThis were key in carrying out this project.
Organizational skill and delegation also played an important role in project success.
This is a little Java Script app that I built. It's from Java Script 30 and it really put a smile on my face to finally build something.
Here is another simple Java Script app that I built. It's a timer that counts down and it's from one of Simon Allerdice's courses. He has been my favourite teacher in learning JS!
My people and soft skills come from a mix of natural gifts and learning through putting myself out there and getting outside my comfort zone on a frequent basis. I love people. I love helping people. I love meeting people. I think we are all amazing in our own way and we are lucky to all be here on Earth together.
When I was growing up I learned many valuable lessons. I was in the Boy Scouts because my parents were divorced and I lived with my mom and she wanted me to have some solid male role models. Turns out she did well. Some of the dads in the troop really pushed me to grow up through my adolescents and into manhood.
Feugiat amet accumsan ante aliquet feugiat accumsan. Ante blandit accumsan eu amet tortor non lorem felis semper. Interdum adipiscing orci feugiat penatibus adipiscing col cubilia lorem ipsum dolor sit amet feugiat consequat.


Workweek
1 Monday
2 Tuesday
3 Wednesday
4 Thursday
5 Friday
Weekend
6 Saturday
7 Sunday
REMINDERS
SPECIAL DATES


@(employees: List[models.Employee], projects: List[models.Project], user: models.users.User,env: play.api.Environment) @main("Employees",user) {
Employee
Add a employee


Visiting the provided link, we can register a user and we see the following blog:
After creating the post we are redirected to the actual post:
The prompt mentioned analytics. When we visit our profile, we see a list of users who visited, as well as the User-Agent
header sent with the request to view the post.
The User-Agent
field caught my attention. Not only is it reflected on the page, but the User-Agent
values must be stored somewhere.
I then tested to see what would happen if I visited my own post with User-Agent
header set to different values in my request. For this I used Burpsuite. I was able to detect SQL injection!
We are lucky enough to leak the entire SQL query being made. Let's try to enumerate this database and see what databases, tables, and columns we can find.
First I leaked the SQL commands that created each table in the database:
I then refreshed my profile page in my browser and saw the following entry:
We have a table named user
with columns that include password
and user
Let's leak all of the passwords! For this I used the following payload which inserted all of the stored passwords in place of the user agent entry in the table:
User-Agent: '||select group_concat(password) from user||'
The fully query that is executed server side would look like this:
insert into visit (post_id, user_id, ua) values (5,2,''||select group_concat(password) from user||'');
Refreshing the profile page, we get the admin password!
After using this password to login as admin, we are presented with the flag.


Skills & Proficiency
Programming languages, Frameworks et libraries
Java / JEE, EJB3, SpringBeans, SEAM, Spring, Hibernate, JSF & Tapestry
Javascript, jQuery, Angular & React
Mainframe IBM, CICS/MVS, JCL, TSO/ISPF, COBOL II TP et BATCH, PACBASE, DB2
Server, BDD & SGBD
Puma, Thin, nginx, apache, jetty, tomcat...
PaaS, Heroku, Clever cloud, amazone, OVH...
PostgreSQL & PostGIS, MySQL...
Tools
RubyMine, Eclipse, Android studio, Xcode & Sublime text
Git, github, svn & d'autres
API REST, Json, geoJson, Apiary, postman...
APIs Google, Twilio, Stripe, Zendesk, Slack...
CodeShip, CodeClimate, Code coverage, Gemnasium, Jenkins...
Integration and continuous deployment, TDD
Sketch, Photoshop, Illustrator & Indesign
Entrepreneurship & Management
Business management, startup, strategy, business model, forecasting
Product design, innovation, POC, sprint design


Use this document as a way to quickly start any new project All you get is this text and a mostly barebones HTML document.


Deals with many computations related to the thermodynamics of atmospheric processes. It includes many functions designed to consider the density of air with varying degrees of water vapour in it, saturation pressures and mixing ratios, conversion of moisture indices, computation of atmospheric states of parcels subject to dry or pseudoadiabatic vertical evolutions and atmospheric instability indices that are routinely used for operational weather forecasts or meteorological diagnostics.
| Version: | 1.2.1 |
| Published: | 2018-09-16 |
| Author: | Jon Sáenz, Santos J. González-Rojí, Sheila Carreno-Madinabeitia and Gabriel Ibarra-Berastegi |
| Maintainer: | Santos J. González-Rojí <santosjose.gonzalez at ehu.eus> |
| License: | GPL-3 |
| NeedsCompilation: | yes |
| Materials: | NEWS |
| CRAN checks: | aiRthermo results |
| Reference manual: | aiRthermo.pdf |
| Package source: | aiRthermo_1.2.1.tar.gz |
| Windows binaries: | r-devel: aiRthermo_1.2.1.zip, r-release: aiRthermo_1.2.1.zip, r-oldrel: aiRthermo_1.2.1.zip |
| OS X binaries: | r-release: aiRthermo_1.2.1.tgz, r-oldrel: aiRthermo_1.2.1.tgz |
| Old sources: | aiRthermo archive |
Please use the canonical form https://CRAN.R-project.org/package=aiRthermo to link to this page.


Display top and bottom schematic view of Saturn and its moons projected for correct Earth viewpoint, with full quantitative data in tabular form.


Beta
direct
democracy
polling station
This webservice provides a polling station
allowing citizens to vote in directdemocracy.
Process and results are auditable by anyone.


{% extends "base_not_logged_in.html" %} {% block content %}
You will receive a mail to confirm your email address once your account has been activated by an administrator.


?INSTITUTE
OF
JAMAICA
FLORA
OF
JAMAICA
Parish:
ST.
JAMES
Name:
Eustoma
exaltatum
(L.)Griseb.
Locality:
0.5
mile
east
of
LONG
BAY.
Altitude:
Sea-level
Date:
June
19,
1966
Habitat:
Brackish
sand.
6reSariĦus
herb
with
glaucous
'[foliage;
corolla
violet-blue*
Collector:
George
R.
Proctor
No.
27501
Eustoma
exaltatum
(L.)
Salisb.
ex
G.
Don
Det.-rev.
M.
Thiv(B)2001
botanical
gard^
1624562
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


// Licensed 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. // Copyright 2005 Google, Inc. All Rights Reserved. /** * @fileoverview Code for handling edit history (undo/redo). * */ goog.provide('goog.editor.plugins.UndoRedo'); goog.require('goog.debug.Logger'); goog.require('goog.dom'); goog.require('goog.dom.NodeOffset'); goog.require('goog.dom.Range'); goog.require('goog.editor.BrowserFeature'); goog.require('goog.editor.Command'); goog.require('goog.editor.Field.EventType'); goog.require('goog.editor.Plugin'); goog.require('goog.editor.plugins.UndoRedoManager'); goog.require('goog.editor.plugins.UndoRedoState'); goog.require('goog.events'); goog.require('goog.events.EventHandler'); /** * Encapsulates undo/redo logic using a custom undo stack (i.e. not browser * built-in). Browser built-in undo stacks are too flaky (e.g. IE's gets * clobbered on DOM modifications). Also, this allows interleaving non-editing * commands into the undo stack via the UndoRedoManager. * * @param {goog.editor.plugins.UndoRedoManager=} opt_manager An undo redo * manager to be used by this plugin. If none is provided one is created. * @constructor * @extends {goog.editor.Plugin} */ goog.editor.plugins.UndoRedo = function(opt_manager) { goog.editor.Plugin.call(this); this.setUndoRedoManager(opt_manager || new goog.editor.plugins.UndoRedoManager()); // Map of goog.editor.Field hashcode to goog.events.EventHandler this.eventHandlers_ = {}; this.currentStates_ = {}; /** * @type {?string} * @private */ this.initialFieldChange_ = null; /** * A copy of {@code goog.editor.plugins.UndoRedo.restoreState} bound to this, * used by undo-redo state objects to restore the state of an editable field. * @type {Function} * @see goog.editor.plugins.UndoRedo#restoreState * @private */ this.boundRestoreState_ = goog.bind(this.restoreState, this); }; goog.inherits(goog.editor.plugins.UndoRedo, goog.editor.Plugin); /** * The logger for this class. * @type {goog.debug.Logger} * @protected */ goog.editor.plugins.UndoRedo.prototype.logger = goog.debug.Logger.getLogger('goog.editor.plugins.UndoRedo'); /** * The {@code UndoState_} whose change is in progress, null if an undo or redo * is not in progress. * * @type {goog.editor.plugins.UndoRedo.UndoState_?} * @private */ goog.editor.plugins.UndoRedo.prototype.inProgressUndo_ = null; /** * The undo-redo stack manager used by this plugin. * @type {goog.editor.plugins.UndoRedoManager} * @private */ goog.editor.plugins.UndoRedo.prototype.undoManager_; /** * The key for the event listener handling state change events from the * undo-redo manager. * @type {number} * @private */ goog.editor.plugins.UndoRedo.prototype.managerStateChangeKey_; /** * Commands implemented by this plugin. * @enum {string} */ goog.editor.plugins.UndoRedo.COMMAND = { UNDO: '+undo', REDO: '+redo' }; /** * Inverse map of execCommand strings to * {@link goog.editor.plugins.UndoRedo.COMMAND} constants. Used to determine * whether a string corresponds to a command this plugin handles in O(1) time. * @type {Object} * @private */ goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_ = goog.object.transpose(goog.editor.plugins.UndoRedo.COMMAND); /** * Set the max undo stack depth (not the real memory usage). * @param {number} depth Depth of the stack. */ goog.editor.plugins.UndoRedo.prototype.setMaxUndoDepth = function(depth) { this.undoManager_.setMaxUndoDepth(depth); }; /** * Set the undo-redo manager used by this plugin. Any state on a previous * undo-redo manager is lost. * @param {goog.editor.plugins.UndoRedoManager} manager The undo-redo manager. */ goog.editor.plugins.UndoRedo.prototype.setUndoRedoManager = function(manager) { if (this.managerStateChangeKey_) { goog.events.unlistenByKey(this.managerStateChangeKey_); } this.undoManager_ = manager; this.managerStateChangeKey_ = /** @type {number} */ ( goog.events.listen(this.undoManager_, goog.editor.plugins.UndoRedoManager.EventType.STATE_CHANGE, this.dispatchCommandValueChange_, false, this)); }; /** * Whether the string corresponds to a command this plugin handles. * @param {string} command Command string to check. * @return {boolean} Whether the string corresponds to a command * this plugin handles. */ goog.editor.plugins.UndoRedo.prototype.isSupportedCommand = function(command) { return command in goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_; }; /** @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.registerFieldObject = function( fieldObject) { this.fieldObject = fieldObject; }; /** * Unregisters and disables the fieldObject with this plugin. Thie does *not* * clobber the undo stack for the fieldObject though. * TODO: For the multifield version, we really should add a way to * ignore undo actions on field's that have been made uneditable. * This is probably as simple as skipping over entries in the undo stack * that have a hashcode of an uneditable field. * @param {goog.editor.Field} fieldObject The field to register with the plugin. */ goog.editor.plugins.UndoRedo.prototype.unregisterFieldObject = function( fieldObject) { this.disable(fieldObject); this.fieldObject = null; }; /** * This is so subclasses can deal with multifield undo-redo. * @return {goog.editor.Field} The active field object for this field. This is * the one registered field object for the single-plugin case and the * focused field for the multi-field plugin case. */ goog.editor.plugins.UndoRedo.prototype.getCurrentFieldObject = function() { return this.fieldObject; }; /** * This is so subclasses can deal with multifield undo-redo. * @param {string} fieldHashCode The Field's hashcode. * @return {goog.editor.Field} The field object with the hashcode. */ goog.editor.plugins.UndoRedo.prototype.getFieldObject = function( fieldHashCode) { // With single field undoredo, there's only one Field involved. return this.fieldObject; }; /** * This is so subclasses can deal with multifield undo-redo. * @return {goog.editor.Field} Target for COMMAND_VALUE_CHANGE events. */ goog.editor.plugins.UndoRedo.prototype.getCurrentEventTarget = function() { return this.fieldObject; }; /** @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.enable = function(fieldObject) { if (this.isEnabled(fieldObject)) { return; } // Don't want pending delayed changes from when undo-redo was disabled // firing after undo-redo is enabled since they might cause undo-redo stack // updates. fieldObject.clearDelayedChange(); var eventHandler = new goog.events.EventHandler(this); // TODO: From ojan during a code review: // The beforechange handler is meant to be there so you can grab the cursor // position *before* the change is made as that's where you want the cursor to // be after an undo. // // It kinda looks like updateCurrentState_ doesn't do that correctly right // now, but it really should be fixed to do so. The cursor position stored in // the state should be the cursor position before any changes are made, not // the cursor position when the change finishes. // // It also seems like the if check below is just a bad one. We should do this // for browsers that use mutation events as well even though the beforechange // happens too late...maybe not. I don't know about this. if (!goog.editor.BrowserFeature.USE_MUTATION_EVENTS) { // We don't listen to beforechange in mutation-event browsers because // there we fire beforechange, then syncronously file change. The point // of before change is to capture before the user has changed anything. eventHandler.listen(fieldObject, goog.editor.Field.EventType.BEFORECHANGE, this.handleBeforeChange_); } eventHandler.listen(fieldObject, goog.editor.Field.EventType.DELAYEDCHANGE, this.handleDelayedChange_); eventHandler.listen(fieldObject, goog.editor.Field.EventType.BLUR, this.handleBlur_); this.eventHandlers_[fieldObject.getHashCode()] = eventHandler; // We want to capture the initial state of a Trogedit field before any // editing has happened. This is necessary so that we can undo the first // change to a field, even if we don't handle beforeChange. this.updateCurrentState_(fieldObject); }; /** @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.disable = function(fieldObject) { // Process any pending changes so we don't lose any undo-redo states that we // want prior to disabling undo-redo. fieldObject.clearDelayedChange(); var eventHandler = this.eventHandlers_[fieldObject.getHashCode()]; if (eventHandler) { eventHandler.dispose(); delete this.eventHandlers_[fieldObject.getHashCode()]; } // We delete the current state of the field on disable. When we re-enable // the state will be re-fetched. In most cases the content will be the same, // but this allows us to pick up changes while not editable. That way, when // undoing after starting an editable session, you can always undo to the // state you started in. Given this sequence of events: // Make editable // Type 'anakin' // Make not editable // Set HTML to be 'padme' // Make editable // Type 'dark side' // Undo // Without re-snapshoting current state on enable, the undo would go from // 'dark-side' -> 'anakin', rather than 'dark-side' -> 'padme'. You couldn't // undo the field to the state that existed immediately after it was made // editable for the second time. if (this.currentStates_[fieldObject.getHashCode()]) { delete this.currentStates_[fieldObject.getHashCode()]; } }; /** @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.isEnabled = function(fieldObject) { // All enabled plugins have a eventHandler so reuse that map rather than // storing additional enabled state. return !!this.eventHandlers_[fieldObject.getHashCode()]; }; /** @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.disposeInternal = function() { goog.editor.plugins.UndoRedo.superClass_.disposeInternal.call(this); for (var hashcode in this.eventHandlers_) { this.eventHandlers_[hashcode].dispose(); delete this.eventHandlers_[hashcode]; } this.fieldObject = null; if (this.undoManager_) { this.undoManager_.dispose(); delete this.undoManager_; } }; /** @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.getTrogClassId = function() { return 'UndoRedo'; }; /** @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.execCommand = function(command, var_args) { if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) { this.undoManager_.undo(); } else if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) { this.undoManager_.redo(); } }; /** @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.queryCommandValue = function(command) { var state = null; if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) { state = this.undoManager_.hasUndoState(); } else if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) { state = this.undoManager_.hasRedoState(); } return state; }; /** * Dispatches the COMMAND_VALUE_CHANGE event on the editable field or the field * manager, as appropriate. * Note: Really, people using multi field mode should be listening directly * to the undo-redo manager for events. * @private */ goog.editor.plugins.UndoRedo.prototype.dispatchCommandValueChange_ = function() { var eventTarget = this.getCurrentEventTarget(); eventTarget.dispatchEvent({ type: goog.editor.Field.EventType.COMMAND_VALUE_CHANGE, commands: [goog.editor.plugins.UndoRedo.COMMAND.REDO, goog.editor.plugins.UndoRedo.COMMAND.UNDO]}); }; /** * Restores the state of the editable field. * @param {goog.editor.plugins.UndoRedo.UndoState_} state The state initiating * the restore. * @param {string} content The content to restore. * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition * The cursor position within the content. */ goog.editor.plugins.UndoRedo.prototype.restoreState = function( state, content, cursorPosition) { // Fire any pending changes to get the current field state up to date and // then stop listening to changes while doing the undo/redo. var fieldObj = this.getFieldObject(state.fieldHashCode); if (!fieldObj) { return; } // Fires any pending changes, and stops the change events. Still want to // dispatch before change, as a change is being made and the change event // will be manually dispatched below after the new content has been restored // (also restarting change events). fieldObj.stopChangeEvents(true, true); // To prevent the situation where we stop change events and then an exception // happens before we can restart change events, the following code must be in // a try-finally block. try { fieldObj.dispatchBeforeChange(); // Restore the state fieldObj.execCommand(goog.editor.Command.CLEAR_LOREM, true); // We specifically set the raw innerHTML of the field here as that's what // we get from the field when we save an undo/redo state. There's // no need to clean/unclean the contents in either direction. fieldObj.getElement().innerHTML = content; if (cursorPosition) { cursorPosition.select(); } var previousFieldObject = this.getCurrentFieldObject(); fieldObj.focus(); // Apps that integrate their undo-redo with Trogedit may be // in a state where there is no previous field object (no field focused at // the time of undo), so check for existence first. if (previousFieldObject && previousFieldObject.getHashCode() != state.fieldHashCode) { previousFieldObject.execCommand(goog.editor.Command.UPDATE_LOREM); } // We need to update currentState_ to reflect the change. this.currentStates_[state.fieldHashCode].setUndoState( content, cursorPosition); } catch (e) { this.logger.severe('Error while restoring undo state', e); } finally { // Clear the delayed change event, set flag so we know not to act on it. this.inProgressUndo_ = state; // Notify the editor that we've changed (fire autosave). // Note that this starts up change events again, so we don't have to // manually do so even though we stopped change events above. fieldObj.dispatchChange(); fieldObj.dispatchSelectionChangeEvent(); } }; /** * @inheritDoc */ goog.editor.plugins.UndoRedo.prototype.handleKeyboardShortcut = function(e, key, isModifierPressed) { if (isModifierPressed) { var command; if (key == 'z') { command = e.shiftKey ? goog.editor.plugins.UndoRedo.COMMAND.REDO : goog.editor.plugins.UndoRedo.COMMAND.UNDO; } else if (key == 'y') { command = goog.editor.plugins.UndoRedo.COMMAND.REDO; } if (command) { // In the case where Trogedit shares it's undo redo stack with another // application it's possible that an undo or redo will not be for an // goog.editor.Field. In this case we don't want to go through the // goog.editor.Field execCommand flow which stops and restarts events on // the current field. Only Trogedit UndoState's have a fieldHashCode so // use that to distinguish between Trogedit and other states. var state = command == goog.editor.plugins.UndoRedo.COMMAND.UNDO ? this.undoManager_.undoPeek() : this.undoManager_.redoPeek(); if (state && state.fieldHashCode) { this.getCurrentFieldObject().execCommand(command); } else { this.execCommand(command); } return true; } } return false; }; /** * Clear the undo/redo stack. */ goog.editor.plugins.UndoRedo.prototype.clearHistory = function() { // Fire all pending change events, so that they don't come back // asynchronously to fill the queue. this.fieldObject.stopChangeEvents(true, true); this.undoManager_.clearHistory(); this.fieldObject.startChangeEvents(); }; /** * Refreshes the current state of the editable field as maintained by undo-redo, * without adding any undo-redo states to the stack. * @param {goog.editor.Field} fieldObject The editable field. */ goog.editor.plugins.UndoRedo.prototype.refreshCurrentState = function( fieldObject) { if (this.isEnabled(fieldObject)) { if (this.currentStates_[fieldObject.getHashCode()]) { delete this.currentStates_[fieldObject.getHashCode()]; } this.updateCurrentState_(fieldObject); } }; /** * Before the field changes, we want to save the state. * @param {goog.events.Event} e The event. * @private */ goog.editor.plugins.UndoRedo.prototype.handleBeforeChange_ = function(e) { if (this.inProgressUndo_) { // We are in between a previous undo and it's delayed change event. // Continuing here clobbers the redo stack. // This does mean that if you are trying to undo/redo really quickly, it // will be gated by the speed of delayed change events. return; } var fieldObj = /** @type {goog.editor.Field} */ (e.target); var fieldHashCode = fieldObj.getHashCode(); if (this.initialFieldChange_ != fieldHashCode) { this.initialFieldChange_ = fieldHashCode; this.updateCurrentState_(fieldObj); } }; /** * After some idle time, we want to save the state. * @param {goog.events.Event} e The event. * @private */ goog.editor.plugins.UndoRedo.prototype.handleDelayedChange_ = function(e) { // This was undo making a change, don't add it BACK into the history if (this.inProgressUndo_) { // Must clear this.inProgressUndo_ before dispatching event because the // dispatch can cause another, queued undo that should be allowed to go // through. var state = this.inProgressUndo_; this.inProgressUndo_ = null; state.dispatchEvent(goog.editor.plugins.UndoRedoState.ACTION_COMPLETED); return; } this.updateCurrentState_(/** @type {goog.editor.Field} */ (e.target)); }; /** * When the user blurs away, we need to save the state on that field. * @param {goog.events.Event} e The event. * @private */ goog.editor.plugins.UndoRedo.prototype.handleBlur_ = function(e) { var fieldObj = /** @type {goog.editor.Field} */ (e.target); if (fieldObj) { fieldObj.clearDelayedChange(); } }; /** * Returns the goog.editor.plugins.UndoRedo.CursorPosition_ for the current * selection in the given Field. * @param {goog.editor.Field} fieldObj The field object. * @return {goog.editor.plugins.UndoRedo.CursorPosition_} The CursorPosition_ or * null if there is no valid selection. * @private */ goog.editor.plugins.UndoRedo.prototype.getCursorPosition_ = function(fieldObj) { var cursorPos = new goog.editor.plugins.UndoRedo.CursorPosition_(fieldObj); if (!cursorPos.isValid()) { return null; } return cursorPos; }; /** * Helper method for saving state. * @param {goog.editor.Field} fieldObj The field object. * @private */ goog.editor.plugins.UndoRedo.prototype.updateCurrentState_ = function( fieldObj) { var fieldHashCode = fieldObj.getHashCode(); // We specifically grab the raw innerHTML of the field here as that's what // we would set on the field in the case of an undo/redo operation. There's // no need to clean/unclean the contents in either direction. In the case of // lorem ipsum being used, we want to capture the effective state (empty, no // cursor position) rather than capturing the lorem html. var content, cursorPos; if (fieldObj.queryCommandValue(goog.editor.Command.USING_LOREM)) { content = ''; cursorPos = null; } else { content = fieldObj.getElement().innerHTML; cursorPos = this.getCursorPosition_(fieldObj); } var currentState = this.currentStates_[fieldHashCode]; if (currentState) { // Don't create states if the content hasn't changed (spurious // delayed change). This can happen when lorem is cleared, for example. if (currentState.undoContent_ == content) { return; } else if (content == '' || currentState.undoContent_ == '') { // If lorem ipsum is on we say the contents are the empty string. However, // for an empty text shape with focus, the empty contents might not be // the same, depending on plugins. We want these two empty states to be // considered identical because to the user they are indistinguishable, // so we use fieldObj.getInjectableContents to map between them. // We cannot use getInjectableContents when first creating the undo // content for a field with lorem, because on enable when this is first // called we can't guarantee plugin registration order, so the // injectableContents at that time might not match the final // injectableContents. var emptyContents = fieldObj.getInjectableContents('', {}); if (content == emptyContents && currentState.undoContent_ == '' || currentState.undoContent_ == emptyContents && content == '') { return; } } currentState.setRedoState(content, cursorPos); this.undoManager_.addState(currentState); } this.currentStates_[fieldHashCode] = new goog.editor.plugins.UndoRedo.UndoState_(fieldHashCode, content, cursorPos, this.boundRestoreState_); }; /** * This object encapsulates the state of an editable field. * * @param {string} fieldHashCode String the id of the field we're saving the * content of. * @param {string} content String the actual text we're saving. * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition * CursorPosLite object for the cursor position in the field. * @param {Function} restore The function used to restore editable field state. * @private * @constructor * @extends {goog.editor.plugins.UndoRedoState} */ goog.editor.plugins.UndoRedo.UndoState_ = function(fieldHashCode, content, cursorPosition, restore) { goog.editor.plugins.UndoRedoState.call(this, true); /** * The hash code for the field whose content is being saved. * @type {string} */ this.fieldHashCode = fieldHashCode; /** * The bound copy of {@code goog.editor.plugins.UndoRedo.restoreState} used by * this state. * @type {Function} * @private */ this.restore_ = restore; this.setUndoState(content, cursorPosition); }; goog.inherits(goog.editor.plugins.UndoRedo.UndoState_, goog.editor.plugins.UndoRedoState); /** * The content to restore on undo. * @type {string} * @private */ goog.editor.plugins.UndoRedo.UndoState_.prototype.undoContent_; /** * The cursor position to restore on undo. * @type {goog.editor.plugins.UndoRedo.CursorPosition_?} * @private */ goog.editor.plugins.UndoRedo.UndoState_.prototype.undoCursorPosition_; /** * The content to restore on redo, undefined until the state is pushed onto the * undo stack. * @type {string|undefined} * @private */ goog.editor.plugins.UndoRedo.UndoState_.prototype.redoContent_; /** * The cursor position to restore on redo, undefined until the state is pushed * onto the undo stack. * @type {goog.editor.plugins.UndoRedo.CursorPosition_|null|undefined} * @private */ goog.editor.plugins.UndoRedo.UndoState_.prototype.redoCursorPosition_; /** * Performs the undo operation represented by this state. */ goog.editor.plugins.UndoRedo.UndoState_.prototype.undo = function() { this.restore_(this, this.undoContent_, this.undoCursorPosition_); }; /** * Performs the redo operation represented by this state. */ goog.editor.plugins.UndoRedo.UndoState_.prototype.redo = function() { this.restore_(this, this.redoContent_, this.redoCursorPosition_); }; /** * Updates the undo portion of this state. Should only be used to update the * current state of an editable field, which is not yet on the undo stack after * an undo or redo operation. You should never be modifying states on the stack! * @param {string} content The current content. * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition * The current cursor position. */ goog.editor.plugins.UndoRedo.UndoState_.prototype.setUndoState = function( content, cursorPosition) { this.undoContent_ = content; this.undoCursorPosition_ = cursorPosition; }; /** * Adds redo information to this state. This method should be called before the * state is added onto the undo stack. * * @param {string} content The content to restore on a redo. * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition * The cursor position to restore on a redo. */ goog.editor.plugins.UndoRedo.UndoState_.prototype.setRedoState = function( content, cursorPosition) { this.redoContent_ = content; this.redoCursorPosition_ = cursorPosition; }; /** * Checks if the *contents* of two * {@code goog.editor.plugins.UndoRedo.UndoState_}s are the same. We don't * bother checking the cursor position (that's not something we'd want to save * anyway). * @param {goog.editor.plugins.UndoRedo.UndoState_} rhs The state to compare. * @return {boolean} Whether the contents are the same. */ goog.editor.plugins.UndoRedo.UndoState_.prototype.equals = function(rhs) { return this.fieldHashCode == rhs.fieldHashCode && this.undoContent_ == rhs.undoContent_ && this.redoContent_ == rhs.redoContent_; }; /** * Stores the state of the selection in a way the survives DOM modifications * that don't modify the user-interactable content (e.g. making something bold * vs. typing a character). * * TODO: Completely get rid of this and use goog.dom.SavedCaretRange. * * @param {goog.editor.Field} field The field the selection is in. * @private * @constructor */ goog.editor.plugins.UndoRedo.CursorPosition_ = function(field) { this.field_ = field; var win = field.getEditableDomHelper().getWindow(); var range = field.getRange(); var isValidRange = !!range && range.isRangeInDocument() && range.getWindow() == win; range = isValidRange ? range : null; if (goog.editor.BrowserFeature.HAS_W3C_RANGES) { this.initW3C_(range); } else if (goog.editor.BrowserFeature.HAS_IE_RANGES) { this.initIE_(range); } }; /** * The standards compliant version keeps a list of childNode offsets. * @param {goog.dom.AbstractRange?} range The range to save. * @private */ goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initW3C_ = function( range) { this.isValid_ = false; // TODO: Check if the range is in the field before trying to save it // for FF 3 contentEditable. if (!range) { return; } var anchorNode = range.getAnchorNode(); var focusNode = range.getFocusNode(); if (!anchorNode || !focusNode) { return; } var anchorOffset = range.getAnchorOffset(); var anchor = new goog.dom.NodeOffset(anchorNode, this.field_.getElement()); var focusOffset = range.getFocusOffset(); var focus = new goog.dom.NodeOffset(focusNode, this.field_.getElement()); // Test range direction. if (range.isReversed()) { this.startOffset_ = focus; this.startChildOffset_ = focusOffset; this.endOffset_ = anchor; this.endChildOffset_ = anchorOffset; } else { this.startOffset_ = anchor; this.startChildOffset_ = anchorOffset; this.endOffset_ = focus; this.endChildOffset_ = focusOffset; } this.isValid_ = true; }; /** * In IE, we just keep track of the text offset (number of characters). * @param {goog.dom.AbstractRange?} range The range to save. * @private */ goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initIE_ = function( range) { this.isValid_ = false; if (!range) { return; } var ieRange = range.getTextRange(0).getBrowserRangeObject(); if (!goog.dom.contains(this.field_.getElement(), ieRange.parentElement())) { return; } // Create a range that encompasses the contentEditable region to serve // as a reference to form ranges below. var contentEditableRange = this.field_.getEditableDomHelper().getDocument().body.createTextRange(); contentEditableRange.moveToElementText(this.field_.getElement()); // startMarker is a range from the start of the contentEditable node to the // start of the current selection. var startMarker = ieRange.duplicate(); startMarker.collapse(true); startMarker.setEndPoint('StartToStart', contentEditableRange); this.startOffset_ = goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_( startMarker); // endMarker is a range from the start of teh contentEditable node to the // end of the current selection. var endMarker = ieRange.duplicate(); endMarker.setEndPoint('StartToStart', contentEditableRange); this.endOffset_ = goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_( endMarker); this.isValid_ = true; }; /** * @return {boolean} Whether this object is valid. */ goog.editor.plugins.UndoRedo.CursorPosition_.prototype.isValid = function() { return this.isValid_; }; /** * @return {string} A string representation of this object. */ goog.editor.plugins.UndoRedo.CursorPosition_.prototype.toString = function() { if (goog.editor.BrowserFeature.HAS_W3C_RANGES) { return 'W3C:' + this.startOffset_.toString() + '\n' + this.startChildOffset_ + ':' + this.endOffset_.toString() + '\n' + this.endChildOffset_; } return 'IE:' + this.startOffset_ + ',' + this.endOffset_; }; /** * Makes the browser's selection match the cursor position. */ goog.editor.plugins.UndoRedo.CursorPosition_.prototype.select = function() { var range = this.getRange_(this.field_.getElement()); if (range) { if (goog.editor.BrowserFeature.HAS_IE_RANGES) { this.field_.getElement().focus(); } goog.dom.Range.createFromBrowserRange(range).select(); } }; /** * Get the range that encompases the the cursor position relative to a given * base node. * @param {Element} baseNode The node to get the cursor position relative to. * @return {Range|TextRange|null} The browser range for this position. * @private */ goog.editor.plugins.UndoRedo.CursorPosition_.prototype.getRange_ = function(baseNode) { if (goog.editor.BrowserFeature.HAS_W3C_RANGES) { var startNode = this.startOffset_.findTargetNode(baseNode); var endNode = this.endOffset_.findTargetNode(baseNode); if (!startNode || !endNode) { return null; } // Create range. return /** @type {Range} */ ( goog.dom.Range.createFromNodes(startNode, this.startChildOffset_, endNode, this.endChildOffset_).getBrowserRangeObject()); } // Create a collapsed selection at the start of the contentEditable region, // which the offsets were calculated relative to before. Note that we force // a text range here so we can use moveToElementText. var sel = baseNode.ownerDocument.body.createTextRange() sel.moveToElementText(baseNode); sel.collapse(true); sel.moveEnd('character', this.endOffset_); sel.moveStart('character', this.startOffset_); return sel; }; /** * Compute the number of characters to the end of the range in IE. * @param {TextRange} range The range to compute an offset for. * @return {number} The number of characters to the end of the range. * @private */ goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_ = function(range) { var testRange = range.duplicate(); // The number of offset characters is a little off depending on // what type of block elements happen to be between the start of the // textedit and the cursor position. We fudge the offset until the // two ranges match. var text = range.text; var guess = text.length; testRange.collapse(true); testRange.moveEnd('character', guess); // Adjust the range until the end points match. This doesn't quite // work if we're at the end of the field so we give up after a few // iterations. var diff; var numTries = 10; while (diff = testRange.compareEndPoints('EndToEnd', range)) { guess -= diff; testRange.moveEnd('character', -diff); --numTries; if (0 == numTries) { break; } } // When we set innerHTML, blank lines become a single space, causing // the cursor position to be off by one. So we accommodate for blank // lines. var offset = 0; var pos = text.indexOf('\n\r'); while (pos != -1) { ++offset; pos = text.indexOf('\n\r', pos + 1); } return guess + offset; };


Original title:
(Contains 0% real Moufang Loops.)
Actual topic:
by Henry Strickland, 2016, for G4G12
Main web page: http://wiki.yak.net/1093
Instead of taking whole number steps from START to FINISH, our board positions are trigintaduonion numbers, and we multiply (instead of add) steps to get from 1 to FINISH.
num num num
real imagimary total
dims dims dims Name
---- ---- ---- -----------------
1 0 1 Real Numbers
1 1 2 Complex Numbers
1 3 4 Quaternions
1 7 8 Octonions
1 15 16 Sedenions
1 31 32 Trigintaduonions
1 (2^n)-1 2^n ...etc...
1 Real Number:
1
2 Complex Numbers:
1 a ( We use "a" instead of "i". )
4 Quaternions:
1, a, b, ab ( Instead of "i", "j", & "k". )
8 Octonions:
1, a, b, ab, c, ac, bc, abc
16 Sedenions:
1, a, b, ab, c, ac, bc, abc,
d, ad, bd, abd, cd, acd, bcd, abcd
32 Trigintaduonions:
1, a, b, ab, c, ac, bc, abc,
d, ad, bd, abd, cd, acd, bcd, abcd,
e, ae, be, abe, ce, ace, bce, abce,
de, ade, bde, abde, cde, acde, bcde, abcde
From here on, we only use the Trigintaduonion Bases (and their negatives) for multiplication.
But it would apply generally to any hyper-complex system.
Multiplication is defined by the usual Cayley-Dickson Construction (see Wikipedia or “The Octonions” by John C. Baez [2001].)
Canonically we write our imaginary bases with letters:
Some are a single letter: they are like primary bases.
Some are multi-letter. They are independant imaginary bases, but they are also the product of 2 or more single-letter bases.
Our convention: Multiply Left-to-Right: “abcde” means “(((ab)c)d)e”
The set of 32 bases and their 32 negatives is closed under multiplication.
Multiplying by 1 and -1 work as we want (on left or right). Two -1’s cancel.
Multiplying any basis (except 1) by itself gives -1 (that is, the letter bases are all imaginary).
As you discovered in the Solitaire Game.
But it only works for a single-letter multiplier!
Examples:
acx(b) = a (b) -c -x = --abcx = abcx
To alphabetize, the (b) jumps over x and then c, producing a minus each time.
acx(c) = a c(c) -x = a (-) -x = --ax = ax
To alphabetize, the (c) jumps over x, producing a minus. Then it annihilates with the other c, producing a second minus.
You end up with the product in canonical form: alphabetized and no duplicates.
Jump the multiplier over letters from right to left, until it is in alphabetical order, adding a minus sign every time you leap.
Then repeated letters annihilate and become a minus sign.
(Related to index-cycling & index-doubling, but different.)
Suppose you already know
abc(ac) = -b
but you now want to know what is
bde(be) = ?
You can reassign letters (introduce or remove gaps) with lines from old to new letters, but do not cross the lines!
a b c d e abc(ac) = -b
\ \ \ ||| || |
| \ \ ||| || |
| \ \ ||| || |
a b c d e bde(be) = -d
If you cross the lines, you might prove that “ab = ba” which is wrong!
Below is a Twist Table for multiplying trigintaduonion bases: it’s gray if the product is negative.
Below that is another Twist Table, for fixing “Dissociations”: it’s gray if the dissociation is the negative of the product.
The second Twist Table looks simpler than the first, so we prefer to use it instead.
Dissociating is my name for removing parentheses. Remember that multiplication is not associative, so this can change the result, so we have to fix it later.
Say you want to multiply bcd by de. Drop the parentheses, and use the Annihilating Leapfrog technique to absorb these extra letters and canonicalize the result:
bce(de)
bce d e ; dissociate d & e
-bcde e ; leapfrog the d (producing a minus)
-bcd(-) ; annihilate the e (producing another minus)
bcd ; cancel the minuses
However this is not the final answer, because dissociating is not safe.
But we can look up the entry for “bcd” & “de” in the Dissociating Twist Table, and we get -1. So we multiply the entire result by it:
(-1) bcd = -bcd
and that will be correct.
The Advanced Card Deck for the Game uses this technique to multiply by multi-letter bases, without the full complexity of the Multiplication Twist Table.
| 1 | a | b | ab | c | ac | bc | abc | d | ad | bd | abd | cd | acd | bcd | abcd | e | ae | be | abe | ce | ace | bce | abce | de | ade | bde | abde | cde | acde | bcde | abcde |
| a | -1 | ab | -b | ac | -c | -abc | bc | ad | -d | -abd | bd | -acd | cd | abcd | -bcd | ae | -e | -abe | be | -ace | ce | abce | -bce | -ade | de | abde | -bde | acde | -cde | -abcde | bcde |
| b | -ab | -1 | a | bc | abc | -c | -ac | bd | abd | -d | -ad | -bcd | -abcd | cd | acd | be | abe | -e | -ae | -bce | -abce | ce | ace | -bde | -abde | de | ade | bcde | abcde | -cde | -acde |
| ab | b | -a | -1 | abc | -bc | ac | -c | abd | -bd | ad | -d | -abcd | bcd | -acd | cd | abe | -be | ae | -e | -abce | bce | -ace | ce | -abde | bde | -ade | de | abcde | -bcde | acde | -cde |
| c | -ac | -bc | -abc | -1 | a | b | ab | cd | acd | bcd | abcd | -d | -ad | -bd | -abd | ce | ace | bce | abce | -e | -ae | -be | -abe | -cde | -acde | -bcde | -abcde | de | ade | bde | abde |
| ac | c | -abc | bc | -a | -1 | -ab | b | acd | -cd | abcd | -bcd | ad | -d | abd | -bd | ace | -ce | abce | -bce | ae | -e | abe | -be | -acde | cde | -abcde | bcde | -ade | de | -abde | bde |
| bc | abc | c | -ac | -b | ab | -1 | -a | bcd | -abcd | -cd | acd | bd | -abd | -d | ad | bce | -abce | -ce | ace | be | -abe | -e | ae | -bcde | abcde | cde | -acde | -bde | abde | de | -ade |
| abc | -bc | ac | c | -ab | -b | a | -1 | abcd | bcd | -acd | -cd | abd | bd | -ad | -d | abce | bce | -ace | -ce | abe | be | -ae | -e | -abcde | -bcde | acde | cde | -abde | -bde | ade | de |
| d | -ad | -bd | -abd | -cd | -acd | -bcd | -abcd | -1 | a | b | ab | c | ac | bc | abc | de | ade | bde | abde | cde | acde | bcde | abcde | -e | -ae | -be | -abe | -ce | -ace | -bce | -abce |
| ad | d | -abd | bd | -acd | cd | abcd | -bcd | -a | -1 | -ab | b | -ac | c | abc | -bc | ade | -de | abde | -bde | acde | -cde | -abcde | bcde | ae | -e | abe | -be | ace | -ce | -abce | bce |
| bd | abd | d | -ad | -bcd | -abcd | cd | acd | -b | ab | -1 | -a | -bc | -abc | c | ac | bde | -abde | -de | ade | bcde | abcde | -cde | -acde | be | -abe | -e | ae | bce | abce | -ce | -ace |
| abd | -bd | ad | d | -abcd | bcd | -acd | cd | -ab | -b | a | -1 | -abc | bc | -ac | c | abde | bde | -ade | -de | abcde | -bcde | acde | -cde | abe | be | -ae | -e | abce | -bce | ace | -ce |
| cd | acd | bcd | abcd | d | -ad | -bd | -abd | -c | ac | bc | abc | -1 | -a | -b | -ab | cde | -acde | -bcde | -abcde | -de | ade | bde | abde | ce | -ace | -bce | -abce | -e | ae | be | abe |
| acd | -cd | abcd | -bcd | ad | d | abd | -bd | -ac | -c | abc | -bc | a | -1 | ab | -b | acde | cde | -abcde | bcde | -ade | -de | -abde | bde | ace | ce | -abce | bce | -ae | -e | -abe | be |
| bcd | -abcd | -cd | acd | bd | -abd | d | ad | -bc | -abc | -c | ac | b | -ab | -1 | a | bcde | abcde | cde | -acde | -bde | abde | -de | -ade | bce | abce | ce | -ace | -be | abe | -e | -ae |
| abcd | bcd | -acd | -cd | abd | bd | -ad | d | -abc | bc | -ac | -c | ab | b | -a | -1 | abcde | -bcde | acde | cde | -abde | -bde | ade | -de | abce | -bce | ace | ce | -abe | -be | ae | -e |
| e | -ae | -be | -abe | -ce | -ace | -bce | -abce | -de | -ade | -bde | -abde | -cde | -acde | -bcde | -abcde | -1 | a | b | ab | c | ac | bc | abc | d | ad | bd | abd | cd | acd | bcd | abcd |
| ae | e | -abe | be | -ace | ce | abce | -bce | -ade | de | abde | -bde | acde | -cde | -abcde | bcde | -a | -1 | -ab | b | -ac | c | abc | -bc | -ad | d | abd | -bd | acd | -cd | -abcd | bcd |
| be | abe | e | -ae | -bce | -abce | ce | ace | -bde | -abde | de | ade | bcde | abcde | -cde | -acde | -b | ab | -1 | -a | -bc | -abc | c | ac | -bd | -abd | d | ad | bcd | abcd | -cd | -acd |
| abe | -be | ae | e | -abce | bce | -ace | ce | -abde | bde | -ade | de | abcde | -bcde | acde | -cde | -ab | -b | a | -1 | -abc | bc | -ac | c | -abd | bd | -ad | d | abcd | -bcd | acd | -cd |
| ce | ace | bce | abce | e | -ae | -be | -abe | -cde | -acde | -bcde | -abcde | de | ade | bde | abde | -c | ac | bc | abc | -1 | -a | -b | -ab | -cd | -acd | -bcd | -abcd | d | ad | bd | abd |
| ace | -ce | abce | -bce | ae | e | abe | -be | -acde | cde | -abcde | bcde | -ade | de | -abde | bde | -ac | -c | abc | -bc | a | -1 | ab | -b | -acd | cd | -abcd | bcd | -ad | d | -abd | bd |
| bce | -abce | -ce | ace | be | -abe | e | ae | -bcde | abcde | cde | -acde | -bde | abde | de | -ade | -bc | -abc | -c | ac | b | -ab | -1 | a | -bcd | abcd | cd | -acd | -bd | abd | d | -ad |
| abce | bce | -ace | -ce | abe | be | -ae | e | -abcde | -bcde | acde | cde | -abde | -bde | ade | de | -abc | bc | -ac | -c | ab | b | -a | -1 | -abcd | -bcd | acd | cd | -abd | -bd | ad | d |
| de | ade | bde | abde | cde | acde | bcde | abcde | e | -ae | -be | -abe | -ce | -ace | -bce | -abce | -d | ad | bd | abd | cd | acd | bcd | abcd | -1 | -a | -b | -ab | -c | -ac | -bc | -abc |
| ade | -de | abde | -bde | acde | -cde | -abcde | bcde | ae | e | abe | -be | ace | -ce | -abce | bce | -ad | -d | abd | -bd | acd | -cd | -abcd | bcd | a | -1 | ab | -b | ac | -c | -abc | bc |
| bde | -abde | -de | ade | bcde | abcde | -cde | -acde | be | -abe | e | ae | bce | abce | -ce | -ace | -bd | -abd | -d | ad | bcd | abcd | -cd | -acd | b | -ab | -1 | a | bc | abc | -c | -ac |
| abde | bde | -ade | -de | abcde | -bcde | acde | -cde | abe | be | -ae | e | abce | -bce | ace | -ce | -abd | bd | -ad | -d | abcd | -bcd | acd | -cd | ab | b | -a | -1 | abc | -bc | ac | -c |
| cde | -acde | -bcde | -abcde | -de | ade | bde | abde | ce | -ace | -bce | -abce | e | ae | be | abe | -cd | -acd | -bcd | -abcd | -d | ad | bd | abd | c | -ac | -bc | -abc | -1 | a | b | ab |
| acde | cde | -abcde | bcde | -ade | -de | -abde | bde | ace | ce | -abce | bce | -ae | e | -abe | be | -acd | cd | -abcd | bcd | -ad | -d | -abd | bd | ac | c | -abc | bc | -a | -1 | -ab | b |
| bcde | abcde | cde | -acde | -bde | abde | -de | -ade | bce | abce | ce | -ace | -be | abe | e | -ae | -bcd | abcd | cd | -acd | -bd | abd | -d | -ad | bc | abc | c | -ac | -b | ab | -1 | -a |
| abcde | -bcde | acde | cde | -abde | -bde | ade | -de | abce | -bce | ace | ce | -abe | -be | ae | e | -abcd | -bcd | acd | cd | -abd | -bd | ad | -d | abc | -bc | ac | c | -ab | -b | a | -1 |
| 1 | a | b | ab | c | ac | bc | abc | d | ad | bd | abd | cd | acd | bcd | abcd | e | ae | be | abe | ce | ace | bce | abce | de | ade | bde | abde | cde | acde | bcde | abcde |
| a | -1 | ab | -b | ac | -c | -abc | bc | ad | -d | -abd | bd | -acd | cd | abcd | -bcd | ae | -e | -abe | be | -ace | ce | abce | -bce | -ade | de | abde | -bde | acde | -cde | -abcde | bcde |
| b | -ab | -1 | a | bc | abc | -c | -ac | bd | abd | -d | -ad | -bcd | -abcd | cd | acd | be | abe | -e | -ae | -bce | -abce | ce | ace | -bde | -abde | de | ade | bcde | abcde | -cde | -acde |
| ab | b | -a | -1 | abc | -bc | ac | -c | abd | -bd | ad | -d | -abcd | bcd | -acd | cd | abe | -be | ae | -e | -abce | bce | -ace | ce | -abde | bde | -ade | de | abcde | -bcde | acde | -cde |
| c | -ac | -bc | -abc | -1 | a | b | ab | cd | acd | bcd | abcd | -d | -ad | -bd | -abd | ce | ace | bce | abce | -e | -ae | -be | -abe | -cde | -acde | -bcde | -abcde | de | ade | bde | abde |
| ac | c | -abc | bc | -a | -1 | -ab | b | acd | -cd | abcd | -bcd | ad | -d | abd | -bd | ace | -ce | abce | -bce | ae | -e | abe | -be | -acde | cde | -abcde | bcde | -ade | de | -abde | bde |
| bc | abc | c | -ac | -b | ab | -1 | -a | bcd | -abcd | -cd | acd | bd | -abd | -d | ad | bce | -abce | -ce | ace | be | -abe | -e | ae | -bcde | abcde | cde | -acde | -bde | abde | de | -ade |
| abc | -bc | ac | c | -ab | -b | a | -1 | abcd | bcd | -acd | -cd | abd | bd | -ad | -d | abce | bce | -ace | -ce | abe | be | -ae | -e | -abcde | -bcde | acde | cde | -abde | -bde | ade | de |
| d | -ad | -bd | -abd | -cd | -acd | -bcd | -abcd | -1 | a | b | ab | c | ac | bc | abc | de | ade | bde | abde | cde | acde | bcde | abcde | -e | -ae | -be | -abe | -ce | -ace | -bce | -abce |
| ad | d | -abd | bd | -acd | cd | abcd | -bcd | -a | -1 | -ab | b | -ac | c | abc | -bc | ade | -de | abde | -bde | acde | -cde | -abcde | bcde | ae | -e | abe | -be | ace | -ce | -abce | bce |
| bd | abd | d | -ad | -bcd | -abcd | cd | acd | -b | ab | -1 | -a | -bc | -abc | c | ac | bde | -abde | -de | ade | bcde | abcde | -cde | -acde | be | -abe | -e | ae | bce | abce | -ce | -ace |
| abd | -bd | ad | d | -abcd | bcd | -acd | cd | -ab | -b | a | -1 | -abc | bc | -ac | c | abde | bde | -ade | -de | abcde | -bcde | acde | -cde | abe | be | -ae | -e | abce | -bce | ace | -ce |
| cd | acd | bcd | abcd | d | -ad | -bd | -abd | -c | ac | bc | abc | -1 | -a | -b | -ab | cde | -acde | -bcde | -abcde | -de | ade | bde | abde | ce | -ace | -bce | -abce | -e | ae | be | abe |
| acd | -cd | abcd | -bcd | ad | d | abd | -bd | -ac | -c | abc | -bc | a | -1 | ab | -b | acde | cde | -abcde | bcde | -ade | -de | -abde | bde | ace | ce | -abce | bce | -ae | -e | -abe | be |
| bcd | -abcd | -cd | acd | bd | -abd | d | ad | -bc | -abc | -c | ac | b | -ab | -1 | a | bcde | abcde | cde | -acde | -bde | abde | -de | -ade | bce | abce | ce | -ace | -be | abe | -e | -ae |
| abcd | bcd | -acd | -cd | abd | bd | -ad | d | -abc | bc | -ac | -c | ab | b | -a | -1 | abcde | -bcde | acde | cde | -abde | -bde | ade | -de | abce | -bce | ace | ce | -abe | -be | ae | -e |
| e | -ae | -be | -abe | -ce | -ace | -bce | -abce | -de | -ade | -bde | -abde | -cde | -acde | -bcde | -abcde | -1 | a | b | ab | c | ac | bc | abc | d | ad | bd | abd | cd | acd | bcd | abcd |
| ae | e | -abe | be | -ace | ce | abce | -bce | -ade | de | abde | -bde | acde | -cde | -abcde | bcde | -a | -1 | -ab | b | -ac | c | abc | -bc | -ad | d | abd | -bd | acd | -cd | -abcd | bcd |
| be | abe | e | -ae | -bce | -abce | ce | ace | -bde | -abde | de | ade | bcde | abcde | -cde | -acde | -b | ab | -1 | -a | -bc | -abc | c | ac | -bd | -abd | d | ad | bcd | abcd | -cd | -acd |
| abe | -be | ae | e | -abce | bce | -ace | ce | -abde | bde | -ade | de | abcde | -bcde | acde | -cde | -ab | -b | a | -1 | -abc | bc | -ac | c | -abd | bd | -ad | d | abcd | -bcd | acd | -cd |
| ce | ace | bce | abce | e | -ae | -be | -abe | -cde | -acde | -bcde | -abcde | de | ade | bde | abde | -c | ac | bc | abc | -1 | -a | -b | -ab | -cd | -acd | -bcd | -abcd | d | ad | bd | abd |
| ace | -ce | abce | -bce | ae | e | abe | -be | -acde | cde | -abcde | bcde | -ade | de | -abde | bde | -ac | -c | abc | -bc | a | -1 | ab | -b | -acd | cd | -abcd | bcd | -ad | d | -abd | bd |
| bce | -abce | -ce | ace | be | -abe | e | ae | -bcde | abcde | cde | -acde | -bde | abde | de | -ade | -bc | -abc | -c | ac | b | -ab | -1 | a | -bcd | abcd | cd | -acd | -bd | abd | d | -ad |
| abce | bce | -ace | -ce | abe | be | -ae | e | -abcde | -bcde | acde | cde | -abde | -bde | ade | de | -abc | bc | -ac | -c | ab | b | -a | -1 | -abcd | -bcd | acd | cd | -abd | -bd | ad | d |
| de | ade | bde | abde | cde | acde | bcde | abcde | e | -ae | -be | -abe | -ce | -ace | -bce | -abce | -d | ad | bd | abd | cd | acd | bcd | abcd | -1 | -a | -b | -ab | -c | -ac | -bc | -abc |
| ade | -de | abde | -bde | acde | -cde | -abcde | bcde | ae | e | abe | -be | ace | -ce | -abce | bce | -ad | -d | abd | -bd | acd | -cd | -abcd | bcd | a | -1 | ab | -b | ac | -c | -abc | bc |
| bde | -abde | -de | ade | bcde | abcde | -cde | -acde | be | -abe | e | ae | bce | abce | -ce | -ace | -bd | -abd | -d | ad | bcd | abcd | -cd | -acd | b | -ab | -1 | a | bc | abc | -c | -ac |
| abde | bde | -ade | -de | abcde | -bcde | acde | -cde | abe | be | -ae | e | abce | -bce | ace | -ce | -abd | bd | -ad | -d | abcd | -bcd | acd | -cd | ab | b | -a | -1 | abc | -bc | ac | -c |
| cde | -acde | -bcde | -abcde | -de | ade | bde | abde | ce | -ace | -bce | -abce | e | ae | be | abe | -cd | -acd | -bcd | -abcd | -d | ad | bd | abd | c | -ac | -bc | -abc | -1 | a | b | ab |
| acde | cde | -abcde | bcde | -ade | -de | -abde | bde | ace | ce | -abce | bce | -ae | e | -abe | be | -acd | cd | -abcd | bcd | -ad | -d | -abd | bd | ac | c | -abc | bc | -a | -1 | -ab | b |
| bcde | abcde | cde | -acde | -bde | abde | -de | -ade | bce | abce | ce | -ace | -be | abe | e | -ae | -bcd | abcd | cd | -acd | -bd | abd | -d | -ad | bc | abc | c | -ac | -b | ab | -1 | -a |
| abcde | -bcde | acde | cde | -abde | -bde | ade | -de | abce | -bce | ace | ce | -abe | -be | ae | e | -abcd | -bcd | acd | cd | -abd | -bd | ad | -d | abc | -bc | ac | c | -ab | -b | a | -1 |


Options
Start
Stop
Randomize
Clear
Center
Next Step
Cell Color
+
0
1
2
Write color
Turn direction
Next ant state
Write color
Turn direction
Next ant state
Write color
Turn direction
Next ant state
Ant state
0
1
L
1
1
1
1
L
1
1
Set Rule
Random Rule


--- title: "Infinite loading" description: |
Infinite loading progress bars provide to the user the idea that an action is under execution.
Using the h-animation--[type]
helper class on an
evo_c-progress-bar__bar
element, you can change the animation.
The available animation for the standard progress bars are:
The available animation for the non standard progress (type2, type3,
45, 90, 135
) bars is:


AVAILABLE BUS
RURAL BUS NO. 7070
Iligan - Laguindingan
Departure Time: 7:00 AM
RURAL BUS NO. 8080
Iligan - Cagayan
Departure Time: 12:00 PM
RURAL BUS NO. 9090
Cagayan - Laguindingan
Departure Time: 3:00 PM
RURAL BUS NO. 1010
Cagayan - Iligan
Departure Time: 6:00 PM
Make Reservation


{% extends 'base.html' %} {% load static %}
Virus Baba is an Application which Enables the Impossible to Test 1.3 Billion Indians possible. This application Promotes Social Distancing and Testin of COVID-19 with ease.
Application Developed by: Nilesh .D. Ohol
Email ID<EMAIL_ADDRESS>If you dont have an Account Click on SignUp.
Click on the Marker to see the Information about the Blood Donation..
Application Developed by: Nilesh Ohol.


Add Admin
Username:
Email Address:
Password:
Add User
Change Password
Username:
New Password:
Change Password
Remove User
Username:
Remove User
Search User
Username:
Search


This pilot tool is intended to help users determine if GBIF mediated data is likely to be suitable for deriving species population trends. The tool allows a user to navigate to a location and timespan of interest, and then it provides an analysis showing if the population for the species is in decline or increase. This analysis involves normalizing the data for the species against all data collected for the group (Lepidoptera). By normalizing against the group, the analysis attempts to compensate for biases in sampling effort. In many cases this will work well, but in other cases this may provide misleading insights – however, by providing a transparent view of the process, the user can judge if there appears to be sufficient data to investigate further.
To explain the algorithm, please consider the following:
1968
4 Early Thorn occurrences out of a total of 12 Lepidoptera
33.33% of the total population
2002
3 Early Thorn occurrences out of a total of 6 Lepidoptera
50% of the total population
Linear regression
Find the line that best describes the data. The slope tells us how fast the species is in decline or growth. In this example it is easy as we only use two points.
The grey area shows the total amount of Lepidoptera normalized to fit the chart.
It grew from 33.33% to 50% over 34 years, so is said to be growing annually at a rate of 0.49%. The increase from 33.33% to 50% represents a 50% increase from the original value.
Trend in period from 1968 - 2002
The species is in growth relative to the total abundance of Lepidoptera. The locations on the map are colored based on the annual growth rates, to allow users to locate areas in decline or increase over the time range.
All data that is used for this application is available for download through GBIF.org.
We welcome all feedback and feature requests for this tool, as we strive towards a better understanding of what analyses are possible with the data that is openly available.
Close
✕
Species populations trends
A pilot to explore if GBIF data supports inference of population trends. Read full explanation
1
Select a species
2
Select binning
size
3
Select the minimum number of years of data required per location to be included:
4
Select area by clicking on the map or shift-dragging a bounding box.


Looks like I've got HTML
, CSS
, and JavaScript
down pat terribly quickly, so this page is my first application of the three of them together via the DOM
. DOM
is the last thing I'll need to know to start some earnest front-end Web development.
If I can make the most of this testing environment, I can move on to more advanced courses, followed by backend development. Maybe even do it professionally.

Gold! A thumb of gold, a hand of gold, an entire soul... of gold! This gold is, indeed, a sight to behold! Always believe in your golden soul, you've got the power to know, you're indestructible! Always believe in gold!
This is a test link to the dog Wikipedia page.
This line is my first test of JavaScript styling in lieu of CSS.
This line is my second test of JavaScript styling, this time assigning a CSS class to this text.
Ipsum lorem something something whatever.
This window's initial size is ??? by ??? pixels, and its url is: ???
This message will self-destruct in 20 seconds
This message changes colors.
This text is crawling and has a hover-over effect, both using only CSS.


Implements functions and instruments for regression model building and its application to forecasting. The main scope of the package is in variables selection and models specification for cases of time series data. This includes promotional modelling, selection between different dynamic regressions with non-standard distributions of errors, selection based on cross validation, solutions to the fat regression model problem and more. Models developed in the package are tailored specifically for forecasting purposes. So as a results there are several methods that allow producing forecasts from these models and visualising them.
| Version: | 0.3.3 |
| Depends: | R (≥ 3.0.2) |
| Imports: | forecast, stats, graphics, utils, lamW, numDeriv, nloptr |
| Suggests: | smooth, doMC, doParallel, foreach, testthat, rmarkdown, knitr |
| Published: | 2018-11-30 |
| Author: | Ivan Svetunkov [aut, cre] (Lecturer at Centre for Marketing Analytics and Forecasting, Lancaster University, UK) |
| Maintainer: | Ivan Svetunkov <ivan at svetunkov.ru> |
| BugReports: | https://github.com/config-i1/greybox/issues |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | https://github.com/config-i1/greybox |
| NeedsCompilation: | no |
| Language: | en-GB |
| Materials: | README NEWS |
| CRAN checks: | greybox results |
| Reference manual: | greybox.pdf |
| Vignettes: |
Greybox - Advanced Linear Model Greybox main vignette Greybox - Rolling Origin |
| Package source: | greybox_0.3.3.tar.gz |
| Windows binaries: | r-devel: greybox_0.3.3.zip, r-release: greybox_0.3.3.zip, r-oldrel: greybox_0.3.3.zip |
| OS X binaries: | r-release: greybox_0.3.3.tgz, r-oldrel: greybox_0.3.3.tgz |
| Old sources: | greybox archive |
| Reverse depends: | smooth |
Please use the canonical form https://CRAN.R-project.org/package=greybox to link to this page.


There are moments when an aspect of reality becomes clear.
There may be something you are missing...
Stop typing, Start Visaulizing.


A friendly smile and a nice cuppa tea and all this military madness would be over in an instant, says Ted Ringrose.
My head hurts. Punditry has left me a blithering jelly of angst and indecision. It is probably my own fault.  The world is significantly loopier when right-wing British columnist Taki agrees with John Pilger, and John Howard with Tony Blair.
I don't like Saddam Hussein but I do like international law, but that's no help because even the lawyers can't agree. (Maybe I shouldn't be surprised as they are paid not to agree.) Blix obfuscates, Blair fulminates, Bush belligerates and builds the biggest bomb, and all the while Baghdad brutalises. What? ``Belligerates" isn't a word? Who cares? I'm confused.
Maybe you couldn't help noticing all the Bs involved in this nasty business.  Which brings me back to Mum. When I was a kid, I would come home from being smacked around the footy field and she would run me a bath and put the kettle on. Then we would sit and chat a haven of common sense and calm. There wasn't a problem we couldn't solve.
True, many of them related to our next holiday, but we assessed a lot of people and we easily agreed on who seemed good and true and who did not. Oh, for a bath and a cuppa now and maybe another slice of that warm orange cake, please.
Maybe George could talk to his mum. Barbara seems like a nice, sensible, tea-making kind of person. Tony could talk to Mrs Blair senior, that is, not Cherie. I am not sure Cherie does tea. Saddam could even have a cup with his mum.
It has been asked before, but what if we let women have a crack at this problem? But is it really helpful to say that if women ran the world we wouldn't be in this mess in the first place? The fact remains that men are in charge and that won't change any time soon. What is also clear is that the men who are meant to look after us have cocked things up and they need some help.
No, ladies, I do not mean by protesting in the streets or taking off your clothes in the park, the latter of which must have Iraqis more than a little perplexed. The men in charge need a new way of looking at things. They need ideas. Quickly.
For some time I have been convinced that there must be a way to exploit the frighteningly immense neural capacity which, by self-choice or prejudice, has been left untapped in the search for solutions to the world's problems. Think of SETI@home, which uses internet-connected home computers, running a program disguised as a screen saver, to search for extraterrestrial intelligence.
 Let's fire it up and give it a whirl. Come on, ladies, it's over to you.
I can hear the collective hum of minds quietly working now and it sounds reassuring. And unlike men, women will be able to multi-task, to solve the world's problems while ensuring children are nourished, partners feel loved and daytime jobs are performed.
But the question is: are you up for it? Sure, you may be equal to the challenge but can you be bothered to accept it? I fear that, just as Mr Bush looks up from his Bible before pressing the big button, he will look around to see that, while Rumsfeld and Powell are rolling around fighting on the eagle-adorned carpet, Condi Rice and Mrs Bush have quietly slipped out. They will have gone off to join the world's women in one of the immense spacecraft they have been secretly constructing. Armed with a lot of chocolate and a few straws of semen, they will head off to colonise space. Goodbye, and thanks for all the lawnmowing.
Help, Mum!
In this column you are invited to apply your wit to anything that makes your blood boil. Send 750 words, with your contact details, to<EMAIL_ADDRESS>Submissions may be edited and published on the internet.


{% extends "layout.html" %} {% block page_title %} Select a charge type {% endblock %} {% block content %} alpha Which law relates to your charge? Which law relates to your charge? Legislation Start typing the legislation you are looking for and select it from the list Or browse by category Industry Infrastructure Buildings Conservation Health and safety Financial Social Environment {% endblock %}
alpha


| Path: | README |
| Last Update: | Wed Jun 03 10:11:11 -0500 2009 |
ActsAsOwned
The ActsAsOwned plugin allows for associating objects with users, verifying this association, and automatically setting the default scope to find according to the current logged in user. Note: This plugin depends on the restful_authentication plugin to access the current user.
Example
Assuming that you could some how access the current logged in user at the model level, you could write something like this for your class.
class OwnedItem < ActiveRecord::Base default_scope :conditions => {:user_id => current_user ? current_user.id : nil} belongs_to :user validates_presence_of :user validates_associated :user before_validation_on_create, Proc.new { |record| record.user = current_user } end
Some of this could also be handled in the controller. Specifically the association of the current user with the record and the scoping of the finds. However, instead of doing all of this, you could just use
class OwnedItem < ActiveRecord::Base acts_as_owned end
Short sweet and to the point.
Copyright (c) 2009 Frank Hall, released under the MIT license


0.BASH
0.BASH is a script that I have been developing for my own purposes. The most recent version is available at
Github


Wall Street opens lower as Trump, Hong Kong sour mood
U.S. stock index futures fell on Monday as President Donald Trump's comments dampened expectations around a U.S.-China trade deal, while escalating violence in Hong Kong added to investor worries.
REUTERS: U.S. stocks opened lower on Monday as comments by President Donald Trump dampened expectations around a U.S.-China trade deal, while escalating violence in Hong Kong added to investor worries.
The Dow Jones Industrial Average fell 100.58 points, or 0.36per cent, at the open to 27,580.66. The S&P 500 opened lower by 12.75 points, or 0.41per cent, at 3,080.33. The Nasdaq Composite dropped 44.05 points, or 0.52per cent, to 8,431.26 at the opening bell.
(Reporting by Sagarika Jaisinghani in Bengaluru; Editing by Anil D'Silva)


Discover Domains
Extension
Prefix
Suffix
Max Length
Max Price
Word List
10000-words-9894.txt
3000-words-3000.txt
5L-words-5757.txt
AAAA..AAAAAAAAAA-182.txt
ABB-650.txt
ABBB-650.txt
CCC-42866.txt
L-26.txt
LL-676.txt
LLL-17576.txt
most-common-1000.txt
religious-864.txt
somewhat-common-2139.txt
Large lists may take a while
Submit


As a developer, you may code in multiple languages or on different
platforms so, it is ok if you don't remember the syntax, but
having a clear concept of the topic is very important. Beginners
who are new to coding get confused when it comes to using margin
vs padding, and may not know the clear difference between the two.
In this article, we will learn about margin, border and padding.
Margin
Margin is the CSS property which defines the space outside of an
element, space between the element border and another element. If
the element does not have any border, then the margin will create
a space from element content to the next outer element.
When you want to have a different margin for each side of an
element, you will have to set the property value individually. The
order of setting value for all side goes in clockwise.
CSS has properties which will allow you to set margin for the
individual side of the element.
There is more than one way you can set the value for the margin properties.
Padding
Padding is the CSS property which defines the space between the
element content, and it's border. If the element does not have any
border, then setting padding value will not have any effect.
Just like margin, you can set the value individually if you want
different padding on each side. The order of setting value for all
side goes in clockwise.
CSS has properties which will allow you to set the padding for the
individual side of the element.
There is more than one way you can set the value for the padding properties.
Margin and padding example
Result
Border
Border properties will allow you to have a specific style, width
and color of an element's border.
Border style: defines the style of the border
Border width: defines the width of the border.
Border example
Result