vdlx-datagrid
provides a way to bind model entities to a table element within VDL views. It offers
much improved performance for larger data sets compared with vdl-table
.
Download the appropriate release version of vdx-datagrid
from the GitHub webiste.
The first two digits of the vdlx-datagrid release version number must match the version of VDL you are
using to develop. For example, if you are developing for VDL 4.6, download vdlx-datagrid version 4.6.x.
Unzip the vdlx-datagrid.zip
release bundle into your Xpress Workbench client_resources
folder. You can then add vdlx-datagrid in your views via the code editor-vdlx-datagrid is not available in the VDL Designer palette:
<vdl-include src="vdlx-datagrid/vdlx-datagrid.vdl"></vdl-include>
vdlx-datagrid
is mostly a drop-in replacement for vdl-table
and can generally be
used by renaming code examples:
<vdlx-datagrid id="basic-example-1">
<vdlx-datagrid-column set="SupportLevels">Support L.</vdlx-datagrid-column>
<vdlx-datagrid-column entity="SupportCosts"></vdlx-datagrid-column>
<vdlx-datagrid-column entity="ServiceLevelAgreements"></vdlx-datagrid-column>
</vdlx-datagrid>
Render a table of related array entities. The array entities for each column are defined as child
<vdlx-datagrid-column>
elements. The common index sets are automatically detected.
The table will emit the following events on user interaction:
selection-changed
- Triggered whenever the selection is changed, e.g. when user creates new selection. This event is triggered on the vdlx-datagrid element. Event handler also receives context of the selection, which includes selection cell list, active cell and selection type.selection-removed
- Triggered whenever the selection is destroyed, e.g. when sorting and filtering. This event is triggered on the vdlx-datagrid element.<vdl-var name="selectedRowData" value="=[]"></vdl-var>
<vdl-action-group name="handleSelectionChanged">
<vdl-action-set-var var="selectedRowData" value="=value ? value.activeCell.rowData : []"></vdl-action-set-var>
</vdl-action-group>
<vdl-action-group name="handleSelectionRemoved">
<vdl-action-set-var var="selectedRowData" value="=[]"></vdl-action-set-var>
</vdl-action-group>
<vdlx-datagrid vdl-event="'selection-changed':handleSelectionChanged, 'selection-removed':handleSelectionRemoved">
<vdlx-datagrid-column entity="MY_ARRAY_1"></vdlx-datagrid-column>
<vdlx-datagrid-column entity="MY_ARRAY_2"></vdlx-datagrid-column>
</vdlx-datagrid>
| add-remove-row |
Setting this will show the add-remove row buttons at the bottom of the grid. Set to "true" to prompt for index selection on row add. Set to addrow-autoinc will switch the behaviour to allow new index values to be created, incrementing from the highest value in the set(s).
|
||||||
|---|---|---|---|---|---|---|---|
| always-show-selection |
Whether to display selection on inactive grids. Set to true to keep selection on a grid when it becomes inactive.
Default value: "false"
|
||||||
| class |
Space-separated list of the classes of the element.
|
||||||
| column-definition |
Specify how columns are defined, allowed values: "auto", "labels", or an object defining column properties [{field:"key", title="Key"}...]. "auto" (default) will generate columns from the data. "labels" will use the "label" property on an object as the column header, and the "value" property as the cell value. Data will be reduced to one row. When using column properties, you should supply aa column definition object for each column you require and each object must have a property named 'field'. The value of the field property must reference a property on the data. For example: column-definition="=[{field:"name", title:"Full Name", field:"tel", title:"Phone Number"}] data="=[{name="John Doe", tel:"1234"}...]". Other recommended properties: title, width, cssClass (space separated class names), headerSortStartingDir (asc/desc)
Default value: "auto"
accepts expression
|
||||||
| column-filter |
Set this to true to enable the column filters. This will show a header row with filter inputs for each column.
|
||||||
| data |
Use this attribute to pass data directly to vdlx-datagrid. Supported formats are; array of primitives: [1,2,3], Array of objects: [{... prop: 1}], or an array of arrays: [...["a",1]]
accepts expression
|
||||||
| export-filename |
The name of the file exported from the table. A file extension will be assigned.
Default value: "data"
accepts expression
|
||||||
| freeze-columns |
The number of columns to freeze in the table starting from the left hand column. Works best when vdlx-datagrid is in a fixed width container
|
||||||
| height |
Grid height, When page-mode is set to scrolling you can set the height of the grid to something other than the default.
Default value: "600"
accepts expression
|
||||||
| id |
Specify an element id for the grid. Useful if you later want to target the grid using a selector. If not given then an id will be generated.
|
||||||
| page-mode |
By default the grid will show all rows in scrolling mode. Set this attribute to paged to enable grid pagination.
|
||||||
| page-size |
The number of rows to show per-page in paged mode.
Default value: "50"
accepts expression
|
||||||
| row-filter |
Expression to be used for filtering the rows of a <vdl-datagrid>. This must be an expression and should resolve to either a function or a boolean value. If a function it will be executed when grid updates. The function will have the following signature (rowData, indices) and should return a boolean.
accepts expression
|
||||||
| save-state |
Set this to false to disable grid state saving. By default grid state is stored in the user's browser session so that user settings (e.g. page, sorting and search) are preserved if grid data is reloaded.
Default value: "true"
|
||||||
| scenario |
The default scenario to use for fetching data in the grid. This can be overridden per column but the default will be used when a column does not specify a particular scenario and the index sets will be fetched from the default scenario. This attribute will not affect the scenario variable in any render expression on the datagrid columns.
accepts expression
|
||||||
| show-export |
Set this to true to display an export to CSV button.
Default value: "false"
accepts expression
|
||||||
| width |
Set the grid to a fixed width, in pixels. Accepts an integer value. If set to the string custom then the grid width is calculated by adding up all the widths of the columns in the grid. If a column doesn't have a width specified then it is given a default value of 100px.
|
| bottom-calc |
Specify a built-in calculation, one of avg, max, min, sum, concat or count to show that calculated value, alternatively provide a custom function, as a dynamic expression.
accepts expression
|
||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| class |
CSS classes to add to the table column cells. You can provide multiple classes separated by spaces.
accepts expression
|
||||||||||
| disable-set-sorting |
When applied to an index column, this will prevent set sorting from being applied to the column. Default table sorting will be used instead. It will also exclude this column from the default list of sorted columns. This option is provided to reduce the sorting overhead where performance is being affected. Set the value to "true" to disable set sorting for this datagrid column.
Default value: "false"
type:
boolean
|
||||||||||
| editable |
Whether the cells within this column are editable. The column will automatically switch to read-only whilst the bound scenario is reserved for execution.
type:
boolean
accepts expression
|
||||||||||
| editor-checked-value |
The value to set the cell data to if input type is checkbox and it is checked.
|
||||||||||
| editor-options |
An expression that results in one of the follow to be used as the select options: an array of values, an object of property to value or an array of objects containing key and value properties. This will automatically set the editor-type to be select.
accepts expression
|
||||||||||
| editor-options-include-empty |
Allow array elements to be removed using the select input. Setting this to true will add a blank item to the top of the select list.
Default value: "false"
|
||||||||||
| editor-options-set |
Name of a set entity to use for select options. This will display labels if a labels entity is defined against this set. This will automatically set the editor-type to be select.
|
||||||||||
| editor-type |
The editor type to use, in edit mode, for cells in this column. If not specified then it will be autodetected based on entity type. Possible values: checkbox, select, text.
|
||||||||||
| editor-unchecked-value |
The value to set the cell data to if input type is checkbox and it is not checked.
|
||||||||||
| entity |
Name of the array entity to show in this column. Throws an error if the entity doesn't exist or is not an array or set type.
|
||||||||||
| filter-by-formatted |
Use formatted values for filtering. This defaults to false unless the entity has a label in which case the default is true.
type:
boolean
|
||||||||||
| format |
Specify a number formatting string. Only applicable to array elements of type integer, real, decision variable and constraint. The formatting syntax is explained in the Xpress Insight Developer Guide.
|
||||||||||
| heading |
A custom header for this column, will default to be the entity alias. Alternatively, you can set the title as the text contents of the <vdlx-datagrid-column> element.
accepts expression
|
||||||||||
| render |
Reference to a custom cell renderer. Overrides any default entity rendering. This will be used to generate the cell value for rendering, filtering and sorting. It must be an expression and resolves as a function, this function should return a string. Render callback may only reference entities through VDL expression that are not present on the table. If it is necessary to use entities data from other columns, then rowData array must be used in the render callback.
accepts expression
|
||||||||||
| scenario |
The scenario id/index for this column. Not allowed on index column (when specifying a set entity). This attribute will not affect the scenario variable in the render expression.
accepts expression
|
||||||||||
| set |
Name of the set entity to show in this column. Throws an error if the entity doesn't exist or is not a set type.
|
||||||||||
| set-position |
Index (zero-based) of occurrence of that index set in the index tuple for the array. Defaults to next available position.
|
||||||||||
| sort-by-formatted |
Use formatted values for sorting. This is always set to enabled for calculated columns.
Default value: "false"
type:
boolean
|
||||||||||
| sort-direction |
The direction the column data should be sorted in.
Default value: "asc"
|
||||||||||
| sort-order |
Sets the column to be sorted by default, provide a number from 0. With multiple sorted columns the number provides the order in which sorting should be applied to the columns, so the highest number will result in the column having sorting applied last.
type:
number
|
||||||||||
| width |
The width, in pixels, to set the column.
accepts expression
|
This tag can be used at either the vdlx-datagrid
level or the vdlx-datagrid-column
level.
When used at the vdlx-datagrid-column
level, it can only accept a single value and will filter
the specified index set for the array entity associated with that column. Note that it will not reduce the amount
of data fetched from the server when used at the column level.
When used at the vdlx-datagrid
level, it can accept one or more values and will filter the specified
index set for all arrays in the table. This will request the filtered data from the server, so reduce the amount
of data that is fetched from the server and processed by the table, resulting in improved performance. The filtered
index set will still be shown as a column in the table, so you will need to use vdl-visible="=false"
to hide this if necessary.
<!-- Example of an index filter on a column -->
<vdlx-datagrid>
<vdlx-datagrid-column entity="FactoryDemand" heading="='Factory Demand (' + vars.filterValue + ')'">
<vdlx-datagrid-index-filter set="Factories" value="=vars.filterValue"></vdlx-datagrid-index-filter>
</vdlx-datagrid-column>
</vdlx-datagrid>
<!-- Example of a server-side index filter on an entire table -->
<vdlx-datagrid vdl-if="=vars.multiFilter.length > 0">
<vdlx-datagrid-index-filter set="MonthsOfYear" value="=vars.multiFilter"></vdlx-datagrid-index-filter>
<vdlx-datagrid-column entity="FactorySupply"></vdlx-datagrid-column>
</vdlx-datagrid>
| set |
Name of the set entity to filter out of the indices for the column.
required
|
|---|---|
| value |
Single value to fix the indices to. If used at the vdlx-datagrid level, the value will accept multiple values in the form of an array or a vdl-var
required
accepts expression
|
| set-position |
Index (zero-based) of occurrence of that index set in the index tuple for the array.
Default value: "0"
|
Add a validation rule to a <vdlx-datagrid-column>
element.
You can declare multiple <vdl-validate>
rules within a
<vdlx-datagrid-column>
and they will all be applied. Each rule can specify whether the field is allowed to save data if that rule
fails (this is soft validation). The pass attribute defines the expression that is called every time the field or autocolumn
changes. The expression is automatically given the variables: entityName
, value
, indices
and rowData
(if used with vdlx-datagrid
). entityName
is the
name of the entity bound to the field, value
is the current value being input, indices
is an array of indices
if the field is bound to an array element and rowData is an array containing indices and values of the current row.
<vdlx-datagrid>
<vdlx-datagrid-column entity="FactoryDemand">
<vdl-validate pass="=value >= scenario.entities.SupportLevel.value"
allow-save="=scenario.entities.CanSave.value">
FactoryDemand should be greater than or equal to SupportLevel
</vdl-validate>
</vdlx-datagrid-column>
</vdlx-datagrid>
| pass |
Expression to used for validating the value of a <vdl-field> or <vdl-table-column>. This must be an expression and
should resolve to either a function or a boolean value. If a function it will be executed on each change to the vdl-field
or vdl-table-column and also when a save is attempted. The function will have the following signature (entityName, value, key)
and should return a boolean.
required
accepts expression
|
||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| allow-save |
If set to true this will allow a field to be saved even though it is marked as invalid.
Default value: "false"
accepts expression
|
Text content only
Text content of the element is used as the message to display when attempting to save and validation fails


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 113489newmembers/10664HowdoIshowthatsumoftrivialvectorofiszero.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/113489-new-members/topic/How.20do.20I.20show.20that.20sum.20of.20trivial.20vector.20of.20.E2.84.9D.20is.20zero.3F.html


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| FlatFilePostprocessor | A FlatFilePostprocessor preproccesses a flat file. |
| FlatFileSignature | |
| FlatFileSignatureFactory | |
| SignatureMethod | Receive notification of the raw data from the body of a flat file (excluding header and trailer) as the file is being read or written. |
| Class Summary | |
|---|---|
| ByteFlatFilePostprocessor | A ByteFlatFilePostprocessor postproccesses a flat file. |
| CharFlatFilePostprocessor | A ByteFlatFilePostprocessor postproccesses a flat file. |
| CrcFlatFileSignatureFactoryAssembler | The FlatFileSignatureAssembler implements an assembler for
assembling FlatFile objects. |
| CrcSignatureMethod | |
| DefaultFlatFileReader | A DelimitedFlatFileReader implements a RecordReader interface. |
| DefaultFlatFileReaderFactory | A FlatFileReaderFactory instance may be used to obtain objects that
implement the RecordReader interface. |
| DefaultFlatFileWriter | |
| DefaultFlatFileWriterFactory | Implements a default flat file writer. |
| FlatContentValidator | |
| FlatFile | The FlatFile defines a flat file. |
| FlatFileAssembler | The FlatFileAssembler implements an assembler for
assembling FlatFile objects. |
| FlatFileBody | The FlatFileBodyFactory
defines a flat file record. |
| FlatFileBodyFactory | The FlatFileBodyFactory
defines a flat file record. |
| FlatFileBodyFactoryAssembler | The FlatFileBodyFactoryAssembler implements an assembler for
assembling FlatFileBodyFactory objects. |
| FlatFileHeader | The FlatFileHeader object describes the layout of a file header |
| FlatFileHeaderAssembler | The FlatFileHeaderAssembler implements an assembler for
assembling FlatFileHeader objects. |
| FlatFileReader | A DelimitedFlatFileReader implements a RecordReader interface. |
| FlatFileReaderFactory | A FlatFileReaderFactory instance may be used to obtain objects that
implement the RecordReader interface. |
| FlatFileReaderFactoryAssembler | The FlatFileReaderFactoryAssembler implements an assembler for
assembling FlatFileReaderFactory objects. |
| FlatFileSignatureFactoryAssembler | The FlatFileSignatureAssembler implements an assembler for
assembling FlatFile objects. |
| FlatFileSignatureImpl | |
| FlatFileTrailer | The FlatFileTrailer object describes the layout of a file header |
| FlatFileTrailerAssembler | The FlatFileTrailerAssembler implements an assembler for
assembling FlatFileTrailer objects. |
| FlatFileWriter | |
| FlatFileWriterFactory | A FlatFileWriterFactory instance may be used to obtain objects that
implement the RecordWriter interface. |
| FlatFileWriterFactoryAssembler | |
| FlatRecordReceiverAdaptor | |
| NonDelimitedFlatContentReceiver | |
| SigningFlatFilePostprocessor | A SigningFlatFilePostprocessor postproccesses a flat file. |
| SizeFlatFileSignatureFactoryAssembler | The FlatFileSignatureAssembler implements an assembler for
assembling FlatFile objects. |
| SizeSignatureMethod |
Provides interfaces and classes for flat file formats.
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Woah, it changed from "digital" to "dev"... very important news.
So, if you're busy, all you need to know is that the old domain (ggtylerr.digital) is going to be removed by the start of March and you'll need to use the new one (ggtylerr.dev) for now on. That counts for anything with a URL; mutat.io, Dark Side SCP, or anything in the future.
If you do have the time, though, I'd like to explain why this is important, and it has a semi-interesting story behind it as well.
So roughly around last year, I found out about this neat program called "GitHub Student Developer Pack", and I thought it was a pretty damn good deal to start out with. It contains pretty much all the tools I use today, including repl.it, Jetbrains IDEs, Unity, and (most important in this story), a free domain for a year.
I already had my mind set on a good domain, which is the new one, ggtylerr.dev. But at the time I thought this was the only free domain I could get (they may have changed this now.) So, I got the domain, along with some other goodies.
Fast forward to present day and I'm scrambling for cash. For some reason, in their infinite wisdom, they didn't think students would still be students by the time their plans have ended. Take one guess how much that domain would cost to renew. $10? $20? Nope, $34 a year for an otherwise normal domain. Just to compare, you can get $1 a month domains.
This new one happened to be one...well, it's $12 a year, but it's pretty much the same thing. You might call me cheapo, and you're correct, 'cause I'm not over-paying for stuff they technically don't own.
Which is actually a pretty good segway to this next bit.
You might notice, but I'm not really good on cash right now. Here's a screenshot of my bank account.
Man, I'm rich! Let's factor in fees too. The hosting service for all my online projects is repl.it, which I also nabbed a free plan from that GitHub dev pack. That plan is $7 a month and it charges me starting on March 2nd, so I got until...
...June 2nd till everything goes down. Luckily by that time I'll be out of HS and (hopefully) in a part-time job, but that is a really tight spot it put me in. So, if you want to support me and keep this thing up just a little longer, I recently set up a Ko-Fi account where you can buy me a coffee. support the website and other online services.
I'll make sure to keep track of all the money raised through there and use it exclusively for paying off these plans, as well as any funding for any future projects. And, for the sake of transparency, at the end of every quarter of the year there will be a donation funding report, listing where all the money raised will/has go towards.
And if you don't have cash or don't care about this, I get you. I ignored the Wikipedia message about donating too.  I know that's said in pretty much every single e-begging message, but hey, sometimes it works.
And if you can't for whatever reason, then sticking around might be best :) Seriously, that helps me massively, cause as far as I know, nearly nobody actually care about this.
Thanks for reading all the way through :D No matter what happens, thank you for checking out any of my projects, and cya till next time.
~ggtylerr


