UK's Labour pledges 26 billion pound boost to healthcare spending
LONDON: Britain's opposition Labour Party will pledge on Wednesday to spend an extra 26 billion pounds (US$33 billion) on healthcare if it wins the Dec. 12 election, including recruiting thousands more staff, rebuilding facilities and providing new equipment.
Labour, which is trailing Prime Minister Boris Johnson's Conservatives in the polls, has sought to make the state-run National Health Service (NHS), a central part of its campaign.
"With experts warning this winter is set to be one of the worst, the truth is our NHS is crying out for a financial rescue plan to deliver real change for patients," the party's health spokesman Jonathan Ashworth will say in a speech in London, according to advance extracts provided by the party.
"We are announcing today the levels of investment our NHS needs to not only again provide the quality care our sick and elderly deserve but secures the NHS for the future as well."
An average annual increase of 4.3 percent for health spending over the next four years will be paid for by proposals to reverse cuts to corporation tax and increase taxes on the richest, Labour said.
The 26 billion pound real terms increase for day-to-day spending from 2018-19 to 2023-24 was 6 billion pounds more than the Conservatives had promised for the same period, it said.
The NHS, which has provided healthcare free at the point of use for more than 70 years, is consistently ranked by voters as the second-biggest issue after Brexit.
Struggling under the pressure of record demand due to a growing and ageing population, as well as cutbacks to social care services, the health service has warned it faces a shortfall in funding despite government promises of extra money.
Labour said it would boost funding on capital expenditure, including maintenance and new high-tech equipment, provide more money for training and education, and expand public health services in areas such as obesity and mental health.
(Reporting by Kylie MacLellan; editing by Stephen Addison)


All of these rates are unfair and predatory, but some of them are appalling. In Texas, payday lenders charge up to 664% interest on a $300 loan - that means that over the course of a year, if you borrow $300, you end up paying back


Venue
This event will be held at the Main Library 112A (and area immediately outside the room), at the University of Arizona in Tucson, Arizona.
Sessions
| Thursday | Friday | |
|---|---|---|
| All Day | Registration | Registration |
| 9am | ------- | |
| 10 - Noon |
| Workshop: Open Science Framework |
| Noon - 2pm |
|
|
| 2 - 4pm | Panel: Open and Reproducible Science |
|
| 4pm | First Day Wrap Up and Free Stuff Giveaway | Raffle |
| 5:30pm | Birds of a Feather Dinners | Gentle Ben's to Celebrate Another Successful Bazaar |
Registration
Register to attend ResBaz, Tucson
Register to attend the Data Management for PostDocs Workshop on Thursday
Register to attend the Open Science Framework Workshops on Friday


Pit Test Coverage Report
Project Summary
Number of Classes
Line Coverage
Mutation Coverage
5
100%
2296/2296
93%
51/55
Breakdown by Package
Name
Number of Classes
Line Coverage
Mutation Coverage
com.github.underscore
1
100%
836/836
86%
18/21
com.github.underscore.lodash
4
100%
1460/1460
97%
33/34
Report generated by
PIT
1.4.4-SNAPSHOT


This example demonstrates the use of the ngeoWfsPermalink service, which is injected inside the gmf-map directive. The following links demonstrate the different features:
ngeoWfsPermalink
gmf-map


inline fun Logger.debug(msg: () -> String): Unit
Log a DEBUG level message produced by evaluating the given lamdba, but only if DEBUG logging is enabled.


An Artifact represents a piece of data that is used or produced in a software development process, or by deployment and operation of an IT system.
An Artifact represents a tangible element in the IT world. It is typically used to model (software) products such as source files, executables, scripts, database tables, messages, documents, specifications, and model files.
An Application Component or System Software may be realized by one or more Artifacts. A Data Object may be realized by one or more Artifacts. A Node may be assigned to an Artifact to model that the Artifact is deployed on the Node.
The name of an Artifact should preferably be the name of the file it represents.
Technology. Passive Structure.
Risk Management EJB, Jar file, Widget, Plug-in.


From Bath & Brushes to Full Groom, Flea Baths to Dog Sitting, we offer a variety of services to keep your pal healthy and looking thier best. All breeds of dogs are welcome!
Pals will always be groomed with TLC in a smoke free environment - no swats or shots. We have complete line of services, with prices that are tailored for your pals needs.
Share your photos, meet our pals.
We are located at 6938 N Oak Trafficway, Gladstone, MO 64118 Our phone number is<PHONE_NUMBER>.
Owned and operated by Barbara Yerington, our company provides professional and loving care to your pet. We are a certified groomer with extensive knowledge about the business.


{% extends "layout.html" %} {% set hide_scream = True %} {% block content %}
We have received your job post and it's now being reviewed. We review all posts to ensure their quality. Once we review your post, we will notify you via email.
You will soon receive an email at {{ email }} with a unique link which you can use to edit your post at any time. Once you edit a post, it will need to be reviewed again before it's published.


The APIServerDaemon executes commands prepared by the FutureGateway APIServer front-end. The front-end is responsible to get user requests from its REST interface and prepares the task execution for the APIServer which physically executes the task. The APIServer daemon retrieves the list of tasks to execute from a database table. Each task may involve a different executor identified by the task queue field 'Target'.
Below a list of actions that could be performed by the APIServerDaemon web interface.


This package contains classes that demonstrates Java's networking and concurrent programming facilities.
Some networking and threading resources:


The hard part of writing a test suite for asynchronous code is figuring out when a test is done, and feeling confident that all the code was run.
node-async-testing addresses that by...
All of the examples in this page can be seen in the test/test-overview.js suite and can be executed by running the following command from within the node-async-testing directory:
node test/test-overview.js
node-async-testing tests are just a functions that take a ‘test object’:
function asynchronousTest(test) {
setTimeout(function() {
// make an assertion (these are just regular Node assertions)
test.ok(true);
// finish the test
test.finish();
});
}
The test object is where all the action takes place. You make your assertions
using this object (test.ok()
, test.deepEquals()
,
etc) and use it to finish the test (test.finish()
). Basically,
all the actions that are directly related to a test use this object.
Test objects have the following properties:
test.finish()
node-async-testing assumes all tests are asynchronous. So in
order for it to know that a given test has completed, you have to
‘finish’ the test by calling test.finish()
.
This let's the test runner know that that particular test doesn't have
any more asynchronous code running.
Even if a test is not asynchronous you still have to finish it:
function synchronousTest(test) {
test.ok(true);
test.finish();
}
It is important that no code from this test is ran after this function is called, otherwise, node-async-testing will think that code corresponds to a different test. Be careful!
If test.finish()
is called more than once, or an assertion is made after finish()
has already been called, an error will be thrown. These features help catch test
errors. Use these to your advantage. For example, at the beginning of an asynchronous
callback make an assertion! If the test has already finished (the callback is being called
when it isn't supposed to be) then the assertion will catch that the test has already finished
and prevent the callback from running any code that can interfere with other tests. Example:
module.exports =
{ 'okay': function(test) {
setTimeout(function() {
/* run code */
test.finish();
}
}
, 'GOOD PRACTICE!': function(test) {
setTimeout(function() {
test.ok(true); // make sure test isn't already finished
/* run code */
test.finish();
}
}
};
test.numAssertions
node-async-testing lets you be explicit about the number of
assertions run in a given test: set numAssertions
on the test
object. This can be very helpful in asynchronous tests where you want to
be sure all callbacks get fired:
suite['test assertions expected'] = function(test) {
test.numAssertions = 1;
test.ok(true);
test.finish();
}
If you are testing asynchronous code, I highly recommend using test.numAssertions
.
node-async-testing depends on test.finish()
to tell it when a test is finished,
so if code is run after finish()
was called you will get innacurate test results. Use
numAssertions
to be sure all your callbacks are called and that they aren't called
too many times.
test.uncaughtExceptionHandler
node-async-testing lets you deal with uncaught errors. If you
expect an error to be thrown asynchronously in your code somewhere (this
is not good practice, but sometimes when using other people's code you
have no choice. Or maybe it is what you want to happen, who am I
to judge?), you can set an uncaughtExceptionHandler
on the
test object:
suite['test catch async error'] = function(test) {
var e = new Error();
test.uncaughtExceptionHandler = function(err) {
test.equal(e, err);
test.finish();
}
setTimeout(function() {
throw e;
}, 500);
};
This property can only be set when running suites serially, because otherwise node-async-testing wouldn't know for which test it was catching the error.
Additionally, the test object has all of the assertion functions that come with the assert module bundled with Node.
These methods are bound to the test object so node-async-testing can know which assertions correspond to which tests.
test.ok(value, [message])
assert.equal(true, value, message);
.test.equal(actual, expected, [message])
==
).test.notEqual(actual, expected, [message])
!=
).test.deepEqual(actual, expected, [message])
test.notDeepEqual(actual, expected, [message])
test.strictEqual(actual, expected, [message])
===
)test.notStrictEqual(actual, expected, [message])
!==
)test.throws(block, [error], [message])
test.doesNotThrow(block, [error], [message])
test.ifError(value, [message])
Because node-async-testing needs to bind the assertion methods to the test object, you can't just use any assertion you have lying around. You have to first register it:
var async_testing = require('async_testing');
async_testing.registerAssertion('customAssertion', function() { ... });
exports['test assert'] = function(test) {
test.customAssertion();
test.finish();
}
Check out test/test-custom_assertions.js for a working example.
node-async-testing is written for running suites of tests, not individual tests. A test suite is just an object with test functions:
var suite = {
'asynchronous test': function(test) {
setTimeout(function() {
test.ok(true);
test.finish();
});
},
'synchronous test': function(test) {
test.ok(true);
test.finish();
}
}
node-async-testing allows you to namespace your tests by putting them in a sub-suite:
var suite =
{ 'namespace 1':
{ 'test A': function(test) { ... }
, 'test B': function(test) { ... }
}
, 'namespace 2':
{ 'test A': function(test) { ... }
, 'test B': function(test) { ... }
}
, 'namespace 3':
{ 'test A': function(test) { ... }
, 'test B': function(test) { ... }
}
};
Suites can be nested arbitrarily deep:
var suite =
{ 'namespace 1':
{ 'namespace 2':
{ 'namespace 3':
{ 'test A': function(test) { ... }
, 'test B': function(test) { ... }
, 'test C': function(test) { ... }
}
}
}
};
wrap()
node-async-testing comes with a convenience function for wrapping all tests
in an object with setup/teardown functions. This function is called wrap
and it takes one argument which is an object which can have the following properties:
suite
setup(test, done)
test
object directly. Because setup
might need
to be asynchronous, you have to call the second argument, done()
,
when it is finished. Optional.
teardown(test, done)
teardown
functions are called regardless of whether or not the test succeeds or
fails. It gets the same arguments as setup
. Optional.
suiteSetup(done)
suiteSetup
might need to be asynchronous, you have to call the
only argument, done()
, when it is finished. Optional.
suiteTeardown(done)
suiteTeardown
functions are called regardless of whether or not the tests in the suite
succeed or fail. It gets the same arguments as suiteSetup
.
Optional.
An example:
var wrap = require('async_testing').wrap;
var suiteSetupCount = 0;
var suite = wrap(
{ suiteSetup: function(done) {
suiteSetupCount++;
done();
}
, setup: function(test, done) {
test.extra1 = 1;
test.extra2 = 2;
done();
}
, suite:
{ 'wrapped test 1': function(test) {
test.equal(1, suiteSetupCount);
test.equal(1, test.extra1);
test.equal(2, test.extra2);
test.finish();
}
, 'wrapped test 2': function(test) {
test.equal(1, suiteSetupCount);
test.equal(1, test.extra1);
test.equal(2, test.extra2);
test.finish();
}
}
, teardown: function(test, done) {
// not that you need to delete these variables here, they'll get cleaned up
// automatically, we're just doing it here as an example of running code
// after some tests
delete test.extra1;
delete test.extra2;
done();
}
, suiteTeardown: function(done) {
delete suiteSetupCount;
done();
}
})
})
You can use a combination of sub-suites and wrapping to provide setup/teardown functions for certain tests.


