| Scarab: Frequently Asked Questions |
Scarab is a modular set of specifications describing protocols, formats, and interfaces for writing distributed applications, with an emphasis on low-end and lightweight implementations. Users can combine Scarab module implementations to build a messaging system to fit their needs, scaling from very simple messaging or data transfer all the way up to where CORBA can take over. Scarab specifications include support for such areas as distributed objects, remote procedure calls, XML messages, TCP transport, and HTTP transport.
The Casbah Project started developing Scarab to serve as the communications component of the Casbah application server. The decision was made to develop Scarab, in favor of using CORBA, because, at the time, CORBA wasn't generally available in the dynamic, high-level languages or on some of the platforms that The Casbah Project was targetting. In addition, because Casbah is an Open Source project, it needed an Open Source CORBA implementation, while an Open Source CORBA was hard to come by at the time.
Alternatives were evaluated but none combined enough of the features that were required for Casbah.
Scarab has features that allow it to support features specific to individual languages while still able to communicate to others. Scarab currently has implementations in Java, Python, Perl, and C. But Scarab can be implemented, and would be helpful, in any number of other languages like Smalltalk, TCL, Objective C, C++, Common Lisp, Scheme, Erlang, EcmaScript, PHP, etc.
The state of CORBA, particularly Open Source implementations, has changed since Scarab development was begun. There are now more language bindings, more platforms with CORBA support, and even some support of dynamic languages within CORBA, but CORBA continues to be out of the reach of many people for many of the same reasons we initially started Scarab. Scarab has turned out to be a fairly simple protocol to implement while at the same time providing a lot of flexibility and room to scale.
No. In most cases Scarab is as simple to use as the objects or procedures in the languages you already use. With Scarab, you create an object or open a connection to a server and from then on you treat that object just as you would any other object. Keep in mind that network errors can and do happen and that your code has to be able to handle those errors.
No. Creating basic clients or servers can often be done anywhere from an afternoon to a few days depending on how many Scarab features you wish to use. Creating richer implementations can take a few weeks. We want to develop guides that will help implementors design their code and provide a development path that allows the developer to add additional features as they need them.
A complete Scarab implementation has all the layers below. Scarab can also be implemented in stages, see the next question. In each layer, some of the implementations are listed, implementations marked with an asterisk (*) are planned.
Application (your application here!) Connection Connection Request encoding LDO-REO, SOAP*, XML-RPC* Marshaling LDO-Marshal, SOAP* Serialization LDO-XML, LDO-Binary, SOAP*, XML-RPC*, WDDX* Transport TCP/IP, HTTP*, SMTP*
NEED TEXT HERE
Scarab is intended to fulfill many of the same goals stated for HTTP-NG. HTTP-NG is very similar to CORBA. Scarab intends to borrows several features from HTTP-NG, such as distributed garbage collection and multiplexing protocol.
These protocols are tied very closely to their respective languages, Scarab is not tied to any particular language. Scarab was inspired by Apple's (nee NeXT's) Portable Distributed Objects (PDO) and Python's pickle.py.
SOAP and XML-RPC are protocols. Scarab supports SOAP and XML-RPC. Scarab extends SOAP and XML-RPC to support multiple transports, multiple messages per session, and other features.
Scarab's XML and binary reference serializations were designed with the assumption that we don't know what datatypes you really need. Rather than define a small set of datatypes that may or may not fit your needs, we've used some of the most basic data types available and then supported a ``type'' attribute that lets you declare a specific type. LDO-Types defines common values for type attributes supported by Scarab applications. If it's your application that is used for both client and server you can also define your own data types. Scarab can also use other serialization formats that provide more specific data types.
An atom is a simple, basic data type like a number, a string, or a date, in contrast to a complex, compound, or aggregate data type like a list, dictionary, record, or structure.
``atom'' or ``atomic'' is the term most commonly used by designers if and when they refer to a value or object that is not composed of or an aggregate of other values or objects. Many descriptions of computer languages, protocols, or formats don't distinguish between simple or complex objects or don't provide a specific term for non-aggregate types (they simply call them ``objects'', for example). The term ``scalar'' is a close second to ``atom'' in terms of common usage.
Alternatives included ``value'', ``data'', ``datum'', ``scalar'', and ``primitive''. ``value'', ``data'', and ``datum'' all seemed wrong because lists and dicts are also values, data, or datum. ``scalar'' seems too closely tied to numeric or quantity values. ``primitive'' is often associated with implementation in a lower-level language (like C or assembler).


In 2013, Tatiana earned the honor of exhibiting her work at Cuba Nostalgia Expo where she was able to meet with the esteemed Cuban dissident Guillermo Farinas, who played an integral part in inspiring her artwork during this time. Tatiana’s career has been characterized by a fusion of her Cuban heritage with her personal interests, actualizing paintings that juxtapose woman and identity. Her latest series revolves around emphasizing the strength, and beauty of ballet dancers as well as the veiled sacrifices that shroud the artistry of these dancers in an attempt to elucidate the grace and intensity of femininity. This series won the contest to represent the lX International Ballet Festival and was exhibited in the Miami Hispanic Ballet White house.
Tatiana was inspired by her admiration for the many Cuban ballet dancers who have defected in order to pursue their dreams as artists and to travel the world showcasing their astounding talents. Her work is filled with these type of stories, collected memories of herself and of her Cuban heritage, which she then reflects on introspectively to ascertain and approach a sense of identity and meaning. These memories are filled with bold colors that exude vividity, allowing the viewer to feel present in this fleeting moment in time. This evanescence of time is shown with elaborations of movement through brash gallant brush strokes.
Her ballerina exhibit for The 19th Annual International Ballet Festival of Miami was displayed at The Miami Hispanic Cultural Arts Center in the summer of 2013
This exhibit was reviewed by Culture Designers but their website culturedesigners.com is no longer working.
The article could previously be found at the following link:
Below are some of the images from their review that I was able to archive.


Time: 0s
Correct: 0/0 (0%)
Streak: 0
Average time: 0s
Click "Start"!
Edit Cards
Settings
Auto-fail in (seconds):
Play sound:
Change background colour:


Video: Fan’s Reaction To LeBron Cursing Is Going Viral
by Tzvi MachlinAthletes cursing during a game is nothing new. It might actually be harder to find an athlete who doesn’t swear out loud during any given game.
But one fan seemed especially peeved to see Los Angeles Lakers megastar LeBron James cursing.
During yesterday’s game between the Lakers and the Minnesota Timberwolves, LeBron was seen cursing along the sideline. As the camera panned across with him, a fan wearing a red shirt could be seen mouthing the words “Watch your mouth.”
The video has quickly gone viral with thousands of likes and hundreds of retweets in the minutes since it was released.
The Lakers and the T-Wolves played a close game through the first three quarters, but LeBron and Anthony Davis ultimately ran away with it in the fourth.
LeBron finished with 32 points and a game-leading 13 assists, while Davis added 50 points and went 10-of-10 from the line.
Hopefully that fan was a Lakers fan, otherwise having to watch LeBron drop those numbers on the T-Wolves might have been more upsetting than seeing him curse out loud.


Previous Page
Next Page
|| Page
-
/
-
||
Previous Chapter
Next Chapter
Your browser does not support html5 canvas.


Union types require a new way of thinking! Learning to slice a domain with this new "direction" can be challenging at first.
public static PositionType GetPositionType (
MovementType movementType,
ApplyToParty applyToParty)
{
if ((movementType == MovementType.Deliver
&& applyToParty == ApplyToParty.Principal)
|| (movementType == MovementType.Return
&& applyToParty == ApplyToParty.Counterparty))
return PositionType.Held;
if ((movementType == MovementType.Return
&& applyToParty == ApplyToParty.Principal)
|| (movementType == MovementType.Deliver
&& applyToParty == ApplyToParty.Counterparty))
return PositionType.Posted;
return PositionType.Undefined;
}
let GetPositionType = function
| Deliver, Principal | Return, Counterparty -> Held
| Return, Principal | Deliver, Counterparty -> Posted
| MovementType.Undefined, _
| _, ApplyToParty.Undefined -> PositionType.Undefined
We've gained:
Need a "Domain Type"
type Direction =
| Held_Deliver_Principal
| Held_Return_Counterparty
| Posted_Return_Principal
| Posted_Deliver_Counterparty
3 enums with 3 states each = only 4/9 states valid!
Or 1 type with 4 states = 4/4 states valid!
let GetMovementTypeToSaveInORM direction =
match direction with
| Held_Deliver_Principal -> Deliver
| Posted_Deliver_Counterparty -> Deliver
| Posted_Return_Principal -> Return
| Held_Return_Counterparty -> Return
let GetSendFn = function
| Held_Deliver_Principal
| Posted_Return_Principal -> SendMessageToPrincipal
| Held_Return_Counterparty
| Posted_Deliver_Counterparty -> SendMessageToCounterparty
Safely convert into this better type?
Failure: Exceptions or Returns?
type Result<'TSuccess,'TFailure> =
| Success of 'TSuccess
| Failure of 'TFailure
let (>>=) result successFunction =
match result with
| Success s -> successFunction s
| Failure f -> Failure f
let RejectPending (user : string) request =
GetApprovalById request.id
>>= EnsurePendingOrResubmit
>>= switch (fun domain ->{domain with Status = Rejected({RejectedDate=DateTime.Now; RejectedBy=user;Reason=request.reason}) })
>>= EnsureReasonSet
>>= UpdateApproval
let ResubmitPending (user : string) request =
GetApprovalById request.id
>>= EnsurePending
>>= switch (fun domain ->{domain with Status = Resubmitted({RejectedDate=DateTime.Now; RejectedBy=user;Reason=request.reason}) })
>>= EnsureReasonSet
>>= UpdateApproval
let GetDirection = function
| Deliver, Principal -> Held_Deliver_Principal
| Return, Counterparty -> Held_Return_Counterparty
| Return, Principal -> Posted_Return_Principal
| Deliver, Counterparty -> Posted_Deliver_Counterparty
http://fsharpforfunandprofit.com/rop/