fly me to the moon is a 3D-animated application driven by webGL technologies from Cesium and Three.js. It's a client-side app
that attempts to provide both a visual and informational experience.
after each scene, please click the blue home icon to reset the camera.
click fly me home to arrive at your current location.
click fly me anywhere to visit some of our planets most spectacular locations.
click fly me to the moon to engage in a Three.js-driven flight animation.
use the search bar to fly anywhere on earth.
click the home icon to reset the camera post-flight.
click the map icon to swap out 3D-ariel view for 2D-terrain view.
visit the source code for more details about this application.
Authored by Scott Jason


Uganda is my country.I love Uganda.
I am a Ugandan by nationaly and l will always choose Uganda amongest all odds.
One thing l love about Uganda is it's nature.
We have been blessed with the best weather which has given us a green view reflected by the lakes,rivers,mountains,hills and most importantly wildlife.
I love my country of its nature mostly in the western side of Uganda.
A district like Kabale has the most beautiful features! The Crater lake made of the different historical islands.
I love my country


Half-Past Seven Stories
by Robert Gordon Anderson
Story 11: "Ole Man Pumpkin"
Additional Information
- Year Published: 1922
- Language: English
- Country of Origin: United States of America
- Source: Anderson, R.G. (1922). Half-Past Seven Stories. New York, NY: G.P. Putnam’s Sons.
-
Readability:
- Flesch–Kincaid Level: 5.5
- Word Count: 2,896
- Genre: Adventure
- Keywords: holiday, tradition
- ✎ Cite This
Downloads
It was October, and the cornfield was deserted and bare. Jehosophat and Marmaduke could remember it as a more beautiful picture. For there, in the Summer, an army had camped, the great army of the corn, with tassels and tall yellow spears, and bright green banners waving and tossing in the wind. But when Fall had come, Father and the Toyman had come, too, with their sickles like swords, to attack and cut down that brave army. And now the corn soldiers were all laid away, stiff and cold, in the barn, or else in the silo—to be pickled in juice!
Marmaduke and Jehosophat looked over the field. It was covered with little hills, and there the feet of the corn soldiers still stood, all that was left of them, for they had been “swished by those swords,” just at the ankles.
Between the hills shone the last of the pumpkins, big, round and yellow—red-yellow like an orange. Most of them had gone in the wagon, long ago, but the largest of all had been left. My, but he was a big fellow! “The biggest in the world!” they declared.
He had been saved for the great day—or night, we should say—Hallowe’en.
But let’s hurry the clock—over three days—to the morning before the celebration.
The three children were watching Mother in the kitchen. She was busy with the big pumpkin, but the Toyman had to help her with it—it was so huge. He lifted it on the table—then—what do you think?
He took a sharp knife and scalped that Pumpkin—just like an Indian—cut a great hole in his head. Then Mother scooped out his insides and chopped them up fine. Ole Man Pumpkin was very brave, just stood it and said never a word.
“Why, he doesn’t holler a bit!” exclaimed Marmaduke. “I would, if anybody scalped me and took my insides out!”
Next, Mother brought out the big pot, filling it part with water, and part with Ole Man Pumpkin’s yellow insides.  It took quite a long time, but the children didn’t grow tired—it was such a mysterious, such an interesting process.
At last Mother decided it had been cooked long enough, and she poured the water into the sink, the nice yellow stuff into a bowl. Then she mashed the lumps till it looked like golden mush.
Now the flour was sifted on the pastry board, and the dough rolled until it was as smooth and flat as a sheet or counterpane. Then quickly and neatly the dough counterpanes were placed in the pans, hanging over the edges like covers overlapping a bed. Taking a knife, Mother cut off these edges even with the pan, then, for decoration, made little marks in the dough all around, like the flutings of the Fairy Lamp.
Of course, the insides of Ole Man Pumpkin wouldn’t taste quite right as they were, so Mother broke some eggs over them, adding some milk and a pinch of spice for seasoning, and the delicious mess was stirred till all was thoroughly mixed.
Soon it was ready, a fine filling for pies and pans or little boys or kings, for that matter, and she scraped it into the pans until the white crust was covered up, all but the fluted edges. Then into the oven went the pies, on the top shelf, and the door was closed to keep the heat in.
Meanwhile the children had been so busy watching Mother and those pies; and their mouths had watered so as they watched, that they hadn’t noticed the Toyman at all—until they heard him say,—
“Good mornin’, Jack!”
Jack Who?
“Mr. Jehosophat Green,” said the Toyman very politely, “let me make you acquainted with Jack, or, as he is sometimes called, ‘Ole Man Pumpkin.’”
Jehosophat bowed low.
“Pleased to meet you,” he said, just like grownup folks.