--- layout: snippet title: "Outlined buttons" permalink: /examples/buttons/outlined/ sitemap: false --- Primary Secondary Warning Danger


from __future__ import print_function
from __future__ import division
from __future__ import unicode_literals
import warnings
import time
import numpy as np
import tensorflow as tf
from deepchem.utils.save import log
from deepchem.models.tensorflow_models import TensorflowGraph
from deepchem.models.tensorflow_models import TensorflowGraphModel
from deepchem.models.tensorflow_models.lr import TensorflowLogisticRegression
[docs]class TensorflowMultiTaskIRVClassifier(TensorflowLogisticRegression):
def __init__(self,
n_tasks,
K=10,
logdir=None,
n_classes=2,
penalty=0.0,
penalty_type="l2",
learning_rate=0.001,
momentum=.8,
optimizer="adam",
batch_size=50,
verbose=True,
seed=None,
**kwargs):
"""Initialize TensorflowMultiTaskIRVClassifier
Parameters
----------
n_tasks: int
Number of tasks
K: int
Number of nearest neighbours used in classification
logdir: str
Location to save data
n_classes: int
number of different labels
penalty: float
Amount of penalty (l2 or l1 applied)
penalty_type: str
Either "l2" or "l1"
learning_rate: float
Learning rate for model.
momentum: float
Momentum. Only applied if optimizer=="momentum"
optimizer: str
Type of optimizer applied.
batch_size: int
Size of minibatches for training.
verbose: True
Perform logging.
seed: int
If not none, is used as random seed for tensorflow.
"""
warnings.warn("The TensorflowMultiTaskIRVClassifier is "
"deprecated. Will be removed in DeepChem 1.4.",
DeprecationWarning)
self.n_tasks = n_tasks
self.K = K
self.n_features = 2 * self.K * self.n_tasks
print("n_features after fit_transform: %d" % int(self.n_features))
TensorflowGraphModel.__init__(
self,
n_tasks,
self.n_features,
logdir=logdir,
layer_sizes=None,
weight_init_stddevs=None,
bias_init_consts=None,
penalty=penalty,
penalty_type=penalty_type,
dropouts=None,
n_classes=n_classes,
learning_rate=learning_rate,
momentum=momentum,
optimizer=optimizer,
batch_size=batch_size,
pad_batches=False,
verbose=verbose,
seed=seed,
**kwargs)
[docs] def build(self, graph, name_scopes, training):
"""Constructs the graph architecture of IRV as described in:
https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2750043/
"""
placeholder_scope = TensorflowGraph.get_placeholder_scope(
graph, name_scopes)
K = self.K
with graph.as_default():
output = []
with placeholder_scope:
mol_features = tf.placeholder(
tf.float32, shape=[None, self.n_features], name='mol_features')
with tf.name_scope('variable'):
V = tf.Variable(tf.constant([0.01, 1.]), name="vote", dtype=tf.float32)
W = tf.Variable(tf.constant([1., 1.]), name="w", dtype=tf.float32)
b = tf.Variable(tf.constant([0.01]), name="b", dtype=tf.float32)
b2 = tf.Variable(tf.constant([0.01]), name="b2", dtype=tf.float32)
label_placeholders = self.add_label_placeholders(graph, name_scopes)
weight_placeholders = self.add_example_weight_placeholders(
graph, name_scopes)
if training:
graph.queue = tf.FIFOQueue(
capacity=5,
dtypes=[tf.float32] *
(len(label_placeholders) + len(weight_placeholders) + 1))
graph.enqueue = graph.queue.enqueue([mol_features] + label_placeholders
+ weight_placeholders)
queue_outputs = graph.queue.dequeue()
labels = queue_outputs[1:len(label_placeholders) + 1]
weights = queue_outputs[len(label_placeholders) + 1:]
features = queue_outputs[0]
else:
labels = label_placeholders
weights = weight_placeholders
features = mol_features
for count in range(self.n_tasks):
similarity = features[:, 2 * K * count:(2 * K * count + K)]
ys = tf.to_int32(features[:, (2 * K * count + K):2 * K * (count + 1)])
R = b + W[0] * similarity + W[1] * tf.constant(
np.arange(K) + 1, dtype=tf.float32)
R = tf.sigmoid(R)
z = tf.reduce_sum(R * tf.gather(V, ys), axis=1) + b2
output.append(tf.reshape(z, shape=[-1, 1]))
return (output, labels, weights)


{% extends "template.html" %} {% block body %}
This is the account page!
Look into the code in app.py to see how the user's name is passed from the previous page(home.html) to this one


Username can contain only letters or numbers, and must be at least 8 characters
Please provide your E-mail
Password should be at least 8 characters and must contain one number
Please confirm password
Forgotten Password? Enter Email:


IRB1.9(1) IRB1.9(1) NAME irb1.9.1 - interactive ruby SYNOPSIS irb [options] DESCRIPTION irb stands for `interactive ruby'. irb is a tool to execute interactively ruby expressions read from stdin. Use of irb is easy if you know ruby. Executing irb, prompts are displayed as follows. Then, enter expression of ruby. A input is executed when it is syntacticaly completed. $ irb1.9.1 irb(main):001:0> 1+2 3 irb(main):002:0> class Foo irb(main):003:1> def foo irb(main):004:2> print 1 irb(main):005:2> end irb(main):006:1> end nil irb(main):007:0> And, Readline extesion module can be used with irb. Using Readline is the standard default action if Readline is installed. OPTIONS -f suppress read ~/.irbrc -m bc mode (fraction or matrix are available) -d set $DEBUG to true (same as `ruby -d') -r load-module same as `ruby -r' --inspect uses `inspect' for output (the default except bc mode) --noinspect doesn't uses inspect for output --readline uses Readline extension module --noreadline doesn't use Readline extension module --prompt prompt-mode --prompt-mode prompt-mode switches prompt mode. Pre-defined prompt modes are `default', `simple', `xmp' and `inf-ruby' --inf-ruby-mode uses prompt appreciate for inf-ruby-mode on emacs. Suppresses --readline. --simple-prompt simple prompt mode --noprompt no prompt --tracer display trace for each execution of commands. --back-trace-limit n displayes backtrace top n and tail n. The default value is 16. --irb_debug n sets internal debug level to n (It shouldn't be used) -v, --version prints the version of irb CONFIGURATIONS irb reads `~/.irbrc' when it is invoked. If `~/.irbrb' doesn't exist irb try to read in the order `.irbrc', `irb.rc', `_irbrc' then `$irbrc'. The following is altanative to the command line option. To use them type as follows in an irb session. IRB.conf[:IRB_NAME]="irb" IRB.conf[:MATH_MODE]=false IRB.conf[:USE_TRACER]=false IRB.conf[:USE_LOADER]=false IRB.conf[:IGNORE_SIGINT]=true IRB.conf[:IGNORE_EOF]=false IRB.conf[:INSPECT_MODE]=nil IRB.conf[:IRB_RC] = nil IRB.conf[:BACK_TRACE_LIMIT]=16 IRB.conf[:USE_LOADER] = false IRB.conf[:USE_READLINE] = nil IRB.conf[:USE_TRACER] = false IRB.conf[:IGNORE_SIGINT] = true IRB.conf[:IGNORE_EOF] = false IRB.conf[:PROMPT_MODE] = :DEFALUT IRB.conf[:PROMPT] = {...} IRB.conf[:DEBUG_LEVEL]=0 IRB.conf[:VERBOSE]=true Customizing prompt To costomize the prompt you set a variable IRB.conf[:PROMPT] For example, describe as follows in `.irbrc'. IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode :PROMPT_I => nil, # normal prompt :PROMPT_S => nil, # prompt for continuated strings :PROMPT_C => nil, # prompt for continuated statement :RETURN => " ==>%s\n" # format to return value } Then, invoke irb with the above prompt mode by $ irb1.9.1 --prompt my-prompt Or add the following in `.irbrc'. IRB.conf[:PROMPT_MODE] = :MY_PROMPT Constants PROMPT_I, PROMPT_S and PROMPT_C specifies the format. In the prompt specification, some special strings are available. %N command name which is running %m to_s of main object (self) %M inspect of main object (self) %l type of string(", ', /, ]), `]' is inner %w[...] %NNi indent level. NN is degits and means as same as printf("%NNd"). It can be ommited %NNn line number. %% % For instance, the default prompt mode is defined as follows: IRB.conf[:PROMPT_MODE][:DEFAULT] = { PROMPT_I => "%N(%m):%03n:%i> ", PROMPT_S => "%N(%m):%03n:%i%l ", PROMPT_C => "%N(%m):%03n:%i* ", RETURN => "%s\n"} RETURN is used to printf. Configurating subirb The command line option or IRB.conf specify the default behavior of (sub)irb. On the other hand, each conf of in the next sction `6. Command' is used to individually configurate (sub)irb. If proc is set to IRB.conf[:IRB_RC], its subirb will be invoked after execution of that proc under giving the context of irb as its aregument. By this mechanism each subirb can be configurated. Command For irb commands, both simple name and `irb_'-prefixed name are prepared. exit, quit, irb_exit Quits (sub)irb. if you've done cb (see below), exit from the binding mode. conf, irb_context Displays current configuration. Modifing the configuration is achieved by sending message to `conf'. conf.back_trace_limit Sets display lines of backtrace as top n and tail n. The default value is 16. conf.debug_level = N Sets debug level of irb. conf.ignore_eof = true/false Whether ^D (control-d) will be ignored or not. If false is set, ^D means quit. conf.ignore_sigint= true/false Whether ^C (control-c) will be ignored or not. If false is set, ^D means quit. If true, during input: cancel inputing then return to top level. during execute: abondon current execution. conf.inf_ruby_mode = true/false Whether inf-ruby-mode or not. The default value is false. conf.inspect_mode = true/false/nil Specifies inspect mode. true: display inspect false: display to_s nil: inspect mode in non math mode, non inspect mode in math mode. conf.irb_level The level of cb. conf.math_mode Whether bc mode or not. conf.use_loader = true/false Whether irb's own file reader method is used when load/require or not. This mode is globaly affected (irb wide). conf.prompt_c prompt for a continuating statement (e.g, immediately after of `if') conf.prompt_i standard prompt conf.prompt_s prompt for a continuating string conf.rc Whether ~/.irbrc is read or not. conf.use_prompt = true/false Prompting or not. conf.use_readline = true/false/nil Whether readline is used or not. true: uses false: doen't use nil: intends to use readline except for inf-reuby-mode (default) conf.verbose=T/F Whether verbose messages are display or not. cb, irb_change_binding [obj] Enter new binding which has a distinct scope of local variables. If obj is given, obj will be self. irb [obj] Invoke subirb. If obj is given, obj will be self. jobs, irb_jobs List of subirb fg n, irb_fg n Switch into specified subirb. The following is candidates of n: irb number thhread irb object self(obj which is specified of irb obj) kill n, irb_kill n Kill subirb. The means of n is as same as the case of irb_fg. System variable _ The latest value of evaluation (it is local) Session Example $ irb1.9.1 irb(main):001:0> irb # invoke subirb irb#1(main):001:0> jobs # list of subirbs #0->irb on main (#<Thread:0x400fb7e4> : stop) #1->irb#1 on main (#<Thread:0x40125d64> : running) nil irb#1(main):002:0> fg 0 # switch job nil irb(main):002:0> class Foo;end nil irb(main):003:0> irb Foo # invoke subirb which has the # context of Foo irb#2(Foo):001:0> def foo # define Foo#foo irb#2(Foo):002:1> print 1 irb#2(Foo):003:1> end nil irb#2(Foo):004:0> fg 0 # switch job nil irb(main):004:0> jobs # list of job #0->irb on main (#<Thread:0x400fb7e4> : running) #1->irb#1 on main (#<Thread:0x40125d64> : stop) #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop) nil irb(main):005:0> Foo.instance_methods # Foo#foo is defined asurely ["foo"] irb(main):006:0> fg 2 # switch job nil irb#2(Foo):005:0> def bar # define Foo#bar irb#2(Foo):006:1> print "bar" irb#2(Foo):007:1> end nil irb#2(Foo):010:0> Foo.instance_methods ["bar", "foo"] irb#2(Foo):011:0> fg 0 nil irb(main):007:0> f = Foo.new #<Foo:0x4010af3c> irb(main):008:0> irb f # invoke subirb which has the # context of f (instance of Foo) irb#3(#<Foo:0x4010af3c>):001:0> jobs #0->irb on main (#<Thread:0x400fb7e4> : stop) #1->irb#1 on main (#<Thread:0x40125d64> : stop) #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop) #3->irb#3 on #<Foo:0x4010af3c> (#<Thread:0x4010a1e0> : running) nil irb#3(#<Foo:0x4010af3c>):002:0> foo # evaluate f.foo 1nil irb#3(#<Foo:0x4010af3c>):003:0> bar # evaluate f.bar barnil irb#3(#<Foo:0x4010af3c>):004:0> kill 1, 2, 3# kill job nil irb(main):009:0> jobs #0->irb on main (#<Thread:0x400fb7e4> : running) nil irb(main):010:0> exit # exit Restrictions Because irb evaluates the inputs immediately after the imput is syntacti‐ cally completed, irb gives slight different result than directly use ruby. Known difference is pointed out here. Declaration of the local variable The following causes an error in ruby: eval "foo = 0" foo -- -:2: undefined local variable or method `foo' for #<Object:0x40283118> (NameError) --- NameError Though, the above will successfully done by irb. >> eval "foo = 0" => 0 >> foo => 0 Ruby evaluates a code after reading entire of code and determination of the scope of local variables. On the other hand, irb do immediately. More precisely, irb evaluate at first evel "foo = 0" then foo is defined on this timing. It is because of this incompatibil‐ ity. If you'd like to detect those differences, begin...end can be used: >> begin ?> eval "foo = 0" >> foo >> end NameError: undefined local variable or method `foo' for #<Object:0x4013d0f0> (irb):3 (irb_local_binding):1:in `eval' Here-document Implementation of Here-document is incomplete. Symbol Irb can not always recognize a symbol as to be Symbol. Concretely, an expression have completed, however Irb regard it as continuation line. December 2002 IRB1.9(1)


head_ref_deleted
by None at 2020-06-18 23:12:28.successfully imported into ASpace:
- [x] WC064
error 413 Request Entity Too Large
extent field needs to be prepped per below
- [x] C0614
error 413 Request Entity Too Large
needed dates fixed (end date occurring before start date)
- [x] MC152
(had to correct an end date occurring before the start date)
- [x] C0807
data issue: Error: #<RuntimeError: Problem creating 'Abreu, Juan': Invalid value: item>
Fixed. NB: ASpace does not allow the word "items" in the value of the extent field. It does accept other values (such as "folders"), however.
- [ ] MC001.04
error 413 Request Entity Too Large
end date before start date needed fixing
broke into two smaller pieces
extent is required
- [x] C0776
error 413 Request Entity Too Large
some unittitles are too long, causing import to fail
- [x] C0879
error: the following errors were found: id_0 : That ID is already in use
Turns out this is the error thrown when the eadid is already in use in ASpace


$ rq -a < data.avro ' at "tracks.items" | spread | flatMap artists | filter (a => !_.startsWith(a.name, "P")) | countBy name | flatMap (_.toPairs) | orderBy 1 desc | collect'


{{slave.hostname}}
{{slave.riskgroup.name}}
Mongod ({{mongod.observed_execution_state}})
{{slave.hostname}}:{{mongod.slave_port}} on
Replica Set {{mongod.replicaset.name}}
|
Change the state to control the deployment of Mongods on this Slave.
Important: if you delete an unreachable Slave, MAMID will loose track of the Mongods it spawned on that Slave. Re-adding such Slave to MAMID will cause force-deletion of these Mongods and their data.
Removal is only possible with the slave in disabled mode.


Why Cronus
Simple yet powerful PaaS framework, built for developers.
Deploy sample application in 10 seconds, and much more.
Differentiators
Manage Java, Python, Node, or ANY Languages or Stacks.
Deploy to Hundreds of Machines in Seconds.
No Vendor Lock In, run on GCP, AWS, Azure.
Light Weight, Setup in 2 Minute.
Scale Simply and Predictably.
Intuitive UI, RESTful APIs
100% Open Source
Architecture
Setup and Deploy
The following IaaS profiles are tested working with Cronus
- AWS: AMI, ubuntu12.04, ubuntu14.04, RHEL7
- GCE: ubuntu12.04, ubuntu14.04, RHEL7, centOS7, opensuse7
- Azure: ubuntu12.04, ubuntu14.04, openlogic7
Prerequisite
Setup
Deploy
On a linux machine with
- sudo access
- python > 2.6.7 && < 3.0
- openssl > 0.9.8
- wget
- system management daemon systemd or upstart
- unzip (CronusMaster only)
- java runtime >= 1.7 (CronusMaster only)
cd ~; wget -qO- 'http://www.cronuspaas.com/downloads/install_cronusmaster' | bash
- CronusAgent is running at https://host:19000/agent
- CronusMaster is running at http://host:9000
- CronusMaster code is downloaded and saved in ~/cronusmaster-master
- In CronusMaster Homepage, run "Deploy a HelloWorld App"
- Check deployed application at http://host:8999


Home
Pages
About University
Academic Calendar
Administration & Teachers
College of Arts and Letters
Departments
Kevin Cunningham
Multimedia
Univer’s History Timeline
Why Unvier?
Contact Us
Features
Timetable
Donations
Donation Details
Events
Event Details
Blog
Single post
Home
Pages
About University
Academic Calendar
Administration & Teachers
College of Arts and Letters
Departments
Kevin Cunningham
Multimedia
Univer’s History Timeline
Why Unvier?
Contact Us
Features
Timetable
Donations
Donation Details
Events
Event Details
Blog
Single post
Search for:
Sample Page
Home
Contact
Sample Page
2015 – 2016
December
21, First Day of Winter Break
February
12, Lincoln Day Holiday
15, Washington Day Holiday
April
19, School Resumes
July
4, Independence Day Holiday
21, Last Day of School
January
19, School Resumes
March
28, Spring Break Begins
May
27, Non-Instructional Day
30, Memorial Day Holiday
2016 – 2017
August
29, First Day of School for students
December
21, First Day of Winter Break
March
28, Spring Break Begins
July
4, Independence Day Holiday
21, Last Day of School
September
5, Labor Day Holiday
January
19, School Resumes
April
19, School Resumes
November
11, Veterans Day Holiday
21-25, Thanksgiving Break
January
12, Lincoln Day Holiday
15, Washington Day Holiday
May
27, Non-Instructional Day
30, Memorial Day Holiday


04th April 2017
SAHAI organized a talk for employees of Hewlett Packard Enterprise, Whitefield, Bangalore on mental health and work life balance, a very important issue in the corporate world today.It was an interactive session, hence very warmly received.


ABC Toys
Making learning fun
ABC Toys is a company that opened its doors in 2001 and it has kept its mission for all those years.
The mission of our company is to create toys that are safe for kindergarten kids but that challenge the kids' mind and motor skills making learning a fun task.
By the way, parents love our toys too


1: You will be given a random nummber at the start of the game.
2: There are four fighters below. By clicking on a fighter you will
add a specific amount of points to your total score.
3: You win the game by matching your total score to the random number,
you lose the game if your total score goes above the random number.
4: The value of each fighter is hidden from you until you click on it.
5: Each time the game restarts the value of the fighters will change.


Record number of fliers expected around Thanksgiving
Airports prepare for large holiday crowds
by Melissa Alonso, CNNWASHINGTON, D.C. - The number of passengers flying over this Thanksgiving holiday period should be one for the record books, the Transportation Security Administration says.
About 26.8 million passengers are expected to pass through TSA checkpoints nationwide from the Friday before Thanksgiving through the Monday afterward, or November 22 to December 2, TSA Acting Deputy Administrator Patricia Cogswell said Wednesday.
That would be a record for the Thanksgiving period, and about 4% more than the same time last year, Cogswell said at a news conference at Ronald Reagan Washington National Airport.
The Sunday after Thanksgiving is expected to be "the single busiest day ever for the US airline industry," said Sharon Pinkerton, senior vice president for industry group Airlines for America.
About 3.1 million passengers are expected on that day, December 1, Pinkerton said.


Note:
ReactTransitionGroup
andReactCSSTransitionGroup
have been moved to thereact-transition-group
package that is maintained by the community. Its 1.x branch is completely API-compatible with the existing addons. Please file bugs and feature requests in the new repository.
The ReactTransitionGroup
add-on component is a low-level API for animation, and ReactCSSTransitionGroup
is an add-on component for easily implementing basic CSS animations and transitions.
ReactCSSTransitionGroup
is a high-level API based on ReactTransitionGroup
and is an easy way to perform
CSS transitions and animations when a React component enters or leaves the DOM. It's inspired by the excellent ng-animate library.
Importing
import ReactCSSTransitionGroup from 'react-transition-group'; // ES6
var ReactCSSTransitionGroup = require('react-transition-group'); // ES5 with npm
class TodoList extends React.Component {
constructor(props) {
super(props);
this.state = {items: ['hello', 'world', 'click', 'me']};
this.handleAdd = this.handleAdd.bind(this);
}
handleAdd() {
const newItems = this.state.items.concat([
prompt('Enter some text')
]);
this.setState({items: newItems});
}
handleRemove(i) {
let newItems = this.state.items.slice();
newItems.splice(i, 1);
this.setState({items: newItems});
}
render() {
const items = this.state.items.map((item, i) => (

 this.handleRemove(i)}>
{item}

));
return (

<button onClick={this.handleAdd}>Add Item</button>
<ReactCSSTransitionGroup
transitionName="example"
transitionEnterTimeout={500}
transitionLeaveTimeout={300}>
{items}
</ReactCSSTransitionGroup>

);
}
}
Note:
You must provide the
key
attribute for all children ofReactCSSTransitionGroup
, even when only rendering a single item. This is how React will determine which children have entered, left, or stayed.
In this component, when a new item is added to ReactCSSTransitionGroup
it will get the example-enter
CSS class and the example-enter-active
CSS class added in the next tick. This is a convention based on the transitionName
prop.
You can use these classes to trigger a CSS animation or transition. For example, try adding this CSS and adding a new list item:
.example-enter {
opacity: 0.01;
}
.example-enter.example-enter-active {
opacity: 1;
transition: opacity 500ms ease-in;
}
.example-leave {
opacity: 1;
}
.example-leave.example-leave-active {
opacity: 0.01;
transition: opacity 300ms ease-in;
}
You'll notice that animation durations need to be specified in both the CSS and the render method; this tells React when to remove the animation classes from the element and – if it's leaving – when to remove the element from the DOM.
ReactCSSTransitionGroup
provides the optional prop transitionAppear
, to add an extra transition phase at the initial mount of the component. There is generally no transition phase at the initial mount as the default value of transitionAppear
is false
. The following is an example which passes the prop transitionAppear
with the value true
.
render() {
return (
<ReactCSSTransitionGroup
transitionName="example"
transitionAppear={true}
transitionAppearTimeout={500}
transitionEnter={false}
transitionLeave={false}>

Fading at Initial Mount

</ReactCSSTransitionGroup>
);
}
During the initial mount ReactCSSTransitionGroup
will get the example-appear
CSS class and the example-appear-active
CSS class added in the next tick.
.example-appear {
opacity: 0.01;
}
.example-appear.example-appear-active {
opacity: 1;
transition: opacity .5s ease-in;
}
At the initial mount, all children of the ReactCSSTransitionGroup
will appear
but not enter
. However, all children later added to an existing ReactCSSTransitionGroup
will enter
but not appear
.
Note:
The prop
transitionAppear
was added toReactCSSTransitionGroup
in version0.13
. To maintain backwards compatibility, the default value is set tofalse
.However, the default values of
transitionEnter
andtransitionLeave
aretrue
so you must specifytransitionEnterTimeout
andtransitionLeaveTimeout
by default. If you don't need either enter or leave animations, passtransitionEnter={false}
ortransitionLeave={false}
.
It is also possible to use custom class names for each of the steps in your transitions. Instead of passing a string
into transitionName you can pass an object containing either the enter
and leave
class
names, or an object containing the enter
, enter-active
, leave-active
, and
leave
class names. If only the enter and leave classes are provided, the enter-active and leave-active
classes will be determined by appending '-active' to the end of the class name. Here are two examples using custom
classes:
// ...
<ReactCSSTransitionGroup
transitionName={ {
enter: 'enter',
enterActive: 'enterActive',
leave: 'leave',
leaveActive: 'leaveActive',
appear: 'appear',
appearActive: 'appearActive'
} }>
{item}
</ReactCSSTransitionGroup>
<ReactCSSTransitionGroup
transitionName={ {
enter: 'enter',
leave: 'leave',
appear: 'appear'
} }>
{item2}
</ReactCSSTransitionGroup>
// ...
In order for it to apply transitions to its children, the ReactCSSTransitionGroup
must already be mounted in the DOM or the prop transitionAppear
must be set to true
.
The example below would not work, because the ReactCSSTransitionGroup
is being mounted along with the new item, instead of the new item being mounted within it. Compare this to the Getting Started section above to see the difference.
render() {
const items = this.state.items.map((item, i) => (

 this.handleRemove(i)}>
<ReactCSSTransitionGroup transitionName="example">
{item}
</ReactCSSTransitionGroup>

));
return (

<button onClick={this.handleAdd}>Add Item</button>
{items}

);
}
In the example above, we rendered a list of items into ReactCSSTransitionGroup
. However, the children of ReactCSSTransitionGroup
can also be one or zero items. This makes it possible to animate a single element entering or leaving. Similarly, you can animate a new element replacing the current element. For example, we can implement a simple image carousel like this:
import ReactCSSTransitionGroup from 'react-transition-group';
function ImageCarousel(props) {
return (

<ReactCSSTransitionGroup
transitionName="carousel"
transitionEnterTimeout={300}
transitionLeaveTimeout={300}>

</ReactCSSTransitionGroup>

);
}
You can disable animating enter
or leave
animations if you want. For example, sometimes you may want an enter
animation and no leave
animation, but ReactCSSTransitionGroup
waits for an animation to complete before removing your DOM node. You can add transitionEnter={false}
or transitionLeave={false}
props to ReactCSSTransitionGroup
to disable these animations.
Note:
When using
ReactCSSTransitionGroup
, there's no way for your components to be notified when a transition has ended or to perform any more complex logic around animation. If you want more fine-grained control, you can use the lower-levelReactTransitionGroup
API which provides the hooks you need to do custom transitions.
Importing
import ReactTransitionGroup from 'react-addons-transition-group' // ES6
var ReactTransitionGroup = require('react-addons-transition-group') // ES5 with npm
ReactTransitionGroup
is the basis for animations. When children are declaratively added or removed from it (as in the example above), special lifecycle methods are called on them.
componentWillAppear()
componentDidAppear()
componentWillEnter()
componentDidEnter()
componentWillLeave()
componentDidLeave()
ReactTransitionGroup
renders as a span
by default. You can change this behavior by
providing a component
prop. For example, here's how you would render a

