|
Biomedical Image Analysis Library
The Biomedical Image Analysis Library is a poweful tool for developers, physicians, researchers, engineers, and so on.
|
Signal handeling declaration. More...
#include <Signal.hpp>
Public Member Functions | |
| Signal () | |
| Basic constructor. More... | |
| Signal (size_t data_size, double data_minimum=0.0, double data_step=1.0) | |
| Basic constructor. All frequencies are initiated with 0.0. More... | |
| template<class D > | |
| Signal (Vector< D > &new_frequency, double data_minimum=0.0, double data_step=1.0) | |
| Basic constructor. More... | |
| template<class D > | |
| Signal (Vector< D > &new_frequency, Vector< D > &new_data) | |
| Basic constructor. More... | |
| Signal (const Signal &sgn) | |
| Copy Constructor. More... | |
| Signal (Signal &&)=default | |
| Move Constructor. More... | |
| Signal & | operator= (const Signal &other) |
| Assigns 'other'signal to this signal. More... | |
| Signal & | operator= (Signal &&)=default |
| Assigns 'other'signal to this signal, moving the content. More... | |
| const double & | operator[] (size_t bin) const |
| Returns frequency at bin 'bin'. More... | |
| double & | operator[] (size_t p) |
| Returns a reference to bin 'bin'. More... | |
| size_t | Size () const |
| Returns the number of bins. More... | |
| size_t | size () const |
| Returns the number of bins. More... | |
| size_t | Bins () const |
| Returns the number of bins. Same as Size( ) method. More... | |
| const double * | Data () const |
| Returns signal data. More... | |
| double * | Data () |
| Returns signal data. More... | |
| const double * | data () const |
| Returns signal data. More... | |
| double * | data () |
| Returns signal data. More... | |
| template<class D > | |
| void | Data (Vector< D > val) |
| Assigns a copy of val to data. Frequency vector remains unchanged. More... | |
| const double * | Frequency () const |
| Returns a pointer to the signal data. More... | |
| double * | Frequency () |
| Returns a pointer to the signal data. More... | |
| void | Frequency (Vector< double > val) |
| Assigns a copy of val to frequency. Data vector remains unchanged. More... | |
| double | MinimumFrequency (size_t min_bin=0) const |
| Returns the minimum frequency contained in bins from min_bin to the last bin (including the extremities). More... | |
| double | MinimumFrequency (size_t min_bin, size_t max_bin) const |
| Returns the minimum frequency contained in bins from min_bin to max_bin (including the extremities). More... | |
| double | MaximumFrequency (size_t min_bin=0) const |
| Returns the maximum frequency contained in bins from min_bin to the last bin (including the extremities). More... | |
| double | MaximumFrequency (size_t min_bin, size_t max_bin) const |
| Returns the maximum frequency contained in bins from min_bin to max_bin (including the extremities). More... | |
| size_t | MinimumFrequencyBin (size_t min_bin=0) const |
| Returns the bin of the minimum frequency contained in bins from min_bin to the last bin (including the extremities). More... | |
| size_t | MinimumFrequencyBin (size_t min_bin, size_t max_bin) const |
| Returns the bin of the minimum frequency contained in bins from min_bin to max_bin (including the extremities). More... | |
| size_t | MaximumFrequencyBin (size_t min_bin=0) const |
| Returns the bin of the maximum frequency contained in bins from min_bin to the last bin (including the extremities). More... | |
| size_t | MaximumFrequencyBin (size_t min_bin, size_t max_bin) const |
| Returns the bin of the maximum frequency contained in bins from min_bin to max_bin (including the extremities). More... | |
| size_t | Bin (double val) const |
| Returns the closest bin into which 'val' would fall. More... | |
| void | Bin (size_t bin, double val) |
| Sets value "val" to histogram bin "bin". More... | |
| const double & | Data (size_t bin) const |
| Returns data corresponding to the input bin. More... | |
| double & | Data (size_t bin) |
| Assigns value to data bin. More... | |
| template<class O > | |
| void | Print (O &os) const |
| Prints signal containts to output stream os. It prints a pair composed by frequency and value per line. More... | |
Signal handeling declaration.
Definition at line 20 of file Signal.hpp.
| Bial::Signal::Signal | ( | ) |
Basic constructor.
| none. |
| Bial::Signal::Signal | ( | size_t | data_size, |
| double | data_minimum = 0.0 , |
||
| double | data_step = 1.0 |
||
| ) |
Basic constructor. All frequencies are initiated with 0.0.
| data_size | Number of samples. |
| data_minimum | Minimum data value. |
| data_step | Data step between two consecutive samples. |
| Bial::Signal::Signal | ( | Vector< D > & | new_frequency, |
| double | data_minimum = 0.0 , |
||
| double | data_step = 1.0 |
||
| ) |
Basic constructor.
| new_frequency | Frequency to be assigned to the signal. |
| data_minimum | Minimum data value. |
| data_step | Data step between two consecutive samples. |
Basic constructor.
| new_frequency | Frequency to be assigned to the signal. |
| new_data | Data to be assigned to the signal. |
Copy Constructor.
| filename | File name. |
|
default |
Move Constructor.
| sgn | Other signal. |
| size_t Bial::Signal::Bin | ( | double | val | ) | const |
Returns the closest bin into which 'val' would fall.
| val | Data value. |
| void Bial::Signal::Bin | ( | size_t | bin, |
| double | val | ||
| ) |
Sets value "val" to histogram bin "bin".
| bin | the bin to be set. |
| val | Data value. |
| size_t Bial::Signal::Bins | ( | ) | const |
Returns the number of bins. Same as Size( ) method.
| none. |
| const double* Bial::Signal::Data | ( | ) | const |
| double* Bial::Signal::Data | ( | ) |
| const double* Bial::Signal::data | ( | ) | const |
| double* Bial::Signal::data | ( | ) |
| void Bial::Signal::Data | ( | Vector< D > | val | ) |
Assigns a copy of val to data. Frequency vector remains unchanged.
| val | A Vector to be assigned. |
| const double& Bial::Signal::Data | ( | size_t | bin | ) | const |
Returns data corresponding to the input bin.
| bin | Data bin. |
| double& Bial::Signal::Data | ( | size_t | bin | ) |
Assigns value to data bin.
| bin | Data bin. |
| val | Data value. |
| const double* Bial::Signal::Frequency | ( | ) | const |
Returns a pointer to the signal data.
| none. |
| double* Bial::Signal::Frequency | ( | ) |
Returns a pointer to the signal data.
| none. |
| void Bial::Signal::Frequency | ( | Vector< double > | val | ) |
Assigns a copy of val to frequency. Data vector remains unchanged.
| val | A Vector to be assigned. |
| double Bial::Signal::MaximumFrequency | ( | size_t | min_bin = 0 | ) | const |
Returns the maximum frequency contained in bins from min_bin to the last bin (including the extremities).
| min_bin | left most bin. |
| double Bial::Signal::MaximumFrequency | ( | size_t | min_bin, |
| size_t | max_bin | ||
| ) | const |
Returns the maximum frequency contained in bins from min_bin to max_bin (including the extremities).
| min_bin | left most bin. |
| max_bin | right most bin. |
| size_t Bial::Signal::MaximumFrequencyBin | ( | size_t | min_bin = 0 | ) | const |
Returns the bin of the maximum frequency contained in bins from min_bin to the last bin (including the extremities).
| min_bin | left most bin. |
| size_t Bial::Signal::MaximumFrequencyBin | ( | size_t | min_bin, |
| size_t | max_bin | ||
| ) | const |
Returns the bin of the maximum frequency contained in bins from min_bin to max_bin (including the extremities).
| min_bin | left most bin. |
| max_bin | right most bin. |
| double Bial::Signal::MinimumFrequency | ( | size_t | min_bin = 0 | ) | const |
Returns the minimum frequency contained in bins from min_bin to the last bin (including the extremities).
| min_bin | left most bin. |
| double Bial::Signal::MinimumFrequency | ( | size_t | min_bin, |
| size_t | max_bin | ||
| ) | const |
Returns the minimum frequency contained in bins from min_bin to max_bin (including the extremities).
| min_bin | left most bin. |
| max_bin | right most bin. |
| size_t Bial::Signal::MinimumFrequencyBin | ( | size_t | min_bin = 0 | ) | const |
Returns the bin of the minimum frequency contained in bins from min_bin to the last bin (including the extremities).
| min_bin | left most bin. |
| size_t Bial::Signal::MinimumFrequencyBin | ( | size_t | min_bin, |
| size_t | max_bin | ||
| ) | const |
Returns the bin of the minimum frequency contained in bins from min_bin to max_bin (including the extremities).
| min_bin | left most bin. |
| max_bin | right most bin. |
Assigns 'other'signal to this signal.
| other | Signal to be assigned to this. |
Assigns 'other'signal to this signal, moving the content.
| other | Signal to be assigned to this. |
| const double& Bial::Signal::operator[] | ( | size_t | bin | ) | const |
Returns frequency at bin 'bin'.
| bin | Bin to be acessed. |
| double& Bial::Signal::operator[] | ( | size_t | p | ) |
| void Bial::Signal::Print | ( | O & | os | ) | const |
Prints signal containts to output stream os. It prints a pair composed by frequency and value per line.
| os | an output stream. |
| size_t Bial::Signal::Size | ( | ) | const |
Returns the number of bins.
| none. |
| size_t Bial::Signal::size | ( | ) | const |
Returns the number of bins.
| none. |