The Toyman took her by the arm, and he in turn made a grand bow.
“Now, Jack, old fellow, this is an honor. Here’s a lady expressin’ a desire to make your acquaintance. Miss Hepzebiah Green, let me present Mr. Jack O. Lantern, otherwise known as ‘Ole Man Pumpkin.’”
Then he turned to Jack.
“You don’t mind my calling you so familiarly, do you?”
Apparently Jack didn’t mind, for he just squatted there, lazy-like, and grinned with all his big square teeth.
Hepzebiah giggled back at him. She was having a glorious time. So were they all.
So, through that long—no, very short —afternoon, the kitchen was filled with pleasant smells and the air of fun and a pleasant surprise to come. They almost thought they could smell the surprise as well as the pies.
It came at last, that is the surprise did, for, just after supper, the Toyman disappeared, probably to do some of his chores.
A little while later there came a tap at the window.
Marmaduke turned.
Jehosophat turned.
Hepzebiah turned.
“Ooh, ooh!” said she;
“Golly!” said Marmaduke; and
“Gee whiz!”, Jehosophat.
Great yellow eyes looked in through the window, and a nose, and a great grinning mouth with big teeth in it.
The visitor nodded, needing no introduction, for they had made his acquaintance already.
He came into the house, helped a little by the Toyman, and still nodding his great yellow head.
They gave him a seat of honor, not by the table, but on it, right in the centre. Marmaduke climbed up and looked down into the big hole in the top of his head. In it was a thick candle, dancing inside his old yellow skull, and he seemed a good comrade, that Ole Man Pumpkin.
But what was the Toyman doing now?
He had a tub in his arms. He set it down, filled it with water, then popped three red apples in it.
And the children got down on their knees around the tub and tried to take the apples in their teeth. But round and round they bobbed, so fast that it was difficult to catch them.
 And always those little red apples bobbed out of reach. Once Jehosophat thought he had caught one, but his teeth slipped on its smooth round cheek and all he got was a piece of skin. It was fun just the same.
A lot of other games they played, with flour, and candles, and rings, and things, then the Toyman gathered them up on his knees and the arm of his chair, and told them a story. A good one? Of course! He never told a poor one.
By this time the children were sneezing and Mother said they’d have to go to bed or they’d catch their “deathocold.”
When they were at last undressed Jehosophat lay his head on the pillow. But it wouldn’t stay down. He could see Ole Man Pumpkin sitting there on the dining-room table—so still! The Toyman had forgotten to put out the candle in his head. It was a thick candle, and it burned a long, long time. Ole Man Pumpkin seemed to be very cheerful with it inside his hollow skull. It made him feel “all lit up,” he heard the Toyman say.
The big, round eyes never blinked.
Then all of a sudden Ole Man Pumpkin started to move. He didn’t have any legs, but he slid from the table to the floor, and somehow climbed up on the window sill, and rolled out of the window. Jehosophat had to get out of bed to see what his new friend was going to do. He followed him across the dining room, over the window sill, and by the barn. And all the little boy had on were his pajamas, but he didn’t feel cold, for Ole Man Pumpkin looked so bright and jolly and warm that Jehosophat felt bright and jolly and warm, too.
Ole Man Pumpkin kept bumping his way along to the cornfield where Mr. Scarecrow stood on guard, though his work for the year was done.
Now Mr. Scarecrow seemed to have a lot of friends around him, and he was making a speech. There was Ole Man Pumpkin, of course; and Jehosophat, who had just arrived; and Mr. Stuckup the Turkey, as usual looking very grand and proud; and the Hippity-hop Bunnies, wiggling their noses in their funny way; and Johnny Cottontail, their little wild cousin, making his nose go, too. And there was Reddy Fox, with one forepaw raised and his eyes as bright as beads; and a whole squad of corn-soldiers with yellow tassels and green banners and tall spears. My! but they looked bright and gay once more!  His arms stood out stiff and straight from the shoulder, but he made queer floppy gestures with his wrists.

Jehosophat shuddered, for he thought he knew what was in Mr. Scarecrow’s mind. That very day in school they had had “Currantyvents,” and Miss Prue Parsons had told them a lot about Reds, and Annarkisseds, and Revolushions they wanted to start all over the world. Horrible, shivery things they were that she had told them!
“Revolt—rebel. Rebel—revolt!” Old Mr. Scarecrow shouted, flapping his wrists and swinging in the wind.
“Hear, hear!” cried the Little Red Apples;
“Hear, hear!” cried the Shiny Pie Pans; and
“Horrible, horrible!”, Mr. Stuckup the Turkey.
Ole Man Pumpkin didn’t say anything, but just grinned and grinned with his big eyes and old yellow teeth.
“There is a cap’talist now, standing before you!” shouted Mr. Scarecrow, and his wrists flapped right at Jehosophat, “away with him!”
“Away with him!” shouted one and all—the Little Red Apples, the Shiny Pie Pans, Mr. Stuckup the Turkey, and the Tall Corn Soldiers; and all the time Ole Man Pumpkin kept grinning and grinning, as if he were enjoying himself most cruelly.
Then Mr. Scarecrow said in a solemn voice:
“Soldiers, do your duty with the prisoner!”
And all at once two Tall Corn Soldiers stood on each side of him, grabbed him by one arm, and growled:
“About face—forward march!”
And the first thing he knew, he was being hustled very swiftly over towards the Pond.
The Little Red Apples and the Shiny Pie Pans rolled on ahead, chattering gaily to each other; Mr. Stuckup marched on very pompously; Ole Man Pumpkin bumped along just in front; the two Corn Soldiers marched by his side; and a lot of others pricked him from behind with their sharp, cruel spears.
What were they going to do with him? That was the question.
He was soon to know, for they had reached the edge of the Pond.
“Duck him!” shouted the Little Red Apples in glee.
And the Tall Corn Soldiers seized Jehosophat by the hair on the top of his head, and shoved him under the water, way under, oh, way, way under.
“Give me a bite!” said the first Little Red Apple, snapping at their prisoner’s face when he came to the surface again.
“Me, too!” shouted the second.
“A big one for me!” yelled the third, and they all rolled in the water and bobbed around, bumping up against his face and trying their best to take a nip out of his cheeks.
He never had known before that apples had teeth, but, sure enough, he felt them now—there was actually a little piece gone from each side of his face.
“Great fun, Hallowe’en!” they called to one another as they bobbed about, still snapping at his cheeks.
“Enough!” It was the two Corn Soldiers who spoke, and Jehosophat was dragged from the Pond. He was dripping wet and he felt pretty cold in his pajamas.
“Now it’s my turn,” said Ole Man Pumpkin. “Take him to the workshop, there’s a lot of sharp tools there.”
Tools! Whatever could they be going to do with him now! But he had no time to think, for there they were, all bumping, or rolling, or stalking along, to the workshop, and taking him with them. They had no keys, but they managed to enter just the same.
“On the table—come, up with him!”
And immediately the two Corn Soldiers seized him by the arms and hoisted him on the table, where he sat in his little pajamas, like a tailor, with his knees crossed under him. But what was the idea? What was that Ole Man Pumpkin telling the Corn Soldiers?
 Quick work, or he’ll spoil.”
