LOST SOULS (New Line) Starring: Winona Ryder, Ben Chaplin, Philip Baker Hall, Sarah Wynter, Elias Koteas, John Hurt. Screenplay: Pierce Gardner. Producers: Nina R. Sadowsky and Meg Ryan. Director: Janusz Kaminski. MPAA Rating: R (violence, profanity, adult themes) Running Time: 95 minutes. Reviewed by Scott Renshaw.
LOST SOULS has been on the shelf at New Line for over a year since its originally scheduled release date last fall. The official story was that it was pushed back to avoid the slew of similarly-themed films slated for the pseudo-end of the millennium (END OF DAYS, STIGMATA). In order to avoid comparisons and find an open market for a film about demonic possession and exorcism, they waited and waited until October 13, 2000 -- the day the successful re-release of THE EXORCIST went nationwide. So much for avoiding comparisons.
LOST SOULS isn't just bad because it's not as good as THE EXORCIST. It's bad because it's yet another exercise in moody production values supporting an utterly weightless story. Winona Ryder stars as Maya Larkin, a young woman working on the Catholic Church's equivalent of the X-Files. Once upon a time she was saved from a demonic possession by Father Ledeaux (John Hurt); now she works with him and his associates on other exorcisms. But the granddaddy of all possessions is on the horizon: Maya has discovered the identity of the man who will become the Antichrist, a best-selling non-fiction writer named Peter Kelson (Ben Chaplin). Kelson himself has no idea that he may be part of a dark plan, but Maya is determined to clue him in, even if it means going toe-to-toe with Evil With a Capital "E."
Gifted cinematographer Janusz Kaminski (who worked with Steven Spielberg on SCHINDLER'S LIST and SAVING PRIVATE RYAN) makes his directing debut with LOST SOULS, and he trots out plenty of visual goodies to tart up the proceedings. Unfortunately, they're the sort of visual goodies that just make you chuckle at their obviousness. There are ominous slow-motion shots of Maya and her associates heading towards an exorcism like an ecclesiastical crew of reservoir dogs. There are jagged edits and low-angle shots intended to evoke evil through obscurity. And there are plenty of shots of slowly-dripping water, which apparently has become the standard-issue portent of Satanic antics. On exactly one occasion, Kaminski's freaky imagery evokes a shiver. For the other 94 minutes of LOST SOULS, it evokes a sense of desperation.
And it's no wonder he's desperate, considering the script he's working with. It's one thing for a film about the Prince of Darkness to be melodramatic, or overwrought, or even silly. It's quite another for it to be an outright bore. LOST SOULS is an incredibly monotonous experience, never once working up a really good scare or a palpable sense of unease. It doesn't develop anything resembling momentum towards a satisfyingly harrowing conclusion, which makes it all-too-easy to dwell on the sluggishly paced expository scenes. Ryder spends the film looking vaguely tormented, while Chaplin spends the film looking puzzled and _then_ vaguely tormented, and there's no reason whatsoever to care about either one of them. It sometimes seems that every part of LOST SOULS that could have inspired a genuinely visceral reaction has been edited out, leaving an indistinct morass of gloomy cinematography in its stead.
Occasionally LOST SOULS shakes itself from its coma-inducing torpor just long enough to be aggressively dumb. The hilarious climax comes as Peter's car radio clock ticks down to his "transformation," suggesting not only that the Apocalypse will be filmed like a scene from SPEED, but that Peter conscientiously synchronized his clock that morning to Hell Mean Time.  There's no excuse for a movie about the primal forces of evil to make Satan's influence seem so banal. Twenty-five years have passed since THE EXORCIST was first released, and it's still a jolt to the system. LOST SOULS could have remained on New Line's shelf for another twenty-five years, and no one would have missed it.
On the Renshaw scale of 0 to 10 possessions with intent to hell: 2.
Visit Scott Renshaw's Screening Room http://www.inconnect.com/~renshaw/ *** Subscribe to receive new reviews directly by email! See the Screening Room for details, or reply to this message with subject "Subscribe".
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


{% extends "base.html" %} {% block frontcontent %}
Sorry, but we've had some kind of error. If this error continues, please email<EMAIL_ADDRESS>and let us know!


Alexiadou, A. 1998. 'An ergative pattern in the syntax of nominative-accusative languages.' Paper presented at the 29th meeting of the North Eastern Linguistics Society, University of Delaware.
Bobaljik, J. 1994. 'What does adjacency do?' In: MIT Working Papers in Linguistics 22: The Morphology-Syntax Connection. , ed. Heidi Harley and Colin Phillips, 1-32.
Bobaljik, Jonathan & Susi Wurmbrand. 1997. 'Preliminary Notes on Agreement in Itelmen.' In MITWPL 30: Papers at the Interface, ed. Benjamin Bruening, Yoonjung Kang and Martha McGinnis. MITWPL, Cambridge, 395-424.
Bonet, Eulalia. 1991. Morphology after syntax: Pronominal clitics in Romance. Doctoral dissertation, MIT. Distributed by MITWPL.
Calabrese 1994. 'Syncretism phenomena in the clitic systems of Italian and Sardinian dialects and the notion or morphological change.' In J.N. Beckman, ed., Proceedings of NELS 25: 2. GLSA, University of Massachusetts, Amherst, 151-174.
Calabrese, Andrea. 1997a. Distributed morphology and sentential complementation in the Salentino dialect of Italian. Harvard Working Papers in Linguistics, Vol. 6, ed. by S. Peter, B. Vaux & S. Kuno. Harvard University, Cambridge.
Calabrese, Andrea. 1997b. On Fission and Impoverishment in the verbal morphology of the dialect of Livinallongo. Manuscript, University of Connecticut, Storrs.
Calabrese, Andrea. 1998. 'Some remarks on the Latin case system and its development in Romance'. Theoretical Analysis ofRomance Languages, ed. Estela Trevin~o and Jose Lema. John Benjamins, Amsterdam, 71-126.
Embick, David. 1995. 'Mobile inflections in Polish.' In Proceedsing of NELS 25:2, ed. J.N. Beckman, GLSA, University of Massachusetts, Amherst, 127-142.
Embick, David. 1996. 'Causativization in Hupa.' BLS 22:83-94.
Embick, David. 1997. Voice and the Interfaces of Syntax. Doctoral dissertation, University of Pennsylvania.
Embick, David. 1998a. 'Voice Systems and the Syntax/Morphology Interface.' In MITWPL 32: Papers from the UPenn/MIT Roundtable on Argument Structure and Aspect. ed. Heidi Harley. MITWPL, Cambridge, 41-72.
Embick, David. 1998b. 'Syntax and Categories: Verbs and Participles in the Latin Perfect.' Mauscript, MIT.
Embick, David & Roumyana Izvorski. 1995. 'Participle-Auxiliary Word-Orders in Slavic.' Formal Approaches to Slavic Linguistics: The Cornell University Meeting, ed. Wayles Browne. Michigan Slavic Publications, Ann Arbor, 210-239.
Embick & Noyer (in progress). 'Morphological Merger and Locality.' Available as MIT Colloqiuim Talk handout.
Halle, Morris. 1990. 'An Approach to Morphology.' NELS 20:1. GLSA, University of Massachusetts, Amherst, 150-84.
Halle, Morris. 1992. 'Latvian Declension.' Morphology Yearbook 1991, ed. Geert Booij and Jaap van der Marle. Kluwer, Dordrecht, 33-47.
Halle, Morris. 1995. 'The Russian Declension.' In Perspectives in Phonology, ed. Jennifer Cole and Charles Kisseberth. CSLI, Stanford, pp. 321-353.
Halle, Morris. 1997. 'Distributed morphology: Impoverishment and fission.' In MITWPL 30: Papers at the Interface, ed. Benjamin Bruening, Yoonjung Kang and Martha McGinnis. MITWPL, Cambridge, 425-449.
Halle, Morris & Alec Marantz. 1993. 'Distributed Morphology and the Pieces of Inflection.' In The View from Building 20, ed. Kenneth Hale and S. Jay Keyser. MIT Press, Cambridge, 111-176.
Halle, Morris & Alec Marantz. 1994. 'Some key features of Distributed Morphology.' In MITWPL 21: Papers on phonology and morphology, ed. Andrew Carnie and Heidi Harley. MITWPL, Cambridge, 275-288.
Halle, Morris & Bert Vaux. 1998. 'Theoretical Aspects of Indo-European Nominal Morphology: The Nominal Declensions of Latin and Armenian.' In Mi'r Curad: Studies in Honor of Clavert Watkins, ed. Jay Jasanoff, H. Craig Melchert and Lisi Olivier. Innsbrucker Beitraege zur Sprachwissenschaft, Innsbruck, 223-240.
Harley, Heidi. 1994. 'Hug a tree: Deriving the morphosyntactic feature hierarchy.' In MITWPL 21: Papers on phonology and morphology, ed. Andrew Carnie and Heidi Harley. MITWPL, Cambridge, 275-288.
Harley, Heidi. 1995. Subjects, Events, and Licensing. Doctoral dissertation, MIT. Available from MITWPL.
Harley, Heidi & Rolf Noyer. 1998a. 'Licensing in the non-lexicalist lexicon: nominalizations, vocabulary items and the Encyclopaedia.' In MITWPL 32: Papers from the UPenn/MIT Roundtable on Argument Structure and Aspect, ed. Heidi Harley. MITWPL, Cambridge, 119-137.
Harley, Heidi & Rolf Noyer. 1998b. 'Mixed nominalizations, short verb movement, and object shift in English.' In Proceedings of NELS 28, ed. by P.N. Tamanji & K. Kusumoto, GLSA, Amherst, 143-157.
Harris, James. 1994. 'The syntax-phonology mapping in Catalan and Spanish clitics.' In MITWPL 21: Papers on phonology and morphology, ed. Andrew Carnie and Heidi Harley. MITWPL, Cambridge, 321-353.
Harris, James. 1995. 'The morphology of Spanish clitics.' In Evolution and Revolution in Linguistic Theory, ed. He'ctor Campos and Paula Kempchinsky. Georgetown University Press, Washington, 168-197.
Harris, James. 1996.' The syntax and morphology of Class Marker suppression in Spanish.' In Grammatical Theory and Romance Languages, ed. Karen Zagona. John Benjamins, Amsterdam, 99-122.
Harris, James. 1997a. 'Why n'ho is pronounced [li] in Barceloni Catalan.' In MITWPL 30: Papers at the Interface, ed. Benjamin Bruening, Yoonjung Kang and Martha McGinnis. MITWPL, Cambridge, 451-479.
Harris, James. 1997b. 'There is no imperative paradigm in Spanish.' In Issues in the Phonology and Morphology of the Major Iberian Languages, ed. Fernando Marti'nez-Gil and Alfonfo Morales-Front. Georgetown University Press, Washington, 537-557.
Harris, James. 1998a. 'Spanish imperatives: syntax meets morphology.' Journal of Linguistics 34: 27-52.
Harris, James. 1998b. 'Enclitic -n in Spanish.' In Armin Schwegler, Bernard Tranel, and Myriam Uribe-Etxebarria (eds.), Romance Linguistics: Theoretical Perspectives. John Benjamins, Amsterdam, 111-127.
Harris, James. (in press). 'Los imperativos plurales seguidos de cli'tico en espan~ol.' Presented at IV Encuentro de Lingu"i'stica del Noroeste, Universidad de Sonora, Hermosillo, Me'xico, November 1996. To appear in proceedings.
Lidz, Jeffrey. 1998. 'Valency in Kannada: Evidence for Interpretive Morphology.' Manuscript, University of Pennsylvania.
Lidz, Jeffrey & William J. Idsardi. 1998. 'Chains and Phono-Logical Form.' Proceedings of the 22nd Penn Linguistics Colloquium. Penn Working Papers in Linguistics.
Marantz, Alec. 1991. 'Case and Licensing.' ESCOL '91: 234-53. Distributed by Ohio State University Department of Linguistics.
Marantz, Alec. 1992. 'How morphemes are realized phonologically.' Paper presented at the DIMACS Workshop on Human Language, Princeton University. Manuscript, MIT.
Marantz, Alec. 1995. 'A Late Note on Late Insertion.' In Explorations in Generative Grammar, ed. Young-Sun Kim, et. al. Hankuk Publishing Co., Seoul, 396-413.
Marantz, Alec. 1997a. 'No escape from syntax: Don't try morphological analysis in the privacy of your own Lexicon.' Proceedings of the 21st Annual Penn Linguistics Colloquium: Penn Working Papers in Linguistics 4: 2, ed. Alexis Dimitriadis et.al. 201-225.
Marantz, Alec. 1997b. 'Stem suppletion, or the arbitrariness of the sign.' Talk given at the Universite' de Paris VIII.
McGinnis, Martha. 1995.'Fission as feature-movement.' In MITWPL 27: Papers on Minimalist Syntax, ed. Robert Pensalfini & Hiroyuki Ura. MIT Working Papers in Linguistics, 165-187.
McGinnis, Martha. 1996.'Two kinds of blocking.' In Morphosyntax in Generative Grammar: Proceedings of the 1996 Seoul International Conference on Generative Grammar, ed. Hee-Don Ahn, Myung-Yoon Kang, Young-Suck Kim & Sookhee Lee. Hankuk Publishing Co., Seoul, 357-368.
McGinnis, Martha. 1998. 'Case and locality in L-Syntax: Evidence from Georgian.' In Papers from The UPenn/MIT Roundtable on Argument Structure and Aspect: MITWPL 32, ed. Heidi Harley. MIT Working Papers in Linguistics, Cambridge, 139-158.
McGinnis, Martha. 1999. 'Is there syntactic inversion in Ojibwa?' In Proceedings of the Workshop on Structure and Constituency in Native American Languages, ed. Leora Bar-El, Rose-Marie Dechaine & Charlotte Reinholz. MIT Occasional Papers in Linguistcs 17, 101-118.
Minkoff, Seth. 1993. 'Plurality, Clitics, and Morphological Merger in Caribbean Spanish.' In Papers from the Fifth Student Conference in Linguistics: MITWPL 20, ed. Vern M. Lindblad and Michael Gamon, 177-192.
Noyer, Rolf. 1997. Features, Positions and Affixes in Autonomous Morphological Structure. Garland Publishing, New York. Revised version of 1992 MIT Doctoral Dissertation.
Noyer, Rolf. 1998. 'Impoverishment theory and morphosyntactic markedness.' In Morphology and its relation to phonology and syntax, ed. Steve Lapointe, Diane K. Brentari, and Patrick Farrell. CSLI, Stanford, 264-285.
Noyer, Rolf. 1999. 'Vietnamese "morphology" and the definition of word.' University of Pennsylvania Working Papers in Linguistics 5:2: Current Work in Linguistics, ed. by A. Dimitriadis, H. Lee, C. Moisset & A. Williams. University of Pennsylvania, Philadelphia, 65-89.
Pensalfini, Robert. 1997. Jingulu Grammar, Dictionary and Texts. PhD Dissertation, MIT. Available from MITWPL.
Ritter, Elizabeth and Heidi Harley. 1998. 'Sorting out you, me and the rest of the world: A feature-geometric analysis of person and number.' Paper presented at the 21st meeting of Generative Linguistics of the Old World, Tilburg, the Netherlands.
Siegel, Laura. 1997. 'Gerundive nominals and aspect.' To appear in the Proceedings of ESCOL 97.
Sauerland, Uli. 1995. 'The Late Insertion of Germanic Inflection.' Manuscript, MIT.
Schuetze, Carson. 1994. 'Serbo-Croatian second position clitic placement and the phonology-syntax interface.' In Papers on Phonology and Morphology: MITWPL 21, ed. Andrew Carnie, Heidi Harley and Tony Bures. MITWPL, Cambridge, 373-473.
Aronoff, Mark. 1994. Morphology by itself. MIT Press, Cambridge.
Baker, Mark. 1988. Incorporation: a Theory of Grammatical Function Changing. University of Chicago Press, Chicago.
Beard, Robert. 1995. Lexeme-Morpheme Base Morphology. SUNY Albany Press, Albany.
Calabrese, Andrea. 1995. 'A constraint-based theory of phonological markedness and simplification procedures.' Linguistic Inquiry 26: 373-463.
Carstairs, Andrew. 1987. Allomorphy in inflection. Croom Helm, London.
Chen, Matthew. 1987. 'The syntax of Xiamen tone sandhi.' Phonology 4: 109-150.
Chomsky, Noam. 1970. 'Remarks on Nominalization.' In: Readings in Transformational Grammar, ed. R. A. Jacobs and P. S. Rosenbaum. Ginn, Waltham, MA, 184-221.
Hale, Kenneth & S. Jay Keyser. 1993. 'On Argument Structure and the Lexical Representation of Syntactic Relations.' In The View from Building 20, ed. S. Jay Keyser and Kenneth Hale. MIT Press, Cambridge, 53-109.
Hale, Kenneth & S. Jay Keyser. 1998. 'The Basic Elements of Argument Structure.' In Papers from The UPenn/MIT Roundtable on Argument Structure and Aspect: MITWPL 32, ed. Heidi Harley. MIT Working Papers in Linguistics, Cambridge, 73-118.
Halle, Morris and Jean-Roger Vergnaud. 1987. An Essay on Stress. MIT Press, Cambridge.
Halpern, Aaron. 1995. On the placement and morphology of clitics. CSLI Publications, Stanford.
Jackendoff, Ray. 1997. The Architecture of the language faculty. MIT Press, Cambridge.
Kiparsky, Paul. 1982. 'Lexical phonology and morphology.' In Linguistics in the Morning Calm, vol. 2, ed. I. S. Yang. Hanshin, Seoul, 3-91.
Kratzer, Angelika. 1996. 'Severing the External Argument from Its Verb.' In Phrase Structure and the Lexicon, ed. Jan Rooryck and Laurie Zaring. Kluwer, Dordrecht, 109-37.
Lieber, Rochelle. 1981. On the organization of the lexicon. Doctoral dissertation, MIT. Available from MITWPL.
Lumsden, John. 1987. Syntactic Features: Parametric Variation in the History of English. Doctoral dissertation, MIT. Available from MITWPL.
Lumsden, John. 1992. 'Underspecification in Grammatical and Natural Gender.' Linguistic Inquiry 23: 469-486.
Marantz, Alec. 1984. On the nature of grammatical relations. MIT Press, Cambridge.
Marantz, Alec. 1988. 'Clitics, morphological merger, and the mapping to phonological structure.' In Michael Hammond and Michael Noonan, eds., Theoretical Morphology: Approaches in Modern Linguistics. Academic Press, San Diego, 253-270.
Pesetsky, David. 1995. Zero syntax: experiencers and cascades. MIT Press, Cambridge.
Sadock, Jerrold. 1991. Autolexical syntax: A theory of parallel grammatical representations. University of Chicago Press, Chicago.
Sapir, Edward. 1921. Language. Harcourt, Brace and World, New York.
Selkirk, Elisabeth O. 1986. 'On derived domains in sentence phonology.' Phonology 3: 371-405.
Selkirk, Elisabeth O. 1996. 'The Prosodic structure of function words.' In Signal to syntax: Bootstrapping from speech to grammar in early acquisition, ed. James L. Morgan and Katherine Demuth. Lawrence Erlbaum, Mahwah, NJ, 187-213.
Silverstein, Michael. 1976. 'A hierarchy of features and ergativity.' In Grammatical Categories in Australian Languages, ed. R. M. W. Dixon. Australian Institute for Aboriginal Studies, Canberra, 112-171.
Sproat, Richard W. 1985. On deriving the lexicon. PhD dissertation, MIT. Available from MITWPL.
Stump, Greg. 1993. 'On Rules of Referral.' Language 69:3:449-479.
Travis, Lisa. 1994. Event Phrase and a theory of functional categories. Presented at the Canadian Linguistics Association, University of Calgary.
Zec, Draga & Sharon Inkelas. 1990.
'Prosodically constrained syntax.' In: The Phonology-Syntax connection,
ed. Sharon Inkeals and Draga Zec. University of Chicago Press, Chicago,
365-378.
Zwicky, Arnold. 1977. 'Hierarchies of
Person.' CLS 13: 714-733. Chicago Linguistics Society,
University of Chicago.
Zwicky, Arnold. 1985a. 'Clitics and particles.' Language 61: 283-305.
Zwicky, Arnold. 1985b. 'How to Describe Inflection.' Proceedings of the Berkeley Linguistics Society 11: 372-386. Berkeley, California.
Zwicky, Arnold & Geoffrey Pullum. 1983. 'Cliticization vs. Inflection: English n't.' Language 59: 502-13.
Zwicky, Arnold and Geoffrey Pullum. 1992. A misconceived approach to morphology. In Proceedings of WCCFL 91, ed. D. Bates. CSLI, Palo Alto, 387-398.


Car: {{selectedEvent.year + ' ' + selectedEvent.make + ' ' + selectedEvent.model + ' ' + selectedEvent.style}}
Dealer: {{selectedEvent.dealerName + ', ' + selectedEvent.dealerAddress + ', ' + selectedEvent.city + ', ' + selectedEvent.state + ' - ' + selectedEvent.zip}}
Price: Price: {{selectedEvent.price | currency}}
Discount:
{{selectedEvent.discount}}%
{{selectedEvent.discount | currency}}
1/{{selectedEvent.groupSize}}
Buy Before: {{selectedEvent.buyBefore | date:'dd-MMM-yyyy'}}
Note: {{selectedEvent.notes}}


Hello! If you've clicked this page you're probably interested in what my code looked like at the beginning. Hint: it didn't look great!
My first introduction to coding was INFO1110 at University. It was a tough subject but it was fun and introduced to me a wide variety of new concepts. It also taught me that there was no magic pass to being good at coding.
From my lessons in computer science, I think that I've developed a certain way of approaching and writing code which is unique to me. If you want to see the proof in the pudding, you can find my old code repos here.


|
Computes the effective address of the second operand (the source operand) and stores it in the first operand (destination operand). The source operand is a memory address (offset part) specified with one of the processors addressing modes; the destination operand is a general-purpose register. The address-size and operand-size attributes affect the action performed by this instruction, as shown in the following table. The operand-size attribute of the instruction is determined by the chosen register; the address-size attribute is determined by the attribute of the code segment.
Address and Operand Size Attributes
| Operand Size | Address Size | Action Performed |
| 16 | 16 | 16-bit effective address is calculated and stored in requested 16-bit register destination. |
| 16 | 32 | 32-bit effective address is calculated. The lower 16 bits of the address are stored in the requested 16-bit register destination. |
| 32 | 16 | 16-bit effective address is calculated. The 16-bit address is zeroextended and stored in the requested 32-bit register destination. |
| 32 | 32 | 32-bit effective address is calculated and stored in the requested 32-bit register destination. |
Different assemblers may use different algorithms based on the size attribute and symbolic reference of the source operand.
|


{% extends "admin/layouts/admin.html" %} {% block title %}Bulk upload ({{ type }}){% endblock %} {% block body %}
Back to the {{ type }} list
Choose a CSV file with these columns:
{{ attr }}


ELECTION COMMISSION OF INDIA
GENERAL ELECTION TO VIDHAN SABHA TRENDS & RESULT 2018
Click below links for
Partywise
Constituencywise-All Candidates
Constituencywise Trends
OUR TEAM
Swetha J
Sushrutha
Kavya GV
Priyanka B
Madhuri J
Sankalp
Sabiha
UNDER THE GUIDANCE OF
K SRIRAM MURTHY
ASSOCIATE MENTOR MSIT


This file is used to check the minimum functional components within build files. A hard coded version is used. Please update this if the Lu version has changed. If everything is successful, you will see a 'SUCCESS' statement in the browser's console.


Factura controller.
Located in /GlavBundle/Controller/FacturaController.php (line 17)
Controller | --FacturaController
Creates a new Factura entity.
Deletes a Factura entity.
Displays a form to edit an existing Factura entity.
Lists all Factura entities.
Displays a form to create a new Factura entity.
Finds and displays a Factura entity.
Edits an existing Factura entity.
Documentation generated on Thu, 09 Jul 2015 15:47:26 +0000 by phpDocumentor 1.4.4


Todos App
Active
{{ active.todo.description }}
Completed
{{ completed.todo.description }}
(completed at {{ (new Date(completed.todo.completed)).toUTCString() }})


WITNESS LIST State Affairs Committee February 5, 2001-2:30P Electric Utility Restructuring On: Baker, Thomas (Association of Electric Companies of Texas and TXU) Briesemeister, Janee (Consumers Union) Lednicky, Lynn (Dynegy) MacLeod, Mark (Environmental Defense) Noel, Thomas (Electric Reliability Council of Texas) Walsh, Judy (Public Utility Commission of Texas) Wood, Pat (Public Utility Commission of Texas)


Overview text
Amanda Lin, a native Chinese speaker, grew up in Taiwan. She loves Chinese culture and folk art. She has been teaching Saturday Chinese School for 9 years. She coordinates Chinese Culture youth camp for her Chinese school and teaches Chinese folk art to local youth clubs and community.
As a Chinese teacher, Amanda Lin believes learning Chinese is not only practicing the language itself. Chinese culture and folk art should be also introduced to students. Culture and folk art bring the spirit to the language. They will make the language learning process become more interactive, vivid and fun.
Shadow puppetry is an ancient form of storytelling. The shadow puppets are held onto a translucent screen. The source of light makes puppets' shadows shown on the screen. puppeteers can make the figures appear to walk , dance and fight.
The Chinese lion dance is usually performed during Chinese New Year and religious festivals. People believe a dancing lion scared away the bad spirits and bring a good luck to everyone.
One of Ancient Chinese Characters is known as the oracle bone script(jia gu wen). They looks like images of the objects such as the sun, the moon, mountains and water. We will create pictures by ancient Chinese Characters. Can you tell a story from the picture?
Dough Figure making began in the Tang Dynasty and has been around 1000 years. Originally, these edible dough figures were made for temples. Currently, dough figures are sold at the night markets or temple fairs in China or Taiwan. People collect dough figures in stead of eating them.
!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i
Click Here!!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i


{{define "Navbar"}}
{{end}} {{define "body"}}Drop in anytime OR register for the whole session.
| Regular: | $15 |
| Student/Senior/Military: | $12 |
| One class a week: | $144 ($12 per class) | (Register at any time - we will pro-rate) |
| Two classes a week: | $264 ($11 per class) | (Register at any time - we will pro-rate) |
| Unlimited classes for Winter Session: | $360 | (Register at any time - we will pro-rate) |
| One class a week: | Subtract $12/week |
| Two classes a week: | Subtract $22/week |
| Unlimited Yoga: | Subtract $30/week |
You can look up weekly prices here. Note that the final week of the session is the same as drop-in pricing.
10% discount for students, seniors and military. Please show ID at time of payment.
To DROP IN to one class at at time:
To sign up for a class you want to attend EVERY WEEK:
Please email<EMAIL_ADDRESS>or call us at<PHONE_NUMBER> to discuss!


To use NHK notification. Please get apikey from
here
, and set below.
don't send notification
service send notification
NHK総合
Eテレ
NHKBS1
NHKBSプレミアム
NHK-FM
save


--- layout: page title: About header-img: "img/about-bg.png" ---
Programming Student, musician, professional trouble maker.


Soldier (1998)
Film review by Arnold Kim
"Soldier", by director Paul Anderson, is a film in which any presence of originality is fleeting. The best moments of the film are in the opning scenes where Kurt Russel's character Todd is shown growing up under strict military supervision. Brutality through the eyes of the innocent and stripped of it every single day growing up is something that has a lot of emotional potential power behind it, and the opening scenes tap into it a little.
Then it goes nowhere with that idea. There is perhaps one rather fleeting scene afterwards that deals with the potential trauma of this dehumanization, and the rest of the film is just some of the biggest action movie cliches I've ever seen. The whole idea of the inhuman, soldier-type character gaining some degree of humanity by defending a potential female love interest and family from his evil counterpart out to kill her is done, and it's been done much better. I was able to predict the plot of the _whole_ story, which wouldn't be so bad if other aspect of the film somewhat interesting.
Between the action sequences, it tries to deal with the aforementioned issues of humanity through the performance of Mr. Russel in the film and the tiny little window to his soul that is his eyes, since his dialog is extremely limited. His performance in that way isn't all that bad, but certainly is not enough to carry this film. Other performances in this film are really not worth much mention at all, and they generally are about as weak as their characters.
But enough of this stuff about plot and character, right? Isn't the most important part of an action film, well, the action?
Even in this aspect the film is a disappointment. In Mortal Kombat (1995), Director Paul Anderson proved that truly engaging use and choreography of action in a film can override problems with plot and produce something entertaining. However, he fails to repeat that in this film. The combat scenes, particularly the big one at the end, is incredibly unimaginatve. Fighting and combat scenes are supposed to bring about thrills in this type of movie, a point which even an otherwise unimpressive film like Starship Troopers seemed to realize. But instead of reaching for something truly interesting to end the film with, it goes for the old, shoot-em up, one guy vs. an army type of cinema that I thought died with the military action films of the 80s. If the film went with some of the ideas it opened up with the introduction more seriously, it could have been a rather engaging science fiction film. However, it utterly failed to go in any new directions after that, making the film a big disappointment.
My score(out of 10): 3
Arnold Kim<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Home
Create new User
Here is the big box, okay, it's small, for now:
{% for m in msg %}
Message by {{m[2].decode() }}:
{{ m[0].decode() }}
Posted: {{ m[1].decode() }}
{% endfor %}


With the Documentation resources too
Deep dive in your chosen integration
Complete guide to building getting your app running on Nano
Learn about all the options, features and how to use them
Get Started integrating your service in Ledger Live
Get started fast with using Ledger APIs with detailed instructions


Thanks for installing Stop Me!
To get started visit a site click the StopMe icon in the extensions section at the top right of your browser to create a daily alarm.
Once an alarm is created you will be able to view your usage of that site, and edit, disable, and delete the alarm.
The alarms section below shows active alarms and allows you to set the time that daily usage is reset back to 0 for all sites.
| URL | Usage Today | Limit | Status |
|---|


We discussed results from the survey and plans for the rest of the semester.
Slides on Survey and Plans (PDF)
Remaining Classes
The scheduled class meetings on Thursday, 23 April and Tuesday, 28 April will be open office hours for discussions about any topic you are interested in, including your final projects. This will be an opportunity to get feedback or advice on any issues for your project, including both techincal and research issues, as well as on planning your presentation. You are also encouraged to use these times as opportunities to coordinate with your team and work on completing your project. You can also you the time on April 28 to test out presenting using zoom and experiment with different options you mnight want to use in your project presentation.
Final Project Submissions
Final project submissions are due Tuesday, 28 April, 2:59pm. For
the project submssion, you will submit a form with your project title,
team members, URL (if you have a public project site), and answer
questions about whether or not you want your presentation recorded and
shared, and if you would like to request more than 10 minutes for your
presentation. It is not necessary to submit a formal project report
or paper if the website you submit is self-contained (e.g., if it is a
code repository, it should include a README.md
that explains the
purpose of your project and describes your results).
Final Projects Symposium Spectacular!
Wednesday, 29 April, 2:00-4:30pm we will hold a Final Projects Symposium Spectacular! This will be in our favorite zoom meeting room. Due to limitations of current Internet Protocols, we regret that the symposium will be BYOB.
Each team will have up to 10 minutes to present your project (unless you pre-arranged for additional time). Your presentation can be a demo, slide show, puppet show, musical, video, or any other form of presentation that you can transmit through zoom.


At any time, you can choose to turn Strict Mode ON/OFF by pressing the Strict Button. With strict mode on, if you play a wrong move, the game will automatically restart from level one. Without the Strict Mode, however, Simon will restart playing from the last level you played wrong.
You can set the level needed to win by entering the level number below. By default, the max level is 20. You cannot change level while a game is running.
Current Max Level: 20
Made with by Sarvasv Arora


The modeling of discrete event systems is most easily introduced with an example. Suppose we want to model the checkout line at a convenience store. There is a single clerk who serves customers in a first come-first served fashion. The time required for the clerk to ring up each customer's bill depends on the number of items purchased. We are interested in determining the average and maximum amount of time that customers spend waiting in line at the clerk's counter.
To simulate this system, we need an object to represent each customer in the line. A class called Customer is created for this purpose. Each customer object has three attributes. One attribute is the time needed to ring up the customer's bill. Because we want to know how long a customer has been waiting in line, we also include two attributes that record when the customer entered the line and when the customer left the line. The difference of these times is the amount of time the customer spent waiting in line. Below is the code for the customer class. This code is in a single header file called Customer.h.
#include "adevs.h" /// A Busy-Mart customer. struct Customer { /// Time needed for the clerk to process the customer double twait; /// Time that the customer entered and left the queue double tenter, tleave; }; /// Create an abbreviation for the Clerk's input/output type. typedef adevs::PortValue<Customer*> IO_Type;
Customers are served (processed) by the clerk, which is our first example of an atomic model. The clerk has a line of people waiting at her counter. When a customer is ready to make a purchase, that customer enters the end of the line. If the clerk is not busy and the line is not empty, then the clerk rings up the bill of the customer that is first in line. That customer then leaves the line and the clerk processes the next customer or, if the line is empty, the clerk sits idly at her counter.
The DEVS model of the clerk is as follows. First, we specify the type of object that the model consumes and produces. For this model, we use PortValue objects. The PortValue class describes a port-value pair. In this case, Customer objects are the value and they appear at the clerk's ``arrive" port. Customers depart via the clerk's ``depart" port.
Second, we specify the state variables that describe the clerk. In this case, the state comprises the customers that are in line. We use a list from the C++ Standard Template Library for this purpose.
To complete the model of the clerk, we implement the four methods that model her behavior. First, lets construct the header file for the clerk. Then we can fill in the details.
#include "adevs.h" #include "Customer.h" #include <list> /** * The Clerk class is derived from the adevs Atomic class. * The Clerk's input/output type is specified using the template * parameter of the base class. */ class Clerk: public adevs::Atomic<IO_Type> { public: /// Constructor. Clerk(); /// Internal transition function. void delta_int(); /// External transition function. void delta_ext(double e, const adevs::Bag<IO_Type>& xb); /// Confluent transition function. void delta_conf(const adevs::Bag<IO_Type>& xb); /// Output function. void output_func(adevs::Bag<IO_Type>& yb); /// Time advance function. double ta(); /// Output value garbage collection. void gc_output(adevs::Bag<IO_Type>& g); /// Destructor. ~Clerk(); /// Model input port. static const int arrive; /// Model output port. static const int depart; private: /// The clerk's clock double t; /// List of waiting customers. std::list<Customer*> line; /// Time spent so far on the customer at the front of the line double t_spent; };This header file is an archetype for almost any atomic model that we want to create. The Clerk class is derived from the Adevs Atomic class. The Clerk implements six virtual methods that it inherits from Atomic. These are the state transition functions delta_int, delta_ext, and delta_conf; the output function output; the time advance function ta, and the garbage collection method gc. The Clerk also has a set of static, constant port variables that correspond to the Clerk's input (customer arrival) and output (customer departure) ports.
The constructor for the Clerk class invokes the constructor of its Atomic base class. The template argument of the base class defines the type of object that the clerk uses for input and output. The Clerk state variables are defined as private class attributes. These are the list of customers (line), the clerk's clock (t), and the time spent so far on the first customer in line (t_spent).
The ports ``arrive" and ``depart" are assigned integer values that are unique within the scope of the Clerk class. Typically, the ports for a model are numbered in a way that corresponds to the order in which they are listed; for example,
// Assign locally unique identifiers to the ports const int Clerk::arrive = 0; const int Clerk::depart = 1;
The Clerk constructor places the Clerk into its initial state. For our experiment, this state is an empty line and the Clerk's clock is initialized to zero.
Clerk::Clerk(): Atomic<IO_Type>(), // Initialize the parent Atomic model t(0.0), // Set the clock to zero t_spent(0.0) // No time spent on a customer so far { }
Because the clerk starts with an empty line, the only interesting thing that can happen is for a customer arrive. Arriving customers appear on the clerk's ``arrive" input port. The arrival of a customer causes the clerk's external transition method to be invoked. The arguments to this method are the time that has elapsed since the clerk last changed state and a bag of PortValue objects.
The external transition method updates the clerk's clock by adding to it the elapsed time. The time spent working on the current customer's order is updated by adding the elapsed time to the time spent so far. After updating these values, the input events are processed. Each PortValue object has two attributes. The first is the port. It contains the number of the port that the event arrived on and is equal to ``arrive'' in this case. The second is the Customer that arrived. The clerk records the time of arrival for the new customer and places him at the back of the line.
void Clerk::delta_ext(double e, const Bag<IO_Type>& xb) { // Print a notice of the external transition cout << "Clerk: Computed the external transition function at t = " << t+e << endl; // Update the clock t += e; // Update the time spent on the customer at the front of the line if (!line.empty()) { t_spent += e; } // Add the new customers to the back of the line. Bag<IO_Type>::const_iterator i = xb.begin(); for (; i != xb.end(); i++) { // Copy the incoming Customer and place it at the back of the line. line.push_back(new Customer(*((*i).value))); // Record the time at which the customer entered the line. line.back()->tenter = t; } // Summarize the model state cout << "Clerk: There are " << line.size() << " customers waiting." << endl; cout << "Clerk: The next customer will leave at t = " << t+ta() << "." << endl; }
The time advance function describes the amount of time that will elapse before the clerk's next internal (self, autonomous) event, barring an input that arrives in the interim. In this case, the time advance is the time remaining for the clerk to process the current customer. If there are no customers in line, then the clerk will not do anything and so the time advance returns infinity (in Adevs represented by DBL_MAX). Otherwise, the clerk's next action is when the first customer in line has been rung up, and so the time advance is the difference of the Customer's twait and the clerk's t_spent.
double Clerk::ta() { // If the list is empty, then next event is at inf if (line.empty()) return DBL_MAX; // Otherwise, return the time remaining to process the current customer return line.front()->twait-t_spent; }
Two things happen when the clerk finishes ringing up a customer. First, the clerk sends that customer on his way. This is accomplished by the clerk's output_func method, which is invoked when the time advance expires. The output_func method places the departing customer onto the Clerk's ``depart" port by creating a PortValue object and putting it into the bag yb of output objects. The clerk's output_func method is shown below.
void Clerk::output_func(Bag<IO_Type>& yb) { // Get the departing customer Customer* leaving = line.front(); // Set the departure time leaving->tleave = t + ta(); // Eject the customer IO_Type y(depart,leaving); yb.insert(y); // Print a notice of the departure cout << "Clerk: Computed the output function at t = " << t+ta() << endl; cout << "Clerk: A customer just departed!" << endl; }
Second, the clerk begins to process the next customer in the line. If, indeed, there is another customer waiting in line, then the clerk begins ringing that customer. Otherwise, the clerk becomes idle. These actions are accomplished by the Clerk's internal transition method, which is called immediately after the output_func method. The Clerk's internal transition method updates the Clerk's clock and removes the departing customer from the line. The code for this method is shown below.
void Clerk::delta_int() { // Print a notice of the internal transition cout << "Clerk: Computed the internal transition function at t = " << t+ta() << endl; // Update the clock t += ta(); // Reset the spent time t_spent = 0.0; // Remove the departing customer from the front of the line. line.pop_front(); // Summarize the model state cout << "Clerk: There are " << line.size() << " customers waiting." << endl; cout << "Clerk: The next customer will leave at t = " << t+ta() << "." << endl; }
We have almost completed the model of the clerk; only one thing remains to be done. Suppose a customer arrives at the clerk's line at the same time that the clerk finishes ringing up a customer. In this case we have a conflict because the internal transition function and external transition function must both be activated to handle these two events (i.e., the simultaneously arriving and departing customers). This conflict is resolved by the confluent transition function.
The clerk handles simultaneous arrivals and departures by first handling the departures and then the arrivals. To do this, the confluent transition function calls the internal transition function first (to remove the departed customer from the list) and then the external transition function (to add new customers to the end of the list and begin ringing up the first customer). The confluent transition function is shown below.
void Clerk::delta_conf(const Bag<IO_Type>& xb) { delta_int(); delta_ext(0.0,xb); }
Clerk: Computed the external transition function at t = 1 Clerk: There are 1 customers waiting. Clerk: The next customer will leave at t = 2. Clerk: Computed the output function at t = 2 Clerk: A customer just departed! Clerk: Computed the internal transition function at t = 2 Clerk: There are 0 customers waiting. Clerk: The next customer will leave at t = 1.79769e+308. Clerk: Computed the external transition function at t = 2 Clerk: There are 1 customers waiting. Clerk: The next customer will leave at t = 6. Clerk: Computed the external transition function at t = 3 Clerk: There are 2 customers waiting. Clerk: The next customer will leave at t = 6. Clerk: Computed the external transition function at t = 5 Clerk: There are 3 customers waiting. Clerk: The next customer will leave at t = 6. Clerk: Computed the output function at t = 6 Clerk: A customer just departed! Clerk: Computed the internal transition function at t = 6 Clerk: There are 2 customers waiting. Clerk: The next customer will leave at t = 10. Clerk: Computed the external transition function at t = 7 Clerk: There are 3 customers waiting. Clerk: The next customer will leave at t = 10. Clerk: Computed the external transition function at t = 8 Clerk: There are 4 customers waiting. Clerk: The next customer will leave at t = 10. Clerk: Computed the output function at t = 10 Clerk: A customer just departed! Clerk: Computed the internal transition function at t = 10 Clerk: There are 3 customers waiting. Clerk: The next customer will leave at t = 12. Clerk: Computed the external transition function at t = 10 Clerk: There are 4 customers waiting. Clerk: The next customer will leave at t = 12. Clerk: Computed the external transition function at t = 11 Clerk: There are 5 customers waiting. Clerk: The next customer will leave at t = 12. Clerk: Computed the output function at t = 12 Clerk: A customer just departed! Clerk: Computed the internal transition function at t = 12 Clerk: There are 4 customers waiting. Clerk: The next customer will leave at t = 22. Clerk: Computed the output function at t = 22 Clerk: A customer just departed! Clerk: Computed the internal transition function at t = 22 Clerk: There are 3 customers waiting. Clerk: The next customer will leave at t = 42. Clerk: Computed the output function at t = 42 Clerk: A customer just departed! Clerk: Computed the internal transition function at t = 42 Clerk: There are 2 customers waiting. Clerk: The next customer will leave at t = 44. Clerk: Computed the output function at t = 44 Clerk: A customer just departed! Clerk: Computed the internal transition function at t = 44 Clerk: There are 1 customers waiting. Clerk: The next customer will leave at t = 45. Clerk: Computed the output function at t = 45 Clerk: A customer just departed! Clerk: Computed the internal transition function at t = 45 Clerk: There are 0 customers waiting. Clerk: The next customer will leave at t = 1.79769e+308.
The basic simulation algorithm is illustrated by this example. Notice that the external transition function is activated when an input (in this case, a customer) arrives on an input port. This is because the external transition function describes the response of the model to input events.
The internal transition function is activated when the simulation clock has reached the model's time of next event. The internal transition function describes the autonomous behavior of the model (i.e., how the model responds to events that it has scheduled for itself). Internal transitions are scheduled with the time advance function.
A call to the internal transition function is always immediately preceded by a call to the output function. Consequently, a model produces output by scheduling events for itself. The value of the output is computed using by the output function using the model's current state.
To complete our simulation of the convenience store, we need two other Atomic models. The first model creates customers for the Clerk to serve. The rate at which customers arrive could be modeled using a random variable or it with a table such as the one used in the example above. In either case, we hope that the model of the customer arrival process accurately reflects what happens in a typical day at the convenience store. Data used in the table for this example could come directly from observing customers at the store, or it might be produced by a statistical model in another tool (e.g., a spreadsheet program).
We will create an Atomic model called a Generator to create customers. This model is driven by a table formatted like Table 3.1. The input file contains a line for each customer. Each line has the customer's time of arrival followed by the customer's time for service. The Generator does not need to process input events because all of its activities are scripted in the input file. The Generator has a single output port ``arrive" through which it exports arriving customers. The model state is the list of Customers yet to arrive at the store. Here is the header file for the Generator.
#include "adevs.h" #include "Customer.h" #include <list> /** * This class produces Customers according to the provided schedule. */ class Generator: public adevs::Atomic<IO_Type> { public: /// Constructor. Generator(const char* data_file); /// Internal transition function. void delta_int(); /// External transition function. void delta_ext(double e, const adevs::Bag<IO_Type>& xb); /// Confluent transition function. void delta_conf(const adevs::Bag<IO_Type>& xb); /// Output function. void output_func(adevs::Bag<IO_Type>& yb); /// Time advance function. double ta(); /// Output value garbage collection. void gc_output(adevs::Bag<IO_Type>& g); /// Destructor. ~Generator(); /// Model output port. static const int arrive; private: /// List of arriving customers. std::list<Customer*> arrivals; };
The behavior of this model is very simple. The constructor opens the file containing the customer data and uses it to create a list of Customer objects. The inter-arrival times of the customers are stored in their tenter fields. Here is the constructor that initializes the model.
// Assign a locally unique number to the arrival port const int Generator::arrive = 0; Generator::Generator(const char* sched_file): Atomic<IO_Type>() { // Open the file containing the schedule fstream input_strm(sched_file); // Store the arrivals in a list double next_arrival_time = 0.0; double last_arrival_time = 0.0; while (true) { Customer* customer = new Customer; input_strm >> next_arrival_time >> customer->twait; // Check for end of file if (input_strm.eof()) { delete customer; break; } // The entry time holds the inter arrival times, not the // absolute entry time. customer->tenter = next_arrival_time-last_arrival_time; // Put the customer at the back of the line arrivals.push_back(customer); last_arrival_time = next_arrival_time; } }
Because the generator does not respond to input events, its external transition function is empty. Similarly, the confluent transition function merely calls the internal transition function (though, in fact, it could be empty because the confluent transition will never be called).
void Generator::delta_ext(double e, const Bag<IO_Type>& xb) { /// The generator is input free, and so it ignores external events. } void Generator::delta_conf(const Bag<IO_Type>& xb) { /// The generator is input free, and so it ignores input. delta_int(); }
The effect of an internal event (i.e., an event scheduled for the generator by itself) is to place the arriving Customer onto the Generator's ``arrive" output port. This is done by the output function.
void Generator::output_func(Bag<IO_Type>& yb) { // First customer in the list is produced as output IO_Type output(arrive,arrivals.front()); yb.insert(output); }After the generator has produced this output, its internal transition function removes the newly arrived customer from the arrival list.
void Generator::delta_int() { // Remove the first customer. Because it was used as the // output object, it will be deleted during the gc_output() // method call at the end of the simulation cycle. arrivals.pop_front(); }
Internal events are scheduled with the time advance function. The Generator's time advance function returns the time remaining until the next Customer arrives at the store. Remember that the tarrival field contains Customers' inter-arrival times, not the absolute arrival times, and the time advance function simply returns this value.
double Generator::ta() { // If there are not more customers, next event time is infinity if (arrivals.empty()) return DBL_MAX; // Otherwise, wait until the next arrival return arrivals.front()->tenter; }
To conduct the simulation experiment, the Generator's output must be connected to the Clerk's input. When these are connected, output from the Generator's ``arrive" port becomes input on the Clerk's ``arrive" port. These inputs cause the Clerk's external transition function to be activated. The relationship between input and output events can be understood by viewing the whole model as a block diagram with two distinct components, the Generator and the Clerk, that are connected via their input and output ports. This view of the model is depicted in Figure 3.2.
The Clerk, Generator, and their interconnections constitute a coupled (or network) model. The coupled model depicted in Figure 3.2 is realized with a Digraph that has the Generator and Clerk as components. Shown below is the code snippet that creates this two component model.
int main(int argc, char** argv) { ... // Create a digraph model whose components use PortValue<Customer*> // objects as input and output objects. adevs::Digraph<Customer*> store; // Create and add the component models Clerk* clrk = new Clerk(); Generator* genr = new Generator(argv[1]); store.add(clrk); store.add(genr); // Couple the components store.couple(genr,genr->arrive,clrk,clrk->arrive); ...This code snippet first creates the components models and then adds them to the Digraph. Next, the components are connected by coupling the ``arrive" output port of the Generator to the ``arrive" input port of the Clerk.
Having created a coupled model to represent the store, all that remains is to perform the simulation. Here is the code snippet that simulates the model.
... adevs::Simulator<IO_Type> sim(&store); while (sim.nextEventTime() < DBL_MAX) { sim.execNextEvent(); } ...Putting this all of this together gives the main routine for the simulation program that generated the execution traces shown in the example above.
#include "Clerk.h" #include "Generator.h" #include "Observer.h" #include <iostream> using namespace std; int main(int argc, char** argv) { if (argc != 3) { cout << "Need input and output files!" << endl; return 1; } // Create a digraph model whose components use PortValue<Customer*> // objects as input and output objects. adevs::Digraph<Customer*> store; // Create and add the component models Clerk* clrk = new Clerk(); Generator* genr = new Generator(argv[1]); Observer* obsrv = new Observer(argv[2]); store.add(clrk); store.add(genr); store.add(obsrv); // Couple the components store.couple(genr,genr->arrive,clrk,clrk->arrive); store.couple(clrk,clrk->depart,obsrv,obsrv->departed); // Create a simulator and run until its done adevs::Simulator<IO_Type> sim(&store); while (sim.nextEventTime() < DBL_MAX) { sim.execNextEvent(); } // Done, component models are deleted when the Digraph is // deleted. return 0; }
We have completed our first Adevs simulation program! However, a few details have been glossed over. The first question - an essential one for a programming language without garbage collection - is what happens to objects that we create in the Generator and Clerk output functions? The answer is that each model has a garbage collection method that is called at the end of every simulation cycle (in the example above, immediately prior to the return of the method execNextEvent()).
In our example, the Clerk and Generator models use their garbage collection method to delete the Customer pointed to by each PortValue object in the garbage list. The implementation of the garbage collection method is shown below. This listing is for the Generator model; the Clerk's gc_output() method is identical.
void Generator::gc_output(Bag<IO_Type>& g) { // Delete the customer that was produced as output Bag<IO_Type>::iterator i; for (i = g.begin(); i != g.end(); i++) { delete (*i).value; } }
A second question is how to collect the statistics that were our original objective. One approach is to modify the Clerk so that it writes waiting times to a file as customers are processed. This approach works but has the unfortunate effect of cluttering up the Clerk with code specific to our experiment.
A better approach is to have an Observer that is coupled to the Clerk's ``depart" port. The Observer records the desired statistics as it receives Customer objects on its ``depart" input port. The advantage of this approach is that we can create new types of clerks to perform the same experiment, using, for example, different queuing strategies, without changing the experimental setup (i.e., customer generation and data collection). Similarly, we can change the experiment (i.e., how customers are generated and what data is collected) without changing the clerk.
Below is the code for the Observer class. This model is driven solely by external events. The observer reacts to an external event by recording the time that the Customer departed the Clerk's queue (i.e., the current simulation time) and how long the Customer waited in line. Here is the Observer header file.
#include "adevs.h" #include "Customer.h" #include <fstream> /** * The Observer records performance statistics for a Clerk model * based on its observable output. */ class Observer: public adevs::Atomic<IO_Type> { public: /// Input port for receiving customers that leave the store. static const int departed; /// Constructor. Results are written to the specified file. Observer(const char* results_file); /// Internal transition function. void delta_int(); /// External transition function. void delta_ext(double e, const adevs::Bag<IO_Type>& xb); /// Confluent transition function. void delta_conf(const adevs::Bag<IO_Type>& xb); /// Time advance function. double ta(); /// Output function. void output_func(adevs::Bag<IO_Type>& yb); /// Output value garbage collection. void gc_output(adevs::Bag<IO_Type>& g); /// Destructor. ~Observer(); private: /// File for storing information about departing customers. std::ofstream output_strm; };Below is the Observer source file.
#include "Observer.h" using namespace std; using namespace adevs; // Assign a locally unique number to the input port const int Observer::departed = 0; Observer::Observer(const char* output_file): Atomic<IO_Type>(), output_strm(output_file) { // Write a header describing the data fields output_strm << "# Col 1: Time customer enters the line" << endl; output_strm << "# Col 2: Time required for customer checkout" << endl; output_strm << "# Col 3: Time customer leaves the store" << endl; output_strm << "# Col 4: Time spent waiting in line" << endl; } double Observer::ta() { // The Observer has no autonomous behavior, so its next event // time is always infinity. return DBL_MAX; } void Observer::delta_int() { // The Observer has no autonomous behavior, so do nothing } void Observer::delta_ext(double e, const Bag<IO_Type>& xb) { // Record the times at which the customer left the line and the // time spent in it. Bag<IO_Type>::const_iterator i; for (i = xb.begin(); i != xb.end(); i++) { const Customer* c = (*i).value; // Compute the time spent waiting in line double waiting_time = (c->tleave-c->tenter)-c->twait; // Dump stats to a file output_strm << c->tenter << " " << c->twait << " " << c->tleave << " " << waiting_time << endl; } } void Observer::delta_conf(const Bag<IO_Type>& xb) { // The Observer has no autonomous behavior, so do nothing } void Observer::output_func(Bag<IO_Type>& yb) { // The Observer produces no output, so do nothing } void Observer::gc_output(Bag<IO_Type>& g) { // The Observer produces no output, so do nothing } Observer::~Observer() { // Close the statistics file output_strm.close(); }
This model is coupled to the Clerk's ``depart" output port in the same manner as before. The resulting coupled model is illustrated in Figure 3.3.
Given the customer arrival data in Table 3.1, the consequent customer departure and waiting times are shown in Table 3.2. With this output, we can use a spreadsheet to find the maximum and average times that the customers spent waiting in line.
Again notice that the customer departure times correspond exactly with the production of customer departure events by the Clerk model. Each entry in Table 3.2 is the result of executing the Observer's external transition function. Also notice that the Observer's internal and confluent transition functions are never executed because the Observer's time advance method always returns infinity.
This section has demonstrated the most common parts of a simulation program built with Adevs. The remainder of the manual covers Atomic and Network models in greater detail, demonstrates the construction of variable structure models, and shows how continuous models can be added to your discrete event simulation.