Users need not learn new programming languages or syntax to use the tool. It lets the user write all the code necessary for the experimenting in python.
NeST is a python package that handles testbed setup, testbed configuration, collecting and visualizing data by providing a user friendly API, addressing common issues involved in conducting networking experiments.
The tool doesn't need high system requirements to be able to run it. It just needs a Linux Operating System with netperf version 2.6 or above and iperf version 3.0.11 or above installed.


Plugin Information |
|---|
View Build Keeper on the plugin site for more information. |
Features
Compatibility
Install
Change log
Features
- Automatically mark builds as "keep forever" to prevent them from being removed when using "discard old builds"
- Use the Policy extension point to define your own policies for selecting builds to keep
Compatibility
This plugin is compatible with Jenkins 1.408+
Install
This plugin can be installed from the Plugin Manager (Manage Jenkins > Manage Plugins) under "Build Wrappers".
To install manually, download the latest plugin from http://mirrors.jenkins-ci.org/plugins/build-keeper-plugin/ and use the Upload Plugin option in the Advanced tab of the Plugin Manager.
Change log
1.3 (16/04/2012)
- Add a policy that evaluates Run Conditions and keeps the build if the build step would have run
- Now requires Jenkins 1.408 (from 1.396)
1.2 (11/01/2012)
- Add a policy to keep the first failed build in a run of consecutive failed builds
1.1 (19/07/2011)
- Add "Keep the first successful build every x days" to keep at least one build every so many days
1.0 (18/07/2011)
- Initial release
Questions, Comments, Bugs and Feature Requests
Please post questions or comments about this plugin to the Jenkins User mailing list.
To report a bug or request an enhancement to this plugin please create a ticket in JIRA.


Newcastle United youngster Kell Watts picks up knee injury and returns to Benton
The Magpies are impressed with his efforts so far after joining Stevenage back in the summer
by Lee RyderNewcastle United youngster Kell Watts has returned to the club following a loan deal from Stevenage.
But the 20-year-old is expected to return to the EFL club in the new year.
Watts has picked up a knee injury while on loan with Mark Sampson's League Two side and has returned to Tyneside for treatment for the rest of the month.
United have been quietly impressed with Watts' loan stint so far with the defender playing in 20 matches this term in the EFL's basement division.
Watts recently signed a three-year deal with the Magpies to commit his future to the club.
The Alnwick-born player was one of the stars of the season for United in the Under-23s last season as they reached two finals and the latter stages of the EFL Trophy.
Watts also made his debut for the first team in pre-season in the Premier League Asia Trophy game against Wolverhampton Wanderers in Nanjing.