“Save the drumstick for me,” gobbled Mr. Stuck-up, “they didn’t bother me much on Hallowe’en, but I’m going to get even for Thanksgiving.”
And all the time the Little Red Apples rolled around the floor in high glee; and the Shiny Pie Pans danced against each other, making a noise like the cymbals of the Salvation Army parade; and Ole Man Pumpkin kept sharpening and sharpening his knife.
Then—then—but it was a new voice that was speaking to him.
“Get up!” it said.
It wasn’t Ole Man Pumpkin that was telling him to get up on that table, so he could scalp him. It was Mother telling him to sit up in bed!
“I knew they had too much pie,” she was saying, and, “come, dear, open your mouth; take this and you’ll feel better in the morning.”
She was on one side of the bed, and Father was on the other, ready to take a hand, as he always did under the circumstances.

However, he took it pretty bravely, swallowed it, gulped, then choked back the tears. But the orange-juice, which followed the yellow stuff, almost made up for it. He always did like orange as a color better than yellow, any day.
And there was Ole Man Pumpkin again, on the dining room table, grinning, not wickedly but cheerfully. He winked at Jehosophat, just like the Ole Man in the Moon, whom he strangely resembled—as much as to say:
“We’ll have a good time yet in spite of that bottle.”
After all, he wasn’t an enemy of the children, who would cut holes in their heads and scoop out their insides—he was their friend, was Ole Man Pumpkin, and Jehosophat felt much relieved at that.


State
Location
-
Location
AVAILABLE
UNAVAILABLE
-
Location setting
ENABLED
DISABLED
-
GPS Location
AVAILABLE
UNAVAILABLE
-
GPS Location setting
ENABLED
DISABLED
-
Network Location
AVAILABLE
UNAVAILABLE
-
Network Location setting
ENABLED
DISABLED
-
Location Mode
-
Location authorized
AUTHORIZED
UNAUTHORIZED
-
Location authorization status
Use permissions


| BoardHelper |
Created by Stanisław Kabaciński.
|
| BoardUtils |
Created by Stanisław Kabaciński.
|
| ChessGameImpl |
Created 10/1/2016.
|
| ChessGameUtils |
Created by Stanisław Kabaciński.
|
| Comment |
Created by Stanisław Kabaciński.
|
| Entity |
Created by Stanisław Kabaciński.
|
| GameBegin |
Created 06.10.2017.
|
| Move |
Created by Stanisław Kabaciński.
|
| MoveFactory |
Created by Stanisław Kabaciński.
|
| MovesFilter |
Created by Stanisław Kabaciński.
|
| MovesFilter.RevertedMove |
|
| NumericAnnotationGlyph |
Created by Stanisław Kabaciński.
|
| ObservableChessGame |
Created by Stanisław Kabaciński.
|
| PossibleMovesProviderImpl |
Created by Stanisław Kabaciński.
|
| SANHelper |
Created by Stanisław Kabaciński.
|
| SANMoveMaker |
Created by Stanisław Kabaciński.
|
| VariantBegin |
Created by Stanisław Kabaciński.
|
| VariantEnd |
Created by Stanisław Kabaciński.
|


Welcome to the mountain habitat! This is one of the rarer habitats in the game, usually present in only a certain area. The Pokemon you find here, although hard to catch, are strong, and would make useful additions to your team...IF you can catch them, that is.
Geodude
Graveller
Golem
Mankey
Primeape
Machop
Machoke
Machamp
Clefairy
Clefable
Charmander
Charmeleon
Charizard