Frozen Notes Applications
While discussing AutoUser, the top tool to run functional test for your Notes Client applications, with Lucius (Smart Touchan's CEO) we compared Notes (pun intended) about the state of Notes applications. We identified a phaenomenon which Lucius labeled " frozen Notes applications" (Accenture seems to have still quite a lot of them).
A frozen Notes application isn't one that is crashing or mis-behaving. It is one, mostly at the core, supporting a critical business process with tentacles interfaces in all directions. Since it has grown over the years there are quite some layers and imprints of developer generations in it. It typically does what it should do well, but there is great reluctancy to touch it. Its interface shows signs of age and enthropy. Neither adding or altering features nor moving it to a new version is considered a risk worth taking by the IT people (I actually have seen R4.6 servers still in operation for exactly that reason). Updating this application is what Wikipedia calls Brownfield development (a term borrowed from civil engineering).
What to do in such situations? The tempation is great to just rewrite the whole thing on a platform that is more in vouge. Joel Spolsky has warned against such attempts and reports coming in of rewrites (regardless of what platform, just ask about VB to VB.NET rewrites) are not very encouraging. A step by step modernisation looks more tedious in theorie but appears to be way more robust in practice.
So what is the right course of action? Document your apps (watch this space for an upcoming feature about that) and put them into a test harness. Way back there used to be LoadRunner (not sure if it is still around) supporting Notes clients. Now there is AutoUser wich is capable of testing applications against a multitude of clients. Refactor your applications when adding new features. Lucius is musing to make AutoUser more widely available. I'm looking forward to that.
A frozen Notes application isn't one that is crashing or mis-behaving. It is one, mostly at the core, supporting a critical business process with
What to do in such situations? The tempation is great to just rewrite the whole thing on a platform that is more in vouge. Joel Spolsky has warned against such attempts and reports coming in of rewrites (regardless of what platform, just ask about VB to VB.NET rewrites) are not very encouraging. A step by step modernisation looks more tedious in theorie but appears to be way more robust in practice.
So what is the right course of action? Document your apps (watch this space for an upcoming feature about that) and put them into a test harness. Way back there used to be LoadRunner (not sure if it is still around) supporting Notes clients. Now there is AutoUser wich is capable of testing applications against a multitude of clients. Refactor your applications when adding new features. Lucius is musing to make AutoUser more widely available. I'm looking forward to that.
Posted by Stephan H Wissel on 22 March 2010 | Comments (3) | categories: Show-N-Tell Thursday


Hello
Let me ask a few questions. I am interested in emontx. Because of It only has CT sensor. But Watt = VI * PF
How can I calculate watt value without knowing V and PF?
Thanks,
zen
Archived Forum |
|
EmonTXSubmitted by Guest on Tue, 03/05/2011 - 08:34Hello Let me ask a few questions. I am interested in emontx. Because of It only has CT sensor. But Watt = VI * PF Thanks, zen » |
Re: EmonTX
Hi Zen,
Thanks your interest in EmonTx, it is still in development and yet to be officially launched on the site.
Your correct, EmonTx only measures current (using a CT) and not voltage. It calculates power P=VI by assuming V=240v (UK grid AC voltage) and PF=1. This is not as accurate as measuring voltage and power since the voltage and power factor can fluctuate. In other worlds EmonTx measures apparent power, not real power.
EmonTx has been designed to be a battery powered wireless node which is easy to install. Often we found when installing energy monitoring systems that there is no power point close to the electricity utility meter to plug in a AC-AC voltage adapter which is needed for voltage measurement.
I am considering in future versions of EmonTx including the option to plug in an AC-AC adapter to measure voltage.
Hope this makes sense.
All the best, Glyn.
Re: EmonTX
Hi Glyn,
Thank you very much. I got it.
I have been planning to build something like power box ( http://instruct1.cit.cornell.edu/courses/ee476/FinalProjects/s2008/cj72_xg37/cj72_xg37/index.html ) and EmonTx.
I found some product such as efergy e2 http://www.efergy.com/Products/efergy-Shop-Energy-Monitors/EFERGY/Efergy-E2/pid-184320.aspx that can show watt information but using only CT sensor. I think they would estimate other values like your answer.
May you have any ideas what is the best way to estimate to get most accurate watt information ?
Sincerely,
zen
Re: EmonTX
Hi Zen,
The two estimates which are required are grid voltage and power factor. Grid voltage can be estimated to be 240V as this is the UK grid voltage (+-10%). The power factor can be assumed to be close to 1 as for resistive loads. AC power thory is explained well by Trsytan on this page: http://openenergymonitor.org/emon/node/61
CT only power measurement is a trade in towards convenience and ease of installation and accuracy. If higher accuracy is required see 'Mains AC non-invasive 3.0' in the input buid section. This design includes voltage measurment.
Glyn.
Re: EmonTX
Hi Glyn
Thanks for your help. May I use your design (EmoxTx) be some part of our product ? Is it open source project that i can do that ?
Best regards,
zen
Re: EmonTX
Hi Zen,
The emonTx hardware designs and software (to be released soon!) are made available under the GNU GPL V3 open-source License and follows the terms of the OSHW (Open-source hardware) Statement of Principles 1.0 .
What this basically means is that you are free to modify, re-distribute and even market the design as you wish. As long as you attribute OpenEnergyMonitor and make any resulting designs available under the same open-source license.
I look forward to hearing about what you do with the designs. We have some PCB's which we hope to make available to buy through the openenergymonitor website in the near future.
Hope this answers your questions.
All the best, Glyn.
Re: EmonTX
Hi Glyn.
I will look forward to hearing your progress of EmonTx.
Thanks for your advice.
zen


Lazaridis School of Business & Economics
Honours Bachalor of Business Administration (B.B.A.), Concentration in Finance
2017 - 2022
Activities & Societies: Enactus Laurier, Laurier Consulting Club, Laurier Investment & Finance Club
Wilfrid Laurier University
Honours Bachalor of Science in Computer Science (B.Sc.) Minor in Mathematics
2017 - 2022
Directed Research: Machine Learning in Finance with advisors Dr. Pooja Vashisth (University of Toronto) and Dr. Jiashu Zhao (Laurier)
Harvard Business School Online
Finance Essentials
2019 - 2019
Part of Harvard CORe; course taken at Deloitte
Coursera
Machine Learning by Stanford University
2021 - 2021
"This course provides a broad introduction to machine learning, datamining, and statistical pattern recognition. Topics include: (i) Supervised learning (parametric/non-parametric algorithms, support vector machines, kernels, neural networks). (ii) Unsupervised learning (clustering, dimensionality reduction, recommender systems, deep learning). (iii) Best practices in machine learning (bias/variance theory; innovation process in machine learning and AI). The course will also draw from numerous case studies and applications, so that you'll also learn how to apply learning algorithms to building smart robots (perception, control), text understanding (web search, anti-spam), computer vision, medical informatics, audio, database mining, and other areas."


@extends("shared/layout.html") @require(igns, menu, page) @import 'shared/sidebar/messages.html' as sb @def title(): @{_('Blocked Users')} | @{config.site.lema} @end @def sidebar(): @# Without a comment here, the menu is not rendered. @if menu == 'message': @{sb.render_sidebar('blocks')!!html} @else: @include('shared/sidebar/user.html') @end @end @def main():
@{_('You can use this page to manage the users you have blocked. You can choose to hide or show private messages from blocked users, and you can choose to hide, blur or show posts and comments by blocked users. To add users to this list, use the “block” link on their user profile or the “block sender” link on their messages.')}
@{_('Blocking other users does not prevent them from seeing the content that you post.')}
@if current_user.is_a_mod:@{_('Posts and comments from blocked users will be shown normally in the subs which you moderate, and if you block someone who is a moderator, the content they post in the subs which they moderate will always be shown.')}
@else:@{_('Posts and comments from blocked users who are moderators will be shown normally in the subs which they moderate.')}
@end| @{ig['name']} |
@{_('You can block users from the “block” link on their user profile or the “block sender” link on their messages.')}
@endif


| Target Namespace | http://www.openapplications.org/oagis/9 |
|---|---|
| Element and Attribute Namespaces |
|
| Schema Composition |
|
| Prefix | Namespace |
|---|---|
| Default namespace | http://www.openapplications.org/oagis/9 |
| xml | http://www.w3.org/XML/1998/namespace |
| xsd | http://www.w3.org/2001/XMLSchema |
| Super-types: | StatusEnabledHeaderType < RequestHeaderType (by extension) |
|---|---|
| Sub-types: |
|
| Name | RequestHeaderType |
|---|---|
| Abstract | yes |
| Documentation | The abstract basis for the Header of all the Procurement Documents.
For a Procurement Document the CustomerParty is the party in which the items have been or will be SoldTo (i.e. the SoldToParty). More information at: http://www.openapplications.org/platform/1. |
| Super-types: | StatusEnabledLineType < RequestLineType (by extension) |
|---|---|
| Sub-types: |
|
| Name | RequestLineType |
|---|---|
| Abstract | no |
| Super-types: | LineType < RequestSubLineType (by extension) |
|---|---|
| Sub-types: | None |
| Name | RequestSubLineType |
|---|---|
| Abstract | no |
| Documentation | The basis for the ProcurementDocumet SubLine. More information at: http://www.openapplications.org/platform/1. |
| Super-types: | StatusEnabledHeaderType < RequestHeaderType (by extension) < ProcurementHeaderType (by extension) |
|---|---|
| Sub-types: |
|
| Name | ProcurementHeaderType |
|---|---|
| Abstract | no |
| Super-types: | StatusEnabledLineType < RequestLineType (by extension) < ProcurementLineType (by extension) |
|---|---|
| Sub-types: |
|
| Name | ProcurementLineType |
|---|---|
| Abstract | no |
| Super-types: | LineType < ProcurementScheduleType (by extension) |
|---|---|
| Sub-types: | None |
| Name | ProcurementScheduleType |
|---|---|
| Abstract | no |
| Documentation | The Quantity Indicates the number of items that are to be deliveried on the Required Date or the number of items to be delivered on each occurence of the Schedule period frequency or the number of items to be delivered on each delivery where the number of deliveries is provided by the NumberOfDelivery field below. More information at: http://www.openapplications.org/platform/1. |
| Super-types: | StatusEnabledHeaderType < RequestHeaderType (by extension) < ProcurementHeaderType (by extension) < OrderHeaderType (by extension) |
|---|---|
| Sub-types: | None |
| Name | OrderHeaderType |
|---|---|
| Abstract | no |
| Super-types: | StatusEnabledLineType < RequestLineType (by extension) < ProcurementLineType (by extension) < OrderLineType (by extension) |
|---|---|
| Sub-types: | None |
| Name | OrderLineType |
|---|---|
| Abstract | no |
| Super-types: | None |
|---|---|
| Sub-types: | None |
| Name | PriceBreakType |
|---|---|
| Abstract | no |
| Name | PriceBreak |
|---|---|
| Type | PriceBreakType |
| Nillable | no |
| Abstract | no |
| Documentation | This defines the prices and modifiers to the price for buying a given quantity or value of an item or item category on a price list line. For Price List Lines that specify Items the price breaks can be specified in terms of quantity or amount. For Price list lines that specify commodity, price breaks can only be specified in terms of currency amount More information at: http://www.openapplications.org/platform/1. |
| Super-types: | None |
|---|---|
| Sub-types: | None |
| Name | QualificationTermType |
|---|---|
| Abstract | no |
| Name | QualificationTerm |
|---|---|
| Type | QualificationTermType |
| Nillable | no |
| Abstract | no |
| Documentation | This is used to describe preferences that will be used to evaluate responses to an RFQ. For example, to identify a preference for sharing CAD data in VRML format the ID = VRML, Type = CAD and Value = 1 or Yes More information at: http://www.openapplications.org/platform/1. |
| Super-types: | None |
|---|---|
| Sub-types: | None |
| Name | OrderCommissionType |
|---|---|
| Abstract | no |
| Documentation | Contains the relevant information about the salesperson and the associated commission information. More information at: http://www.openapplications.org/platform/1. |
| Name | OrderCommission |
|---|---|
| Type | OrderCommissionType |
| Nillable | no |
| Abstract | no |
| Documentation | Contains the relevant information about the salesperson and the associated commission information. More information at: http://www.openapplications.org/platform/1. |


Testing leads to failure, and failure leads to understanding.
-Burt Rutan
Welcome To Java Mock Test
Enter Your Name
Start Quiz


Dale has been diagnosed with stage 3B Metastatic Melanoma, he has been for 2 operations and requires a year of Immunotherapy treatments. These are extremely expensive and his medical aid has refused to cover the costs. PLEASE DONATE.
Please donate to Dale's fundraiser on backabuddy.co.za


Select - a11y
Slotted Label
Apples
Bananas
Oranges
Apples
Bananas
Oranges
Apples
Bananas
Oranges
Apples
Bananas
Oranges


Type function Library CoronaProvider.ads.vungle.* Return value Boolean Revision Current Public Release (2013.2076) Keywords ad, ads, show, showAd, vungle Sample code https://github.com/Vungle/coronaplugin-release/tree/master/samples See also ads.show()
Displays a full-screen video ad if one is cached and available for display.
ads.show( adUnitType [, params] )
String. Vungle supports the following ad types:
interstitial
- default video ad unitincentivized
- video ad unit with optional server-to-server callback for in-app rewardsTable. Optional parameters for configuring video ad. See params
Table Properties below.
params
Table PropertiesBoolean. true
(default) if the video ad should transition in with a slide effect. false
if it should appear instantaneously.
Boolean. true
(default) if the video ad should auto-rotate with the device's orientation. false
if it should use the ad's preferred orientation.
Boolean. true
if the Android back button should stop playback during the video ad and display the post-roll. false
(default) if the back button should be disabled during video ad playback.
Note: The back button is always enabled in the post-roll. When pressed, it exits the ad completely and returns the user to your application.
Boolean. true
(default) if sound should be enabled during video ad playback (subject to the device's sound settings as well). false
if video playback should start muted. The user can always choose to mute or unmute sound during playback.
incentivized
' ad type only)String. The user identifier you wish to receive in a server-to-server callback to reward the user in your application for a completed video ad view.
incentivized
' ad type only)Boolean. true
(default) if a close button allowing the user to skip a video ad should be shown after 4 seconds. false
if no close button should be shown, forcing the user to watch the entire video ad.
Note: The close button can be hidden for both ad types on the Vungle Dashboard.
-- name of the Vungle 'ads' provider
local provider = "vungle"
-- replace with your own Vungle application ID
local appId = "vungleTest"
-- load Corona 'ads' library
local ads = require "ads"
-- listener that handles a video ad not being available for display
local function adListener( event )
if event.type == "adStart" and event.isError then
-- cached video ad not available for display
end
end
-- initialize the 'ads' library using Vungle as the provider with 'adListener' as an optional 3rd parameter
ads.init( provider, appId, adListener )
-- display an ad if a cached video is available for playback
local wasAdShown = ads.show( "interstitial", { isAnimated = false, isBackButtonEnabled = true } )


nips nips2006 nips2006-187 nips2006-187-reference knowledge-graph by maker-knowledge-mining
Source: pdf
Author: Thomas Voegtlin
Abstract: In biological neurons, the timing of a spike depends on the timing of synaptic currents, in a way that is classically described by the Phase Response Curve. This has implications for temporal coding: an action potential that arrives on a synapse has an implicit meaning, that depends on the position of the postsynaptic neuron on the ﬁring cycle. Here we show that this implicit code can be used to perform computations. Using theta neurons, we derive a spike-timing dependent learning rule from an error criterion. We demonstrate how to train an auto-encoder neural network using this rule. 1
[1] W. Maass. Lower bounds for the computational power of networks of spiking neurons. Neural Computation, 8(1):1–40, 1996.
[2] S.M. Bohte, J.N. Kok, and H. La Poutr´ . Spike-prop: error-backprogation in multi-layer networks of e spiking neurons. Neurocomputing, 48:17–37, 2002.
[3] A. J. Bell and L. C. Parra. Maximising sensitivity in a spiking network. In Advances in Neural Information Processing Systems, volume 17, pages 121–128, 2005.
[4] R. F. Gal´ n, G. B. Ermentrout, and N. N. Urban. Efﬁcient estimation of phase-resetting curves in real a neurons and its signiﬁcance for neural-network modeling. Physical Review Letters, 94:158101, 2005.
[5] G. B. Ermentrout. Type I membranes, phase resetting curves, and synchrony. Neural Computation, 8:979–1001, 1996.
[6] W. Gerstner and W. M. Kistler. Spiking Neuron Models : Single Neurons, Populations, Plasticity. Cambridge University Press, 2002.
[7] R. P. N. Rao and T. J. Sejnowski. Predictive sequence learning in recurrent neocortical circuits. In Advances in Neural Information Processing Systems, volume 12, pages 164–170, 2000.
[8] E. Oja. Neural networks, principal components and subspaces. International Journal of Neural Systems, 1(1):61–68, 1989.
[9] B. Olshausen and D. Field. Sparse coding of natural images produces localized, oriented, bandpass receptive ﬁelds. Nature, 381:607–609, 1996.
[10] E. Oja. The nonlinear PCA learning rule in independent component analysis. Neurocomputing, 17(1):25– 46, 1997.
[11] Lengyel M., Kwag J., Paulsen O., and Dayan P. Matching storage and recall:hippocampal spike timingdependent plasticity and phase response curves. Nature Neuroscience, 8:1677–1683, 2006.


SpaOTsc API Reference¶
The SpaOTsc module¶
-
spaotsc.SpaOTsc.
choose_landmarks
(pts, n, dmat=None, method='maxmin', assignment='nearest')¶ Choose a set of landmark points from a set of points.
[1] De Silva, Vin, and Gunnar E. Carlsson. “Topological estimation using witness complexes.” SPBG 4 (2004): 157-166.
Parameters: - pts (class:numpy.ndarray) – coordinates of points (n_points, nD) needed if dmat not given
- n (int) – number of landmark points to select
- dmat (class:numpy.ndarray) – the distance matrix for the points (n_points, n_points)
Returns: the indices of selected points and an assignment matrix to assign original points to landmark points (n_landmarks, n_points)
Return type: class:numpy.ndarray
-
spaotsc.SpaOTsc.
compute_mcc
(true_labels, pred_labels)¶ Compute matthew’s correlation coefficient.
Parameters: - true_labels (class:numpy.ndarray) – 1D integer array
- pred_labels (class:numpy.ndarray) – 1D integer array
Returns: mcc
Return type: float
-
spaotsc.SpaOTsc.
knn_graph
(D, k)¶ Construct a k-nearest-neighbor graph as igraph object.
Parameters: - D (class:numpy.ndarray) – a distance matrix for constructing the knn graph
- k (int) – number of nearest neighbors
Returns: a knn graph object
Return type: class:igraph.Graph
-
spaotsc.SpaOTsc.
knn_graph_nx
(D, k)¶ Construct a k-nearest-neighbor graph as networkx object.
Parameters: - D (class:numpy.ndarray) – a distance matrix for constructing the knn graph
- k (int) – number of nearest neighbors
Returns: a knn graph object and a list of edges
Return type: class:networkx.Graph, list of tuples
-
spaotsc.SpaOTsc.
phi_exp
(x, eta, nu, p)¶ The exponential weight kernel. Computes exp(-(x/eta)^(p*nu)).
Parameters: - x (float or class:numpy.ndarray) – the input value
- eta (float) – the cutoff for this soft thresholding kernel
- nu (int) – a possitive integer for the power term, a bigger nu gives sharper threshold boundary
- p (int) – p=1: emphasize elements lower than cutoff; p=-1: emphasize elements higher than cutoff
Returns: the kernel output with same shape of x
Return type: same as x
-
spaotsc.SpaOTsc.
sci
(x, y, W, scale=False)¶ Computes the spatial correlation index in Eq. (9) of [1].
[1] Chen, Yanguang. “A new methodology of spatial cross-correlation analysis.” PloS one 10.5 (2015): e0126158.
Parameters: - x (class:numpy.ndarray) – the variable’s values at the spatial locations
- y (class:numpy.ndarray) – the other variable’s values at the spatial locations
- W (class:numpy.ndarray) – weight matrix (symmetric) among the locations with W[i,i] = 0
- scale (boolean) – whether to scale the inputs s.t. (1) sum_{i,j}W_{ij} = 1 and (2) x = (x-mu(x))/sigma(x)
Returns: a global spatial cross correlation index
Return type: float
-
class
spaotsc.SpaOTsc.
spatial_sc
(sc_data=None, is_data=None, sc_data_bin=None, is_data_bin=None, is_pos=None, is_dmat=None, sc_dmat=None)¶ An object for connecting and analysis of spatial data and single-cell transcriptomics data.
A minimal example usage: Assume we have (1) a pandas DataFrame for single-cell data
df_sc
with rows being cells and columns being genes (2) a numpy array for distance matrix among spatial locationsis_dmat
(3) a numpy array for dissimilarity between single-cell data and spatial datacost_matrix
(4) a numpy array for dissimilarity matrix within single-cell datasc_dmat
>>> import spaotsc >>> spsc = spaotsc.SpaOTsc.spatial_sc(sc_data=df_sc, is_dmat=is_dmat, sc_dmat=sc_dmat) >>> spsc.transport_plan(cost_matrix) >>> spsc.cell_cell_distance(use_landmark=True) >>> spsc.clustering() >>> spsc.spatial_signaling_ot(['Wnt5'],['fz'],DSgenes_up=['CycD'],DSgenes_down=['dpp']) >>> signal_strengths,_=spsc.infer_signal_range_ml(['Wnt5'],['fz'],['CycD','dpp'], effect_ranges=[10,50,100]) >>> intercellular_grn=spsc.spatial_grn_range(['Wnt5','fz','CycD','dpp'])
Parameters: - sc_data (class:pandas.DataFrame) – single-cell data of size (n_cells, n_genes)
- is_data (class:pandas.DataFrame) – spatial data of size (n_locations, n_genes)
- sc_data_bin (class:pandas.DataFrame) – binarized single-cell data
- is_data_bin (class:pandas.DataFrame) – binarized spatial data
- is_pos (class:numpy.ndarray) – coordinates of spatial locations (n_locations, n_dimensions)
- is_dmat (class:numpy.ndarray) – distance matrix for spatial locations (n_locations, n_locations)
- sc_dmat (class:numpy.ndarray) – dissimilarity matrix for single-cell data (n_cells, n_cells)
List of instance attributes:
Variables: - sc_data (class:pandas.DataFrame) – single-cell data of size (n_cells, n_genes)
__init__
- is_data (class:pandas.DataFrame) – spatial data of size (n_locations, n_genes)
__init__
- sc_data_bin (class:pandas.DataFrame) – binarized single-cell data
__init__
- is_data_bin (class:pandas.DataFrame) – binarized spatial data
__init__
- is_pos (class:numpy.ndarray) – coordinates of spatial locations (n_locations, n_dimensions)
__init__
- is_dmat (class:numpy.ndarray) – distance matrix for spatial locations (n_locations, n_locations)
__init__
- sc_dmat (class:numpy.ndarray) – dissimilarity matrix for single-cell data (n_cells, n_cells)
__init__
- gamma_mapping (class:numpy.ndarray) – the mapping matrix between single-cell data and spatial data (n_cells, n_locations)
transport_plan
- sc_dmat_spatial (class:numpy.ndarray) – the spatial cell-cell distance for single-cell data (n_cells, n_cells)
cell_cell_distance
- clustering_ncluster_org (int) – number of clusters in original clustering of single-cell data
clustering
- clustering_nsubcluster (list of int) – number of cell spatial subclusters within each original cluster
clustering
- clustering_partition_org (list of numpy integer arrays) – the cell indices for each original cluster
clustering
- clustering_partition_inds (dictionary) – the cell indices for the cell spatial subclusters, e.g. the key (0,1) returns the cell indices for the second spatial subcluster within the first original cell cluster.
clustering
- gene_cor_scc (class:pandas.DataFrame) – the intracellular spearmanr correlation between genes
nonspatial_correlation
- gene_cor_is (class:pandas.DataFrame) – the intercellular spatial correlation between genes
spatial_correlation
- g_bin_edges (dictionary) – the bin edges for the discretization of gene expressions with gene name string as dictionary key
discretize_expression
-
cell_cell_distance
(epsilon=0.01, rho=inf, scaling=True, sc_dmat_spatial=None, use_landmark=False, n_landmark=100)¶ Compute spatial distance between single cells using optimal transport.
Generates: self.sc_dmat_spatial: (n_cell, n_cell) numpy.ndarray
Requires: self.gamma_mapping, self.is_dmat
Parameters: - epsilon (float, defaults to 0.01) – weight for entropy regularization term
- rho (float, defaults to inf) – weight for KL divergence penalizing unbalanced transport
- scaling (boolean, defaults to True) – whether to scale the cost_matrix (is_dmat) to avoid numerical overflow
- sc_dmat_spatial (class:numpy.ndarray, optional) – the spatial distance matrix for single cells (n_cells, n_cells). If given, simply set the distance matrix without computing.
- use_landmark (boolean, defaults to False) – whether to use landmark points for computing transport distance.
- n_landmark (int, defaults to 100) – number of landmark points to use if use_landmark
Returns: (spatial) cell-cell distance matrix (n_cells, n_cells)
Return type: class:numpy.ndarray
-
clustering
(genes=None, pca_n_components=None, res_sc=0.5, res_is=0.3, min_n=3)¶ Clustering and spatial subclustering.
Generates:
self.clustering_nsubcluster: list of int, numbers of subclusters in each cluster obtained in regular clustering of single-cell data
self.clustering_partition_inds: list of cell index arrays for clusters
self.clustering_partition_org: a dictionary for cell index arrays of spatial subclusters. The key (1,0) gives the first subcluster for the second cluster.
Requires:
self.sc_dmat_spatial, self.sc_data
Parameters: - genes (list) – genes to use when clustering single-cell data. All genes in self.sc_data are used if not specified.
- pca_n_components (int) – number of pca components when clustering single-cell data
- res_sc (float, defaults to 0.5) – resolution parameter in louvain clustering for single-cell data
- res_is (float, defaults to 0.3) – resolution parameter in louvain clustering for spatial subclustering of single-cel data
- min_n (int, defaults to 3) – minimum number of members to be considered a cluster
-
discretize_expression
(genes=None, p0=1e-15)¶ Discretize gene expression using Bayesian blocks.
Generate: self.g_bin_edges: a dictionary of block edges with gene names as keys
Requires: self.sc_data
Parameters: p0 (float, defaults to 1E-15) – the p0 score in Bayesian blocks. A smaller p0 has lower tolerance of false rate, i.e. resulting in fewer blocks.
-
gene_clustering
(gene_dmat, res=3, k=5, rng_seed=48823)¶ Cluster the genes based on their spatial pattern difference.
Parameters: - gene_dmat (class:numpy.ndarray) – the distance matrix for genes (n_gene, n_gene)
- res (float, defaults to 3) – resolution parameter used by louvain clustering, higher res gives more clusters
- k (int, defaults to 5) – the k for knn graph fed to louvain algorithm
- rng_seed (int) – random seed for louvain algorithm to get consistent results
Returns: a list of index vectors for the clusters
Return type: list of list of int
-
gene_gene_distance
(genes=None, epsilon=0.01, rho=inf, scaling=True, sc_dmat_spatial=None, use_landmark=False, n_landmark=100)¶ Compute Wasserstein distance between gene expressions in scRNA-seq data.
Parameters: - genes (list of str) – the gene names to compute distance
- epsilon (float, defaults to 0.01) – weight for entropy regularization term
- rho (float, defaults to inf) – weight for KL divergence penalizing unbalanced transport
- scaling (boolean, defaults to True) – whether to scale the cost matrix
- sc_dmat_spatial (class:numpy.ndarray) – spatial distance matrix over the single cells
- use_landmark (boolean, defaults to False) – whether to use landmark points to accelarate computation
- n_landmark (int, defaults to 100) – number of landmark genes to use
Returns: gene-gene distance matrix
Return type: class:numpy.ndarray
-
gene_pair_ml_effect_range
(gene_1, gene_2, background_genes=None, cor_cut=None, n_top_g=None, effect_ranges=None, method='Importance')¶ Deriving scores for intercellular gene regulation (how much effect does gene_1 in neiborhood have on gene_2) using random forest.
Requires: self.sc_dmat_spatial, self.sc_data, self.gene_cor_scc
Parameters: - gene_1 (str) – the name of source gene whose expression in the neighborhood will be examined
- gene_2 (str) – the name of target gene whose cellular expression will be used
- background_genes (list of str) – a name list for gene that are correlated to gene_2
- cor_cut (float) – the cut_off choosing background genes. used when background_genes is not specified
- n_top_g (int) – the number of genes with highest correlation to gene_2 to be used as background_genes. used when both background_genes and cor_cut are not specified
- effect_ranges (list of float) – list of spatial distances to consider
- method (str, defaults to 'Importance') – ‘Importance’: interpret the feature importance as regulation strength; ‘Prediction’: interpret prediction accuracy in cross-validation as regulation strength.
Returns: a (n_distance, 2) array with the first row recording the spatial distances examined and the second row being the effect strength
Return type: class:numpy.ndarray
-
gene_pair_pid_effect_range
(gene_1, gene_2, background_genes=None, cor_cut=None, n_top_g=None, effect_ranges=None, p0=1e-15, cell_id=None, output_individual=False)¶ - The unique information provided by G1_nb (within various ranges) to
- G2 considering background genes Gi
Requires: self.sc_dmat_spatial, self.sc_data, self.gene_cor_scc
Parameters: - gene_1 (str) – the name of source gene whose expression in the neighborhood will be examined
- gene_2 (str) – the name of target gene whose cellular expression will be used
- background_genes (list of str) – a name list for gene that are correlated to gene_2
- cor_cut (float) – the cut_off choosing background genes. used when background_genes is not specified
- n_top_g (int) – the number of genes with highest correlation to gene_2 to be used as background_genes. used when both background_genes and cor_cut are not specified
- effect_ranges (list of float) – list of spatial distances to consider
- p0 (float, defaults to 1E-15) – the p0 score in Bayesian blocks. A smaller p0 has lower tolerance of false rate, i.e. resulting in fewer blocks.
- output_individual (boolean, defaults to False) – where to output the information computed with each background gene
Returns: a (n_distance, 2) array with the first row recording the spatial distances examined and the second row being the effect strength
Return type: class:numpy.ndarray
-
infer_signal_range_ml
(Lgenes, Rgenes, Dgenes, n_top_g=50, effect_ranges=None, method='Importance', custom_dmat=None)¶ Determine spatial distance for given signaling using random forest.
Requires: self.sc_dmat_spatial, self.sc_data, self.gene_cor_scc
Parameters: - Lgenes (list of str) – name list of ligand genes
- Rgenes (list of str) – name list of receptor genes
- Dgenes (list of str) – name list of downstream genes
- n_top_g (int, defaults to 50) – number of background genes to use when building predictive model.
- effect_ranges (list of float) – the spatial distances to examine
- method (str, defaults to 'Importance') – the way of interpreting likelihood for each spatial distance
- custom_dmat (class:numpy.ndarray) – a cell-cell distance matrix given by user. self.sc_dmat_spatial is used if not given.
Returns: (n_distance, 2) array for spatial distances (first row) and effect strengths (second row); and a (n_distance, n_DSgenes) array for the effect strength of each downstream genes.
Return type: two class:numpy.ndarray
-
nonspatial_correlation
(genes=None)¶ Compute gene-gene correlation matrix for pre-screening of genes.
Generates: self.gene_cor_scc
Requires: self.sc_data`, self.sc_genes
Parameters: genes (list of str) – list of gene names. If not specified, all genes in self.sc_data are used.
-
rank_marker_genes
(cid, genes=None, method='ranksum', return_scores=False)¶ Rank genes to identify markers for cell clusters.
Parameters: - cid (class:numpy.1darray) – cell indices for the cluster
- genes (list) – candidate genes to examine. If not specified, all genes are used.
- method (str, defaults to 'ranksum') – method to use. 1. ‘roc’, using auc-roc score to rank; 2. ‘ranksum’, using ranksum statistics.
- return_scores (boolean, defaults to False) – whether to return scores instead of sorted gene indices
Returns: sorted gene indices (if return_scores==False) or gene scores (if return_scores==True)
Return type: class:numpy.1darray
-
spatial_correlation
(genes=None, effect_range=None, kernel='lorentz', kernel_nu=10)¶ Computes spatial correlation between genes for pre-screening.
Generates: self.gene_cor_is pandas DataFrame
Requires: self.sc_data
Parameters: - genes (list of str) – list of gene to examine
- effect_range (float) – spatial distance
- kernel (str, defaults to 'lorentz') – type of kernels for weight matrix
- kernel_nu (int, defaults to 10) – power for weight kernel
-
spatial_grn_range
(genes, effect_range=None, cor_cut=None, n_top_edge=None, cor_cut_bg=None, n_top_g_bg=None, method='pid', p0=1e-15, output_individual=False)¶ Generate the spatial map for intercellular gene-gene regulatory information flow.
Requires: self.sc_data, self.sc_dmat_spatial, self.gene_cor_scc, self.gene_cor_is
Parameters: - genes (list of str) – name list of genes to be examined
- effect_range (float) – spatial distance for analyzing the intercellular processes
- cor_cut (float) – the cutoff for spatial correlation between two genes for further examination (used if n_top_edge not specified)
- n_top_edge (int) – the number of gene pairs to examine with highest spatial correlation
- cor_cut_bg (float) – the cutoff for intracellular gene correlation to select background genes
- n_top_g_bg (int) – the number of genes with highest intracellular gene correlation with the target gene to use as background genes (used if cor_cut_bg not specified)
- p0 (float, defaults to 1E-15) – the p0 value for Bayesian blocks (lower p0 gives fewer number of bins)
- output_individual (boolean, defaults to False) – whether to output the individual values computed with each background gene
Returns: a data frame with rows being source genes and columns being target genes
Return type: class:pandas.DataFrame
-
spatial_signaling_ot
(Lgenes, Rgenes, Tgenes=[], Rbgenes=[], DSgenes_up=[], DSgenes_down=[], gene_bandwidth={}, effect_range=None, rho=10.0, epsilon=0.2, kernel_nu=5, use_kernel_ligand=False, use_kernel_receptor=False, return_weight_only=False)¶ Generate cell-cell signaling using optimal transport for a list of ligands and a list of receptors.
Requires: self.sc_dmat_spatial, self.sc_data
Parameters: - Lgenes – name list of the ligand gene
- Rgenes (list of str) – name list of receptor genes
- Tgenes (list of str, optional) – name list of genes for transporters of ligands
- Rbgenes (list of str, optional) – name list of genes for proteins bound to receptor for the receptor to work
- DSgenes_up (list of str) – name list of up regulated genes by the ligand-receptor
- DSgenes_down (list of str) – name list of down regulated genes by the ligand-receptor
- gene_bandwidth (dictionary (str to scalar), all outputs default to 1) – the cutoffs for each gene to be considered expressed
- effect_range (float) – spatial distance cutoff for the signaling
- epsilon (float, defaults to 0.2) – weight for entropy regularization term
- rho (float, defaults to inf) – weight for KL divergence penalizing unbalanced transport
- kernel_nu (float, defaults to 5) – the power parameter for the exponential kernel, bigger nu means sharper soft cutoff
- use_kernel_ligand (boolean, defaults to False) – whether use kernel function to rescale ligand expression
- use_kernel_receptor (boolean, defaults to False) – whether use kernel function to rescale receptor expression
- return_weight_only (boolean, defaults to False) – whether to only return the weight for source distribution and destination distribution
Returns: a scoring matrix for the given signaling genes (cells, cells), (i,j) entry is the score for cell i sending signals to cell j
Return type: class:numpy.ndarray
-
spatial_signaling_ot_singleligand
(Lgene, Rgene, Tgenes=None, Rbgene=None, DSgenes_up=None, DSgenes_down=None, effect_range=None, rho=10.0, epsilon=0.2)¶ Generate cell-cell signaling using optimal transport for a single ligand.
Requires: self.sc_dmat_spatial, self.sc_data
Parameters: - Lgene (str) – name of the ligand gene
- Rgene (list of str) – name list of receptor genes
- Tgenes (list of str, optional) – name list of genes for transporters of ligands
- Rbgene (list of str, optional) – name list of genes for proteins bound to receptor for the receptor to work
- DSgenes_up (list of str) – name list of up regulated genes by the ligand-receptor
- DSgenes_down (list of str) – name list of down regulated genes by the ligand-receptor
- effect_range (float) – spatial distance cutoff for the signaling
- epsilon (float, defaults to 0.2) – weight for entropy regularization term
- rho (float, defaults to inf) – weight for KL divergence penalizing unbalanced transport
Returns: a scoring matrix for the given signaling genes (cells, cells), (i,j) entry is the score for cell i sending signals to cell j
Return type: class:numpy.ndarray
-
spatial_signaling_scoring
(Lgene, Rgene, Rbgene=None, Tgenes=None, DSgenes_up=None, DSgenes_down=None, effect_range=None, kernel='exp', kernel_nu=5, gene_eta=None, penalty_type='addition')¶ Generate cell-cell signaling using predefined scoring function.
Requires: self.sc_dmat_spatial, self.sc_data
Parameters: - Lgene (str) – name of the ligand gene
- Rgene (list of str) – name list of receptor genes
- Rbgene (list of str, optional) – name list of genes for proteins bound to receptor for the receptor to work
- Tgenes (list of str, optional) – name list of genes for transporters of ligands
- DSgenes_up (list of str) – name list of up regulated genes by the ligand-receptor
- DSgenes_down (list of str) – name list of down regulated genes by the ligand-receptor
- effect_range (float) – spatial distance cutoff for the signaling
- kernel (str, defaults to 'exp') – weight kernel to use for soft thresholding
- kernel_nu (float, defaults to 5) – power for weight kernel, a higher power gives a shaper edge
- gene_eta (list of float, defaults to 1s) – a list of threshold values for the downstream genes
- penalty_type (str, defaults to 'addition') – how to penalize inconsistency of downstream genes. ‘addition’: relaxed penalty; ‘multiplication’: strict penalty
Returns: a scoring matrix for the given signaling genes (cells, cells), (i,j) entry is the score for cell i sending signals to cell j
Return type: class:numpy.ndarray
-
transport_plan
(cost_matrix, cor_matrix=None, alpha=0.1, epsilon=1.0, rho=100.0, G_sc=None, G_is=None, scaling=False)¶ Mapping between single cells and spatial data as transport plan.
Generates: self.gamma_mapping: (n_cells, n_locations) numpy.ndarray
Parameters: - cost_matrix (class:numpy.ndarray) – dissimilarity matrix between single-cell data and spatial data (cells, locations)
- cor_matrix (class:numpy.ndarray, optional) – similarity matrix between single-cell data and spatial data (cells, locations)
- alpha (float, [0,1], defaults to 0.1) – weight for structured part (Gromov-Wassertein loss term)
- epsilon (float, defaults to 1.0) – weight for entropy regularization term
- rho (float, defaults to 100.0) – weight for KL divergence penalizing unbalanced transport
- G_sc (class:numpy.ndarray) – dissimilarity matrix within single-cell data (cells, cells)
- G_is (class:numpy.ndarray) – distance matrix within spatial data (locations, locations)
- scaling (boolean, defaults to False) – whether scale the cost_matrix to have max=1
Returns: a mapping between single-cell data and spatial data (cells, locations)
Return type: class:numpy.ndarray
-
visualize_cells
(type=1, method='umap', perplexity=30.0, umap_n_neighbors=5, umap_min_dist=0.1)¶ Visualization of cells.
Parameters: type (int) – the type of visualization type=1 dimension reduction with spatial distance, label with original clusters; type=2 dimension reduction with scRNAseq, label with spatial subclusters; type=3 dimension reduction with spatial distance, label with spatial subclusters; type=4 dimension reduction with scRNAseq, label with original clusters.
-
visualize_subclusters
(pts=None, k=3, cut=None, vmin=0.005, vmax=0.03333333333333333, umap_k=3, figsize=(20, 20))¶ Visualize subclusters as a summary and distributions over the original geometry (2D).
Parameters: - pts (class:numpy.ndarray) – the coordinates of original geometry (n_locations, 2)
- k (int) – the number nearest neighbors to connect in the subcluster summary plot
- vmin (float) – the vmin for colormap of the edges in the summary plot
- vmax (float) – the vmax for colormap of the edges in the summary plot
- umap_k (int) – the n_neighbors parameter in umap dimension reduction


MR. & MRS. BRIDGE A film review by Frank Maloney Copyright 1990 Frank Maloney
MR. & MRS. BRIDGE is adapted by Ruth Prawer Jhabvala from two novels by Evan S. Connell, MRS. BRIDGE (1959) and MR. BRIDGE (1969); the film is produced and directed by the team of Merchant-Ivory that earlier brought us ROOM WITH A VIEW, MAURICE, and others.
The artistic goal and challenge is to find what is interesting, dramatic, and human in the smug, comfortable country-club lives (in this case, Kansas City-Mission Hills, 1930's and early 1940's).
The movie consists of a series episodes, almost vignettes, not quite but nearly free-standing. We move from the rigid, glacial walls the characters present us to see them as real people with their own pains and tragedies. There is much comedy here and some sadness. If we watch them and only say, "what's the problem? they have everything they need" we are being very much like some of the characters themselves. Part of their tragedy is often an inability to sympathize, to see beyond their own narrow lives. In slowly opening up the characters to us, the movie is entirely successful.
Much of the success is probably Ruth Prawer Jhabvala's script, which moves by easy degrees like a new friendship. The opening introductions, the growing knowledge of the other person's personality and quirks and faults, the acceptance, the caring, the concern and involvement.
Much of the success has to go to Paul Newman and Joanne Woodward, who have been making movies together off and on for 35 years more or less. Honestly, I have never seen them act better. It will be the subject of some discussion over who does the better job. Woodward's performance is a little easier to appreciate, her character is more lovable and emotional; she does wonderful things communicating strength and fragility, confusion and wisdom. Newman's character is inarticulate, superficially unloving, under control, unemotional, and underneath as seething and emotional as any of us; making that characterization live is a major achievement for an actor and Newman delivers.
Of course, the title characters are not the only ones. The supporting performances were uniformly excellent. I especially liked the juicy job of the very "advanced" psychiatrist, who lives in a moderniste house with African sculpture, wears loud waistcoats and a beard, and seems always to be enjoying enormously a cigar and a private joke. He is played by the same actor who played the country vicar in ROOM WITH A VIEW and who romped so enthusiastically in the nude bathing scene, Simon Callow. I can also mention with pleasure the performance of Blythe Danner, Mrs. Bridge's best and unhappy friend.
Like all of Merchant-Ivory's period pieces, the look of this movie is wonderful, rich, convincing, and detailed.
I wholeheartedly recommend MR. & MRS. BRIDGE to all adults.
-- Frank Richard Aloysius Jude Maloney .
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


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use BasicAction | |
|---|---|
| uchicago.src.codegen | |
| uchicago.src.sim.engine | |
| uchicago.src.sim.util |
| Uses of BasicAction in uchicago.src.codegen |
|---|
| Methods in uchicago.src.codegen with parameters of type BasicAction | |
|---|---|
void |
Stepper.setBasicAction(BasicAction a)
|
| Uses of BasicAction in uchicago.src.sim.engine |
|---|
| Subclasses of BasicAction in uchicago.src.sim.engine | |
|---|---|
class |
ActionGroup
A collection of BasicActions to be executed by a schedule. |
class |
AsynchSchedule
A subclass of schedule useful for asynchronous scheduling. |
class |
CallBackSchedule
The CallBackSchedule class. |
class |
RandomScheduleGroup
|
class |
Schedule
Manages the execution of BasicActions (ActionGroups, SimActions, and SimListActions) according to a simulation clock. |
class |
ScheduleBase
Abstract base class for Schedule and SubSchedule. |
class |
ScheduleGroup
A specialized BasicAction containing other BasicActions. |
class |
SimAction
Deprecated. No longer used now that bytecode is generated directly. |
class |
SimListAction
Deprecated. No longer needed due to direct bytecode generation of BasicActions. |
class |
SubSchedule
Deprecated. |
class |
ThreadedAction
A wrapper that executes BasicActions within a Thread. |
| Fields in uchicago.src.sim.engine declared as BasicAction | |
|---|---|
protected BasicAction |
BaseController.pauseAtAction
|
| Methods in uchicago.src.sim.engine that return BasicAction | |
|---|---|
static BasicAction |
ActionUtilities.createActionFor(java.lang.Object o,
java.lang.String methodName)
Creates a BasicAction whose execute method calls the specified method on the specified object. |
static BasicAction |
ActionUtilities.createActionForEach(java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Creates a BasicAction whose execute method calls the specified method on every Object of the specified Class in the specified list. |
static BasicAction |
ActionUtilities.createActionForEach(java.util.List list,
java.lang.String methodName)
Creates a BasicAction whose execute method calls the specified method on every object in the specified list. |
static BasicAction |
ActionUtilities.createActionForEachRnd(java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Creates a BasicAction whose execute method calls the specified method on every Object of the specified Class in the specified list. |
static BasicAction |
ActionUtilities.createActionForEachRnd(java.util.List list,
java.lang.String methodName)
Creates a BasicAction whose execute method calls the specified method on every object in the specified list. |
BasicAction |
ActionQueue.peekMin()
|
BasicAction |
ActionQueue.popMin()
|
BasicAction |
ScheduleBase.removeAction(BasicAction action)
Removes the specified action from this Schedule. |
BasicAction |
AsynchSchedule.schedule(double time,
IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
Schedules a method to be called on an agent. |
BasicAction |
CallBackSchedule.schedule(double time,
java.lang.Object o,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
|
BasicAction |
ScheduleBase.scheduleActionAt(double at,
BasicAction action)
Schedules the specified BasicAction to occur at the specified clock tick in RANDOM order. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
BasicAction action,
double duration)
Schedules the specified BasicAction to occur at the specified clock tick in RANDOM order. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
BasicAction action,
ScheduleBase.Order order)
Schedules the specified BasicAction to occur at the specified clock tick in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAt(double at,
BasicAction action,
ScheduleBase.Order order,
double duration)
Schedules the specified BasicAction to occur at the specified clock tick in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.util.List list,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.util.List list,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.util.List list,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.lang.Object o,
java.lang.String methodName)
Schedules the execution of the specified method on the specified object to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.lang.Object o,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on the specified object to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.lang.Object o,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on the specified object to occur at the specified clock tick in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAt(double at,
java.lang.Object o,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on the specified object to occur at the specified clock tick in the specified order. |
BasicAction |
Schedule.scheduleActionAtEnd(BasicAction action)
Schedules the execution of the specified action for the end of the simulation run. |
BasicAction |
Schedule.scheduleActionAtEnd(java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List for the end of the simulation. |
BasicAction |
Schedule.scheduleActionAtEnd(java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List for the end of the simulation. |
BasicAction |
Schedule.scheduleActionAtEnd(java.lang.Object o,
java.lang.String methodName)
Schedules the execution of the specified method on the specified object for the end of the simulation run. |
BasicAction |
Schedule.scheduleActionAtEndRnd(java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List for the end of the simulation. |
BasicAction |
Schedule.scheduleActionAtEndRnd(java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List for the end of the simulation. |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
BasicAction action)
Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks). |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
BasicAction action,
double duration)
Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks). |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
BasicAction action,
ScheduleBase.Order order)
Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks) in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
BasicAction action,
ScheduleBase.Order order,
double duration)
Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks) in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.util.List list,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.util.List list,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. |
protected BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.util.List list,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.lang.Object o,
java.lang.String methodName)
Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks). |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.lang.Object o,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks). |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.lang.Object o,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks) in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
java.lang.Object o,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks) in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAtIntervalRnd(double interval,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks). |
BasicAction |
ScheduleBase.scheduleActionAtIntervalRnd(double interval,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks). |
BasicAction |
ScheduleBase.scheduleActionAtIntervalRnd(double interval,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAtIntervalRnd(double interval,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAtIntervalRnd(double interval,
java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. |
BasicAction |
ScheduleBase.scheduleActionAtIntervalRnd(double interval,
java.util.List list,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. |
BasicAction |
ScheduleBase.scheduleActionAtIntervalRnd(double interval,
java.util.List list,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. |
protected BasicAction |
ScheduleBase.scheduleActionAtIntervalRnd(double interval,
java.util.List list,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. |
BasicAction |
Schedule.scheduleActionAtPause(BasicAction action)
Schedules the execution of the specified action for a pause in the simulation run. |
BasicAction |
Schedule.scheduleActionAtPause(java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List for a pause in the simulation. |
BasicAction |
Schedule.scheduleActionAtPause(java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List for a pause in the simulation. |
BasicAction |
Schedule.scheduleActionAtPause(java.lang.Object o,
java.lang.String methodName)
Schedules the execution of the specified method on the specified object for a pause in the simulation run. |
BasicAction |
Schedule.scheduleActionAtPauseRnd(java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List for a pause in the simulation. |
BasicAction |
Schedule.scheduleActionAtPauseRnd(java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List for a pause in the simulation. |
BasicAction |
ScheduleBase.scheduleActionAtRnd(double at,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAtRnd(double at,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAtRnd(double at,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAtRnd(double at,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. |
BasicAction |
ScheduleBase.scheduleActionAtRnd(double at,
java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAtRnd(double at,
java.util.List list,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. |
BasicAction |
ScheduleBase.scheduleActionAtRnd(double at,
java.util.List list,
java.lang.String methodName,
ScheduleBase.Order order)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAtRnd(double at,
java.util.List list,
java.lang.String methodName,
ScheduleBase.Order order,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
BasicAction action)
Schedules the specified BasicAction to execute starting at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
BasicAction action,
double duration)
Schedules the specified BasicAction to execute starting at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
java.util.List list,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
java.lang.Object o,
java.lang.String methodName)
Schedules the execution of the specified method on the specified object to start at the specified clock tick and continue every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
java.lang.Object o,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on the specified object to start at the specified clock tick and continue every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginningRnd(double beginning,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginningRnd(double beginning,
java.util.List list,
java.lang.Class superClass,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginningRnd(double beginning,
java.util.List list,
java.lang.String methodName)
Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginningRnd(double beginning,
java.util.List list,
java.lang.String methodName,
double duration)
Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. |
BasicAction |
AsynchSchedule.scheduleAfterWaiting(IAsynchAgent agent,
java.lang.String methodName)
Schedules a method to be called on an agent after a certain waiting period. |
BasicAction |
AsynchSchedule.scheduleAfterWaiting(IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0)
Schedules a method to be called on an agent after a certain waiting period. |
BasicAction |
AsynchSchedule.scheduleAfterWaiting(IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
Schedules a method to be called on an agent after a certain waiting period. |
BasicAction |
AsynchSchedule.scheduleAfterWaiting(IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
Schedules a method to be called on an agent after a certain waiting period. |
BasicAction |
AsynchAgent.scheduleAfterWaiting(java.lang.String methodName)
Schedules a method to be called on this agent after a certain waiting period. |
BasicAction |
AsynchAgent.scheduleAfterWaiting(java.lang.String methodName,
java.lang.Object param0)
Schedules a method to be called on this agent after a certain waiting period. |
BasicAction |
AsynchAgent.scheduleAfterWaiting(java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
Schedules a method to be called on this agent after a certain waiting period. |
BasicAction |
AsynchAgent.scheduleAfterWaiting(java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
Schedules a method to be called on this agent after a certain waiting period. |
BasicAction |
AsynchSchedule.scheduleAt(double time,
IAsynchAgent agent,
java.lang.String methodName)
Schedules a method to be called on an agent at a certain time. |
BasicAction |
AsynchSchedule.scheduleAt(double time,
IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0)
Schedules a method to be called on an agent at a certain time. |
BasicAction |
AsynchSchedule.scheduleAt(double time,
IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
Schedules a method to be called on an agent at a certain time. |
BasicAction |
AsynchSchedule.scheduleAt(double time,
IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
Schedules a method to be called on an agent at a certain time. |
BasicAction |
CallBackSchedule.scheduleAt(double time,
java.lang.Object o,
java.lang.String methodName)
|
BasicAction |
CallBackSchedule.scheduleAt(double time,
java.lang.Object o,
java.lang.String methodName,
java.lang.Object param0)
|
BasicAction |
CallBackSchedule.scheduleAt(double time,
java.lang.Object o,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
|
BasicAction |
CallBackSchedule.scheduleAt(double time,
java.lang.Object o,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
|
BasicAction |
AsynchAgent.scheduleAt(double time,
java.lang.String methodName)
Schedules a method to be called on this agent at a certain time. |
BasicAction |
AsynchAgent.scheduleAt(double time,
java.lang.String methodName,
java.lang.Object param0)
Schedules a method to be called on this agent at a certain time. |
BasicAction |
AsynchAgent.scheduleAt(double time,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
Schedules a method to be called on this agent at a certain time. |
BasicAction |
AsynchAgent.scheduleAt(double time,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
Schedules a method to be called on this agent at a certain time. |
BasicAction |
AsynchSchedule.scheduleNow(IAsynchAgent o,
java.lang.String methodName)
Schedules a method to be called now. |
BasicAction |
AsynchSchedule.scheduleNow(IAsynchAgent o,
java.lang.String methodName,
java.lang.Object param0)
Schedules a method to be called now. |
BasicAction |
AsynchSchedule.scheduleNow(IAsynchAgent o,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
Schedules a method to be called now. |
BasicAction |
AsynchSchedule.scheduleNow(IAsynchAgent o,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
Schedules a method to be called now. |
BasicAction |
CallBackSchedule.scheduleNow(java.lang.Object o,
java.lang.String methodName)
|
BasicAction |
CallBackSchedule.scheduleNow(java.lang.Object o,
java.lang.String methodName,
java.lang.Object param0)
|
BasicAction |
CallBackSchedule.scheduleNow(java.lang.Object o,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
|
BasicAction |
CallBackSchedule.scheduleNow(java.lang.Object o,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
|
BasicAction |
AsynchAgent.scheduleNow(java.lang.String methodName)
Schedules a method to be called on this agent after a cerain waiting period. |
BasicAction |
AsynchAgent.scheduleNow(java.lang.String methodName,
java.lang.Object param0)
|
BasicAction |
AsynchAgent.scheduleNow(java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
|
BasicAction |
AsynchAgent.scheduleNow(java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
|
BasicAction |
AsynchSchedule.scheduleWhenAvailable(IAsynchAgent o,
java.lang.String methodName)
Schedules a method to be called when the agent is next available. |
BasicAction |
AsynchSchedule.scheduleWhenAvailable(IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0)
Schedules a method to be called when the agent is next available. |
BasicAction |
AsynchSchedule.scheduleWhenAvailable(IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
Schedules a method to be called when the agent is next available. |
BasicAction |
AsynchSchedule.scheduleWhenAvailable(IAsynchAgent agent,
java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
Schedules a method to be called when the agent is next available. |
BasicAction |
AsynchAgent.scheduleWhenAvailable(java.lang.String methodName)
Schedules a method to be called when the agent is next available. |
BasicAction |
AsynchAgent.scheduleWhenAvailable(java.lang.String methodName,
java.lang.Object param0)
Schedules a method to be called when the agent is next available. |
BasicAction |
AsynchAgent.scheduleWhenAvailable(java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1)
Schedules a method to be called when the agent is next available. |
BasicAction |
AsynchAgent.scheduleWhenAvailable(java.lang.String methodName,
java.lang.Object param0,
java.lang.Object param1,
java.lang.Object param2)
Schedules a method to be called when the agent is next available. |
| Methods in uchicago.src.sim.engine with parameters of type BasicAction | |
|---|---|
void |
ActionGroup.addAction(BasicAction action)
Adds a BasicAction to the list of BasicActions to execute. |
void |
ScheduleGroup.addBasicAction(BasicAction action)
|
void |
ActionQueue.insert(BasicAction action)
Insert the specified action into the heap. |
void |
ScheduleGroup.removeAction(BasicAction action)
|
BasicAction |
ScheduleBase.removeAction(BasicAction action)
Removes the specified action from this Schedule. |
void |
ActionGroup.removeAction(BasicAction action)
Removes the specified BasicAction from the group. |
void |
ScheduleBase.removeActionAt(double at,
BasicAction action)
Removes the specified action from this Schedule at the specified tick. |
void |
Schedule.removeEndAction(BasicAction action)
Removes the specified action from the list of actions to be executed at the end of a simulation. |
void |
Schedule.removePauseAction(BasicAction action)
Removes the specified action from the list of actions to be executed at the pause in a simulation. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
BasicAction action)
Schedules the specified BasicAction to occur at the specified clock tick in RANDOM order. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
BasicAction action,
double duration)
Schedules the specified BasicAction to occur at the specified clock tick in RANDOM order. |
BasicAction |
ScheduleBase.scheduleActionAt(double at,
BasicAction action,
ScheduleBase.Order order)
Schedules the specified BasicAction to occur at the specified clock tick in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAt(double at,
BasicAction action,
ScheduleBase.Order order,
double duration)
Schedules the specified BasicAction to occur at the specified clock tick in the specified order. |
BasicAction |
Schedule.scheduleActionAtEnd(BasicAction action)
Schedules the execution of the specified action for the end of the simulation run. |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
BasicAction action)
Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks). |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
BasicAction action,
double duration)
Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks). |
BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
BasicAction action,
ScheduleBase.Order order)
Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks) in the specified order. |
protected BasicAction |
ScheduleBase.scheduleActionAtInterval(double interval,
BasicAction action,
ScheduleBase.Order order,
double duration)
Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks) in the specified order. |
BasicAction |
Schedule.scheduleActionAtPause(BasicAction action)
Schedules the execution of the specified action for a pause in the simulation run. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
BasicAction action)
Schedules the specified BasicAction to execute starting at the specified clock tick and every tick thereafter. |
BasicAction |
ScheduleBase.scheduleActionBeginning(double beginning,
BasicAction action,
double duration)
Schedules the specified BasicAction to execute starting at the specified clock tick and every tick thereafter. |
void |
ActionQueue.toss(BasicAction action)
|
boolean |
ActionQueue.voidAction(BasicAction action)
Find the specified Action in the queue and void it. |
| Constructors in uchicago.src.sim.engine with parameters of type BasicAction | |
|---|---|
ThreadedAction(BasicAction action,
double duration)
|
| Uses of BasicAction in uchicago.src.sim.util |
|---|
| Methods in uchicago.src.sim.util that return BasicAction | |
|---|---|
static BasicAction |
ByteCodeBuilder.generateBasicAction(java.lang.Object target,
java.lang.String methodName)
Dynamically creates a BasicAction object whose execute method calls the specified method on the specified object. |
static BasicAction |
ByteCodeBuilder.generateBasicActionForList(java.util.List list,
java.lang.String methodName)
Dynamically creates a BasicAction object whose execute method will iterate through the specifed list and call the specified method on each object in that list. |
static BasicAction |
ByteCodeBuilder.generateBasicActionForList(java.util.List list,
java.lang.String methodName,
java.lang.Class clazz,
boolean randomize)
Dynamically creates a BasicAction object whose execute method will iterate through the specifed list and call the specified method on each object in that list. |
static BasicAction |
ByteCodeBuilder.generateBasicActionForListRnd(java.util.List list,
java.lang.String methodName)
Dynamically creates a BasicAction object whose execute method will shuffle the specified list with uchicago.src.sim.util.SimUtilites.shuffle and then iterate through the specifed list, calling the specified method on each object in that list. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Xbox Deals with Gold feature Aven Colony and Trine 4
Check out these great deals on Xbox One games.
by Asher MadanWhat you need to know
- Every week Microsoft and certain publishers discount numerous games on Xbox One and Xbox 360.
- This week games like Aven Colony and Trine 4 are available for less.
- We've listed some of the popular discounted games here.
- Search for the game you want on your console or the Microsoft Store to purchase it.
Every week Microsoft and certain publishers discount numerous games for Xbox Live users. Some deals are available only to Xbox Live Gold members and others are available to anyone who utilizes the service through a Spotlight sale. A wide variety of titles, ranging from small experiences to massive blockbusters, are available for substantially less. This week, prominent games like Aven Colony and Trine 4 are on sale. Here's a look at some popular discounted titles.
Xbox One
- Aven Colony | 70 percent | $8.99
- Ducati: 90th Anniversary | 80 percent | $3.99
- Guns, Gore & Cannoli 2 | 33 percent | $8.70
- MotoGP 17 | 75 percent | $7.49
- MotoGP 18 | 75 percent | $9.99
- MXGP3: The Official Motocross Video Game | 80 percent | $5.99
- NASCAR Heat 4 | 20 percent | $39.99
- The Council | 75 percent | $1.74
- The Technomancer | 75 percent | $4.99
- Trine 4: The Nightmare Prince* | 20 percent | $23.99
- Trine Ultimate Collection* | 20 percent | $39.99
Keep in mind that you need to be an Xbox Live Gold member to access the majority of these discounts. For the complete list visit Major Nelson. Search for the games on your Xbox One or Microsoft Store website to purchase them.
Which games are you interested in? Let us know! Be sure to check out games like Aven Colony and Trine 4 because they're great experiences.
Best of the best
Xbox Game Pass Ultimate
Play for a few months
Xbox Game Pass gives you access to over 200 games for one monthly fee. Xbox Game Pass Ultimate also adds Xbox Live Gold to the package so you can play online with your friends.
Get more Xbox
Xbox
- Xbox One S vs. Xbox One X: Which should you buy?
- Best Xbox One X and Xbox One S Accessories
- Best Xbox One Headsets 2019
- Best Xbox One Wireless Headsets 2019
- Best Xbox Controller Charging Stations in 2019
We may earn a commission for purchases using our links. Learn more.


You
Antonfalkone
Planet Earth
Liked by
and
antonfalkoneexample caption text goes here and if it is way too long is will wrap like that.
1 hour ago
Liked by
antonfalkoneand
other 108antonfalkoneexample caption text goes here and if it is way too long is will wrap like that.
1 hour ago


This is the header 1!

My favorite site is
GitHub
!
https://www.oracle.com/index.html


§712-1254 Bar to prosecution. If a violation of this part or chapter 329 is a violation of a federal law or the law of another state, a conviction or acquittal under federal law or the law of another state for the same act is a bar to prosecution in this State. [L 1972, c 9, pt of §1]


All fields below are required except for "Address Line 2".
You have been logged in and will shortly be redirected to "Problems". ×
The teamname you entered is incorrect or the passphrase does not match the teamname entered. ×
Please enter an email address of a school teacher.
This is the address to which prizes will be sent, if your team is eligible.
This is the address to which certificates for team participation will be sent. If you would like, you can use a different address.


let Evil = null;
a : morally reprehensible : sinful, wicked an evil impulse
b : arising from actual or imputed bad character or conduct a person of evil reputation
"By oneself, indeed, is evil done; by oneself is one defiled. By oneself is evil left undone; by oneself, indeed, is one purified. Purity and impurity depend on oneself. No one purifies another."
Acting without the fear of Allah, taking other deities beside Him, serving someone else besides Him and living to please others and to make gains from this earthly life-all this can lead a person into evil.
Evil = !Good
He continued: “What comes out of a man, that is what defiles him. 21For from within the hearts of men come evil thoughts, sexual immorality, theft, murder, adultery,h 22greed, wickedness, deceit, debauchery, envy, slander, arrogance, and foolishness. 23All these evils come from within, and these are what defile a man.”
Evil = [sexual immorality,
theft,
murder,
adultery,
greed,
wickedness,
deceit,
debauchery,
envy,
slander,
arrogance,
foolishness]
"The evil that is in the world almost always comes of ignorance, and good intentions may do as much harm as malevolence if they lack understanding." - Albert Camus
if (action.indexOf('understanding') === -1) {
Evil = true;
}
else {
???
}
“We judge ourselves by our intentions and others by their behaviour.”
- Stephen M.R. Covey, The Speed of Trust: The One Thing that Changes Everything
if (intent === malicious) {
Evil = true;
}
else {
???
}
if (action === malicious) {
Evil = true;
if (self.understand(intent)) {
Evil = false
}
}
while (empathy <= 0) {
Evil = true;
}
understanding quote
evil != injustice
Think about the time someone wronged you, or someone you love
Slides available at: tehfedaykin.github.io/DoesEvilExist


|
mime-form-decode
|
A class which knows how to decode MIME. More...
#include <Decoder.h>
Public Member Functions | |
| Decoder () | |
| Default constructor. More... | |
| virtual | ~Decoder () |
| void | close () |
| The data producer should call this once all data has been presented to the decoder to finalise processing and clean up all resources. More... | |
| void | decode (unsigned char c) |
| The data produced should call this method to present data to the decoder. More... | |
| virtual void | object_created (Object *object)=0 |
| A MIME object has been discovered in the input data. More... | |
| virtual void | data_start (Object *obj)=0 |
| A MIME object's data starts processing. More... | |
| virtual void | data (Object *obj, unsigned char *data, int len)=0 |
| Deliver data parsed from the MIME object. More... | |
| virtual void | data_end (Object *obj)=0 |
| All data from the MIME object has been delivered. More... | |
Private Attributes | |
| Parser * | parser |
| Object * | obj |
A class which knows how to decode MIME.
To do something useful, derive a class from it, and implement all the calls in the ClientInterface interface.
| Decoder::Decoder | ( | ) |
| void Decoder::close | ( | ) |
The data producer should call this once all data has been presented to the decoder to finalise processing and clean up all resources.
Definition at line 28 of file Decoder.cpp.
References mime::Parser::close(), obj, and parser.
Referenced by main().
|
pure virtualinherited |
Deliver data parsed from the MIME object.
Implemented in mime::StringDecoder, and TestDecoder.
Referenced by mime::SimpleParser::parse(), mime::Base64Parser::parse(), and mime::QuotedPrintableParser::parse().
|
pure virtualinherited |
All data from the MIME object has been delivered.
Implemented in mime::StringDecoder, and TestDecoder.
Referenced by mime::SimpleParser::close(), mime::Base64Parser::close(), and mime::QuotedPrintableParser::close().
|
pure virtualinherited |
A MIME object's data starts processing.
Implemented in mime::StringDecoder, and TestDecoder.
Referenced by mime::Base64Parser::Base64Parser(), mime::QuotedPrintableParser::QuotedPrintableParser(), and mime::SimpleParser::SimpleParser().
| void Decoder::decode | ( | unsigned char | c | ) |
The data produced should call this method to present data to the decoder.
Definition at line 15 of file Decoder.cpp.
References mime::ParserFactory::generic(), obj, mime::Parser::parse(), and parser.
Referenced by main(), and mime::StringDecoder::processString().
|
pure virtualinherited |
A MIME object has been discovered in the input data.
Data may or may not follow.
Implemented in mime::StringDecoder, and TestDecoder.
Referenced by mime::AnyObjectParser::parse().
|
private |
|
private |