:
<ReactTransitionGroup component="ul">
{/* ... */}
</ReactTransitionGroup>
Any additional, user-defined, properties will become properties of the rendered component. For example, here's how
you would render a

with CSS class:
<ReactTransitionGroup component="ul" className="animated-list">
{/* ... */}
</ReactTransitionGroup>
Every DOM component that React can render is available for use. However, component
does not need to be a
DOM component. It can be any React component you want; even ones you've written yourself! Just write
component={List}
and your component will receive this.props.children
.
People often use ReactTransitionGroup
to animate mounting and unmounting of a single child such as a collapsible panel. Normally ReactTransitionGroup
wraps all its children in a span
(or a custom component
as described above). This is because any React component has to return a single root element, and ReactTransitionGroup
is no exception to this rule.
However if you only need to render a single child inside ReactTransitionGroup
, you can completely avoid wrapping it in a
or any other DOM component. To do this, create a custom component that renders the first child passed to it directly:
function FirstChild(props) {
const childrenArray = React.Children.toArray(props.children);
return childrenArray[0] || null;
}
Now you can specify FirstChild
as the component
prop in <ReactTransitionGroup>
props and avoid any wrappers in the result DOM:
<ReactTransitionGroup component={FirstChild}>
{someCondition ? <MyComponent /> : null}
</ReactTransitionGroup>
This only works when you are animating a single child in and out, such as a collapsible panel. This approach wouldn't
work when animating multiple children or replacing the single child with another child, such as an image carousel.
For an image carousel, while the current image is animating out, another image will animate in, so
<ReactTransitionGroup>
needs to give them a common DOM parent. You can't avoid the wrapper for
multiple children, but you can customize the wrapper with the component
prop as described above.
componentWillAppear()
This is called at the same time as componentDidMount()
for components that are initially mounted in a TransitionGroup
. It will block other animations from occurring until callback
is called. It is only called on the initial render of a TransitionGroup
.
componentDidAppear()
This is called after the callback
function that was passed to componentWillAppear
is called.
componentWillEnter()
This is called at the same time as componentDidMount()
for components added to an existing TransitionGroup
. It will block other animations from occurring until callback
is called. It will not be called on the initial render of a TransitionGroup
.
componentDidEnter()
This is called after the callback
function that was passed to componentWillEnter()
is called.
componentWillLeave()
This is called when the child has been removed from the ReactTransitionGroup
. Though the child has been removed, ReactTransitionGroup
will keep it in the DOM until callback
is called.
componentDidLeave()
This is called when the willLeave
callback
is called (at the same time as componentWillUnmount()
).