| Network Working Group | D. Fuelling |
| Internet-Draft | Ripple |
| Intended status: Standards Track | July 07, 2020 |
| Expires: January 8, 2021 |
PayID Discovery
draft-fuelling-payid-discovery-01
This specification defines the PayID Discovery protocol, which can be used to discover information about a 'payid' URI using standard HTTP methods.
The primary use-case of this protocol is to define how to transform a PayID URI into a URL that can be used with other protocols.
This specification is a draft proposal, and is part of the PayID Protocol initiative. Feedback related to this document should be sent in the form of a Github issue at: https://github.com/payid-org/rfcs/issues.
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."
This Internet-Draft will expire on January 8, 2021.
Copyright (c) 2020 IETF Trust and the persons identified as the document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.
PayID Discovery is used to transform a PayID URI [PAYID-URI] into a URL (defined below as a PayID Discovery URL) that can then be used by higher-order protocols to discover metadata about a PayID-enabled service provider.
This document specifies two modes of PayID discovery: one using Webfinger [RFC7033] to resolve a corresponding PayID Discovery URL from a PayID using an interactive protocol. The second mode uses a manual mechanism to assemble a PayID Discovery URL from a PayID by-hand.
In 'interactive' mode, a PayID can be presented to a Webfinger-enabled service endpoint that supports PayID Discovery. The resource returns a Webfinger-compliant JavaScript Object Notation (JSON) [RFC4627] object that can be used to perform PayID Discovery as defined in section 4.1 of this document.
As an alternative, "manual" mode MAY be used to decompose a PayID into a URL, without any intermediate server interaction by simply transposing portions of a PayID URI into a URL format. This procedure is defined in section 4.2 of this document.
It should be noted that "manual" mode does not allow divergence between the string characters in a PayID URI and any corresponding PayID URL. Interactive mode, on the other hand, does allow such divergence, and is thus more powerful. For example, in manual mode, the PayID 'alice$example.com' MUST always map to the URL 'https://example.com/alice', whereas in interactive mode that same PayID URI can map to any arbitrary URL structure determined by the service provider, such as 'https://example.com/users/alice'.
Information returned via PayID Discovery might be used for direct human consumption (e.g., looking up someone's Bitcoin address), or it might be used by systems to help carry out some operation (e.g., facilitating, with additional security mechanisms, protocols to support compliance or other legal requirements necessary to facilitate a payment).
The information returned via this protocol is intended to be static in nature. As such, PayID Discovery is not intended to be used to return dynamic information like a payment account balance or the current status of a payment account.
PayID Discovery is designed to be used across many applications. Use of PayID Discovery is illustrated in the examples in Section 3 and described more formally in Section 4.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119].
This section shows sample uses of PayID Discovery in several hypothetical scenarios.
Imagine Alice wishes to send a friend some XRP from a web-based wallet provider that Alice has an account on. Alice would log-in to the wallet provider and enter Bob's PayID (say, bob$receiver.example.com) into the wallet UI to start the payment.
The Wallet application would first perform a WebFinger query looking for the PayID Discovery service provider, like this:
GET /.well-known/webfinger? resource=payid%3Abob%24receiver.example.com HTTP/1.1 Host: receiver.example.com
The server might respond like this:
HTTP/1.1 200 OK Access-Control-Allow-Origin: * Content-Type: application/jrd+json { "subject" : "payid:bob$receiver.example.com", "links" : [ { "rel": "https://payid.org/ns/payid-uri-template/1.0", "template": "https://receiver.example.com/users/{acctpart}" } ] }
Alice's wallet then uses the URL template found in the template property to assemble the specified PayId URL, https://receiver.example.com/users/bob.
Per [RFC7033], Webfinger requests can be filtered by using a "rel" parameter in the Webfinger request. Because support for the "rel" parameter is not required nor guaranteed, the client must not assume the "links" array will contain only the link relations related to PayID Discovery.
Imagine Alice, as in the example above, wants to send a friend some XRP from a web-based wallet provider that Alice has an account on. However, in this example, let's assume that the PayID Alice is wanting to pay doesn't support "interactive" PayID discovery (i.e., the receiver's server doesn't support Webfinger).
Alice would log-in to her wallet provider and enter Bob's PayID (say bob$receiver.example.com) to make a payment.
The Wallet application would first attempt a WebFinger query as in the example above, like this:
GET /.well-known/webfinger? resource=payid%3Abob%24receiver.example.com& HTTP/1.1 Host: receiver.example.com
However, in this case the receiver.example.com server doesn't support "interactive" PayID Discovery, so the server responds like this:
HTTP/1.1 404 NOT FOUND
Because Alice's Wallet can utilize "manual" PayID Discovery, the wallet software merely transforms bob$receiever.example.com into the URL https://receiver.example.com/bob. Alice's wallet then uses that URL to continue making a PayID payment.
It should be noted that "manual" mode does not allow the PayID URI to diverge from the underlying URL returned via PayID Discovery. Because of this, "interactive" PayID Discovery is generally preferred.
The PayID Discovery protocol is used to request information about an entity identified by a PayID URI.
When successful, PayID Discovery always yields a PayID URL, which is a URI as defined by [RFC3986] using the 'https' scheme defined in section 2.7.2 [RFC7230]. A PayID URL can be used for any purposes outside the scope of this document.
PayID Discovery is performed using one of two modes: "interactive" or "manual." Clients MUST attempt "interactive" mode first. If that mode fails to yield a PayID URL, then "manual" mode MAY be used as an alternative discovery mechanism.
Interactive PayID Discovery is broken up into a series of steps, each of which is defined in more detail below. The following is a visual representation of the protocol flow:
+--------------------------+ | PayID URI | | alice$example.com | +--------------------------+ | v +--------------------------+ | Assemble | | PayID Discovery URL | +--------------------------+ | v +--------------------------+ | Query | +-----| PayID Discovery URL |-----+ | +--------------------------+ | | Success | | | v | +---------------------------+ Failure | Parse PayID Metadata | | +---------------------------+ | | | v | +---------------------------+ | | Select PayID URI Template | | +---------------------------+ | | v v +--------------------------+ +---------------------------+ | Manual PayID Discovery | | Assemble PayID URL | +--------------------------+ +---------------------------+ | | +---------------------+----------------+ | v +---------------------------+ | PayID URL | | https://example.com/alice | +---------------------------+
PayID Discovery utilizes the Webfinger [RFC7033] specification in a narrowly defined profile.
This document defines a PayID Discovery URL as being a Webfinger resource URI where the specified resource value is a valid PayID URI [PAYID-URI].
For example, the PayID Discovery URL for alice$example.com is
https://example.com/.well-known/webfinger? resource=payid%3Aalice%24example.com
A Webfinger query MUST be performed against the PayID Discovery URL, as described in section 4.2 of Webfinger.
In response, the WebFinger resource returns a JSON Resource Descriptor (JRD) as the resource representation to convey information about the requested PayID.
If the Webfinger endpoint returns a non-200 HTTP response status code, then interactive PayID Discovery is considered to have failed. Clients MAY attempt to assemble a PayID URL using "manual" mode as defined in section 4.2.1 of this document.
If the PayID Discovery server returns a valid response, the response will contain one or more of the JRDs defined in section 5 of this document.
If any of the JRDs contain a 'rel' value that represents a PayID URL Template, then that template value MUST be used in the next protocol step.
Failing the above, if the 'rel' value of any JRDs represents a PayID Discovery URL, then that URL MUST be used in step 2 above, repeated recursively if needed, until a valid PayID URI Template is obtained. That URI Template value MUST be used in the next protocol step.
A PayID URL is constructed by applying the PayID URI to the PayID URI Template string obtained in the step above. The PayID URI template MAY contain a URI string without any variables to represent a host-level PayID URL that is identical for every PayID URI on a particular host.
For example, a PayID Discovery endpoint that only supports a single account might use a URI template string with no variables, like this:
{ "rel": "https://payid.org/ns/payid-uri-template/1.0", "template": "https://example.com/alice" }
The result of this step is the PayID URL. Once obtained, PayID Discovery is considered to have completed successfully.
This specification defines a simple template syntax for PayID URI transformation. A template is a string containing brace-enclosed ("{}") variable names marking the parts of the string that are to be substituted by the corresponding variable values.
This specification defines a one variable – "acctpart" – which corresponds to the 'acctpart' of a PayID URI as defined in [PAYID-URI].
When substituting the 'acctpart' value into a URI 'path' as defined by [RFC3986], values MUST NOT be percent or otherwise encoded because the 'acctpart' value of a PayID URI always conforms to the character set allowed by paths in [RFC3986].
However, before substituting template variables into a URI 'query' part, values MUST be encoded using UTF-8, and any character other than unreserved (as defined by [RFC3986]) MUST be percent-encoded per [RFC3986].
Protocols MAY define additional variables and syntax rules, but MUST NOT change the meaning of the 'acctpart' variable. If a client is unable to successfully process a template (e.g., unknown variable names, unknown or incompatible syntax), the JRD SHOULD be ignored.
The template syntax ABNF is as follows:
uri-char = ( reserved / unreserved / pct-encoded ) var-char = ALPHA / DIGIT / "." / "_" var-name = %x<IP_ADDRESS>.<IP_ADDRESS> / ( 1*var-char ) ; "acctpart" or other names variable = "{" var-name "}" PAYID-URI-Template = *( uri-char / variable )
For example:
Input: alice$example.org Template: https://example.org/{acctpart} Output: https://example.org/alice
If "Interactive" mode is not supported or otherwise fails to yield a PayID URL, then a PayID URL MAY be assembled manually using the following predefined ruleset:
For example:
Input: bob.primary$example.org Output: https://example.org/bob.primary
The resulting URL is a PayID URL.
The following is a visual representation of the Fallback Assembly protocol flow:
+--------------------------+ | PayID URI | | alice$example.com | +--------------------------+ | v +--------------------------+ |Manual PayID URL Assembly | +--------------------------+ | v +---------------------------+ | PayID URL | | https://example.com/alice | +---------------------------+
This document defines two JRDs that conform to section 4.4 of the Webfinger RFC.
This type of JRD can be used to represent a URL that is a PayID Discovery URL. This is useful for delegating PayID Discovery to another service endpoint:
The following is an example of a JRD that indicates a PayID Discovery URL:
{ "rel": "https://payid.org/ns/payid-discovery-url/1.0", "href": "https://delegate.example.com/.well-known/webfinger?resource= payid%3Aalice%24example.com" }
This type of JRD can be used to represent a URL that is a PayID URL Template.
The following is an example of a JRD that indicates a PayID URI Template:
{ "rel": "https://payid.org/ns/payid-uri-template/1.0", "template": "https://example.com/{acctpart}" }
Various security considerations should be taken into account for PayID Discovery.
Among other resource, consult section 9 of [RFC7033] and section 7 of [RFC3986] for important security considerations involved in PayID Discovery.
As with most services provided on the Internet, it is possible for a domain owner to utilize "hosted" WebFinger services. Consult section 7 of [RFC7033] for considerations that could apply to both "manual" and "interactive" PayID Discovery when hosted by a third-party.
PayID Discovery resources might not be accessible from a web browser due to "Same-Origin" policies. See section 5 of [RFC7033] for CORS considerations that apply to both "manual" and "interactive" PayID Discovery modes.
As with all web resources, access to the PayID Discovery resource could require authentication. See section 6 of [RFC7033] for Access Control considerations that could apply to both "manual" and "interactive" PayID Discovery modes.
This document defines the following Link relation types per [RFC7033]. See section 3 for examples of each type of Link.
This document was heavily influenced by, and builds upon, Webfinger [RFC7033] (adapted for a payments use-case) as well as the supporting RFCs that it relies upon and that influenced it, especially [RFC5988] and [RFC6415]. The author would like to acknowledge the contributions of everyone who worked on those and any related specifications.
In addition, the author would like to acknowledge everyone who provided feedback and use-cases for this derivative specification.
| [PAYID-URI] | Fuelling, D., "The 'payid' URI Scheme", n.d.. |
| [RFC2119] | Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997. |
| [RFC3986] | Berners-Lee, T., Fielding, R. and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, DOI 10.17487/RFC3986, January 2005. |
| [RFC4627] | Crockford, D., "The application/json Media Type for JavaScript Object Notation (JSON)", RFC 4627, DOI 10.17487/RFC4627, July 2006. |
| [RFC6570] | Gregorio, J., Fielding, R., Hadley, M., Nottingham, M. and D. Orchard, "URI Template", RFC 6570, DOI 10.17487/RFC6570, March 2012. |
| [RFC7033] | Jones, P., Salgueiro, G., Jones, M. and J. Smarr, "WebFinger", RFC 7033, DOI 10.17487/RFC7033, September 2013. |
| [RFC7230] | Fielding, R. and J. Reschke, "Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing", RFC 7230, DOI 10.17487/RFC7230, June 2014. |
| [RFC5988] | Nottingham, M., "Web Linking", RFC 5988, DOI 10.17487/RFC5988, October 2010. |
| [RFC6415] | Hammer-Lahav, E. and B. Cook, "Web Host Metadata", RFC 6415, DOI 10.17487/RFC6415, October 2011. |


call psb_sum(icontxt, dat, root)
This subroutine implements a sum reduction operation based on the
underlying communication library.
- Type:
- Synchronous.
- On Entry
-
- icontxt
- the communication context identifying the virtual
parallel machine.
Scope: global.
Type: required.
Intent: in.
Specified as: an integer variable.
- dat
- The local contribution to the global sum.
Scope: global.
Type: required.
Intent: inout.
Specified as: an integer, real or complex variable, which may be a
scalar, or a rank 1 or 2 array. Type, kind, rank and size must agree on all processes.
- root
- Process to hold the final sum, or to make it available
on all processes.
Scope: global.
Type: optional.
Intent: in.
Specified as: an integer value
, default -1.
- On Return
-
- dat
- On destination process(es), the result of the sum operation.
Scope: global.
Type: required.
Intent: inout.
Specified as: an integer, real or complex variable, which may be a
scalar, or a rank 1 or 2 array.
Type, kind, rank and size must agree on all processes.
Notes
- The
dat
argument is both input and output, and its
value may be changed even on processes different from the final
result destination.
- The
dat
argument may also be a long integer scalar.


Real World Algorithms
Chapters
Assignments
Translations
Slides
Errata
{% block content %}{% endblock %}
{% include 'analytics.html' %}