Ember.EventDispatcher Class
Ember.EventDispatcher
handles delegating browser events to their
corresponding Ember.Views.
For example, when you click on a view,
Ember.EventDispatcher
ensures that that view's mouseDown
method gets
called.
Item Index
Methods
- _lazyInjections
- _onLookup
- _scheduledDestroy
- addClass
- addObserver
- attr
- beginPropertyChanges
- cacheFor
- decrementProperty
- destroy
- element
- endPropertyChanges
- get
- getProperties
- getViewClientRects
- getWithDefault
- hasObserverFor
- id
- incrementProperty
- init
- notifyPropertyChange
- prop
- propertyDidChange
- propertyWillChange
- push
- removeAttr
- removeObserver
- removeProp
- renderBuffer
- reopen
- reopenClass
- set
- setProperties
- setup
- setupHandler
- string
- style
- toggleProperty
- toString
- willDestroy
Methods
_lazyInjections
()
Object
Returns a hash of property names and container names that injected properties will lookup on the container lazily.
Returns:
Hash of all lazy injected property keys to container names
_onLookup
()
private
Provides lookup-time type validation for injected properties.
_scheduledDestroy
()
private
Invoked by the run loop to actually destroy the object. This is
scheduled for execution by the destroy
method.
addClass
-
className
Adds a class to the buffer, which will be rendered to the class attribute.
Parameters:
-
className
StringClass name to add to the buffer
addObserver
-
key
-
target
-
method
Adds an observer on a property.
This is the core method used to register an observer for a property.
Once you call this method, any time the key's value is set, your observer will be notified. Note that the observers are triggered any time the value is set, regardless of whether it has actually changed. Your observer should be prepared to handle that.
You can also pass an optional context parameter to this method. The context will be passed to your observer method whenever it is triggered. Note that if you add the same target/method pair on a key multiple times with different context parameters, your observer will only be called once with the last context you passed.
Observer Methods
Observer methods you pass should generally have the following signature if
you do not pass a context
parameter:
fooDidChange: function(sender, key, value, rev) { };
The sender is the object that changed. The key is the property that changes. The value property is currently reserved and unused. The rev is the last property revision of the object when it changed, which you can use to detect if the key value has really changed or not.
If you pass a context
parameter, the context will be passed before the
revision like so:
fooDidChange: function(sender, key, value, context, rev) { };
Usually you will not need the value, context or revision parameters at the end. In this case, it is common to write observer methods that take only a sender and key value as parameters or, if you aren't interested in any of these values, to write an observer that has no parameters at all.
attr
-
name
-
value
Adds an attribute which will be rendered to the element.
Returns:
this or the current attribute value
beginPropertyChanges
()
Ember.Observable
Begins a grouping of property changes.
You can use this method to group property changes so that notifications
will not be sent until the changes are finished. If you plan to make a
large number of changes to an object at one time, you should call this
method at the beginning of the changes to begin deferring change
notifications. When you are done making changes, call
endPropertyChanges()
to deliver the deferred change notifications and end
deferring.
Returns:
cacheFor
-
keyName
Returns the cached value of a computed property, if it exists. This allows you to inspect the value of a computed property without accidentally invoking it if it is intended to be generated lazily.
Parameters:
-
keyName
String
Returns:
The cached value of the computed property, if any
decrementProperty
-
keyName
-
decrement
Set the value of a property to the current value minus some amount.
player.decrementProperty('lives');
orc.decrementProperty('health', 5);
Parameters:
Returns:
The new property value
destroy
()
Ember.Object
Destroys an object by setting the isDestroyed
flag and removing its
metadata, which effectively destroys observers and bindings.
If you try to set a property on a destroyed object, an exception will be raised.
Note that destruction is scheduled for the end of the run loop and does not happen immediately. It will set an isDestroying flag immediately.
Returns:
receiver
element
()
DOMElement
Returns:
The element corresponding to the generated HTML of this buffer
endPropertyChanges
()
Ember.Observable
Ends a grouping of property changes.
You can use this method to group property changes so that notifications
will not be sent until the changes are finished. If you plan to make a
large number of changes to an object at one time, you should call
beginPropertyChanges()
at the beginning of the changes to defer change
notifications. When you are done making changes, call this method to
deliver the deferred change notifications and end deferring.
Returns:
get
-
keyName
Retrieves the value of a property from the object.
This method is usually similar to using object[keyName]
or object.keyName
,
however it supports both computed properties and the unknownProperty
handler.
Because get
unifies the syntax for accessing all these kinds
of properties, it can make many refactorings easier, such as replacing a
simple property with a computed property, or vice versa.
Computed Properties
Computed properties are methods defined with the property
modifier
declared at the end, such as:
fullName: function() {
return this.get('firstName') + ' ' + this.get('lastName');
}.property('firstName', 'lastName')
When you call get
on a computed property, the function will be
called and the return value will be returned instead of the function
itself.
Unknown Properties
Likewise, if you try to call get
on a property whose value is
undefined
, the unknownProperty()
method will be called on the object.
If this method returns any value other than undefined
, it will be returned
instead. This allows you to implement "virtual" properties that are
not defined upfront.
Parameters:
-
keyName
StringThe property to retrieve
Returns:
The property value or undefined.
getProperties
-
list
To get the values of multiple properties at once, call getProperties
with a list of strings or an array:
record.getProperties('firstName', 'lastName', 'zipCode');
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
is equivalent to:
record.getProperties(['firstName', 'lastName', 'zipCode']);
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
Parameters:
-
list
String... | Arrayof keys to get
Returns:
getViewClientRects
-
view
getViewClientRects
provides information about the position of the border
box edges of a view relative to the viewport.
It is only intended to be used by development tools like the Ember Inpsector and may not work on older browsers.
Parameters:
-
view
Ember.View
getWithDefault
-
keyName
-
defaultValue
Retrieves the value of a property, or a default value in the case that the
property returns undefined
.
person.getWithDefault('lastName', 'Doe');
Parameters:
Returns:
The property value or the defaultValue.
hasObserverFor
-
key
Returns true
if the object currently has observers registered for a
particular key. You can use this method to potentially defer performing
an expensive action until someone begins observing a particular property
on the object.
Parameters:
-
key
StringKey to check
Returns:
incrementProperty
-
keyName
-
increment
Set the value of a property to the current value plus some amount.
person.incrementProperty('age');
team.incrementProperty('score', 2);
Parameters:
Returns:
The new property value
init
()
An overridable method called when objects are instantiated. By default, does nothing unless it is overridden during class definition.
Example:
App.Person = Ember.Object.extend({
init: function() {
alert('Name is ' + this.get('name'));
}
});
var steve = App.Person.create({
name: "Steve"
});
// alerts 'Name is Steve'.
NOTE: If you do override init
for a framework class like Ember.View
or
Ember.ArrayController
, be sure to call this._super()
in your
init
declaration! If you don't, Ember may not have an opportunity to
do important setup work, and you'll see strange behavior in your
application.
notifyPropertyChange
-
keyName
Convenience method to call propertyWillChange
and propertyDidChange
in
succession.
Parameters:
-
keyName
StringThe property key to be notified about.
Returns:
prop
-
name
-
value
Adds a property which will be rendered to the element.
Returns:
this or the current property value
propertyDidChange
-
keyName
Notify the observer system that a property has just changed.
Sometimes you need to change a value directly or indirectly without
actually calling get()
or set()
on it. In this case, you can use this
method and propertyWillChange()
instead. Calling these two methods
together will notify all observers that the property has potentially
changed value.
Note that you must always call propertyWillChange
and propertyDidChange
as a pair. If you do not, it may get the property change groups out of
order and cause notifications to be delivered more often than you would
like.
Parameters:
-
keyName
StringThe property key that has just changed.
Returns:
propertyWillChange
-
keyName
Notify the observer system that a property is about to change.
Sometimes you need to change a value directly or indirectly without
actually calling get()
or set()
on it. In this case, you can use this
method and propertyDidChange()
instead. Calling these two methods
together will notify all observers that the property has potentially
changed value.
Note that you must always call propertyWillChange
and propertyDidChange
as a pair. If you do not, it may get the property change groups out of
order and cause notifications to be delivered more often than you would
like.
Parameters:
-
keyName
StringThe property key that is about to change.
Returns:
push
-
string
Adds a string of HTML to the RenderBuffer
.
Parameters:
-
string
StringHTML to push into the buffer
removeAttr
-
name
Remove an attribute from the list of attributes to render.
Parameters:
-
name
StringThe name of the attribute
removeObserver
-
key
-
target
-
method
Remove an observer you have previously registered on this object. Pass
the same key, target, and method you passed to addObserver()
and your
target will no longer receive notifications.
removeProp
-
name
Remove an property from the list of properties to render.
Parameters:
-
name
StringThe name of the property
renderBuffer
-
tagName
Ember.renderBuffer
gathers information regarding the view and generates the
final representation. Ember.renderBuffer
will generate HTML which can be pushed
to the DOM.
var buffer = Ember.renderBuffer('div', contextualElement);
Parameters:
-
tagName
Stringtag name (such as 'div' or 'p') used for the buffer
reopen
()
Augments a constructor's prototype with additional properties and functions:
MyObject = Ember.Object.extend({
name: 'an object'
});
o = MyObject.create();
o.get('name'); // 'an object'
MyObject.reopen({
say: function(msg){
console.log(msg);
}
})
o2 = MyObject.create();
o2.say("hello"); // logs "hello"
o.say("goodbye"); // logs "goodbye"
To add functions and properties to the constructor itself,
see reopenClass
reopenClass
()
Augments a constructor's own properties and functions:
MyObject = Ember.Object.extend({
name: 'an object'
});
MyObject.reopenClass({
canBuild: false
});
MyObject.canBuild; // false
o = MyObject.create();
In other words, this creates static properties and functions for the class. These are only available on the class and not on any instance of that class.
App.Person = Ember.Object.extend({
name : "",
sayHello : function(){
alert("Hello. My name is " + this.get('name'));
}
});
App.Person.reopenClass({
species : "Homo sapiens",
createPerson: function(newPersonsName){
return App.Person.create({
name:newPersonsName
});
}
});
var tom = App.Person.create({
name : "Tom Dale"
});
var yehuda = App.Person.createPerson("Yehuda Katz");
tom.sayHello(); // "Hello. My name is Tom Dale"
yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
alert(App.Person.species); // "Homo sapiens"
Note that species
and createPerson
are not valid on the tom
and yehuda
variables. They are only valid on App.Person
.
To add functions and properties to instances of
a constructor by extending the constructor's prototype
see reopen
set
-
keyName
-
value
Sets the provided key or path to the value.
This method is generally very similar to calling object[key] = value
or
object.key = value
, except that it provides support for computed
properties, the setUnknownProperty()
method and property observers.
Computed Properties
If you try to set a value on a key that has a computed property handler
defined (see the get()
method for an example), then set()
will call
that method, passing both the value and key instead of simply changing
the value itself. This is useful for those times when you need to
implement a property that is composed of one or more member
properties.
Unknown Properties
If you try to set a value on a key that is undefined in the target
object, then the setUnknownProperty()
handler will be called instead. This
gives you an opportunity to implement complex "virtual" properties that
are not predefined on the object. If setUnknownProperty()
returns
undefined, then set()
will simply set the value on the object.
Property Observers
In addition to changing the property, set()
will also register a property
change with the object. Unless you have placed this call inside of a
beginPropertyChanges()
and endPropertyChanges(),
any "local" observers
(i.e. observer methods declared on the same object), will be called
immediately. Any "remote" observers (i.e. observer methods declared on
another object) will be placed in a queue and called at a later time in a
coalesced manner.
Chaining
In addition to property changes, set()
returns the value of the object
itself so you can do chaining like this:
record.set('firstName', 'Charles').set('lastName', 'Jolley');
Returns:
setProperties
-
hash
Sets a list of properties at once. These properties are set inside
a single beginPropertyChanges
and endPropertyChanges
batch, so
observers will be buffered.
record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
Parameters:
-
hash
Hashthe hash of keys and values to set
Returns:
setup
-
addedEvents
Sets up event listeners for standard browser events.
This will be called after the browser sends a DOMContentReady
event. By
default, it will set up all of the listeners on the document body. If you
would like to register the listeners on a different element, set the event
dispatcher's root
property.
Parameters:
-
addedEvents
Hash
setupHandler
-
rootElement
-
event
-
eventName
Registers an event listener on the rootElement. If the given event is triggered, the provided event handler will be triggered on the target view.
If the target view does not implement the event handler, or if the handler
returns false
, the parent view will be called. The event will continue to
bubble to each successive parent view until it reaches the top.
style
-
name
-
value
Adds a style to the style attribute which will be rendered to the element.
toggleProperty
-
keyName
Set the value of a boolean property to the opposite of its current value.
starship.toggleProperty('warpDriveEngaged');
Parameters:
-
keyName
StringThe name of the property to toggle
Returns:
The new property value
toString
()
String
Returns a string representation which attempts to provide more information
than Javascript's toString
typically does, in a generic way for all Ember
objects.
App.Person = Em.Object.extend()
person = App.Person.create()
person.toString() //=> "<App.Person:ember1024>"
If the object's class is not defined on an Ember namespace, it will indicate it is a subclass of the registered superclass:
`
javascript
Student = App.Person.extend() student = Student.create() student.toString() //=> "<(subclass of App.Person):ember1025>"
If the method toStringExtension
is defined, its return value will be
included in the output.
`
javascript
App.Teacher = App.Person.extend({
toStringExtension: function() {
return this.get('fullName');
}
});
teacher = App.Teacher.create()
teacher.toString(); //=> "<App.Teacher:ember1026:Tom Dale>"
Returns:
string representation
willDestroy
()
Override to implement teardown.
Properties
canDispatchToEventManager
Boolean
It enables events to be dispatched to the view's eventManager.
When present,
this object takes precedence over handling of events on the view itself.
Note that most Ember applications do not use this feature. If your app also
does not use it, consider setting this property to false to gain some performance
improvement by allowing the EventDispatcher to skip the search for the
eventManager
on the view tree.
var EventDispatcher = Em.EventDispatcher.extend({
events: {
click : 'click',
focusin : 'focusIn',
focusout : 'focusOut',
change : 'change'
},
canDispatchToEventManager: false
});
container.register('event_dispatcher:main', EventDispatcher);
Default: 'true'
classes
Array
Array of class names which will be applied in the class attribute.
You can use setClasses()
to set this property directly. If you
use addClass()
, it will be maintained for you.
Default: null
concatenatedProperties
Array
Defines the properties that will be concatenated from the superclass (instead of overridden).
By default, when you extend an Ember class a property defined in
the subclass overrides a property with the same name that is defined
in the superclass. However, there are some cases where it is preferable
to build up a property's value by combining the superclass' property
value with the subclass' value. An example of this in use within Ember
is the classNames
property of Ember.View
.
Here is some sample code showing the difference between a concatenated property and a normal one:
App.BarView = Ember.View.extend({
someNonConcatenatedProperty: ['bar'],
classNames: ['bar']
});
App.FooBarView = App.BarView.extend({
someNonConcatenatedProperty: ['foo'],
classNames: ['foo']
});
var fooBarView = App.FooBarView.create();
fooBarView.get('someNonConcatenatedProperty'); // ['foo']
fooBarView.get('classNames'); // ['ember-view', 'bar', 'foo']
This behavior extends to object creation as well. Continuing the above example:
var view = App.FooBarView.create({
someNonConcatenatedProperty: ['baz'],
classNames: ['baz']
})
view.get('someNonConcatenatedProperty'); // ['baz']
view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']
Adding a single property that is not an array will just add it in the array:
var view = App.FooBarView.create({
classNames: 'baz'
})
view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']
Using the concatenatedProperties
property, we can tell Ember to mix the
content of the properties.
In Ember.View
the classNameBindings
and attributeBindings
properties
are also concatenated, in addition to classNames
.
This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual concatenated property (to not mislead your users to think they can override the property in a subclass).
Default: null
elementAttributes
Hash
A hash keyed on the name of the attribute and whose value will be
applied to that attribute. For example, if you wanted to apply a
data-view="Foo.bar"
property to an element, you would set the
elementAttributes hash to {'data-view':'Foo.bar'}
.
You should not maintain this hash yourself, rather, you should use
the attr()
method of Ember.RenderBuffer
.
Default: {}
elementClasses
Array
private
An internal set used to de-dupe class names when addClass()
is
used. After each call to addClass()
, the classes
property
will be updated.
Default: null
elementId
String
The id in of the element, to be applied in the id attribute.
You should not set this property yourself, rather, you should use
the id()
method of Ember.RenderBuffer
.
Default: null
elementProperties
Hash
A hash keyed on the name of the properties and whose value will be
applied to that property. For example, if you wanted to apply a
checked=true
property to an element, you would set the
elementProperties hash to {'checked':true}
.
You should not maintain this hash yourself, rather, you should use
the prop()
method of Ember.RenderBuffer
.
Default: {}
elementStyle
Hash
A hash keyed on the name of the style attribute and whose value will
be applied to that attribute. For example, if you wanted to apply a
background-color:black;
style to an element, you would set the
elementStyle hash to {'background-color':'black'}
.
You should not maintain this hash yourself, rather, you should use
the style()
method of Ember.RenderBuffer
.
Default: {}
elementTag
String
The tagname of the element an instance of Ember.RenderBuffer
represents.
Usually, this gets set as the first parameter to Ember.RenderBuffer
. For
example, if you wanted to create a p
tag, then you would call
Ember.RenderBuffer('p', contextualElement)
Default: null
events
Object
The set of events names (and associated handler function names) to be setup
and dispatched by the EventDispatcher
. Custom events can added to this list at setup
time, generally via the Ember.Application.customEvents
hash. Only override this
default set to prevent the EventDispatcher from listening on some events all together.
This set will be modified by setup
to also include any events added at that time.
isDestroyed
Unknown
Destroyed object property flag.
if this property is true
the observers and bindings were already
removed by the effect of calling the destroy()
method.
Default: false
isDestroying
Unknown
Destruction scheduled flag. The destroy()
method has been called.
The object stays intact until the end of the run loop at which point
the isDestroyed
flag is set.
Default: false
rootElement
DOMElement
private
The root DOM element to which event listeners should be attached. Event listeners will be attached to the document unless this is overridden.
Can be specified as a DOMElement or a selector string.
The default body is a string since this may be evaluated before document.body exists in the DOM.
Default: 'body'