Source Code
You can download the complete source for the HTML5/Javascript version of the visualizations here:A few notes / warnings:
- Do not try to look at the code to understand the algorithms. I have done one or two tricky things to get the visualizations to work property that rather obscure the algorithms themselves. Your favorte textbook, or even wikipedia, is a better bet for appropriate source code.
- Like all software projects, this one is a bit of a living thing -- it started life as a Java project, was rewritten in ActionScript3 (that is, flash), and then ported to Javascript. It was also my opportunity to learn flash and javascript, so by the time I figured out the best way to do things, half of the software was already written. I've done some going back to clean stuff up, but there is still a quite a lot of ugliness. Next time all my code will be pretty :).
Visualization Creation Tutorial
To creeate a new visualization, you need to create a javascript file and an HTML file. The HTML file should just be copied from a template, changing only one or two items (like the name of the javascript file). Examples of the HTML template and how to change it are at the end of this tutorial. In the javascript file, you will create a function (an object, really, but functions are objects in javascript) that:- Creates any appropriate controls to control you visualization (inserting elements, deletig elements, etc)
- Creates callbacks for these controls that implement the visualizations. The visualizations are implemented by sending an array of strings to the animation manager -- the animation manager will then implement the animation, and handle all of the animation controls for you
- Listen for an undo event from the animation manager. When an undo event is detected, roll back the last operation
Using Algorithm function
Creating the javascript function is stil farily complicated, even when using the rest of the library. Many of the ugly details can be automated if your function "subclasses" the Algorithm function (located in AlgorithmLibrary/Algorithm.js (which is sort of a faux "class"). Consider the skeleton "MyAlgorithm" function included in the tarfile: Looking at various pieces of the file in turn:Copyright: Code is released under in a FreeBSD license.
// Copyright 2011 David Galles, University of San Francisco. All rights reserved. // // Redistribution and use in source and binary forms, with or without modification, are // permitted provided that the following conditions are met: // // 1. Redistributions of source code must retain the above copyright notice, this list of // conditions and the following disclaimer. // // 2. Redistributions in binary form must reproduce the above copyright notice, this list // of conditions and the following disclaimer in the documentation and/or other materials // provided with the distribution.   // // The views and conclusions contained in the software and documentation are those of the // authors and should not be interpreted as representing official policies, either expressed // or implied, of the University of San Francisco
function MyAlgorithm(am, w, h) { this.init(am, w, h); } MyAlgorithm.prototype = new Algorithm(); MyAlgorithm.prototype.constructor = MyAlgorithm; MyAlgorithm.superclass = Algorithm.prototype;
- Call the superclass counstructor. Note the syntax, it's a little odd, but we are forcing javascript into an tradtional object-oriented paradigm, so it will complain a little at us.
- Add necessary controls
- Initialize our "Memory Manager". For the most part, we will use a very simple memory manager -- the old Pascal-style "Never free" memory manager. Start the free list at 0, and then increment it every time you need a new piece of memory.
- Initialize any data structures we will be using
MyAlgorithm.prototype.init = function(am, w, h) { // Call the unit function of our "superclass", which adds a couple of // listeners, and sets up the undo stack MyAlgorithm.superclass.init.call(this, am, w, h); this.addControls(); // Useful for memory management this.nextIndex = 0; // TODO: Add any code necessary to set up your own algorithm. Initialize data // structures, etc. }
MyAlgorithm.prototype.addControls = function() { this.controls = []; // Add any necessary controls for your algorithm. // There are libraries that help with text entry, buttons, check boxes, radio groups // // To add a button myButton: // this.mybytton = addControlToAlgorithmBar("Button", "MyButtonText"); // this.mybytton.onclick = this.myCallback.bind(this); // this.controls.push(this.mybutton); // where myCallback is a method on this function that implemnts the callback // // To add a text field myField: // this.myField = addControlToAlgorithmBar("Text", ""); // this.myField.onkeydown = this.returnSubmit(this.myField, // this.anotherCallback.bind(this), // callback to make when return is pressed // maxFieldLen, // integer, max number of characters allowed in field // intOnly); // boolean, true of only digits can be entered. // this.controls.push(this.myField); // // To add a textbox: // this.myCheckbox = addCheckboxToAlgorithmBar("Checkbox Label"); // this.myCheckbox.onclick = this.checkboxCallback.bind(this); // this.controls.push(myCheckbox); // // To add a radio button group: // this.radioButtonList = addRadioButtonGroupToAlgorithmBar(["radio button label 1", // "radio button label 2", // "radio button label 3"], // "MyButtonGroupName"); // this.radioButtonList[0].onclick = this.firstRadioButtonCallback.bind(this); // this.controls.push(this.radioButtonList[0]); // this.radioButtonList[1].onclick = this.secondRadioButtonCallback.bind(this); // this.controls.push(this.radioButtonList[1]); // this.radioButtonList[2].onclick = this.thirdRadioButtonCallback.bind(this); // this.controls.push(this.radioButtonList[1]); // // Note that we are adding the controls to the controls array so that they can be enabled / disabled // by the animation manager (see enableUI / disableUI below) }
- This reset method is called, which resets the state of your object to exactly how it was before any operations were performed
- All of the operations up until the last one are replayed (though the animation information is thrown away
- We end up in the same state that we were in right before the last operation was done
MyAlgorithm.prototype.reset = function() { // Reset all of your data structures to *exactly* the state they have immediately after the init // function is called. This method is called whenever an "undo" is performed. Your data // structures are completely cleaned, and then all of the actions *up to but not including* the // last action are then redone. If you implement all of your actions through the "implementAction" // method below, then all of this work is done for you in the Animation "superclass" // Reset the (very simple) memory manager this.nextIndex = 0; }
////////////////////////////////////////////// // Callbacks: ////////////////////////////////////////////// // // All of your callbacks should *not* do any work directly, but instead should go through the // implement action command. That way, undos are handled by ths system "behind the scenes" // // A typical example: // //MyAlgorithm.prototype.insertCallback = function(event) //{ // // Get value to insert from textfield (created in addControls above) // var insertedValue = this.insertField.value; // // // If you want numbers to all have leading zeroes, you can add them like this: // insertedValue = this.normalizeNumber(insertedValue, 4); // // // Only do insertion if the text field is not empty ... // if (insertedValue != "") // { // // Clear text field after operation // this.insertField.value = ""; // // Do the actual work. The function implementAction is defined in the algorithm superclass // this.implementAction(this.insertElement.bind(this), insertedValue); // } //} // Note that implementAction takes as parameters a function and an argument, and then calls that // function using that argument (while also storing the function/argument pair for future undos) ////////////////////////////////////////////// // Doing actual work ////////////////////////////////////////////// // The functions that are called by implementAction (like insertElement in the comments above) need to: // // 1. Create an array of strings that represent commands to give to the animation manager // 2. Return this array of commands // // We strongly recommend that you use the this.cmd function, which is a handy utility function that // appends commands onto the instance variable this.commands // // A simple example: // //MyAlgorithm.simpleAction(input) //{ // this.commands = []; // Empty out our commands variable, so it isn't corrupted by previous actions // // // Get a new memory ID for the circle that we are going to create // var circleID = nextIndex++; // var circleX = 50; // var circleY = 50; // // // Create a circle // this.cmd("CreateCircle", circleID, "Label", circleX, circleY); // circleX = 100; // // Move the circle // this.cmd("Move", circleID, circleX, circleY); // // First Animation step done // this.cmd("Step"); // circleX = 50; // circleY = 100; // // Move the circle again // this.cmd("Move", circleID, circleX, circleY); // // Next Animation step done // this.cmd("Step"); // // Return the commands that were generated by the "cmd" calls: // return this.commands; //}
// Called by our superclass when we get an animation started event -- need to wait for the // event to finish before we start doing anything MyAlgorithm.prototype.disableUI = function(event) { for (var i = 0; i < this.controls.length; i++) { this.controls[i].disabled = true; } } // Called by our superclass when we get an animation completed event -- we can /// now interact again. MyAlgorithm.prototype.enableUI = function(event) { for (var i = 0; i < this.controls.length; i++) { this.controls[i].disabled = true; } }
//////////////////////////////////////////////////////////// // Script to start up your function, called from the webapge: //////////////////////////////////////////////////////////// var currentAlg; function init() { var animManag = initCanvas(); currentAlg = new MyAlgorithm(animManag, canvas.width, canvas.height); }
Animation Commands
The commands that we give to the animatino manager are a list (array) of strings. Each string starts with the name of the command (case-insensitive) followed by a list of arguments, separated by the token <;&rt;. The first argument of (almost) every command is the ID of the object you want to create or access. So, the string to Move element 37 to position (100, 120) would be:- "Move<;>37<;>100<;>120"
Object Creation and Deletion Commands
Object creation commands take as a first argument an integer representing the index of the object to create. This integer must not be the same as another object that is currently active in the system (though you can reuse numbers once the objects have been deleted). Like all commands, the creation commands have some required and some optional parameters.- CreateCircle: objectID, label, [initial_x, initial_y]
- objectID: Non-negative integer that represents the ID of this object. Must be different from any ID currently active. Should be as small as posslbe for better performance.
- label: the label that appears in the middle of the circle. It may contain end of line (\n) characters, which allows you to place a multi-line label in the circle. Labels are centered in circles.
- initial_x: (optional, defaults to 0) the initial x position of the circle
- initial_y: (optional, defaults to 0) the initial u position of the circle
- CreateRectange: objectID, label, width, height, [initial_x, initial_y, xJustify, yJustufy, backgroundColor, foregroundColor]
- objectID: Non-negative integer that represents the ID of this object. Must be different from any ID currently active. Should be as small as posslbe for better performance.
- label: the label that appears in the middle of the rectangle. It may contain end of line (\n) characters, which allows you to place a multi-line label in the rectangle. Labels are centered in rectangles.
- width: The width of the rectangle, in pixels
- height: The height of the rectangle, in pixels
- initial_x: (optional, defaults to 0) the initial x position of the rectangle
- initial_y: (optional, defaults to 0) the initial u position of the rectangle
- xJustify: (optional, defaults to "center"). One of "center", "left", "right" -- If the rectangle is at location (x, y), does x stand for the left, center, or right of the rectangle
- yJustify: (optional, defaults to "center"). One of "center", "top", "bottom" -- If the rectangle is at location (x,y0 does y stand for the top, center, or bottom of the rectangle
- backgroundColor: The initial color of the background of the rectangle, using HTML colors (#FF0000 for red, #00FF00 for green, and so on)
- backgroundColor: The initial color of the forground of the rectangle, using HTML colors (#FF0000 for red, #00FF00 for green, and so on)
- CreateHighlightCircle: objectID, color, [initial_x, initial_y, radius]
A highlight circle is much like a standard circle, except that it has no label, and no background color, so that it does not obscure other objects like a circle does.- objectID: Non-negative integer that represents the ID of this object. Must be different from any ID currently active. Should be as small as posslbe for better performance.
- color: The initial color of the circle, using HTML colors (#FF0000 for red, #00FF00 for green, and so on)
- initial_x: (optional, defaults to 0) the initial x position of the circle
- initial_y: (optional, defaults to 0) the initial u position of the circle
- radius: (optional, defaults to 20) The radius of the circle.
- CreateLabel: objectID, label, [initial_x, initial_x, centered]
- objectID: Non-negative integer that represents the ID of this object. Must be different from any ID currently active. Should be as small as posslbe for better performance.
- label: the text of the label. It may contain end of line (\n) characters, which allows you to place a multi-line labels.
- initial_x: (optional, defaults to 0) the initial x position of the label
- initial_y: (optional, defaults to 0) the initial y position of the label
- centered: (optional, defaults to true) true or 1 if the label should be centered, false or 0 if it should not.
- CreateLinkedList: objectID, label, width, height, [initial_x, initial_y, linkPercent, verticalOrientation, linkPosEnd, numLabels]
- objectID: Non-negative integer that represents the ID of this object. Must be different from any ID currently active. Should be as small as posslbe for better performance.
- label: The label inside this linked list element (or the first label, if there are more than one)
- width: The width of the linked list element, in pixels
- height: The height of the linked list element, in pixels
- initial_x: (optional, defaults to 0) the initial x position of the linked list element
- initial_y: (optional, defaults to 0) the initial y position of the linked list element
- linkPercent: (optional, defaults to 0.25) The percentage of the linked list element that the outgoing pointer takes up.
- verticalOrientation: (optional, defaults to true). Should the linked list element be vertial (true) or horizontal (false)
- linkPosEnd: (optional, defaults to false). Should the poiner appear at the bottom or left of the linked list element (true), or the top or right of the linked list element (false)
- numLabels: (optional, defaults to 1). The number of labels that the linked lists element can hold. See the adjacency list implementat of a graph visualization for an example of a linked list element with more than 1 label.
- CreateBTreeNode: objectID, widthPerLabel, height, numLabels, inital_x, initial_y, backgroundColor, foregroundColor Somewhat special-purpose animated object created for B-Trees. Single rectangle containing any number of labels, with no dividing lines between the labels. Edges can be attached between each label, and to the left of the leftmost label, and to the right of the rightmost label. See the BTree and B+ Tree visualizations for examples.
- objectID: Non-negative integer that represents the ID of this object. Must be different from any ID currently active. Should be as small as posslbe for better performance.
- widthPerLabel: The width of the B-Tree node is the number of labels * the width per label. Value is in pixels.
- height: Height of the B-Tree node in pixels
- numLabels: The number of labels in the BTree node.
- initial_x: The initial x position of the B-Tree node
- initial_y: The initial y position of the B-Tree node
- backgroundColor: The initial color of the background of the rectangle, using HTML colors (#FF0000 for red, #00FF00 for green, and so on)
- backgroundColor: The initial color of the forground of the rectangle, using HTML colors (#FF0000 for red, #00FF00 for green, and so on)
- Delete: objectID
- objectID: The ID of the object to delete. All edges incident on this object will be removed. (If the delete is undone, then all such edges will be restored). Once an Animated Element has been deleted, its ID is free to be used again. Note that overly complicated ID management (which is really memory management, since IDs are just indicies into a "memory array" of active animated objects) is not necessarily recommended, since it can lead to some subtle bugs.
Object Manipulation Commands
- Move: objectID, toX, toY Move the object smoothly over the next step from the current position to the new position
- objectID: The ID of the object to move. The object must exists, or an exception will be thrown
- toX: The new X location to move to
- toY: The new Y location to move to
- SetForegroundColor: objectID, color Sets the foreground color (outline color and label color) of an object. Note that if an object has several labels this will set the color of all labels.
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- color: New foreground color
- SetBackgroundColor: objectID, color Sets the background color of current object. Note that if an object has several labels this will set the color of an object.
- objectID: The ID of the object to modify. The object must exist, or an exception will be thrown
- color: New background color
- SetHighlight: objectID, highlightVal Mark an object as either highlighted or unhighlighted, based on the value of highlightVal. objects that are highlighted will pulse red. Any object can be highlighted (thought labels are slightly harder to read when highlighted) Note that if an object is left highlighted after an animation is ended, it will not pulse until the animation starts again. Edges can be highlighted using the highlight edge command.
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- highlightVal: 1 or true, turn on highlighting. 0 or false, turn off highlighting.
- SetText: objectID, newText, [textIndex] Sets the value of the label associated with the object (the printing withing a circle, for instance).
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- newText: The new text of the label
- textIndex: (optional, defaults to 0) Index of the text label to change. Only used in objects that have more than one text label (B-Tree nodes, Linked List nodes). If the object does not support multiple labels, this is a no-op.
- SetAlpha: objectID Sets the alpha (transparency) of the object. 0 is completely transparent, 1 is completely opaque
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- SetHeight: objectID, newHeight Sets the height (in pixels) of the object.
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- newHeight: The new height of the object.
- SetWidth: objectID, newWIdth Sets the width (in pixels) of the object.
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- newWidth: The new width of the object.
- SetTextColor: objectID, newColor, [textIndex] Sets the color of the label associated with the object
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- newColor: The new color to set. As with all colors, should be a html color string
- textIndex: (optional, defaults to 0) If the object contain multiple labels (such as a linked-list node, or a B-Tree node) determine which label to change the color of. If the object only has one label, this parameter is ignored.
- SetNull: objectID, nullValue Currently only used for linked-list elements. Should the area set aside for the pointer in the linked list object be drawn as a null pointer (slash through the field)? This should probably be automated (draw the slash if and only if the node is not connected to anything), but for now this must be done manually.
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- nullValue: 0 or false for do not draw the slash, 1 or true for draw the slash.
- SetNumElements: objectID, numElements Currently only used for B-Tree nodes. Changes the number of labels stored in this B-tree node. Should probably be extended to at least Linked-list nodes.
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- numElements: integer, the number of elements this B-Tree node should have
Edge Manipulation Commands
Edges are manipulated by giving the two objects associated with the edge. While edges can be graphically directed or undirected, all edges under the hood have a direction, which is the direction that they were given when the edge was created. There can only be one edge from any object to any other object (though there can be an edge from object1 to object2, and a different edge from object2 to object1.) Edges are always referred to by two IDs - the objectID of the "from" object, followed by the objectID of the "to" object. Any object can be connected to any other object.- Connect: fromID, toID, [linkColor, curve, directed, label, anchorPosition]
- fromID: The ID of the object at the tail of the new edge
- toID: The ID of the object at the head of the new edge
- linkColor: (optional, defaults to "#000000") The color of the edge
- linkColor: (optional, defaults to false) true for a diected edge, false for an undirected edge
- curve: (optional, defaults to 0.0) The "curviness" of the edge. 0.0 is perfectly straight, positive values arc to the right, negative values arc to the left.
- directed (optional, defaults to true). True if the edge is directed, false if the edge is undirected
- label (optional, defaults to ""). The label that appears along the edge (useful for things like edge costs in graphs)
- anchorPosition (optional, defaults to 0) If the edge could have more than one attachment postion at the "from" node, (currently only used for B-Tree nodes, but could well be expanded to things like doubly-linked lists) the index of the attachment position to use. Ignored for animated objects that do not have multiple attachment positions
- Disconnect: fromID, toID Removes an edge between two elements. If there is no edge, then this operation is a no-op.
- fromID: The ID of the "From" direction of the edge
- toID: The ID of the "To" direction of the edge
- SetAlpha: objectID Sets the alpha (transparency) of the object. 0 is completely transparent, 1 is completely opaque
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- SetEdgeHighlight: fromID, toID, highlightVal Mark an edge as either highlighted or unhighlighted, based on the value of highlightVal. Edges that are highlighted will pulse red.
- fromID: The ID of the "From" direction of the edge
- toID: The ID of the "To" direction of the edge
- higlightVal: 0 or false, turn of higlighting. 1 or true, turn on highlighting.
- ,
Special Commands
- Step: <No parameters> The step command allows you to keep everything from happening at once. The way that most animations will work is that you will create a group of objects, then do a step, then do some movements, then do a step, then do more movements, then do a step, and so on. All commands that appear between adjacent steps will happen simultaneously. Each step represents where the animation will pause when it is in single-step mode.
- SetLayer objectID, newLayer Sets the layer of the object. All objects default to layer 0, and the "shown" layer always defaults to 0. You can change the layers of different objects, and then change the list of which layers are currently shown, to show or hide objects dynamically. (This is often useful for allowing the user to show or hide information, or to alternate between different versions of a representation). An object will only appear if its layer is one of the layers listed to be shown. An edge will only appear of each of the objects that it connect are to be shown. While commands cannot be executed while an animation is running, the global set of visible layers can be changed while an animation is running
- objectID: The ID of the object to modify. The object must exists, or an exception will be thrown
- layer: The new layer for this object. Each object must live in one and only one layer (though any combination of layers can be shown at any given time)
Simple Stack Example
Everything make sense so far? Time for a simple, complete example. A simple stack visualization can be found at: Looking at the complete SimpleStack.js file in its entirety:All code released under a FreeBSD license
// Copyright 2011 David Galles, University of San Francisco. All rights reserved. // // Redistribution and use in source and binary forms, with or without modification, are // permitted provided that the following conditions are met: // // 1. Redistributions of source code must retain the above copyright notice, this list of // conditions and the following disclaimer. // // 2. Redistributions in binary form must reproduce the above copyright notice, this list // of conditions and the following disclaimer in the documentation and/or other materials // provided with the distribution.   // // The views and conclusions contained in the software and documentation are those of the // authors and should not be interpreted as representing official policies, either expressed // or implied, of the University of San Francisco
function SimpleStack(am, w, h) { this.init(am, w, h); } SimpleStack.prototype = new Algorithm(); SimpleStack.prototype.constructor = SimpleStack; SimpleStack.superclass = Algorithm.prototype;
SimpleStack.ELEMENT_WIDTH = 30; SimpleStack.ELEMENT_HEIGHT = 30; SimpleStack.INSERT_X = 30; SimpleStack.INSERT_Y = 30; SimpleStack.STARTING_X = 30; SimpleStack.STARTING_Y = 100; SimpleStack.FOREGROUND_COLOR = "#000055" SimpleStack.BACKGROUND_COLOR = "#AAAAFF"
function SimpleStack( ...However, all of the work of the constructor is done in the init function -- that way constructors of subclass can effectively call the constructors of their superclasses. For the init function in this case, we need to do very little work. In this simple example we are not adding any elements to the canvas at load time. All we need to do is set up our own internal data structures. We are keeping track of two arrays -- an array that stores the actual stack (stackValues), and an array that stores the objectIDs of the elements of the stack (stackID)
SimpleStack.prototype.init = function(am, w, h) { // Call the unit function of our "superclass", which adds a couple of // listeners, and sets up the undo stack SimpleStack.superclass.init.call(this, am, w, h); this.addControls(); // Useful for memory management this.nextIndex = 0; this.stackID = []; this.stackValues = []; this.stackTop = 0; }
this.popButton.onclick = this.popCallbackto add our callbacks. Why not? This would pass in the proper function, but not the proper contex -- essentially, it would be passing a pointer to the code of the function, without saving the "this" pointer. So we need to bind the "this" pointer to our function before we store it.
SimpleStack.prototype.addControls = function() { this.controls = []; this.pushField = addControlToAlgorithmBar("Text", ""); this.pushField.onkeydown = this.returnSubmit(this.pushField, this.pushCallback.bind(this), // callback to make when return is pressed 4, // integer, max number of characters allowed in field false); // boolean, true of only digits can be entered. this.controls.push(this.pushField); this.pushButton = addControlToAlgorithmBar("Button", "Push"); this.pushButton.onclick = this.pushCallback.bind(this); this.controls.push(this.pushButton); this.popButton = addControlToAlgorithmBar("Button", "Pop"); this.popButton.onclick = this.popCallback.bind(this); this.controls.push(this.popButton); }
Function.prototype.bind = function() { var _function = this; var args = Array.prototype.slice.call(arguments); var scope = args.shift() return function() { for (var i = 0; i < arguments.length; i++) { args.push(arguments[i]); } return _function.apply(scope, args); } }Moving on ... Next up is the reset function. All visualizations must implement the reset method. The reset method needs to restore all of our variables to the state that they were in right after the call to init. In our case, we only have 2 variables of importance. We could have recreated the arrays stackID and stackValues, but that is not necessary in this case, since we don't care about the current values in those arrays -- we will write over any value before we read it, once the stack top is 0.
SimpleStack.prototype.reset = function() { // Reset the (very simple) memory manager. // NOTE: If we had added a number of objects to the scene *before* any user // input, then we would want to set this to the appropriate value based // on objects added to the scene before the first user input this.nextIndex = 0; // Reset our data structure. (Simple in this case) this.stackTop = 0; }
SimpleStack.prototype.pushCallback = function() { var pushedValue = this.pushField.value; if (pushedValue != "") { this.pushField.value = ""; this.implementAction(this.push.bind(this), pushedValue); } } SimpleStack.prototype.popCallback = function() { this.implementAction(this.pop.bind(this), ""); }
SimpleStack.prototype.push = function(pushedValue) { this.commands = []; this.stackID[this.stackTop] = this.nextIndex++; this.cmd("CreateRectangle", this.stackID[this.stackTop], pushedValue, SimpleStack.ELEMENT_WIDTH, SimpleStack.ELEMENT_HEIGHT, SimpleStack.INSERT_X, SimpleStack.INSERT_Y); this.cmd("SetForegroundColor", this.stackID[this.stackTop], SimpleStack.FOREGROUND_COLOR); this.cmd("SetBackgroundColor", this.stackID[this.stackTop], SimpleStack.BACKGROUND_COLOR); this.cmd("Step"); var nextXPos = SimpleStack.STARTING_X + this.stackTop * SimpleStack.ELEMENT_WIDTH; var nextYPos = SimpleStack.STARTING_Y; this.cmd("Move", this.stackID[this.stackTop], nextXPos, nextYPos); this.cmd("Step"); // Not necessary, but not harmful either this.stackTop++; return this.commands; } SimpleStack.prototype.pop = function(unused) { this.commands = []; if (this.stackTop > 0) { this.stackTop--; this.cmd("Move", this.stackID[this.stackTop], SimpleStack.INSERT_X, SimpleStack.INSERT_Y); this.cmd("Step"); this.cmd("Delete", this.stackID[this.stackTop]); this.cmd("Step"); // OPTIONAL: We can do a little better with memory leaks in our own memory manager by // reclaiming this memory. It is recommened that you *NOT* do this unless // you really know what you are doing (memory management leads to tricky bugs!) // *and* you really need to (very long runnning visualizaitons, not common) // Because this is a stack, we can reclaim memory easily. Most of the time, this // is not the case, and can be dangerous. // nextIndex = this.stackID[this.stackTop]; } return this.commands; }
// Called by our superclass when we get an animation started event -- need to wait for the // event to finish before we start doing anything SimpleStack.prototype.disableUI = function(event) { for (var i = 0; i < this.controls.length; i++) { this.controls[i].disabled = true; } } // Called by our superclass when we get an animation completed event -- we can /// now interact again. SimpleStack.prototype.enableUI = function(event) { for (var i = 0; i < this.controls.length; i++) { this.controls[i].disabled = false; } }
//////////////////////////////////////////////////////////// // Script to start up your function, called from the webapge: //////////////////////////////////////////////////////////// var currentAlg; function init() { var animManag = initCanvas(); currentAlg = new SimpleStack(animManag, canvas.width, canvas.height); }
HTML Template
This visualization system is a combination of HTML and javascript -- you need a webpage to embed the javascript, and that webpage needs the following items:- A bunch of <script> tags in the header to load oll of the necessary scripts. These files need to be included in the correct order, based on dependancies. (It would be nice if javascript had a standard #include-like mechanism to avoid manually inserting all of these files in the HTM. While there are some ways around it -- dynamically inserting the <script> tags using javascript calls -- not all browsers seem to work with these somewhat hacky methods. A brute-force inclusion of all the files, in the proper order, works everywhere)
- An empty table with the id "algoControlSection" where the algorithm specific controls are to be placed
- A canvas element, where the animations will appear
- An empty table with the id "GeneralAnimationControls" where general animation controls are to be placed
- An onload = "init();" command in the body tag to kick everything off
<html> <head> <title> Place your title here </title> <!-- css sheet for how the page is laid out --> <link rel="stylesheet" href="visualizationPageStyle.css"> <!-- jqueury stuff. Only used for the animation speed slider. --> <link rel="stylesheet" href="ThirdParty/jquery-ui-1.8.11.custom.css"> <script src="ThirdParty/jquery-1.5.2.min.js"></script> <script src="ThirdParty/jquery-ui-1.8.11.custom.min.js"></script> <!-- Javascript for the actual visualization code --> <script type = "application/javascript" src = "AnimationLibrary/CustomEvents.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/UndoFunctions.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/AnimatedObject.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/AnimatedLabel.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/AnimatedCircle.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/AnimatedRectangle.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/AnimatedLinkedList.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/HighlightCircle.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/Line.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/ObjectManager.js"> </script> <script type = "application/javascript" src = "AnimationLibrary/AnimationMain.js"> </script> <script type = "application/javascript" src = "AlgorithmLibrary/Algorithm.js"> </script> <script type = "application/javascript" src = "Place path to your javasript file here"> </script> </head> <body onload="init();" class="VisualizationMainPage"> <div id = "container"> <div id="header"> <h1>Place your Header here </h1> </div> <div = id = "mainContent"> <div id = "algoControlSection"> <!-- Table for buttons to control specific animation (insert/find/etc) --> <!-- (filled in by javascript code specific to the animtion) --> <table id="AlgorithmSpecificControls"> </table> </div> <!-- Drawing canvas where all animation is done. Note: can be resized in code --> <canvas id="canvas" width="1000" height="500"></canvas> <div id = "generalAnimationControlSection"> <!-- Table for buttons to control general animation (play/pause/undo/etc) -> <!-- (filled in by javascript code, specifically AnimationMain.js) --> <table id="GeneralAnimationControls"> </table> </div> </div> <!-- mainContent --> <div id="footer"> <p><a href="Algorithms.html">Algorithm Visualizations</a></p> </div> </div><!-- container --> </body> </html>
Quirks and Advanced Techniques
Object Diplsay Order
If two object overlap, which one is placed on top? The animation system uses the following rules to determine draw order:- All non-highlighted items are drawn after all highlighted items (so highlighted items will appear on top of non-highlighted items)
- All items with the same highlight state are drawn in order of their identifiers (so objects with larger identifiers will be drawn in front of objects with small identifiers)


IFZ FinTech Conference 2020
by Hochschule Luzern| 04 - 04 mar 2020 | Rotkreuz |
Fascinating and constructive debates of and with top class speakers.
FinTech is considered an innovative solution for the challenges in the financial industry and shows a high growth rate. In addition to the presentation of the results of the IFZ FinTech study, we will be hearing about recent developments in the field of FinTech from our excellent speakers.
The speeches are either in German or English, without simultaneous translation.
Speakers
- Thomas Ankenbrand, Lucerne School of Business, Institute of Financial Services Zug IFZ
- Urs Meier, Homburger AG
- Fabio Sigrist, Lucerne School of Business, Institute of Financial Services Zug IFZ
- Further speakers to be announced
place of event
Lucerne School of Business Institute of Financial Services Zug
Campus Zug-Rotkreuz, Suurstoffi 1
6343 Rotkreuz


{% extends "base.html" %} {% block title %}Home{% endblock %} {% block heading %}Globus Auth Demo of XSEDE Client App{% endblock %} {% block content %}
Display your Globus Auth account's XSEDE identity information by logging in using any identity linked to the same Globus Auth account as your XSEDE identity.
{% endblock %}


Writer
scalaz
withNamedViewAndCluster
BreadCrumbs
withNamedViewAndClusterAndTopic
BreadCrumbs
withView
BreadCrumbs
withViewAndCluster
BreadCrumbs
writePreferredReplicaElectionData
PreferredReplicaLeaderElectionCommand


Giant Kern
| Fighting Style | ||
| When Dieing Do they run | ? | |
| Ranged Attack | ? | |
| AOE Area of Attack | ? | |
| Spawns lesser monsters | ? |
Giant Kern Pronounced g-eye-ant kirn
Kerns have got to be the most unique monsters. They are made form molten rock and have two large feet. They are short but very large and husky. They vary in color from a green and brown to a maroon and black. They have two thick horns curving downward from their foreheads.  Two 'tails' stick out behind the spikes on the Kern's back. On each 'tail' is a white or blue tattoo. When you explore the depths of Darkon 3 listen for their heavy stomp and deep roar; it's a sign to start running!
Locating Giant Kern
The most popular spawn of Kern is in the Southernmost part of Darkon 3 . Just directly to the
East of the House of Glaphan.
| Giant Kern |
Available
that involve this masquerpet
Giant Kern Statistics
| Name | lvl | HP | Def | Mdef | Exp | Atk | Ele |
| Giant Kern | 104 | 1,235,058 | 103 | 178 | 3,073,551 | 2,299~2,420 |
Note: Atk stat comes from kFlyff and may differ from our version.
Drops
Rnamond Icecream Cake Food item for recovering HP. Meat Salad Food item for recovering HP. Eighth Refresher Food item for recovering MP. VitalDrink 800 Food item for recovering FP. Vigor Ring Ring which increases STR by +1. Penya In game currency. Also drops equipment such as Armor and Weapons .
Trivia