typeCast keyboard is a russian keyboard mapper to US keyboard layout, that can be extended to other user layouts and other target languages.
typeCast was built for multilingual support, is platform agnostic and can be used as offline access.
Write a sentence in russian below.
Напишите предложение на русском языке ниже.


The ChessGameController is a central and important module; it sets the state of the game, of the player and the board. This module co-ordinates with modules like ChessPlayer, BoardLayout, Board and PieceCreator to constantly control the state of the current game. It calls the BoardLayout module to set the initial state of the board.
It sends out a call to the PieceCreator module to create and render the pieces in game as they are in their initial state. It tracks the status, team and pieces of the chess players by calling the ChessPlayer module. The ChessGameController can be thought of as a main class which calls and implements various other subclasses.
As seen above it creates objects of the above mentioned modules and implements them. It uses these modules to create the starting layout and place pieces, count number of pieces, who they belong to.
While the ChessGameController module deals with the overall state and game creation by calling other modules, the BoardLayout modules actually creates the initial layout and board state. The BoardLayout module is responsible for the state of the board. It acts as sort of a sub class and the main function which is the ChessGameController calls an object of the BoardLayout and implements it.
BoardLayout assigns variables and tracks which team the piece belongs to (black or white), along with which piece it is (rook, king etc.).
It allows other modules like the Board and ChessGameController module to get position co-ordinates, piece name (king) and piece colour (white). It calculates the position co-ordinates, piece name (king) and piece colour (white) and returns this information through member functions. These functions can be invoked or used by other modules when by calling an object of BoardLayout class.
The BoardLayout module can be thought of as a service provider of board information, for other modules to use.
This Function performs the move after a piece is selected, if a user is selecting a piece he can perform these 4 things TryToTakeOppositePiece , UpdateBoardOnPieceMove, MovePiece , deselectPiece , endTurn.
CalcuateCoordsFromPosition function is calculating the coordinates in the range of 0-7
OnSquareSelected function is used if a square is already selected and user is again selecting it so in result it should be deselected and if user is trying to move a piece then the selected piece should be moved to the new coordinates .
If a user is trying to take a piece this function will remove that piece. The Board Layout contains all the main functionality of the game.


Using ebic
Currently ebic can be used only as a command line tool.
In order to build a program simply run:
$ make
Check our 'input.txt' data file to see the required input file format. In order to run an example simply type:
$ ./ebic -i input.txt
The basic usage of ebic is:
$ ./ebic [OPTIONS]
To override any of default options extra arguments should be added:
Options:
-
-i,--input TEXT input file (required!)
-
-n,--iterations INT number of iterations [default: 5000]
-
-b,--biclusters INT number of biclusters [100]
-
-x,--overlap FLOAT overlap threshold [0.75]
-
-g,--gpus INT number of gpus [1]
-
-a,--approx FLOAT approximate trends acceptance ratio [0.85]
-
-t,--negative-trends INT negative trends [1]
-
-l,--log is logging enabled [false]
Input
Input files are expected to have a row and a column headers, the values need to be separated by whitespace. The current release of ebic doesn't handle missing values. Check our toy file (input.txt) for the required file format.
Outputs
ebic writes to its working directory two text files: [input_filename]-res and [input_filename]-blocks.
The first output file contains in its first line the number of detected biclusters and in consecutive lines each bicluster identifiers in the following format.
Bicluster([row0 row1 ... ],[column0, column1, ...])
The second file extracts the actual values of the bicluster from the dataset. Its format is as follows:
BC[bicluster_number] [number_of_rows x number_of columns]
Extracted part of the input dataset with rows and columns labels of the bicluster.


{% extends "errors/base.html" %} {% set seotitle = "503 Service unavailable" %} {% block container %}
All form submits are blocked.
We apologize, but this is required to update the site correctly.
Normally, it will take a several minutes to finish the process.
Please, try again later!