Before Change
// TODO(epot): Should clear the runner once every image has been encoded.
// TODO(epot): Better support for multi-shape image (instead of re-building
// a new graph every time)
image_encoded = self._runner.run(ENCODE_FN[image_format], np_image)
return {
"encoded": image_encoded,
"format": image_format,
"shape": np_image.shape,
}
def decode_sample(self, encoded_image):
Reconstruct the image from the tf example.
tf_image = tf.image.decode_image(
After Change
def encode_sample(self, image_or_path):
Convert the given image into a dict convertible to tf example.
if isinstance(image_or_path, np.ndarray):
encoded_image = self._encode_image(image_or_path)
else:
with tf.gfile.Open(image_or_path, "rb") as image_f:
encoded_image = image_f.read()
return encoded_image
def decode_sample(self, sample):
Reconstruct the image from the tf example.
img = tf.image.decode_image(sample, channels=self._shape[-1],


{{ "" | safeHTML }} {{ with .Site.Params.university.title }}{{ . | markdownify }}{{ end }} Registeration is handled via the University webstore. All tickets are £30.
Registeration is handled via the University webstore. All tickets are £30.


LIFE IS BEAUTIFUL
*** (out of 4) - a good movie
Release Date: October 23, 1998 Starring: Roberto Benigni, Nicoletta Braschi, Giustino Durano, Sergio Bini Bustric, Horst Bucholz Directed by: Roberto Benigni Distributed by: Miramax Films MPAA Rating: PG-13 (holocaust-related thematic elements) URL: http://www.execpc.com/~kinnopio/reviews/1999/lifeisbeaut.htm
The love for family is one of the strongest driving forces in any man's life, especially for those who have fostered their family under precarious circumstances. Thematically in cinema, love for family has been used frequently and emphatically to highlight more abstract aspects of characters; it is rare, however, for it to develop as outstandingly as it does in Roberto Benigni's neo-classic drama, LIFE IS BEAUTIFUL. Through a central cast of father, mother, and son, Benigni demonstrates the wonderful, undying love that a family shares in the best of times and the worst of times.
Life *is* beautiful for Guido Orefice (Roberto Benigni, directing himself here for the sixth time in his career), an Italian Jew, master con man, and aspiring waiter extraordinaire. Living in 1930's Italy, he lives a carefree life of good fortune; it is made even better when he happens upon a pretty schoolteacher named Dora (Nicoletta Braschi). Although Dora is already engaged, Guido manages to sweep her off her feet and persuades her to marry him instead; the two have a child named Joshua (Giorgio Cantarini). Unfortunately for the happy family, the Third Reich and its Nazi minions occupy Italy and imprison all Jews in work camps.
It is after the movie takes this dramatic turn that the movie's theme of family love becomes the strongest. Although prior to this turning point Benigni plays Guido with a sort of goofy charm, he relaxes the role to ensure his son's happiness. Now, instead of awkwardly seducing the sweet Dora, he constantly reassures his son that everything will be all right. Benigni's performance is truly a well-rounded one, and certainly one of the more fluid turns all year.
The supports are all strong as well, but the movie truly excels in its script. LIFE IS BEAUTIFUL is a self-proclaimed fable, one which tells its story in grand, two-part fashion. In certain parts it manages to sink to the level of a "Saturday Night Live" spinoff -- a number of humorous skits connected by a token plot -- but in the movie's second half the script's circular nature becomes admirably obvious. Characters make reprise appearances in fine form, and certain events which are intially curious become critically linked to the plot's outcome.
In all, fans of foreign film will see this as a memorable motion picture, and novice movie-watchers may take this opportunity to see their first "artsy" film. LIFE IS BEAUTIFUL is an artsy movie by convention but easily accessible to everyone, and above all is a fine thematic picture.
all contents © 1999 Craig Roush
-- Craig Roush<EMAIL_ADDRESS>-- Kinnopio's Movie Reviews http://www.execpc.com/~kinnopio
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


The Eisenhower matrix is a time management principle to prioritize and plan tasks especially in situations when there's just too much to do. Another use-case of this matrix is to prioritize long-term goals for oneself.
Important and urgent tasks should be done by yourself immediately or as soon as possible. Enough time of each day should be reserved for these kind of tasks. However, the ultimate goal would be to avoid tasks becoming urgent and keeping this quadrant empty - this will allow you working on the important tasks.
Important tasks should be scheduled ahead of time or be done whenever time allows it.
Urgent but less important tasks might be delegated or resolved without spending too much time on them.
Tasks that you would consider neighter important nor urgent might be things that you should simply not do or schedule for doing later.
With First things first scheduled tasks will automatically switch into the urgent lane once they become urgent.
Drag & drop to schedule: First things first allows you to drag and drop tasks between the four quadrants to triage the tasks urgency and importance without spending too much time on planning.
Board selection: With "Cards I'm assigned to" all cards you're a member of will be displayed. (Pro tip: In Trello hover over a card and press the space-bar to assign a card to yourself, no mouse-click required.) If a specific board is being selected from the dropdown menu, all cards of the selected board will be displayed.
Urgency and importance can be updated by setting the due date and the label of cards. By default, the current day and the red label will be used to determine importance and urgency, both of which can be defined in the menu on top of the matrix.
Your Trello data will only be transmitted via HTTPS between your browser and the Trello servers and no data will be stored outside of the Trello system.
Please sign in with your Trello account first. After signing in, cards you're assigned to will be loaded into the matrix, or you can select specific boards from the list to load all cards from.
Your data will not be stored anywhere else and the only data being modified by this service is the due date and one label used to mark a card as being important.
Please visit the development board at https://trello.com/b/xiUsbwKO to vote and comment on the current development.


Anatomical slices for Subject {sub_num:03d}
Center slices
Axial -20%
Axial -10%
Axial +10%
Axial +20%
Coronal -20%
Coronal -10%
Coronal +10%
Coronal +20%
Sagittal -20%
Sagittal -10%
Sagittal +10%
Sagittal +20%


March 1
Hackathon registration open
Hackathon registration open
DevPost Hackathon platform open with resources for collaboration, team-building, and product development
Hackathon registration deadline
Friedman School faculty mentors announced for teams
Nutrition Data Summit 2018!
Collaborative spaces available daily
Nutrition Entrepreneurship instructors available for mentorship during office hours
Hackathon pitch competition and awards


{{group.name}}
{{group.description}}
{% set page_title = 'HEXA-A - Join group' %} {% extends 'layout.html' %} {% block container %}
{{group.description}}
Created by {{group.created_by.username}}
{{group.members_count}} members


This driver reads files in SEG-Y format. Those files are binary files that contain single-line seismic digital data. The driver will report the attributes of the trace header (in their raw form, see the SEG-Y specification for more information), and use the receiver group coordinates as geometry. The sample values are also reported.
A layer "{basefilename}_header" is also created and contains a single feature with the content of the text and binary file headers.


SignUp|Login
Home
Online Shop
Trade Sale
Whole Sale
About Us
Contact Us
Online Shop
Billing Details
First Name :
*
Last Name :
*
Country/Region :
*
Street Address :
*
Town/City :
*
Postal Code :
*
Email :
*
Order Notes :
*
Congratulations! You have been granted free Shipping as the bill value is over $30
Please provide accurate Payment Details and confirm your Order
Payment Details
Credit/Debit Card Type :
Visa
Master Card
Debit Card
American Express
Platinum Visa
Card Number :
Card Expiration Date :


Which is true about the relationship between
algorithms and problems?
"A problem is a mapping from inputs to outputs, and there might be many algorithms that can accomplish this mapping."
- "A problem is a mapping from inputs to outputs. Since this mapping is fixed, there is only one right way to compute the mapping."
- "An algorithm is another term for a problem."
- "A problem is a recipe, and an algorithm is a solution to a problem."
A problem is a mapping from inputs to outputs.
An algorithm is a recipe.
There are many algorithms that can solve a given problem.


A type X
meets the CancellationSlot
requirements
if it satisfies the requirements of CopyConstructible
(C++Std
[copyconstructible]) and Destructible
(C++Std [destructible]),
as well as the additional requirements listed below.
In the table below, x1
and x2
denote (possibly
const) values of type X
, mx1
denotes an xvalue
of type X
, H
denotes a type that satisfies CancellationHandler
,
h
denotes an xvalue of type H
, and u0
to uN
denote identifiers.
Table 6. CancellationSlot requirements
|
expression |
type |
assertion/note |
|---|---|---|
|
|
Shall not exit via an exception. |
|
|
|
Shall not exit via an exception. |
|
|
|
|
Returns |
|
|
|
Same as |
|
|
|
|
|
|
|
Requires that |


B C D E G I P Q R S T W
All Classes All Packages
All Classes All Packages
All Classes All Packages
B
- build() - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientBuilder
-
Creates an instance of
SqsPriorityClient
. - builder(SqsClient) - Static method in class com.github.gregwhitaker.sqs.SqsPriorityClient
-
Gets the builder for constructing an instance of
SqsPriorityClient
.
C
- com.github.gregwhitaker.sqs - package com.github.gregwhitaker.sqs
- com.github.gregwhitaker.sqs.internal - package com.github.gregwhitaker.sqs.internal
- config - Variable in class com.github.gregwhitaker.sqs.SqsPriorityClientBuilder
D
- DEFAULT_EMPTY_RECEIVE_TIMEOUT - Variable in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Default duration queue reading is paused for a queue when the max empty receives are encountered.
- DEFAULT_MAX_EMPTY_RECEIVE_COUNT - Variable in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Default maximum number of empty receives encountered on a queue before reading is temporarily paused.
- DEFAULT_MAX_NUMBER_OF_MESSAGES - Variable in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Default maximum number of SQS messages to retrieve at a time.
- deleteMessage(String) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClient
-
Deletes a message from the queue.
E
- end() - Method in class com.github.gregwhitaker.sqs.SqsPriorityQueueBuilder
-
Ends configuration of the builder and returns to the parent builder.
G
- getEmptyReceiveCnt() - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Gets the empty receive count of the queue.
- getEmptyReceiveTimeout() - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Gets the timeout for empty receives.
- getIndex() - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Gets the index ranking of the queue.
- getMaxEmptyReceiveCount() - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Gets the maximum number of empty receives on a queue before reading is paused.
- getMaxNumberOfMessages() - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Gets the maximum number of messages to retrieve from a queue in a single read.
- getQueueName() - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Gets the name of the queue.
- getQueueUrl() - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Gets the queue url.
- getSqsClient() - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Gets the AWS sqs client.
- getThreshold() - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Gets the calculated threshold for the queue.
- getWeight() - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Gets the configured weight of the queue.
- getWeightedQueues() - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Gets the priority weighted queues.
I
- incrementEmptyReceive() - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Increments the empty receive count of this queue by 1.
- isAvailable() - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Checks to see if the queue is available for reads.
P
- parentBuilder - Variable in class com.github.gregwhitaker.sqs.SqsPriorityQueueBuilder
- PriorityQueueInfo - Class in com.github.gregwhitaker.sqs.internal
-
Stores information about queues managed by the client.
- PriorityQueueInfo(int, String, String, double, double) - Constructor for class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Creates a new instance of
PriorityQueueInfo
.
Q
- queue(String, double) - Method in class com.github.gregwhitaker.sqs.SqsPriorityQueueBuilder
-
Adds a weighted queue from which to send and receive messages.
R
- receiveMessages() - Method in class com.github.gregwhitaker.sqs.SqsPriorityClient
-
Receives a stream of messages that never completes.
- receiveMessages(long) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClient
-
Receives a finite stream of the specified number of messages and then completes.
S
- setEmptyReceiveTimeout(Duration) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Sets the timeout for empty receives.
- setMaxEmptyReceiveCount(int) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Sets the maximum number of empty receives on a queue before reading is paused.
- setMaxNumberOfMessages(int) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Sets the maximum number of messages to retrieve from a queue in a single read.
- setSqsClient(SqsClient) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Sets the AWS sqs client.
- setWeightedQueues(LinkedHashMap<String, Double>) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
-
Sets the priority weighted queues.
- SqsPriorityClient - Class in com.github.gregwhitaker.sqs
-
SQS client that receives messages from multiple queues based on weighted priority.
- SqsPriorityClientBuilder - Class in com.github.gregwhitaker.sqs
-
Configures and builds an instance of
SqsPriorityClient
. - SqsPriorityClientBuilder(SqsClient) - Constructor for class com.github.gregwhitaker.sqs.SqsPriorityClientBuilder
- SqsPriorityClientConfig - Class in com.github.gregwhitaker.sqs
-
SqsPriorityClient configuration
- SqsPriorityClientConfig() - Constructor for class com.github.gregwhitaker.sqs.SqsPriorityClientConfig
- SqsPriorityQueueBuilder - Class in com.github.gregwhitaker.sqs
-
Builder that creates the configuration for the priority queues.
T
- timeout(Duration) - Method in class com.github.gregwhitaker.sqs.internal.PriorityQueueInfo
-
Marks the queue as timed out for the specified duration.
W
- withEmptyReceiveTimeout(Duration) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientBuilder
-
Sets the duration of the temporary read pause triggered when the maximum number of empty receives is encountered for a queue.
- withMaxEmptyReceiveCount(int) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientBuilder
-
Maximum number of empty reads from a queue before reading is temporarily paused to prevent rate-limiting by the AWS API.
- withMaxNumberOfMessages(int) - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientBuilder
-
Maximum number of messages to retrieve from a queue in a single read.
- withQueues() - Method in class com.github.gregwhitaker.sqs.SqsPriorityClientBuilder
-
Adds priority queues from which to read messages.
All Classes All Packages


New look Queen Vic in Gosforth The Queen Victoria has re-opened in Gosforth with a new look 23 Nov 2019, 15:07 by Simon Duke A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle) A look around the revamped Queen Victoria Bar and Restaurant in Gosforth.(Image: Newcastle Chronicle)


Second staffer says Trump, Sondland discussed need for Ukraine 'investigations': AP
WASHINGTON (Reuters) - A second staffer for the U.S. Embassy in Kiev overheard a phone call between President Donald Trump and the U.S. envoy to the European Union, in which the need for Ukraine to conduct “investigations” was discussed, the Associated Press reported on Thursday, citing an unnamed source briefed on the situation.
On Wednesday, the top U.S. diplomat in Ukraine, William Taylor, disclosed the previously unknown July 26 call in public comments during Congress’ first televised hearings amid lawmakers’ impeachment inquiry.


Home
Điện thoại
SamSUng
Iphone
LG
MOTOROLA
XIAOMI
Oppp
Vivo
Realme
Huawei
Nokia
Laptop
Macbook
HP
Asus
Dell
Acer
Tablet
ipad
samsung
huawei
lenovo
masstel
Đồng hồ
SamSUng
Iphone
LG
XIAOMI
Oppp
Vivo
Realme
Nokia
Blog
Liên Hệ
Menu
Home
Home 2
Home 3
Home 4
Home 5
Home 6
Home 7
Home 8
Man
Dresses
Coctail
Day
Evening
Sports
Handbags
Blazers
Table
Coats
Kids
Clothing
T-Shirt
Coats
Jackets
Jeans
Women
Rings
Coats & Jackets
Blazers
Jackets
Rincoats
Dresses
Ankle Boots
Footwear
Clog Sandals
Combat Boots
Accessories
Bootees bags
Blazers
Jackets
Jackets
Top
Briefs
Camis
Nigntwears
Shapewears
Shop
Shop Pages
List View
Grid View
My Account
Wishlist
Cart
Checkout
Product Types
Simple Product
Variables Product
Grouped Product
Downloadable
Virtual Product
External Product
Pages
Shop Grid
Shop List
Product Details
Contact Us
About Us
Shopping cart
Checkout
Wishlist
Login
404 Error
About Us
Contact Us
2
2
Đăng Nhập
/
Đăng Ký
Đăng Nhập
Email
*
Mật khẩu
*
Remember Me


 Glynn Purnell shows you how to put it all together.
For the coriander oil, bring a pan of salted water to the boil. Prepare a bowl of ice-cold water. Add the coriander to the pan and blanch for 10 seconds, then drain and add to the cold water.
Drain the blanched coriander and put it in a jug. Add the vegetable oil and blend together using a hand-held blender. Continue to blend for about five minutes, or until very finely chopped. Cover and chill in the fridge for 24 hours.
For the pickled carrots, put the sliced carrots in a bowl. In a saucepan, warm the sugar, vinegar and oil over a low heat until the sugar has dissolved in the liquid. Stir in the soy sauce until combined. Pour the mixture over the carrots, then cover and set aside.
For the spiced cauliflower, melt the butter in a saucepan over a medium heat. When the butter is foaming, add the curry powder, all the spices and the dried chilli flakes. Stir well and fry for 1-2 minutes, or until fragrant.
Add the cauliflower florets and enough vegetable stock to cover them. Bring the mixture to the boil, then reduce the heat and simmer for 20 minutes, or until tender. Remove the pan from the heat and set aside so that the cauliflower pieces cool in the stock.
For the red lentils, heat the oil in a frying pan over a medium heat. Add the onion and garlic and fry for 3-4 minutes, or until softened but not coloured. Stir in the curry powder until well combined.
Add the lentils and cover with the hot stock, then bring the mixture to a gentle simmer and cook, stirring occasionally, for 10-15 minutes, or until the lentils are tender. Drain well, then stir through the red chilli, coriander and lime juice. Keep warm.
For the coconut sauce, bring the coconut milk and lime leaf to the boil in a small saucepan. Continue to boil until the volume of liquid has reduced by half.
Remove the lime leaf from the pan, then stir in the sliced mint and a pinch of salt.
For the toasted coconut, preheat the oven to 170C/340F/Gas 3½. Line a baking tray with baking parchment. Arrange the coconut slices onto the baking tray and bake in the oven until pale golden-brown.
Just before serving, drain the cooled cauliflower florets. Heat the butter in a frying pan over a medium heat. When the butter is foaming, add the cauliflower and fry until golden-brown. Squeeze over a little lime juice.
Strain the coriander oil through a fine-mesh sieve before serving.
To serve, spoon a portion of lentils into the centre of each serving plate. Arrange a few roasted cauliflower florets on top. Garnish with the pickled carrots, toasted coconut and a sprig of coriander, then drizzle over a little of the coconut sauce and coriander oil.


Just said goodbye to in-laws on their way down to the coast. Heading out soon for Corvallis for family birthday festivities!
4/19/2009, 7:51:12 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Just said goodbye to in-laws on their way down to the coast. Heading out soon for Corvallis for family birthday festivities!
4/19/2009, 7:51:12 AM
Favs: 0
Retweets: 0
link


{% extends "base.html" %} {% block content %}
Note The copy feature is disabled if a similar course offering already exists in the same semester in {{academic_year_copy_to}}.
Note {{comment}}


Inputs
Sequences
The
Sequence File Format
Generators
randomSeq
: Generates sequences of values uniformly at random in a given range.
exptSeq
: Generates sequences of values with repeats appearing in an exponential distribution.
almostSortedSeq
: Generates almost sorted sequences.
trigramSeq
: Generates sequences of character strings generated using at random using a trigram probability distribution.
addDataSeq
: Adds auxiliary data to a sequence of a simple type.
Graphs
The
Graph File Format
Geometry
The
Geometry File Format


Home
Quests
Heart-to-Hearts
Unique Monsters
Xenoblade Wiki on Fandom
WARNING: This page
DOES
contain spoilers for Prison Island and beyond! Browse with caution!
To reveal the spoilers, highlight or mouse over the hidden rows.


Week 1 - Chefs in the Kitchen
Starting the Fire to my DBC Adventure! December 13th, 2014
Let's begin with how I found Dev Bootcamp. My friend, who's studying computer science, always used to tell me about his classes and what's been tough or challenging within them. Coding came up whenever I met up with him because his life was absorbed by his major. When I told him I was thinking about learning how to code, he was excited to give me a recipe to get started. He suggested I start small and work with a website to learn how to code for free. Once my interest picked up, we spoke about possibly going for a bootcamp, rather than going back to school. It was great to have the support of a friend and it was awesome on his part to not spoon-feed me everything.
From this point, I did my research and I found a ton of different schools. Some were for well seasoned coders and some were for beginners. Some were quite shady and some were not. But what I found was that, unlike nearly all of the schools out there, Dev Bootcamp wasn't simply teaching you how to write code. They were teaching you a lifestyle. It wasn't just hours of sitting in a chair and coding to them. Their program promoted the culture of programming and how to keep a balance in your life.
This is what I was looking for. I want the experience of learning how to program but I don't want to sacrifice my journey of growing as person. DBC was built for that reason. They're looking to teach all aspects of life, but with a concentration on becoming a programmer.
I'm immensely excited to throw myself into this different learning environment and I'm immensely nervous to see where this will take me. Shereef spoke about the fears people have going into Phase 1 and I can definitely relate. Nearly everyone will experience these fears but just make sure you keep pushing yourself past it! Life is all about learning! Stay hungry!
Kitchen puns everywhere.


--- layout: post title: 'Maze Generation: Recursive Division' post_id: 17 categories: - under the hood date: 2011-01-12 08:29:00.000000000 -07:00 author: Jamis permalink: 2011/1/12/maze-generation-recursive-division-algorithm.html summary: > A novel method for generating fractal-like mazes is presented, with sample code and an animation ---
All of the maze algorithms I’ve covered so far (recursive backtracking, Eller’s, Kruskal’s, and Prim’s) were implemented as “passage carvers”: they started with a solid grid and hollowed the passages out of it. Some algorithms can be implemented a different way (and indeed, some must be implemented this way): as “wall adders”, where the process begins with a large empty space, and adds walls until a maze results.
The “recursive division” algorithm is one that must be implemented as a wall adder. This algorithm is particularly fascinating because of its fractal nature: you could theoretically continue the process indefinitely at progressively finer and finer levels of detail.
It works like this:
You’ll find that at every step, you still have a valid maze. Each repetition of the algorithm simply increases the level of detail. Pretty cool!
Let’s walk through an example to get an idea of how this works in practice.
We’re going to start with a larger grid this time, 5×5, just to show how the algorithm quickly converges. (If there is too much hand-waving, call me on it in the comments! I’ll be more than happy to expand wherever things get too obtuse.)
First, we’ll bisect it vertically, because I’m just that kind of a guy. I’ll just close my eyes and point…here…so we’ll add a wall at x=3:
Then, we randomly add a gap in the wall, so that we preserve the connectability of the graph:
And that finishes the first iteration. Now, we repeat these steps on each of the two subfields that we created by adding that wall. Let’s go with the field on the right, first.
Now, theoretically, we could bisect that either vertically or horizontally. However, for best results, if you’re bisecting a field that is taller than it is wide (like we are now), it’s best to bisect horizontally. It’ll prevent really glaring biases in the finished product, and generally makes for more interesting mazes. (Similarly, when bisecting a field that is wider than it is tall, you should prefer a vertical wall.)
So, let’s cut this field in half horizontally this time, and then add a passage through it:
|
|
|
(From here on out, I’m going to merge the “add wall” and “erase passage” steps into a single step: you’ve been warned!)
That completes another iteration. Let’s do one more quick iteration on the top-right field, now, and see how the recursion bottoms out when you hit your target resolution.
The field in the top-right is a square, so we can randomly choose between a horizontal or a vertical bisection. Let’s go with vertical:
Now, we’ve got two new subfields to recurse into, but hark! We can’t divide them any further without passing our target resolution (our grid is only 5×5, remember). So the recursion bottoms out, and we rewind back up the stack.
I’m going to be moving much faster now, chugging along to the end of the algorithm.
|
|
|
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
|
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
|
And we’re done! The result is a perfect maze.
If you’re not using IE, you can step through the algorithm yourself using this nifty Javascript demo. The one of the left is a 5×5 grid, and the one on the right is a 15×15 grid (so you can get a better feel for how the recursion works on larger mazes).
So, how would you implement this? My implementation really only needed a single supporting method, aside from the actual algorithm itself:
1 2 3 4 5 6 7 8 9 |
def choose_orientation(width, height) if width < height HORIZONTAL elsif height < width VERTICAL else rand(2) == 0 ? HORIZONTAL : VERTICAL end end |
The choose_orientation method gave me a simple abstraction for deciding which way a field with the given dimensions ought to be bisected. Once I had that in hand, I just needed a divide
method, which recursively divided the field as described:
1 2 3 |
def divide(grid, x, y, width, height, orientation) # ... end |
The algorithm was started by calling divide on the entire grid:
1 |
divide(grid, 0, 0, width, height, choose_orientation(width, height)) |
The method itself first checks to see if the maze has reached the target resolution:
1 |
return if width < 2 || height < 2 |
Then, it sets a convenience flag so we can query the orientation, and starts answering questions about where the wall needs to be drawn, and where the passage through the wall will be:
1 2 3 4 5 6 7 8 9 |
horizontal = orientation == HORIZONTAL # where will the wall be drawn from? wx = x + (horizontal ? 0 : rand(width-2)) wy = y + (horizontal ? rand(height-2) : 0) # where will the passage through the wall exist? px = wx + (horizontal ? rand(width) : 0) py = wy + (horizontal ? 0 : rand(height)) |
Then a few helper values get set, to aid in drawing the wall:
1 2 3 4 5 6 7 8 9 |
# what direction will the wall be drawn? dx = horizontal ? 1 : 0 dy = horizontal ? 0 : 1 # how long will the wall be? length = horizontal ? width : height # what direction is perpendicular to the wall? dir = horizontal ? S : E |
Once that’s all set up, we can actually draw the wall:
1 2 3 4 5 |
length.times do grid[wy][wx] |= dir if wx != px || wy != py wx += dx wy += dy end |
Lastly, we determine the bounds of the subfields, and recurse:
1 2 3 4 5 6 7 |
nx, ny = x, y w, h = horizontal ? [width, wy-y+1] : [wx-x+1, height] divide(grid, nx, ny, w, h, choose_orientation(w, h)) nx, ny = horizontal ? [x, wy+1] : [wx+1, y] w, h = horizontal ? [width, y+height-wy-1] : [x+width-wx-1, height] divide(grid, nx, ny, w, h, choose_orientation(w, h)) |
And that’s really all there is to it. My complete implementation is here, including some simple ASCII output routines (an ANSI terminal is required):
I really had a blast implementing this algorithm. It’s especially hypnotic to watch the demos as they animate its progress. I’d love to see someone implement a mandelbrot-style “infinite zoom” with a recursive-division maze. I’m not sure there’s a lot of practical value there, but it seems like it could have a high degree of “cool”. :)
As far as the mazes themselves, it’s readily apparent after generating a few that the mazes will tend to have a lot of short cul-de-sacs, like Kruskal’s and Prim’s, and the nature of the algorithm tends to create long walls that span significant portions of the field, which leads to visual artifacts that (in my opinion) detract from the appearance of the maze. Some of this could be overcome by artfully choosing where to place walls, but that will only take you so far. So, alas, I don’t think I’ll be using this algorithm for anything besides demo animations.
Give it a try yourself, though, and see how your implementation turns out. If you come up with something cool, let me know!