Mark R. Brown
Open Market, Inc.
Document Version: 1.08
11 June 1996
FastCGI is an open extension to CGI that provides high performance for all Internet applications without the penalties of Web server APIs.
FastCGI is designed to be layered on top of existing Web server APIs. For instance, the mod_fastcgi Apache module adds FastCGI support to the Apache server. FastCGI can also be used, with reduced functionality and reduced performance, on any Web server that supports CGI.
This FastCGI Developer's Kit is designed to make developing FastCGI applications easy. The kit currently supports FastCGI applications written in C/C++, Perl, Tcl, and Java.
This document:
The kit includes a technical white paper, doc/fastcgi-whitepaper/fastcgi.htm. You should read at least the first three sections of the technical white paper before starting to write FastCGI applications. The performance paper will help you understand how application design affects performance with FastCGI.
The FastCGI Specification, doc/fcgi-spec.html, defines the interface between a FastCGI application and a Web server that supports FastCGI. The software in the kit implements the specification. You don't need to read the specification in order to write applications.
Additional information is provided in the FAQ document, which contains frequently asked questions about application development using FastCGI, as well as some general information.
Experience with CGI programming will be extremely valuable in writing FastCGI applications. If you don't have enough experience with CGI programming, you should read one of the popular books on the topic or study the NCSA CGI page. For a more formal treatment of CGI/1.1 see the Internet Draft CGI 1.1 Specification.
The kit is a compressed tar (tar.Z) file, distributed via the fastcgi.com Web page. Unpacking the tar file creates a new directory fcgi-devel-kit.
Open the kit's index page, fcgi-devel-kit/index.html, using the "Open File" command in your Web browser. The index page gives you an overview of the kit structure and helps you navigate the kit. The index page also contains links that run some example applications, but the applications won't work when index.html is opened using the "Open File" command because they aren't aren't being accessed through a Web server.
In order to use the kit in earnest you'll need a Web server that you control, a Web server running with your user ID. The Web server will be starting FastCGI applications that you will need to debug; this will be a lot more convenient for you if these processes run with your user ID. It is best to have a Web server that supports FastCGI. Section 4 discusses Web server issues.
If you can, keep the kit on a file system accessible from your personal workstation, do your builds on your workstation, and run your Web server on your workstation. If that's not possible, arrange a configuration such that the kit is accessible from the machine that's going to run your Web server, and build the kit and your applications on a machine that's configured exactly the same way (same processor architecture, operating system, etc.) as the machine that's going to run your Web server.
To build the kit you execute this sequence of commands in the fcgi-devel-kit directory:
% ./configure % make
We've built and exercised the kit on these platforms (listed in alphabetical order):
Once you've built the kit, follow the directions in Section 4 to bring up your Web server and run the example applications.
The fcgi_stdio library provides the easiest transition for C CGI programs and C CGI programmers to FastCGI. Using this library your application can run using either CGI or FastCGI, with the same binary for both situations.
To introduce the fcgi_stdio library we give a pair of examples: a tiny CGI program and the translation of this program to FastCGI. These two example programs are included in the kit.
The CGI program is examples/tiny-cgi.c:
#include <stdio.h> #include <stdlib.h> void main(void) { int count = 0; printf("Content-type: text/html\r\n" "\r\n" "<title>CGI Hello!</title>" "
CGI Hello!
" "Request number %d running on host %s\n", ++count, getenv("SERVER_NAME")); }
The key features of this tiny CGI program are:
The count variable is degenerate in this example; the CGI program runs a single request, so the request number is always one. This variable will be more interesting in the FastCGI example.
The corresponding FastCGI program is examples/tiny-fcgi.c:
#include "fcgi_stdio.h" #include <stdlib.h> void main(void) { int count = 0; while(FCGI_Accept() >= 0) printf("Content-type: text/html\r\n" "\r\n" "<title>FastCGI Hello!</title>" "
FastCGI Hello!
" "Request number %d running on host %s\n", ++count, getenv("SERVER_NAME")); }
The key features of this tiny FastCGI program are:
The count variable increments each time through the loop, so the program displays a new request number each time. You can use the reload button in your browser to demonstrate this, once you've got the program built and running.
If you can build examples/tiny-cgi.c, it will be straightforward for you to build examples/tiny-fcgi.c. You need to:
See examples/Makefile (created by configure) for a Makefile that builds both programs. Autoconf handles the platform-dependent linking issues; to see how, examine configure.in and examples/Makefile.in.
Section 4 is all about how to run FastCGI applications.
You can use CGI to run application binaries built with the fcgi_stdio library. The FCGI_Accept function tests its environment to determine how the application was invoked. If it was invoked as a CGI program, the first call to FCGI_Accept is essentially a no-op and the second call returns -1. In effect, the request loop disappears.
Of course, when a FastCGI application is run using CGI it does not get the benefits of FastCGI. For instance, the application exits after servicing a single request, so it cannot maintain cached information.
fcgi_stdio.h works by first including stdio.h, then defining macros to replace essentially all of the types and procedures defined in stdio.h. (stdio.h defines a few procedures that have nothing to do with FILE *, such as sprintf and sscanf; fcgi_stdio.h doesn't replace these.) For instance, FILE becomes FCGI_FILE and printf becomes FCGI_printf. You'll only see these new names if you read fcgi_stdio.h or examine your C source code after preprocessing.
Here are some consequences of this implementation technique:
#ifndef _STDIO_H #define _STDIO_H
The specific symbol used for multiple-include protection, _STDIO_H in this example, varies from platform to platform. As long as your platform protects stdio.h against multiple includes, you can forget about this issue.
gcc -include /usr/local/include/fcgi_stdio.h wonderlib.c
causes gcc to include fcgi_stdio.h before it even begins to read the module wonderlib.c.
FILE *myStream = fopen(path, "r"); answer = MungeStream(FCGI_ToFile(myStream));
Here MungeStream is a library function that you can't recompile and FCGI_ToFile is a macro that converts from FCGI_FILE * to FILE *. The macro FCGI_ToFile is defined in fcgi_stdio.h.
The main task in converting a CGI program into a FastCGI program is separating the code that needs to execute once, initializing the program, from the code that needs to run for each request. In our tiny example, initializing the count variable is outside the loop, while incrementing the count variable goes inside.
Retained application state may be an issue. You must ensure that any application state created in processing one request has no unintended effects on later requests. FastCGI offers the possibility of significant application performance improvements, through caching; it is up to you to make the caches work correctly.
Storage leaks may be an issue. Many CGI programs don't worry about storage leaks because the programs don't run for long enough for bloating to be a problem. When converting to FastCGI, you can either use a tool such as Purify from Pure Software to discover and fix storage leaks, or you can run a C garbage collector such as Great Circle from Geodesic Systems.
Currently there are some limits to the compatibility provided by the fcgi_stdio library:
FILE *myStream = fopen(path, "r"); count = fscanf(FCGI_ToFile(myStream), format, ...);
The FCGI_Accept manpage, doc/FCGI_Accept.3, describes the function in the traditional format.
The FCGI_Finish (doc/FCGI_Finish.3), FCGI_SetExitStatus (doc/FCGI_SetExitStatus.3), and FCGI_StartFilterData (doc/FCGI_StartFilterData.3) manpages document capabilities of the fcgi-stdio library that are not illustrated above.
The fcgiapp library is a second C library for FastCGI. It does not provide the high degree of source code compatibility provided by fcgi_stdio; in return, it does not make such heavy use of #define. fcgi_stdio is implemented as a thin layer on top of fcgiapp.
Applications built using the fcgiapp library cannot run as CGI programs; that feature is provided at the fcgi_stdio level.
Functions defined in fcgiapp are named using the prefix FCGX_ rather than FCGI_. For instance, FCGX_Accept is the fcgiapp version of FCGI_Accept.
Documentation of the fcgiapp library takes the form of extensive comments in the header file include/fcgiapp.h. The sample programs examples/tiny-fcgi2.c and examples/echo2.c illustrate how to use fcgiapp.
A major advantage of the FastCGI approach to high-performance Web applications is its language-neutrality. CGI scripts written in popular languages such as Perl and Tcl can be evolved into high-performance FastCGI applications.
We have produced FastCGI-integrated Perl and Tcl interpreters. Doing so was easy, since Perl and Tcl are conventional C applications and fcgi_stdio was designed for converting conventional C applications. Essentially no source code changes were required in these programs; a small amount of code was added in order to make FCGI_Accept and other FastCGI primitives available in these languages. And because these interpreters were developed using fcgi_stdio, they run standard Perl and Tcl applications (e.g. CGI scripts) as well as FastCGI applications.
See the fastcgi.com Web page for more information about the Perl and Tcl libraries.
Here are the Perl and Tcl versions of tiny-fcgi:
#!./perl use FCGI; $count = 0; while(FCGI::accept() >= 0) { print("Content-type: text/html\r\n\r\n", "<title>FastCGI Hello! (Perl)</title>\n", "
FastCGI Hello! (Perl)
\n"; "Request number ", ++$count, " running on host ";$env(SERVER_NAME)"); }
#!./tclsh set count 0 while {[FCGI_Accept] >= 0 } { incr count puts -nonewline "Content-type: text/html\r\n\r\n" puts "<title>FastCGI Hello! (Tcl)</title>" puts "
FastCGI Hello! (Tcl)
" puts "Request number $count running on host $env(SERVER_NAME)" }
Converting a Perl or Tcl CGI application to FastCGI is not fundamentally different from converting a C CGI application to FastCGI. You separate the portion of the application that performs one-time initialization from the portion that performs per-request processing. You put the per-request processing into a loop controlled by FCGI::accept (Perl) or FCGI_Accept (Tcl).
Java is not just for browser-based applets. It is already suitable for writing some Web server applications, and its range of applicability will only grow as Java compilers and other Java tools improve.
The FCGIInterface class provides facilities for Java applications analogous to what fcgi_stdio provides for C applications. Using this library your Java application can run using either CGI or FastCGI.
The kit includes separate companion document on using FastCGI with Java. The source code for FastCGI classes is contained in directory java/src and the compiled code in java/classes.
Here is the Java version of tiny-fcgi:
import FCGIInterface; class TinyFCGI { public static void main (String args[]) { int count = 0; while(new FCGIInterface().FCGIaccept()>= 0) { count ++; System.out.println("Content-type: text/html\r\n\r\n"); System.out.println( "<title>FastCGI Hello! (Java)</title>"); System.out.println("
FastCGI Hello! (Java)
"); System.out.println( "request number " + count + " running on host " + System.getProperty("SERVER_NAME") + ""); } } }
For a current listing of Web servers that support FastCGI, see the fastcgi.com Web page.
Some of the Web servers that support FastCGI perform management of FastCGI applications. You don't need to start and stop FastCGI applications; the Web server takes care of this. If an application process should crash, the Web server restarts it.
Web servers support FastCGI via new configuration directives. Since these directives are server-specific, get more information from the documentation that accompanies each server.
The program cgi-fcgi allows you to run FastCGI applications using any Web server that supports CGI.
Here is how cgi-fcgi works. cgi-fcgi is a standard CGI program that uses Unix domain or TCP/IP sockets to communicate with a FastCGI application. cgi-fcgi takes the path name or host/port name of a listening socket as a parameter and connects to the FastCGI application listening on that socket. cgi-fcgi then forwards the CGI environment variables and stdin data to the FastCGI application, and forwards the stdout and stderr data from the FastCGI application to the Web server. When the FastCGI application signals the end of its response, cgi-fcgi flushes its buffers and exits.
Obviously, having cgi-fcgi is not as good as having a server with integrated FastCGI support:
But cgi-fcgi does allow you to develop applications that retain state in memory between connections, which often provides a major performance boost over normal CGI. And all the applications you develop using cgi-fcgi will work with Web servers that have integrated support for FastCGI.
The file examples/tiny-fcgi.cgi demonstrates a way to use cgi-fcgi to run a typical application, in this case the examples/tiny-fcgi application:
#!../cgi-fcgi/cgi-fcgi -f -connect sockets/tiny-fcgi tiny-fcgi
On most Unix platforms, executing this command-interpreter file runs cgi-fcgi with arguments -f and examples/tiny-fcgi.cgi. (Beware: On some Unix platforms, including HP-UX, the first line of a command-interpreter file cannot contain more than 32 characters, including the newline; you may need to install the cgi-fcgi application in a standard place like /usr/local/bin or create a symbolic link to the cgi-fcgi application in the directory containing your application.) The cgi-fcgi program reads the command-interpreter file and connects to the FastCGI application whose listening socket is examples/sockets/tiny-fcgi.
Continuing the example, if cgi-fcgi's connection attempt fails, it creates a new process running the program examples/tiny-fcgi and listening on socket examples/sockets/tiny-fcgi. Then cgi-fcgi retries the connection attempt, which now should succeed.
The cgi-fcgi program has two other modes of operation. In one mode it connects to applications but does not start them; in the other it starts applications but does not connect to them. These modes are required when using TCP/IP. The cgi-fcgi manpage, doc/cgi-fcgi.1, tells the full story.
To run the example applications using cgi-fcgi, start your Web server and give it the directory fcgi-devel-kit as the root of its URL space. If the machine running your server is called bowser and your server is running on port 8888, you'd then open the URL http://bowser:8888/index.html to reach the kit's index page. Now the links on the index page that run example applications via cgi-fcgi should be active.
On Digital UNIX 3.0 there's a problem with Unix domain listening sockets on NFS file systems. The symptom when using cgi-fcgi is an exit status of 38 (ENOTSOCK: socket operation on non-socket), but cgi-fcgi may dump core in this case when compiled optimized. Work-around: Store your Unix domain listening sockets on a non NFS file system, upgrade to Digital UNIX 3.2, or use TCP sockets.
On AIX there's a problem with shared listening sockets. The symptoms can include application core dumps and kernel panic. Work-around: Run a single FastCGI application server per listening socket.
The mailing list fastcgi-developers is used for discussions of issues in developing FastCGI applications. Topics include announcement of FastCGI-capable Web servers or changes to such servers, announcement of new application libraries or changes to such libraries, announcement of known bugs, discussion of design trade-offs in FastCGI application programming, and discussion of development plans and experiences. To join the list, see http://fastcgi.com/fastcgi-developers.
A link to a mail archive can be found on the FastCGI home page, http://www.fastcgi.com


From everyday essentials to rare imports, our partnered suppliers are ready to ensure your kitchen and staff have everything they need to make your business thrive. Business relationships are an important part of any succesful venture. We at Chicago Food Distributors not only want to help find the products and suppliers you need, but also help you find invaluable business partners along the way.
With our ever expanding network of suppliers, we can cover the Chicagoland area in all directions. Think you're out of reach? Enter where you are looking for service in the Extra Information section of the form.
"I was finally able to move on from my previous supplier of ten years! I had no idea there were so many suppliers around town."
"Not only was I able to cut my restaurants kitchen costs, but we also expanded to a second location with the savings".
"Finding new business partners increased our revenue by 30% and allowed me to give my staff raises across the board!"


?IMAGED
yoÇ>
BOTANICAL
Garder
FLORA
OF
DESECHEO
\S.f
PUERTO
RICO
HERBARIUM
of
the
AGRICULTURAL
EXPERIMENT
STATION
Mayagez
Campus,
University
of
Puerto
Rico,
Rio
Piedras
Family
;
5^poTVe-e,ae
No
:
,P-5
0ã
Name:
L,
^
e-A
1
a.
ok
o
v
a~ta.
(.L
Pf.
JU1
1
Z1968
Locality:
Date:
Coll:
R-O-Woodbury-L.F.Martoren
NEW
YORK
BOTANICAL
GARDEN
Observations
:
39
00843'
00843139
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Format: TexCoord Left, Right, Up, Bottom,
Example: TexCoord 0, 1, 0, 0.125,
Purpose: Uses only a fraction of the given Image. the given Numbers are factors from 0 to 1. with left 0.0 and right 0.5 Up 0 and bottom 1; The Left Side of an Image would be taken skiping the Right part from the center. That gained Fraction Image is that stretched to the frames Size. It is suggested to open the used image with something like GIMP select the wanted space change to show percent.
Purpose: One can produce a tiled image using numbers bigger than 1 for right and bottom.
Example: TexCoord 0, 2, 0, 2,
Used in: Texture(SIMPLEFRAME)


Before looking at the buildDisplay() method, it is helpful to understand how Repast actually sets up and draws displays. Setting up Repast for drawing consists of several steps. The first of these is creating what you want to be drawn. Usually, these are agents and their environment. As mentioned in How To Build a Repast Model agents etc. are created in buildModel(). Also in buildModel() these agents are added to some sort of space, a Object2DTorus for example, and sometimes a list. Then in buildDisplay() the display (e.g. Object2DDisplay) appropriate to the space is created and the space is added to that display. The list, if it exists, is also added to the display. The display itself is then added to a DisplaySurface either as a displayable or as a displayableProbeable depending on whether probing is to be performed on the objects contained by the space in the display. (The DisplaySurface itself should be created in the model's setup() method. In short then, after buildDisplay() you have a DisplaySurface containing displays that contain spaces that contain the objects to be displayed.
With this structure setup then, the actual drawing sequence is as follows. The updateDisplay method is called on the DisplaySurface object. Typically, this call is scheduled and the scheduling mechanism makes the call. Having received this call, the DisplaySurface object tells all the displays it contains to display themselves. Having received this call, the displays either gets a list of all the objects in the space that they contain, or if a list of objects was added, they just use that list. The display then requests some drawing information (coordinates, etc.) from each object in the list, sets up the drawing surface using this information, and then tells each object in the list to draw itself. These objects then draw themselves. In order for a display to display an object it expects the drawable object to implement certain methods. These methods vary slightly according to the display and are encapsulated in one or another of the drawable interfaces. A mapping of which interfaces to use with which spaces and displays is given below.
As mentioned in How To Build a Repast Model the display is usually created in the buildDisplay() method. A very simple buildDisplay() might look like:
public void buildDisplay() {
Object2DDisplay agentDisplay = new Object2DDisplay(world);
agentDisplay.setObjectList(agentList);
dsurf.addDisplayableProbeable(agentDisplay, "Agents");
addSimEventListener(dsurf);
}
where world is a space, an Object2DTorus populated with agents, agentList is a simple list of agents, and dsurf is a DisplaySurface, all having been created previously in buildModel() or in the case of dsurf in setup(). Here the display is created and as part of its construction the space "world" added to it. Then agentList is also added to it for display. This display, agentDisplay, is then added to the DisplaySurface dsurf as both a displayable and a probeable. As a displayable dsurf will display agentDisplay in the manner outlined above. As a probeable dsurf will allow probing on the agents contained in the space, in this case world, contained by agentDisplay. The final method adds dsurf to the model as a listener for stop and pause events. This allows dsurf to know when the model is stopped or paused and behave accordingly. It may seem redundant to add both agentList and world to agentDisplay. It is not, however, because spaces do more than provide displays with lists of objects to display, they also take part in the probing mechanism.
The Text Display
The TextDisplay differs
from the other displays in that it does not display a space. Rather,
it used to display text on the DisplaySurface. You specify what text
to display and the TextDisplay will display that text.
Setting up a TextDisplay works as follows:
td = new TextDisplay(20, 20, Color.yellow);
dsurf.addDisplayableProbeable(td, "text");
This creates a TextDisplay which will display text at the specified x
and y coordinates (20, 20) and in yellow. This kind of code would
typically occur in your buildDisplay() method. "td" here is
an instance variable of your model class. Note that the coordinates
refer to pixels and not to grid cell locations. The TextDisplay
"td" is then added to the DisplaySurface just like any other
display. By default the text is displayed inside a rectangle of the
same color as the text. This rectangle can be moved around the display
using the mouse. You specify the text to display using the
addLine(String line)
method. This adds text without
removing previously added text. To remove any previously added text,
you use the clearLines()
method. The addition of new text
is typically done as part of a scheduled action in order that the text
reflect the new state of the model. For example,
td.clearLines();
td.addLine("tick count: " + getTickCount());
The above would be scheduled to occur every tick, and thus would display a new tick count value each tick of the model.
There are variations on the addLine
and
clearLines
methods as well as methods for turning the
rectangle on and off. See the API docs for more
info.
Taking Snapshots and Making Movies
Repast can be used to take snapshots, that is gif images of the
current display, as well as make quicktime movies using the display as
it changes over the course of a run. All this functionality is
available through the DisplaySurface
class. You can either manually setup your simulation to take snapshots
and create movies, or use the buttons provided in the Repast Action
tab. What follows is a description of manual setup.
To setup the display surface for taking shapshots, you would call
dsurf.setSnapshotFileName(some_fileName);
in buildDisplay(). A DisplaySurface will use this name as the base for the the actual gif file or files. Then in the buildSchedule() method you schedule the DisplaySurface to actually take snapshots of the display at the tick of the simulation. For example given a DisplaySurface dsurf,
schedule.scheduleActionAtInterval(100, dsurf,
"takeSnapshot");
dsurf will now create gifs of the display at every 100 ticks of the simulation. The resulting gif files will be some_fileName_tick_count.gif. For example, heatbugpic100.gif.
You can also take snapshots of the Repast charting objects (OpenSequenceGraph and OpenHistogram) in a nearly identical way. Simply substitute the variable names of your charting objects for dsurf in the above.
Making movies is similar. To prepare a DisplaySurface for making a movie you would call
dsurf.setMovieName(movie_name,
DisplaySurface.QUICK_TIME);
And to actually turn the display at certain simulation tick into a frame of the movie, you need to schedule the addMovieFrame on a DisplaySurface.
schedule.scheduleActionAtInterval(10, dsurf,
"addMovieFrame");
which will take the display every 10 ticks and make a movie frame from it. At the moment only quicktime movies are supported. The resulting movie file will be whatever the movie_name was in setMovieName combined with the extension appropriate to the type of movie. For example, "heatBugMovie.mov". You must also explicitly send the closeMovie message to the DisplaySurface. For example,
schedule.scheduleActionAtEnd(dsurf,
"closeMovie");
while will send the closeMovie message at the end of the simulation. When the movie has finished writing itself to a file, you will see the message box informing you of this. Do not exit the simulation until you see and click on the message box.
Making movies of the Repast chart objects is not supported as this time.
The Repast action tab can be used to automate taking snapshots and making movies of your DisplaySurfaces or charting objects. Clicking on the appropriate button on the Repast action tab will present you with a self-explanatory series of choices. However, in order for this to work, you'll need to pay some attention to how these objects are created in your setup() method. In general you'll need to create these objects in the setup method and register them as DisplaySurfaces or MediaProducters. DisplaySurfaces should be registered as DisplaySurfaces and the charting objects as MediaProducers. For example,
private void setup() {
...
dsurf = new DisplaySurface(this, "Sugar Scape");
registerDisplaySurface("Sugar Scape", dsurf);
bar = new OpenHistogram("Agent Wealth Distribution", 10, 0, this);
graph = new OpenSequenceGraph("Agent Attributes", this, "./graph_data.txt",
Statistics.CSV);
registerMediaProducer("Hist", bar);
registerMediaProducer("Plot", graph);
...
}
Registering an object or DisplaySurface allows it to be displayed as available as a source of snapshots and movies. Clicking the "take Snapshot" button in the Repast Actions tab allows you to choose from among these registered objects as sources of snapshots. In the above case you'd have a choice of one or all of "Sugar Scape", "Hist", or "Plot".
Note: at this time making movies of charting objects is not supported.
Drawable, Space and Display Mappings
Use the following table to determine what interface to implement on
your agents when using a particular space and display. So for example,
if your agents inhabit an Object2DTorus
you would use an Object2DDisplay
and the agents inhabiting the Object2DTorus would have to implement
the Drawable
interface.
| Space | Display | Interface |
| Object2DGrid | Object2DDisplay | Drawable |
| Object2DTorus | Object2DDisplay | Drawable |
| Object2DGrid | Network2DGridDisplay |
Nodes: Drawable2DNode
Edges: DrawableEdge |
| Object2DTorus | Network2DGridDisplay |
Nodes: Drawable2DGridNode
Edges: DrawableEdge |
| Diffuse2D | Value2DDisplay | N/A. Map to values to a ColorMap instead. |
| Multi2DGrid | MultiObject2DDisplay | Drawable |
| Multi2DTorus | MultiObject2DDisplay | Drawable |
| OrderedMulti2DGrid | MultiObject2DDisplay | Drawable |
| OrderedMulti2DTorus | MultiObject2DDisplay | Drawable |
| Object2DHexagonalGrid | Object2DHexaDisplay | Drawable |
| Object2DHexagonalTorus | Object2DHexaDisplay | Drawable |
| DiffuseHexagonal2D | Value2DHexaDisplay | N/A. Map to values to a ColorMap instead. |
| RasterSpace | Object2DDisplay | Drawable |
Network display is discussed in the Network Models document.