|
This is the personal web site of
John Henry Thompson.
I want to make it easy for people to use the computer as an
expressive instrument, and to inspire people to learn about
themselves and the world.
current & future
background
|
I like to see how the pixels work, that's why this image looks
so fuzzy...
|


This will display useful information.
close
Share with your friends:
close
You are offline.
Help
Share
#
logout


Application Data Exchange Assessment Framework and Functional Requirements for Mobile Health - Local Development build (v0.1.0). See the Directory of published versions
This section describes how an Actor can be assessed for conformance to this guide.
Conformity assessment must be readily reproducible across different assessors. It should be measurable against each requirement, as well as through groups of requirements in a functional area or category. However, pass/fail conformity assessment (e.g., as is done for UL Listing or CE Mark) is generally insufficient when there is great diversity in end-user requirements. Thus, this guide takes the approach that there are multiple levels of “conformance”, as has been done with other specifications.
Some IETF specifications (known as Requests for Comments or RFC) have distinguished between conforming and fully conforming to the specification. A conforming system implements all SHALL requirements, but a fully conforming system implements all SHALL and SHOULD requirements. The distinction is useful, but the terminology used is subtle and may not be easily understood for users not familiar with this usage. It shows up in a few commonly used RFCs, but is not common, and the distinction would lost on those not familiar with standards conformity assessment in general.
This guide describes a more user friendly stars rating system on an ordinal scale of 1 to 5. However, unlike some stars rating systems which simply based on aggregated ratings of subjective assessors, this guide defines a rating system which is based on objective criteria, which should be more readily reproducable across different assessors.
The following demonstrates the scoring: where 0 stars is fully non-conforming, 1 star meets some requirements, 2 starts meets most of the requirements, 3 stars meets all required criteria, 4 meets all required criteria and some degree of recommended criteria, and 5 stars meets all required criteria, and most or all of the recommended criteria.
For the purposes of this guide, most is defined as 50% or more. [should this be higher? –KWB]
Each requirement criterion is individually measured on a pass/fail basis, and includes one or more scenarios containing GIVEN/WHEN/THEN statements describing how to perform the test. Only SHALL and SHOULD criteria are used in this assessment. Criteria using MAY or NEED NOT are merely present to clarify allowed behavior and describe optional behaviors for which there is no value judgment. These criteria are often provided to clarify to implementors nuances that might be confusing without further explanation.
For any given requirement, if any test scenario fails, the SUT fails to conform to the requirement. Otherwise the SUT conforms to this requirement.
The results of conformance testing for a given SUT include:
A given requirement may not be applicable to a given SUT, or the assessor may not have performed a specified test on the SUT (e.g., because test sponsor did not require those tests be performed).
For example, there is a requirement that the results of a blood pressure measurement be displayed to the user. This is a requirement of an App, but is NOT a requirement of a Device. Thus, the results for this test would be reported as Not Applicable. In another case, the there are requirements on devices to be able to report blood pressure, heart rate, and respiration rate. However, these three observations are not reported by all devices, and aren’t always needed for every use case. Thus, a clinic evaluating devices for use in blood pressure monitoring may elect to Not Test a device against the sub-category containing requirements on respiration rate. In this case, the test was not performed.
For more clarity: The inability of a device to record respiration rate does not make the test “not applicable” when the category for basic device operations is chosen. This is a failure of the device to support that function. This does NOT indicate a flaw in the device. It merely reports the device’s inability to support that requirement.
As in laboratory diagnostics, tests provide objective evidence. Assessments perform computations on those results to enable interpretation of test results. The 0-5 star rating of a system is the assessment, the pass/fail status for each requirement are the tests.
The procedure for computing assessments is as follows. For a group of requirements (e.g., a category or sub-category):
To report the assessment, the following values should be provided:
These values provide the interpretation of the result (the star ranking), and allow sub-category results to be aggregated upwards to category results. Assessments can be computed at a category even when some of the sub-category tests have not been performed. In this case, the testing for the category must be recorded as being incomplete (and this status will propagate upwards to the next category and so on).
Technical specifications such as FHIR or CDA Implementation guides can also be tested using this guide, regulatory and other requirements, and even clinical guidelines can be assessed against this guide. However, because these are specifications, not systems, they require additional considerations when computing reporting assessments and results. What is important for implementers of a specification is to be able to determine the difference between what is minimally required, what can be supported with additional effort, and what simply cannot be done.
Two sets of results must be computed and assessed. The first set of results report what the specification under test requires (the minimal results). The second set of results report what the specification allows (the maximal results). An assessment is reported for each of these possible results. The minimal results show how the assessment would perform against an actual implementation conforming to the specification without any additional work. The maximal results show how the assessment would perform against an actual implementation that started off by conforming to the specification being tested, but was augmented to ensure conformance to this guide.
Consider evaluating the FHIR Observation Vital Signs and the AMA IHMI Observation Blood Pressure requirements, against both the Basic and Clinical Blood Pressure Observation requirements of this guide.
A FHIR Observation Resource conforming to either of these two guides guide will get 5 stars when evaluated against the the Basic Blood Pressure Observation. One can safely choose an implementation meeting either one and expect that it will meet those requirements.
However, a FHIR Observation resource meeting only the minimum necessary requirements of the FHIR Observation Vital Signs profile will NOT meet the requirements of the Clinical Blood Pressure requirements of this guide, it will likely get two stars. But, one conforming to the AMI IHMI Observation Blood Pressure 3 requirements will meet the more stringent guidelines in the Clinical Blood Pressure requirements (it will receive 3 or more stars). Thus, if your application needs to meet the clinical blood pressure requirements of this guide, and you have access to an implementation meeting the AMI IHMI Observation Blood Pressure 3 requirements, then that should be the way to go (when other considerations are not relevant).
Even so, the FHIR Observation Vital Signs profile does not prohibit one from creating a FHIR Observation resource that also conforms to the Clinical Blood Pressure Observation requirements of this guide. The distance between these two represents a certain amount of effort that must be expended to go that final step. That effort may need to be weighed against the cost of acquiring an implementation supporting the more demanding profile.
Given two requirements S and G, where S describes the implementation guide being tested, and G describes a scenario this guide:
The assessment results for the maximal case will always be at least as good as the assessment results for the minimal case. Reporting both assessments enables users who may have access to an implementation supporting S to also support G, and to assess how much additional work is needed to make the output of the implementation of S support G.
For a given criteria group in this guide, the reporting recommendations are as follows:
Display the category name, followed by a number of filled stars given by the assessment ranking in green (or black for B&W images). Follow that by a number of open stars outlined in red (or black for B&W images) necessary to ensure that there are always 5 stars displayed. After the stars include three - four numbers reported in the following form: {SHALL-passed}+{SHOULD-passed}/{SHALL-total}+{SHOULD-total}
Indent categories under subcategories if they are displayed in the same area.
An example report is given below:
Physical Activity and Sleep 1+2/6+6
Physical Activity 0+1/3+3
Sleep 1+1/3+3
Basic Vital Signs 10+3/11+11
Basic SPO2 2+1/3+3
Basic Respiration and Pulse 3+0/3+3
Basic Blood Pressure 3+1/3+3
Basic Height and Weight 2+1/2+2
Display the category name, followed by a number of stars filled in red (or black for B&W images) given by the minimal assessment ranking. Follow that by a number of filled stars in yellow (or light-gray screen in B&W images) necessary to bring the total up to the maximal assessment ranking (this may be 0). Follow that by a number of open stars outlined in red (or black for B&W images) necessary to ensure that there are always 5 stars displayed. After the stars include three - six numbers reported in the form: {SHALL-min-passed}-{SHALL-max-passed}+{SHOULD-min-passed}-{SHOULD-max-passed}/{SHALL-total}+{SHOULD-total}
When min-passed and max-passed are the same value, they should be reported as a single number.
Indent categories under subcategories if they are displayed in the same area.
An example report is given below:
Physical Activity and Sleep 1+2/6+6
Physical Activity 0+1/3+3
Sleep 1+1/3+3
Basic Vital Signs 10-11+4-9/11+11
Basic SPO2 2-3+1-3/3+3
Basic Respiration and Pulse 3+0-2/3+3
Basic Blood Pressure 3+1-3/3+3
Basic Height and Weight 2+1-2/2+2
NOTE: Colors for Red, Green and Yellow should be selected from a color-blind safe pallette.
Gherkin describes a language that is used for testing
applications. The core of this language is made up of three keywords GIVEN
, WHEN
and
THEN
and the conjunction AND
structured into scenarios (or examples) to test a specific feature.
This guide describes a requirement using the Feature: keyword in Gherkin.
Requirements can further be broken down into specific business rules using the Rule: keyword to describe a business rule under test. When rules are used, if any rule fails, the entire feature fails.
Each test is provided using the Scenario: keyword to describe how the feature can be tested.
Descriptive text will follow the Feature, Rule, or Scenario to provide more detailed information. This guide uses Rationale: as a keyword to explain the reason why a particular feature is important. Sometimes requirements are obvious, and including the rationale for a particular requirement aids in communicating the need for a feature.
The keywords have the following meanings:
AND
at the start of the next line (and subsequent lines).AND
or to reverse the logic of the
condition BUT
.This guide uses tags to identifier the actors to which a feature is applicable. The form of these tags is @{Actor-Name}[-{Shall|Should}]
When only the actor name is given, the feature represents a Shall requirement, as in @App below. This can be made explicit by using @App-Shall instead.
Specific rules or scenarios can also be marked with these tags to create rules specific to the actors to which they are applied.
An example requirement is provided below.
@App @Device-Should
Feature: User data SHALL be hidden after a period of inactivity.
This example illustrates the form of a Functional Requirement. Each requirement will be recorded as a feature in Gherkin. The heading preceding the requirement will provide the requirement identifier and name. Requirement identifiers are numbered in sequence, and preceded by a short mnemonic that identifies the requirement category. This example requirement has the identifier EX-1, and the name “Example Feature”. Rationale: User data should not be exposed when a user is not interactive with the device or application. Hiding the screen prevents user data from being exposed.
Rule: A screen saver must be present that SHALL hide the users data after a configurable period of time has elapsed.
Scenario: Example Scenario
GIVEN
the screen saver is configured to hide the screen after 5 minutes.
WHEN
the time period has elapsed
THEN
screen is hidden,
AND
the user must reenter their password to resume work,
BUT
the user is not logged out.
Rule: If the user does not configure the screen saver, then the default timeout period SHALL be used.
Scenario: Default Scenario
GIVEN
the screen saver has NOT been configured by the user
WHEN
the default timeout period has elapsed
THEN
screen is hidden,
AND
the user must reenter their password to resume work,
BUT
the user is not logged out.


...an urban sensing platform that aims to take advantage of the reach and regularity of public transportation to collect data about a city. Using a off-the-shelf microcontrollers for computation, Bluetooth Low Energy for communication, and machine learning for analysis, we created a modular system that can seamlessly integrate arbitrary sensor functions through hardware peripherals.
An IR depth sensor + accelerometer detect potholes and irregularities in roads
A door-mounted IR sensor measures passenger departure and dispersion at each bus stop
Rooftop particle sensors measure air pollution and the existance of toxic chemicals.
A rooftop sound detector captures the noise levels in different parts of the city.
2.4 GHz Wifi
Every piece of sensor data originates at a sensor and is sent over to the Atmega via the specific protocol for that sensor, ADC for IR and sound, and SPI for the accelerometer. From there, the Atmega sends the data to the Rpi via I2C. The reciever on the Pi caches a local copy in Redis as well as offloading another copy to the server. The server then saves it to our time series InfluxDB. The celery jobs then see new data is available and start to stream process it, saving it in Postgres after completion. Lastly, the map and metrics server queries Postgres to finally display the data in a meaningful way.
Aatish Nayak
Riya Savla
Ridhi Surana
Chris Wei


In Ruby, everything is an object. If you want to interact with these objects or change them in some you can use methods. You can create your own methods but Ruby also has a huge bank of predefined methods that you can call on as you like. Different objects use different types of methods. Objects that are a collection of items, like an array or a hash, use a specific type of method to preform an action on each individual item within them. These methods are called enumerables. We're going to be looking at how the #map enumerable works. Well start with a simple array:
array = [1, 2, 3, 4, 5]
Now lets say we want to add 1 to every item in this array. We can do this using #map. First we will call the #map enumerable method on our array and then pass it a block of code that we want it to preform on our array.
array = [1, 2, 3, 4, 5]
p array.map {|x| x+1}
# => [2, 3, 4, 5, 6]
p array
# => [1, 2, 3, 4, 5]
So we can see that #map behaved exactly how we expected it to by adding 1 to each element in the array. However, on the third row when we checked the value of array again, we can see it stayed the same.
This is a nice feature of #map. It does not alter the original array but rather clones it and preforms it's block of code on the new clone.
If you want to change the original array though, no worries! Just slap an exclamation mark on the end of #map and you've done it.
array = [1, 2, 3, 4, 5, 6, 7]
p array.map! {|x| x+1}
# => [2, 3, 4, 5, 6]
p array
# => [2, 3, 4, 5, 6]
So there you go, you can now effect great change within your collections.


Web APIs
The following standard APIs are supported by Crosswalk on both Android and Tizen since Crosswalk <IP_ADDRESS>.
Version key:
[t] = Tizen only;
[a] = Android only
[X.X.X.X] = this Crosswalk version or later
[X.X.X.X;x86|ARM] = this version or later for the specified architecture.
Runtime & Packaging
Multimedia & Graphics
- CSS Animations - Animate CSS properties over time using keyframes.
- CSS Backgrounds and Borders Level 3 - CSS features for borders and backgrounds.
- CSS Color Module Level 3 - CSS features for color values and properties.
- CSS Flexible Box Layout - A CSS box model for user interface design.
- CSS Fonts Level 3 - Font properties and dynamic font resource loading.
- CSS Multi-column Layout - Multi-column layouts with CSS.
- CSS Text Decoration Level 3 - Text decoration CSS features.
- CSS Transforms - Change the position of content in 3D space without disrupting the normal flow using CSS.
- CSS Transitions - Enables property changes in CSS values over time.
- HTML Canvas 2D Context - An API for 2D immediate mode graphics.
- HTML5 Audio/Video - Audio and Video support without plugins.
- Media Queries Level 3 - CSS media features for adapting the same content to different output devices and screens.
- Scalable Vector Graphics (SVG) 1.1 - An XML markup language for 2D vector graphics.
- WebRTC[a] [<IP_ADDRESS>;x86] - Peer to peer sharing of video and audio streams.
Networking & Storage
- File API - Asynchronously read the contents of files or raw data buffers stored on the client.
- File API: Directories and System - Expose a sandboxed filesystem on the client.
- File API: Writer - Write files to a sandboxed sandboxed filesystem on the client.
- HTML5 Web Messaging - A mechanism for communicating between browsing contexts.
- Indexed DB - An asynchronous client-side storage API for fast access to large amounts of structured data.
- Messaging[a] - Allows SMS and MMS message sending and receiving.
- Online State - Online and offline events for the network state.
- Web SQL - Store data in databases on the client using a variant of SQL.
- Web Sockets - A low overhead bi-directional communication with web servers over a persistent TCP connection.
- Web Storage - A simple synchronous client-side storage API for storing name-value pairs.
- XMLHttpRequest - Transfer data between a client and a server programmatically over HTTP.
Performance & Optimization
- Navigation Timing - Access timing information related to navigation and elements.
- Page Visibility[a] - Programmatically determine the visibility state of the web application.
- Resource Timing - Access timing information related to HTML elements.
- Selectors Level 1 and Level 2 - Retrieve elements from the DOM using CSS selectors.
- Typed Array 1.0 - Data types for raw binary data for performance-critical tasks.
- Web Workers - Run scripts in parallel to the main page.
Device & Hardware
- Device Orientation Events - DOM events which provide information about the physical orientation and motion of the device.
- Fullscreen - Programmatically instruct an element on the page to be presented in full screen mode.
- Geolocation - Access geographical location information associated with the hosting device.
- HTML5 Date and Time state for input element[a] - Picker controls for date and time input types.
- HTML5 Telephone, Email and URL state for input element[a] - Picker controls for telephone, email and URL input types.
- Media Capture and Streams[a] - Provides access to local media streams including video (camera) and audio (microphone).
- Screen Orientation - Enables screen orientation locking and provides access to screen orientation data and events.
- Touch Events - Handle touch events programmatically.
- Vibration[<IP_ADDRESS>] - Programmatically control a device's vibration mechanism.
- Web Notifications[<IP_ADDRESS>] - Use the device's native notification mechanism (e.g. status bar on Android) to display messages to the user.
Social
Experimental APIs
In addition to the standard APIs, Crosswalk provides additional experimental or emerging standards APIs to further support building a native application experience using web platform technologies.
- Device Capabilities - Retrieve information about the underlaying system.
- Launch Screen[<IP_ADDRESS>] - Display a static user interface on application launch and hide it when the application is ready.
- Presentation API[a] - Access external displays from within web applications. For more information see the Presentation API developer documentation.
- Raw Sockets - Raw TCP and UDP sockets for client and server sides.
- SIMD[<IP_ADDRESS>] - Data types and operations for access to the Single Instruction Multiple Data (SIMD) instruction sets available on common CPU architectures, such as SSE (IA32/X64) and NEON (ARMv7). Note that the implementation to generate NEON instructions is not done.
Tizen Extension APIs
In addition to the experimental Crosswalk APIs, the Crosswalk developers have created a Crosswalk extension for Tizen users which provides many of the Tizen APIs. You can find information on those APIs on the Tizen Extension APIs page.
Some content in the Standard APIs section of this page has been adapted from chromestatus.com, © 2013 The Chromium Authors, used under Creative Commons Attribution 2.5 license


We use one image to which we applied a filter for a different color. Mouvement are calculated with vetors function offered by WCP.


fun update(serverInstance: ServerInstance): Job
Tell repositories to update their content, but not so aggressively (E.g. Don't display errors). Called when active server is added, or an old server is now active.


Bill Belichick shows he never forgets with trolling of Lane Johnson
by Mark CannizzaroWho says Bill Belichick doesn’t read the newspapers, watch TV or have a sense of humor?
After his team beat the Eagles Sunday in Philadelphia, the Patriots coach delivered a deadpan special as he trolled Eagles tackle Lane Johnson with a read-between-the-lines zinger.
To review: After the Eagles beat the Patriots in Super Bowl LII two seasons ago, Johnson, on a podcast, tweaked the rigid “Patriot Way,” saying, “I just think that the Patriot Way is a fear-based organization. Obviously, do they win? Hell yes, they win. They’ve won for a long time. Do I think people enjoy [it] and can say, ‘I had a lot of fun playing there?’ No, I don’t. I’d much rather have fun and win a Super Bowl than be miserable and win five Super Bowls.”
Enter Belichick and his elephant-like memory on Sunday.
“It looked like everyone had fun out there today and we played with a lot of good energy, and it was good to come down here and get a win,” Belichick told reporters.
Anyone who doesn’t believe that wasn’t an intentional (albeit subtle) shot doesn’t believe Tom Brady is an elite quarterback. Every strained morsel that comes from Belichick’s mouth is calculated.
It was amusing — and “fun” — to see Belichick’s well-played tweak, which was a break from the monotony of his usual array of dismissive one-word non-answers.


Dialogs can be created dynamically with any component as the content using a DialogService.
Dynamic dialogs require an instance of a DialogService that is responsible for displaying a dialog with a component as its content. Since the dynamically loaded content is not defined at build time, a configuration is necessary using the entryComponents of your parent module. Example below, displays a list of cars using the CarsListDemo component so it needs to be configured at entryComponents along with the import of DynamicDialogModule. The configuration of the demo page is as follows;
Next step, is injecting an instance of a DialogService to the component that will open the dialog.
Displaying a dialog is done with the open method where the first parameter is the type of component to load and the second parameter is the configuration of the Dialog such as header, width and more.
In case you need to pass data to the component that is dynamically loaded, use the data property that can be access using the DynamicDialogConfig class. In additon, the loaded component can also control the Dialog using the DynamicDialogRef API. Both the DynamicDialogConfig and DynamicDialogRef are injectable using the constructor.
Most of the time, requirement is returning a value from the dialog. DialogRef's close method is used for this purpose where the parameter passed will be available at the onClose event at the caller. Here is an example on how to close the dialog from the CarsListDemo by passing a selected car.
Now at the class that opens the dialog, the selected car gets passed to the Observable.
Dynamic Dialogs provide the following customization options.
| Name | Type | Default | Description |
|---|---|---|---|
| data | any | null | An object to pass to the component loaded inside the Dialog. |
| header | string | null | Header text of the dialog. |
| footer | string | null | Footer text of the dialog. |
| width | string | null | Width of the dialog. |
| height | string | null | Height of the dialog. |
| closeOnEscape | boolean | true | Specifices if pressing escape key should hide the dialog. |
| baseZIndex | number | 0 | Base zIndex value to use in layering. |
| autoZIndex | boolean | true | Whether to automatically manage layering. |
| dismissableMask | boolean | false | Specifices if clicking the modal background should hide the dialog. |
| rtl | boolean | false | When enabled dialog is displayed in RTL direction. |
| style | string | null | Inline style of the component. |
| contentStyle | string | null | Inline style of the content section. |
| styleClass | string | null | Style class of the component. |
| transitionOptions | string | 400ms cubic-bezier(0.25, 0.8, 0.25, 1) | Transition options of the animation. |
| closable | boolean | true | Adds a close icon to the header to hide the dialog. |
| showHeader | boolean | true | Whether to show the header or not. |
| Name | Parameters | Description |
|---|---|---|
| onClose | event: Event object | Callback to invoke when dialog is closed. |
| onDestroy | event: Event object | Callback to invoke when dialog is destroyed. |
Following is the list of structural style classes, for theming classes visit theming page.
| Name | Element |
|---|---|
| p-dialog | Container element |
| p-dynamicdialog | Container element |
| p-dialog-titlebar | Container of header. |
| p-dialog-title | Header element. |
| p-dialog-titlebar-icon | Icon container inside header. |
| p-dialog-titlebar-close | Close icon element. |
| p-dialog-content | Content element. |
| p-dialog-footer | Footer element. |
None.


--- layout: view description: "ball3D" categories: [canvas,lib] --- your browser do not support canvas


Welcome
A good web developer needs a good text editor or an IDE. Here are a number of options you can chose from. All of the following are available on both Mac and Windows, unless otherwise stated.
A good web developer needs a good text editor or an IDE. Here are a number of options you can chose from. All of the following are available on both Mac and Windows, unless otherwise stated.
Aptana Studio 3 is a professional IDE. It features HTML, CSS and JavaScript code assist, The IDE also provides wizards for deployment to Heroku or Engine Yard, as well as support for FTP clients. It brings along an integrated terminal and a debugger as well as git integration for version control
Atom is a text editor developed in Electron. Atom is a lightweight cross platform. It's highly extensible with a built in package manager. Atom also provides multiple panes and autocompletion to help improve your productivity.
Brackets is an Electron app designed for web development. It is lightweight and modern, yet powerful and extensible.
Sublime is one of the most popular text editors available. Written in C++, it is very fast. Sublime comes with thousands of extensions you can install as you desire. Sublime is free for use but it's creator does ask for a one time payment.
Created by JetBrains, the same people behind Pycharm, Webstorm is a powerful JavaScript IDE. Webstorm has powerful code completion, on-the-fly error detection and refactoring tools for JavaScript, Typescript, stylesheet languages and the top frameworks such as Vue, React and Angular. But you better bust out the wallet, Webstorm is about $169.
VS Code is lightweight and powerful and my personal favorite. It is highly extensible with thousands of plug ins to chose from. The syntax highlighting is consistent. It integrates wellw with ESLint, pointing out errors and offering suggestions and it comes with an integrated terminal that allows you to run your build tools right inside the editor. Built by Microsoft using Electron, VS Code is free.


Preparation time
30 mins to 1 hour
Cooking time
1 to 2 hours
Serves
Makes 24
Dietary
Serve these summery petits fours with coffee at the end of a dinner party, or as special tea time treats.
For the pastry, pulse the flour, icing sugar and butter in a food processor until the mixture resembles fine breadcrumbs. Add the vanilla seeds and pulse briefly. Remove from the food processor and pour the crumbs into a large bowl. Add the eggs and use a blunt knife to form a paste. Roll into a ball, flatten, cover in cling film and chill in the fridge for 30 minutes.
For the gooseberry and elderflower jam, place a saucer in the freezer.
Smear the bottom of a large saucepan with the butter, then add the gooseberries and water and simmer for 15 minutes or until the gooseberries are tender. Reduce the heat, add the sugar and stir until well combined. Let this mixture heat through until the sugar has dissolved then increase the heat and boil for 8-10 minutes. Remove the pan from the heat and drop a teaspoon of the mixture onto the chilled saucer - you are looking for a skin to form on the surface once it has cooled. If it hasn’t, continue to boil, checking every five minutes, until the setting point is reached. Put the jam into a bowl and allow the mixture to cool a little before stirring in the cordial.
Preheat the oven to 180C/350F/Gas 4. Grease two 12-hole petit four tins.
Roll the pastry out thinly on a floured work surface and use it to line the petit four tins. Chill in the fridge for 30 minutes.
Meanwhile, for the frangipane, beat the eggs in a jug and set aside. Beat the butter and sugar until light and fluffy then add the beaten eggs a little at a time until well combined. Stir in the ground almonds.
Spoon a little jam into the bottom of the tart cases, cover with a little frangipane then bake in the oven for 15 minutes or until the filling is just beginning to set. Arrange the flaked almonds in a flower pattern on top of the tarts then return them to the oven for 10-15 minutes or until golden-brown. Cool on a wire rack.


| PostgreSQL Tcl Interface Documentation | ||||
|---|---|---|---|---|
| Prev | Fast Backward | Fast Forward | Next |
pg_escape_string
quotes a string and escapes single quotes and backslashes within the string, making it safe for inclusion into SQL statements.
If you're doing something like
pg_exec $conn "insert into foo values ('$name');"
and name
contains text includeng an unescaped single quote, such as Bob's House, at best the insert will fail, and at worst your software will be exploited via an SQL injection attack. Passing value strings through pg_escape_string
will properly quote them for insertion into SQL commands.
pg_exec $conn "insert into foo values ([pg_escape_string $name]);"
...will make sure that any special characters that occur in name, such as single quote or backslash, will be properly quoted.
Returns the string, escaped for inclusion into SQL queries. Note that it adds a set of single quotes around the outside of the string as well.
In most cases, with recent versions of SQL, it is better to use the native parameter insertion capabilities of the SQL server and protocol. If you are using a version of PostgreSQL more recent then 7.4, consider the optional parameter arguments to pg_exec and pg_sendquery, and the paramarray option to pg_exec, pg_sendquery, and pg_select.


{% include 'toolbar.html' %}
{% include 'profile.html' %} {% include 'logout-button.html' %}
Tell everybody what you're up to! What's new? What's changed?
{% csrf_token%} {{ form.as_p }}


ViewMarriageActivity()
Activity for displaying the details of a marriage.
This activity is not responsible for editing a marriage: for such cases, EditMarriageActivity should be started for result (it will return the new/updated object to the calling activity).
While this activity does not deal with editing a marriage, it does provide the option to edit the person being displayed by starting EditMarriageActivity for result. Consequently, thisactivity should be started for result, because it could return an updated person object to thecalling activity.


CEO’s Message
We have a broad and diversified customer base ranging from farmers who make a living in our country’s towns and villages and whose agricultural endeavors create value for all of us to corporate customers whose exports contribute to the national economy, from the SMEs that are the backbone of our economy to people engaged in every sort of occupation. The products, services, and solutions that we provide to this huge group ourselves and through the subsidiaries that make up the Ziraat Finance Group shape the future of our country as much as they do its present while our strategic decisions and actions contribute as much to the efficient functioning of markets as they do to economic stability.
One of the fundamental innovations that we have achieved under the heading of our sustainability-related efforts is that, as a result of a comprehensive study that takes into account the views of both our internal and external stakeholders, we have identified a set of sustainability priorities that we believe will affect Ziraat Bank’s success in the future as much as it does today.
On the basis of our prioritization findings, details of which are presented in the appropriate sections of this report, market- and customer-focus rank foremost among the issues that are of key importance to Ziraat Bank’s performance. This result, which is the shared opinion of our stakeholders, coincides with the fundamental objective of the strategic transformation program that our Bank has been conducting for the last three years. That is because, given the competitive conditions that prevail nowadays, a service provider’s sustainable future and strong performance are possible if and only if there also exists a strategy which puts one’s customer at the focal point of everything and which seeks to maximize the value that one proposes to offer.
In addition to market- and customer-focus, our prioritization study also revealed that our rich array of banking products and services, our extensive geographical reach and degree of customer access, and our diversified deposit base also rank high among the reasons why customers prefer Ziraat Bank. Other issues cited by our stakeholders as being as crucial to Ziraat Bank’s future performance as to that of the present are: specific support for agriculture as embodied in Ziraat Bank’s mission, provision of services to the SMEs and entrepreneurs who are so important to the national economy, safeguarding customer data, and effective corporate governance and risk management in a manner that also embraces sustainability management.
The priorities that emerged from this study are important not just for our Bank but for all of the members of the Ziraat Finance Group as well. These findings will serve as our guide when shaping our roadmap and strategies in the period ahead and will also play a significant role in further strengthening our ability to create added value.
This year Ziraat Bank once again concentrated on integrating its sustainability approach into all aspects of its banking business. As a result of the efforts made in line with this, Ziraat Bank further developed its banking products and services, introduced innovative new products to the market, streamlined its service processes and made them more efficient, and–most important of all–came up with new solutions that addressed its customers’ needs. While continuing to develop our organizational structure in response to current needs and expand our service network, our primary focus was on making additional improvements in our customers’ service experience.
What individuals and companies alike demand is banking-market products that are easily accessible, understandable, comparable, and consumer-friendly. For this reason, Ziraat Bank engages in an ongoing effort to satisfy that demand for every customer segment in every business line in which it is active.
Similarly the new internet banking modules which we recently brought online and which we are continuing to develop have been received with high levels of customer appreciation and satisfaction. Each and every product, service, and process that we digitize by integrating technology into every aspect of our business processes achieves tremendously important gains for us in terms of improving our resource efficiency, environmental performance, and overall productivity. Besides enabling us to make the best and most productive use of our resources, this approach also leads to substantial savings in our costs.
In 2014 we launched our “Banking Without Barriers” project, whose aim is to give our customers with disabilities a better and more comfortable banking experience and which we believe to be extremely important in terms of its social benefits. We are focusing our attentions on giving such customers more convenient access to our banking products and services through such means as physical changes at our service venues, call buttons, Braille-equipped information panels, specially-designed ATM units, and an online branch that can be used by the visually impaired.
In 2014 we completed worthy projects aimed at managing not just our carbon footprint but our entire ecological footprint in the best and most efficient way possible while also achieving significant savings in the process. One of the most important inputs that a bank uses is paper. The digitalization projects that we have been conducting over the last few years have led to extremely important gains and enabled us to achieve substantial savings in paper consumption. Similarly and as a result of changes that have been made, we have achieved notable improvements in water, electricity, and natural gas consumption in the conduct of our headquarters services operations.
All of the activities which I have summarized here we see as being important progress towards the fulfillment of our sustainability goals and we therefore regard 2014 as a year in which we advanced surefootedly in the direction of making Ziraat Bank a more customer-focused bank.
Thus it gives me pleasure to say that the progress we achieved throughout 2015, demonstrates our commitment to fulfilling our promise to be “Turkey’s oldest new bank”. The results that we have achieved– particularly in terms of customer- and market-focus–show that we are making sound progress consistent with our goals and that our customers, who make up our core stakeholder group, are demonstrating an ever-greater preference for the Ziraat brand.
Recognizing that change is a never-ending journey and aware of the need to constantly renew itself and adapt to today’s tough competitive environment. Ziraat Bank continued to advance together with its stakeholders in 2014.
The Change and Transformation Project that Ziraat Bank launched in 2012 reached a new stage in 2014 that may be summed up by its “Moving Forward Together” watchword. The efforts to implement the infrastructural change and corporate transformation components of that project will continue in the future as well.
The goal of the Ziraat Change and Transformation Project is to shepherd the Ziraat Finance Group’s essential Corporate Banking, Branch Banking, and International Banking operations into the future and finalize the group’s global transformation. Under this project, our Bank’s sustainability priorities are rooted in the principles of sound customer relationship management, institutionalized business processes, operational excellence, objective and transparent human resources management, effective information technology, and of course a strong balance sheet. That being so, efforts were made in line with the Annual Strategic Roadmap, which was laid out to guide the bank towards its strategic goals and which is overseen by the Strategic Steering Committee, and enduring value was created as a result.
With respect to integrating globally-accepted sustainability principles into our business processes, we will be continuing to add environmental and social risk-management criteria to our lending processes and to undertake new projects in order to incorporate a wider range of dimensions into our structural development.
Having been a leading and trend-setting industry actor for a hundred and fifty-two years, Ziraat Bank intends to remain one in the future as well. Our Bank calls upon the strengths of its extensive service network, professional management team, strong corporate governance, in-depth market acumen, unrivalled knowledge and experience, and-most important of all-rock-solid brand as it continues to shape the future.
Both the banking industry as a whole and the other domains of financial services in which the subsidiaries that make up the Ziraat Finance Group are active in particular necessarily interact with the swiftly changing and evolving demands of the global and national economies.
The rapid developments to which we are witness today clearly point to the birth of a new global economic balance. That process will continue to affect not just our country but our business as well. At the same time, we regard all of the top issues on the world’s sustainability agenda-but especially the impairment and misuse of natural resources together with climate change and global warming-as both risks and opportunities for both Ziraat Bank and its stakeholders alike.
Today we stand more ready than ever to work with our stakeholders in order to properly manage our risks and business opportunities and to make use of both in order to power our performance. We regard 2015 and the years that follow as a crucially important period in which our potential will impact on our performance. We intend to continue engaging in a multidimensional effort in line with our sustainability priorities and to generate increasingly more synergies throughout the Ziraat Finance Group. In this way, we will also be creating increasingly more value that we can share with our stakeholders and with our country as a whole.
In closing and speaking both personally and on behalf of the Ziraat Bank Board of Directors, I want to thank our employees for the efforts that are the enduring source of our performance, our customers for preferring to do business with us, and our other stakeholders for their confidence in the Ziraat name.
Very truly yours,
Hüseyin AYDIN
CEO


KDESTROY
Section: User Commands (1)Index Return to Main Contents
NAME
kdestroy - destroy Kerberos ticketsSYNOPSIS
kdestroy [-q] [-c cache_name]DESCRIPTION
The kdestroy utility destroys the user's active Kerberos authorization tickets by writing zeros to the specified credentials cache that contains them. If the credentials cache is not specified, the default credentials cache is destroyed.OPTIONS
- -q
- Run quietly. Normally kdestroy beeps if it fails to destroy the user's tickets. The -q flag suppresses this behavior.
- -c cache_name
-
use
cache_name
as the credentials (ticket) cache name and location; if this option is
not used, the default cache name and location are used.
The default credentials cache may vary between systems. If the KRB5CCNAME environment variable is set, its value is used to name the default ticket cache.
Most installations recommend that you place the kdestroy command in your .logout file, so that your tickets are destroyed automatically when you log out.
ENVIRONMENT
Kdestroy uses the following environment variables:- KRB5CCNAME
- Location of the Kerberos 5 credentials (ticket) cache.
FILES
- /tmp/krb5cc_[uid]
- default location of Kerberos 5 credentials cache ([uid] is the decimal UID of the user).
SEE ALSO
kinit(1), klist(1), krb5(3)BUGS
Only the tickets in the specified credentials cache are destroyed. Separate ticket caches are used to hold root instance and password changing tickets. These should probably be destroyed too, or all of a user's tickets kept in a single credentials cache.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:05 GMT, December 24, 2015


| Top |
| guint | accel-key | Read / Write |
| GtkCellRendererAccelMode | accel-mode | Read / Write |
| GdkModifierType | accel-mods | Read / Write |
| guint | keycode | Read / Write |
GObject ╰── GInitiallyUnowned ╰── GtkCellRenderer ╰── GtkCellRendererText ╰── GtkCellRendererAccel
GtkCellRendererAccel displays a keyboard accelerator (i.e. a key
combination like Control + a
). If the cell renderer is editable,
the accelerator can be changed by simply typing the new combination.
The GtkCellRendererAccel cell renderer was added in GTK+ 2.10.
GtkCellRenderer *
gtk_cell_renderer_accel_new (void
);
Creates a new GtkCellRendererAccel.
Since: 2.10
“accel-key”
property“accel-key” guint
The keyval of the accelerator.
Flags: Read / Write
Allowed values: <= G_MAXINT
Default value: 0
Since: 2.10
“accel-mode”
property“accel-mode” GtkCellRendererAccelMode
Determines if the edited accelerators are GTK+ accelerators. If they are, consumed modifiers are suppressed, only accelerators accepted by GTK+ are allowed, and the accelerators are rendered in the same way as they are in menus.
Flags: Read / Write
Default value: GTK_CELL_RENDERER_ACCEL_MODE_GTK
Since: 2.10
“accel-mods”
property“accel-mods” GdkModifierType
The modifier mask of the accelerator.
Flags: Read / Write
Since: 2.10
“keycode”
property“keycode” guint
The hardware keycode of the accelerator. Note that the hardware keycode is only relevant if the key does not have a keyval. Normally, the keyboard configuration should assign keyvals to all keys.
Flags: Read / Write
Allowed values: <= G_MAXINT
Default value: 0
Since: 2.10
“accel-cleared”
signalvoid user_function (GtkCellRendererAccel *accel, gchar *path_string, gpointer user_data)
Gets emitted when the user has removed the accelerator.
accel |
the object reveiving the signal |
|
path_string |
the path identifying the row of the edited cell |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.10
“accel-edited”
signalvoid user_function (GtkCellRendererAccel *accel, gchar *path_string, guint accel_key, GdkModifierType accel_mods, guint hardware_keycode, gpointer user_data)
Gets emitted when the user has selected a new accelerator.
accel |
the object reveiving the signal |
|
path_string |
the path identifying the row of the edited cell |
|
accel_key |
the new accelerator keyval |
|
accel_mods |
the new acclerator modifier mask |
|
hardware_keycode |
the keycode of the new accelerator |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.10


The product page provides all the details about a specified product. From here users can add the product to their cart for purchase.
With a generously rounded browline and flattering medium fit, Anders is a surefire crowd-pleaser.
Medium
48-20-145
$95 including prescription lenses

Frame Fit

Measurements

<button class="button-lg button__primary" type="button">Add to cart</button>

$ including prescription lenses

Our Promise

Free shipping and returns, always.</h1

We have a 30-day, no-questions-asked return policy for all our frames as well as a one-year, no-scratch guarantee for our lenses; we’ll replace your scratched lenses for free within the first 12 months.

Nothing but the best

Made from custom cellulose acetate and stainless steel

Cut from a single sheet of acetate to maintain color parity

Offer 100% UV protection

Akulon-coated screws for durability

Lenses made from polycarbonate, the most impact-resistant material for eyeglasses

Anti-scratch and anti-reflective coating included


| java.lang.Object | |
| ↳ | graph.Edge |
| Known Direct Subclasses |
An edge is a simple immutable object consisting of a head and tail vertex. Edges do not directly support
an associated edge weight. If a weight is needed, a
WeightedEdge
may be used instead. Edges may be inserted into a graph, and arrays of edges may be retrieved so that, for example, all edges
in the graph can be examined or those edges can be identified whose head is some particular vertex.
The vertices of an edge may be represented as either integers or letters of the alphabet. Integers must be used for graphs having
more than 26 vertices. If character representation is used, the edge should be constructed as in the example
Edge e = new Edge('r', 'u', true);
The toString()
method of such an edge will then return the string "(r, u)".
Although edges are inherently directed, the same Edge
objects are also used to describe edges of undirected graphs.
An edge in an undirected graph is viewed as the equivalent of 2 directed edges between the corresponding
vertices. More formally: An undirected graph contains the edge (from, to) iff it also contains the
edge (to, from). In an undirected graph, however, these 2 directed edges will be counted as a single edge when counting the number of
edges in the graph.
| Public Constructors | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
Edge(int from, int to) | ||||||||||
|
|
Edge(int from, int to, boolean charRep)
Construct an edge in which vertices may be represented by letters of the alphabet.
|
| Public Methods | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
charRep()
The edge uses letters of the alphabet rather than integers to represent vertices.
|
||||||||||
|
|
equals(Edge e)
The calling edge equals the argument edge e.
|
||||||||||
|
|
from()
Returns an integer corresponding to the head vertex of the edge.
|
||||||||||
|
|
to()
Returns an integer corresponding to the tail vertex of the edge.
|
||||||||||
|
|
toString()
Returns a string representation of the edge.
|
Construct an edge from vertex from to vertex to using integer
representation of vertices. The charRep()
method of an edge constructed in this way will return false.
java.lang.IllegalArgumentException
if the from or to argument is negative.Construct an edge from vertex from to vertex to using
character representation of vertices if charRep is set to true
or integer representation if charRep is false
.
The charRep()
method of an edge constructed in this way will return the value of charRep.
If charRep is set to true
, client programs will likely
prefer to use characters in the specification of
the head and tail vertices. For example:
Edge e = new Edge('r', 'u', true);
java.lang.IllegalArgumentException
if either of the following conditions holds:
true
and both from and to
are neither in the range 'a' - 'z' nor 'A' - 'Z'. This includes the case where one vertex is
in the range 'a' - 'z' and the other is in the range 'A' - 'Z'.Determine whether or not the edge represents vertices as letters or as integers.
Overrides the equals(Object o)
method
of java.lang.Object
.
2 edges are considered to be equal iff 1) they have the same head and tail vertices and 2) they represent vertices in the same form (as letters
or integers).
| e | edge in reference to which the calling edge is to be tested for equality. |
|---|
Determine the edge's head vertex as an integer value. If the edge uses character representation,
this value must be typecast to a char
in order to immediately determine the character
represented by the given integer.
Determine the edge's tail vertex as an integer value. If the edge uses character representation,
this value must be typecast to a char
in order to immediately determine the character
represented by the given integer.
Overrides the toString()
method
of java.lang.Object
.
Returns a string of the form "(u, v)" representing the calling edge. If the edge represents
vertices as characters (as determined by its charRep()
method), u
and v will be the corresponding letters.


Export your data
All your data are stored within the
health app
Then, simply use the
XML file
in the
homepage form
.


The starry Python API¶
Contents¶
Introduction¶
This page documents the starry
API, which is coded
in C++ with a pybind11
Python interface. The API consists
of a Map
class, which houses all of the surface map photometry
stuff, and a kepler
module, which connects photometry to
dynamics via a simple (multi-)Keplerian solver.
There are two broad ways in which users can access
the core starry
functionality:
Users can instantiate a
Map
class to compute phase curves and occultation light curves by directly specifying the rotational state of the object and (optionally) the position and size of an occultor. Users can specify spherical harmonic coefficients, limb darkening coefficients, or both. There is also support for both monochromatic and wavelength-dependent maps and light curves. This class may be particularly useful for users who wish to integratestarry
with their own dynamical code or for users wishing to compute simple light curves without any orbital solutions.Users can instantiate a
kepler.Primary
and one or morekepler.Secondary
objects and feed them into akepler.System
instance for integration with the Keplerian solver. Thekepler.Primary
andkepler.Secondary
classes inherit fromMap
, so users have access to all of the functionality of the previous method.
At present, starry
uses a simple Keplerian solver to compute orbits,
so the second approach listed above is limited to two-body systems or systems
where the secondary masses are negligible. Stay tuned for the next release
of the code, which will incorporate an N-body solver.
The Map class¶
-
class
starry.
Map
¶ Instantiate a
starry
surface map. The map is described as an expansion in spherical harmonics, with optional arbitrary order limb darkening. Users can set the spherical harmonic coefficients by direct assignment to thel, m
index of the map instance. Ifmap
is an instance of this class,map[1, 0] = 0.5
sets the coefficient of the \(Y_{1,0}\) harmonic to \(\frac{1}{2}\). Users can set limb darkening coefficients by direct assignment to the
l
index of the map:map[1] = 0.4
sets the first order limb darkening coefficient \(u_1\) to \(0.4\).
Note
Map instances are normalized such that the average disk-integrated intensity is equal to the coefficient of the \(Y_{0,0}\) term, which defaults to unity. The total luminosity over all \(4\pi\) steradians is therefore four times the \(Y_{0,0}\) coefficient. This normalization is particularly convenient for constant or purely limb-darkened maps, whose disk-integrated intensity is always equal to unity.
Warning
Note that the total degree of the map can never exceed
lmax
. For example, iflmax=5
and you set spherical harmonic coefficients up tolmax=3
, you may only set limb darkening coefficients up to second order.As of version 0.2.1,
starry
supports multi-wavelength maps via thenwav
keyword argument. If this argument is set to a value greater than one, light curves will be computed for each wavelength bin of the map. All coefficients at a given value ofl, m
and all limb darkening coefficients at a given value ofl
are now vectors, with one value per wavelength bin. Functions likeflux()
and__call__()
will return one value per wavelength bin, and gradients will be computed at every wavelength. Note that this feature is still experimental, so please raise an issue on GitHub if you run into any trouble.- Parameters
lmax (int) – Largest spherical harmonic degree in the surface map. Default 2.
nwav (int) – Number of map wavelength bins. Default 1.
multi (bool) – Use multi-precision to perform all calculations? Default
False
. IfTrue
, defaults to 32-digit (approximately 128-bit) floating point precision. This can be adjusted by changing theSTARRY_NMULTI
compiler macro.
-
__call__
(theta=0, x=0, y=0)¶ Return the specific intensity at a point
(x, y)
on the map. Users may optionally provide a rotation state. Note that this does not rotate the base map.
-
flux
(theta=0, xo=0, yo=0, ro=0, gradient=False)¶ Return the total flux received by the observer from the map. Computes the total flux received by the observer during or outside of an occultation.
- Parameters
theta (float or ndarray) – Angle of rotation. Default 0.
xo (float or ndarray) – The
x
position of the occultor (if any). Default 0.yo (float or ndarray) – The
y
position of the occultor (if any). Default 0.ro (float) – The radius of the occultor in units of this body’s radius. Default 0 (no occultation).
gradient (bool) – Compute and return the gradient of the flux as well? Default
False
.
- Returns
The flux received by the observer (a scalar or a vector). If
gradient
isTrue
, returns the tuple(F, dF)
, whereF
is the flux anddF
is a dictionary containing the derivatives with respect to each of the input parameters and each of the map coefficients.
-
rotate
(theta=0)¶ Rotate the base map an angle
theta
aboutaxis
. This performs a permanent rotation to the base map. Subsequent rotations and calculations will be performed relative to this rotational state.- Parameters
theta (float or ndarray) – Angle of rotation in degrees. Default 0.
-
show
(cmap='plasma', res=300)¶ Convenience routine to quickly display the body’s surface map.
- Parameters
Note
For maps with
nwav > 1
, this method displays an animated sequence of frames, one per wavelength bin. Users can save this to disk by specifying agif
keyword with the name of the GIF image to save to.
-
animate
(cmap='plasma', res=150, frames=50, interval=75, gif='')¶ Convenience routine to animate the body’s surface map as it rotates.
- Parameters
cmap (str) – The
matplotlib
colormap name. Defaultplasma
.res (int) – The resolution of the map in pixels on a side. Default 150.
frames (int) – The number of frames in the animation. Default 50.
interval (int) – Interval in milliseconds between frames. Default 75.
gif (str) – The name of the .gif file to save the animation to. If set, does not show the animation. Default
None
.
-
load_image
(image, lmax=None)¶ Load an array or an image from file. This routine loads an image file, computes its spherical harmonic expansion up to degree
lmax
, and sets the map vector. Alternatively, users may provide a two-dimensionalnumpy
array, structured such that the pixel at index(0, 0)
is at latitude \(+90^\circ\) and longitude \(180^\circ W\).- Parameters
Note
For maps with
nwav > 1
, users may specify anwav
keyword argument indicating the wavelength bin into which the image or array will be loaded.Load an array or an image from file. This routine loads an image file, computes its spherical harmonic expansion up to degree
lmax
, and sets the map vector. Alternatively, users may provide a two-dimensionalnumpy
array, structured such that the pixel at index(0, 0)
is at latitude \(+90^\circ\) and longitude \(180^\circ W\).- Parameters
Note
For maps with
nwav > 1
, users may specify anwav
keyword argument indicating the wavelength bin into which the image or array will be loaded.
-
load_healpix
(image, lmax=None)¶ Load a healpix image array. This routine loads a
healpix
array, computes its spherical harmonic expansion up to degreelmax
, and sets the map vector.- Parameters
Note
For maps with
nwav > 1
, users may specify anwav
keyword argument indicating the wavelength bin into which the image or array will be loaded.
-
add_gaussian
(sigma=0.1, amp=1, lat=0, lon=0, lmax=None)¶ Add the spherical harmonic expansion of a gaussian to the current map. This routine adds a gaussian-like feature to the surface map by computing the spherical harmonic expansion of a 3D gaussian constrained to the surface of the sphere. This is useful for, say, modeling star spots or other discrete, localized features on a body’s surface.
Note
Because this routine wraps a Python function, it is slow and should probably not be used repeatedly when fitting a map to data!
Warning
This routine is still in beta and may change in the near future.
- Parameters
sigma (float) – The standard deviation of the gaussian. Default 0.1
amp (float) – The amplitude. Default 1.0, resulting in a gaussian whose integral over the sphere is unity.
lat (float) – The latitude of the center of the gaussian in degrees. Default 0.
lon (float) – The longitude of the center of the gaussian in degrees. Default 0.
-
reset
()¶ Set all of the map coefficients to zero, except for \(Y_{0,0}\), which is set to unity.
-
lmax
¶ The highest spherical harmonic degree of the map. Read-only.
-
nwav
¶ The number of wavelength bins. Read-only.
-
multi
¶ Are calculations done using multi-precision? Read-only.
-
N
¶ The number of map coefficients, equal to \((l + 1)^2\). Read-only.
-
y
¶ The spherical harmonic map vector. This is a vector of the coefficients of the spherical harmonics \(\{Y_{0,0}, Y_{1,-1}, Y_{1,0}, Y_{1,1}, ...\}\). Read-only.
-
u
¶ The limb darkening map vector. This is a vector of the limb darkening coefficients \(\{u_1, u_2, u_3, ...\}\). Read-only.
-
p
¶ The polynomial map vector. This is a vector of the coefficients of the polynomial basis \(\{1, x, z, y, x^2, xz, ...\}\). Read-only.
-
g
¶ The Green’s polynomial map vector. This is a vector of the coefficients of the polynomial basis \(\{1, 2x, z, y, 3x^2, -3xz, ...\}\). Read-only.
-
r
¶ The current rotation solution vector r. Each term in this vector corresponds to the total flux observed from each of the terms in the polynomial basis. Read-only.
-
s
¶ The current occultation solution vector s. Each term in this vector corresponds to the total flux observeed from each of the terms in the Green’s basis. Read-only.
Note
For pure linear and quadratic limb darkening, the full solution vector is not computed, so this vector will not necessarily reflect the true solution coefficients.
-
axis
¶ A normalized unit vector specifying the default axis of rotation for the map. Default \(\hat{y} = (0, 1, 0)\).
The kepler module¶
The starry.kepler
module allows users to incorporate the
features of the starry.Map
class into a simple Keplerian
solver to model systems of stars, planets, or moons. The bodies in the
starry.kepler
module inherit from starry.Map
, so
all of the functionality outlined above is also available here.
-
class
starry.kepler.
Primary
¶ Instantiate a primary body. This body is assumed to be fixed at the origin. This class inherits from
Map
, so users can assign to and retrieve spherical harmonic and limb darkening coefficients in the same way. Refer to the documentation ofMap
for all options.-
r
¶ The radius of the primary body, fixed at unity.
-
L
¶ The luminosity of the primary body, fixed at unity.
-
tref
¶ A reference time in days. Several of the orbital elements are specified at this time.
-
prot
¶ The rotation period of the body in days. For non-rotating bodies, set this to
np.inf
(or zero).
-
lightcurve
¶ The computed light curve for this body. If
nwav = 1
, this is a timeseries vector of fluxes. Fornwav > 1
, this is a matrix whose columns are the timeseries in each wavelength bin.Note
Users must call the
compute
method of theSystem
object before accessing this attribute.
-
gradient
¶ The gradient of the body’s light curve. This is a dictionary of vectors (
nwav = 1
) or matrices (nwav > 1
). The dictionary keys are the names of all parameters of all bodies in the currentSystem
object, formatted asbody.parameter
, wherebody
isA
for the primary andb
,c
,d
, etc. for the secondaries. Theparameter
label is the name of the parameter.Note
Users must call the
compute
method of theSystem
object withgradient=True
before accessing this attribute.Note
The gradients with respect to map coefficients are stored as vectors in the y and u attributes of the gradient dictionary, starting with the first degree coefficients. The derivatives with respect to the constant terms \(Y_{0,0}\) and \(u_0\) are not computed, since those values are constant!
Note
Depending on the properties of a body’s map, not all map coefficient gradients may be computed. For instance, for purely limb-darkened maps (whose \(Y_{l,m}\) coefficients are zero for \(l > 1\)), the derivatives of the flux with respect to the spherical harmonic coefficients are not computed. This is entirely in the interest of speed. To force the code to compute these, set one of the spherical harmonic coefficients to a very small (i.e., \(10^{-15}\)) value. A similar caveat applies to maps with no limb-darkening, for which the derivatives with respect to the limb darkening coefficients are not computed by default.
-
r_m
¶ The radius of the primary body in meters. This is used exclusively for calculating the light travel time delay in the system. The default value is zero, in which case the speed of light is effectively infinite and there is no time delay. When this parameter is set, the time delay is computed with a second-order Taylor expansion, which should be accurate enough for most applications. Note that the reference point for the time delay (where \(\Delta t = 0\)) is the barycenter of the system. Transits of bodies across the primary will therefore occur earlier, while occultations will occur later, than if there were no delay.
-
-
class
starry.kepler.
Secondary
¶ Instantiate a secondary body. This body is assumed to be massless and orbits the primary in a pure Keplerian orbit. This class inherits from
Map
, so users can assign to and retrieve spherical harmonic and limb darkening coefficients in the same way. Refer to the documentation ofMap
for all options.Note
When specifying the map coefficients of a
Secondary
body, we need to be careful about the frame in which the map is defined.starry
was developed with exoplanet secondary eclipses in mind, so the map coefficients correspond to the map that would be visible at opposition, i.e., at “secondary eclipse” for an exoplanet in an edge-on orbit. For bodies in inclined/rotated orbits, the map coefficients correspond to the map that would be visible to an observer located down the \(z\) axis, along the plane of the orbit. This means the map coefficients are independent of the inclination or longitude of ascending node of the orbit. If this is all very confusing, check out the tutorial on orbital geometry.-
r
¶ The radius of the body in units of the primary’s radius. Default 0.1.
-
L
¶ The luminosity of the body in units of the primary’s luminosity. Default 0.0.
-
tref
¶ A reference time in days. Several of the orbital elements are specified at this time.
-
prot
¶ The rotation period of the body in days. For non-rotating bodies, set this to
np.inf
(or zero).
-
lightcurve
¶ The computed light curve for this body. If
nwav = 1
, this is a timeseries vector of fluxes. Fornwav > 1
, this is a matrix whose columns are the timeseries in each wavelength bin.Note
Users must call the
compute
method of theSystem
object before accessing this attribute.
-
gradient
¶ The gradient of the body’s light curve. This is a dictionary of vectors (
nwav = 1
) or matrices (nwav > 1
). The dictionary keys are the names of all parameters of all bodies in the currentSystem
object, formatted asbody.parameter
, wherebody
isA
for the primary andb
,c
,d
, etc. for the secondaries. Theparameter
label is the name of the parameter.Note
Users must call the
compute
method of theSystem
object withgradient=True
before accessing this attribute.Note
The gradients with respect to map coefficients are stored as vectors in the y and u attributes of the gradient dictionary, starting with the first degree coefficients. The derivatives with respect to the constant terms \(Y_{0,0}\) and \(u_0\) are not computed, since those values are constant!
Note
Depending on the properties of a body’s map, not all map coefficient gradients may be computed. For instance, for purely limb-darkened maps (whose \(Y_{l,m}\) coefficients are zero for \(l > 1\)), the derivatives of the flux with respect to the spherical harmonic coefficients are not computed. This is entirely in the interest of speed. To force the code to compute these, set one of the spherical harmonic coefficients to a very small (i.e., \(10^{-15}\)) value. A similar caveat applies to maps with no limb-darkening, for which the derivatives with respect to the limb darkening coefficients are not computed by default.
-
a
¶ The semi-major axis of the body in units of the primary radius. Default 50.
-
porb
¶ The orbital period of the body in days. Default 1.
-
inc
¶ The inclination of the body in degrees. Default 90.
-
ecc
¶ The eccentricity of the body. Default 0.
-
w
¶ The longitude of pericenter for the body’s orbit in degrees. This parameter is typically denoted \(\varpi\). Default 90.
-
Omega
¶ The longitude of ascending node in degrees. Default 0.
-
lambda0
¶ The mean longitude of the body in degrees at the reference time. Default 90. Note that for a circular, edge-on orbit, a transit occurs when \(\lambda_0 = 90^\circ\).
-
X
¶ The vector of
x
positions of the body in units of the primary radius. Read-only.Note
Users must call the
compute
method of theSystem
object before accessing this attribute.
-
-
class
starry.kepler.
System
¶ Instantiate a Keplerian orbital system. The primary is fixed at the origin, and all secondary bodies are assumed to be massless.
- Parameters
-
primary
¶ The primary body in the Keplerian system.
-
secondaries
¶ A list of the secondary bodies in the Keplerian system.
-
compute
(time, gradient=False)¶ Compute the system light curve analytically. Compute the full system light curve at the times given by the
time
array and store the result inlightcurve
. The light curve for each body in the system is stored in the body’slightcurve
attribute. Optionally, also compute the gradient of the light curve and store it in thegradient
attribute of the system and each of the body instances.
-
lightcurve
¶ The computed light curve for the system, equal to the sum of the light curves of each of the bodies. If
nwav = 1
, this is a timeseries vector of fluxes. Fornwav > 1
, this is a matrix whose columns are the timeseries in each wavelength bin.Note
Users should call
compute()
first.
-
gradient
¶ The gradient of the systems’s light curve. This is a dictionary of vectors (
nwav = 1
) or matrices (nwav > 1
). See the docstring ofPrimary.gradient
for more details.Note
Users should call
compute()
first.
-
exposure_time
¶ Exposure time for each data point in the light curve. Default 0. If nonzero, integrates the light curve over the exposure time using a recursive technique to approximate the integral.
-
exposure_tol
¶ Tolerance of the recursive exposure time algorithm. Default is square root of machine epsilon.
-
exposure_max_depth
¶ Maximum number of recursions in the exposure time algorithm. Default 4. Increase this for higher accuracy (and longer run times).


We are located in the West Valley of Arizona. Uriel has 20 years + of experience in construction. You will have a finished result that looks great! Our team will stop at nothing to ensure that you come away with 100% satisfaction. If your project has to do with home improvements, we are here to handle your construction needs. So when you want quality work at affordable prices, give us a call for a free estimate and consultation.


5.11 Exercises
Use Squid's -s option and verify
that its messages are saved by your syslog daemon. Run squid -X
-d9, and examine some of the debugging
messages. Write a shell script that stops Squid but doesn't
exit until all Squid processes exit. Play with squid -k
rotate. What happens if you have
tail -f
cache.log running when you rotate the log
files?
|


Class DurableOrchestrationContext
Parameter data for orchestration bindings that can be used to schedule function-based activities.
Inheritance
Inherited Members
Namespace: Microsoft.Azure.WebJobs
Assembly: Microsoft.Azure.WebJobs.Extensions.DurableTask.dll
Syntax
public sealed class DurableOrchestrationContext
Properties
| Improve this Doc View SourceCurrentUtcDateTime
Gets the current date/time in a way that is safe for use by orchestrator functions.
Declaration
public DateTime CurrentUtcDateTime { get; }
Property Value
| Type | Description |
|---|---|
| System.DateTime | The orchestration's current date/time in UTC. |
Remarks
This date/time value is derived from the orchestration history. It always returns the same value at specific points in the orchestrator function code, making it deterministic and safe for replay.
InstanceId
Gets the instance ID of the currently executing orchestration.
Declaration
public string InstanceId { get; }
Property Value
| Type | Description |
|---|---|
| System.String | The ID of the current orchestration instance. |
Remarks
The instance ID is generated and fixed when the orchestrator function is scheduled. It can be either auto-generated, in which case it is formatted as a GUID, or it can be user-specified with any format.
IsReplaying
Gets a value indicating whether the orchestrator function is currently replaying itself.
Declaration
public bool IsReplaying { get; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
|
Remarks
This property is useful when there is logic that needs to run only when the orchestrator function
is not replaying. For example, certain types of application logging may become too noisy when duplicated
as part of orchestrator function replay. The orchestrator code could check to see whether the function is
being replayed and then issue the log statements when this value is false
.
Methods
| Improve this Doc View SourceCallActivityAsync(String, Object[])
Schedules an activity function named functionName
for execution.
Declaration
public Task CallActivityAsync(string functionName, params object[] parameters)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | functionName | The name of the activity function to call. |
| System.Object[] | parameters | The JSON-serializeable parameters to pass as input to the function. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task | A durable task that completes when the called function completes or fails. |
Exceptions
| Type | Condition |
|---|---|
| System.ArgumentException | The specified function does not exist, is disabled, or is not an orchestrator function. |
| System.InvalidOperationException | The current thread is different than the thread which started the orchestrator execution. |
| DurableTask.Core.Exceptions.TaskFailedException | The activity function failed with an unhandled exception. |
CallActivityAsync<TResult>(String, Object[])
Schedules an activity function named functionName
for execution.
Declaration
public Task<TResult> CallActivityAsync<TResult>(string functionName, params object[] parameters)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | functionName | The name of the activity function to call. |
| System.Object[] | parameters | The JSON-serializeable parameters to pass as input to the function. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task<TResult> | A durable task that completes when the called function completes or fails. |
Type Parameters
| Name | Description |
|---|---|
| TResult | The return type of the scheduled activity function. |
Exceptions
| Type | Condition |
|---|---|
| System.ArgumentException | The specified function does not exist, is disabled, or is not an orchestrator function. |
| System.InvalidOperationException | The current thread is different than the thread which started the orchestrator execution. |
| DurableTask.Core.Exceptions.TaskFailedException | The activity function failed with an unhandled exception. |
CallActivityWithRetryAsync(String, RetryOptions, Object[])
Schedules an activity function named functionName
for execution with retry options.
Declaration
public Task CallActivityWithRetryAsync(string functionName, RetryOptions retryOptions, params object[] parameters)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | functionName | The name of the activity function to call. |
| RetryOptions | retryOptions | The retry option for the activity function. |
| System.Object[] | parameters | The JSON-serializeable parameters to pass as input to the function. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task | A durable task that completes when the called function completes or fails. |
Exceptions
| Type | Condition |
|---|---|
| System.ArgumentNullException | The retry option object is null. |
| System.ArgumentException | The specified function does not exist, is disabled, or is not an orchestrator function. |
| System.InvalidOperationException | The current thread is different than the thread which started the orchestrator execution. |
| DurableTask.Core.Exceptions.TaskFailedException | The activity function failed with an unhandled exception. |
CallActivityWithRetryAsync<TResult>(String, RetryOptions, Object[])
Schedules an activity function named functionName
for execution with retry options.
Declaration
public Task<TResult> CallActivityWithRetryAsync<TResult>(string functionName, RetryOptions retryOptions, params object[] parameters)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | functionName | The name of the activity function to call. |
| RetryOptions | retryOptions | The retry option for the activity function. |
| System.Object[] | parameters | The JSON-serializeable parameters to pass as input to the function. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task<TResult> | A durable task that completes when the called function completes or fails. |
Type Parameters
| Name | Description |
|---|---|
| TResult | The return type of the scheduled activity function. |
Exceptions
| Type | Condition |
|---|---|
| System.ArgumentNullException | The retry option object is null. |
| System.ArgumentException | The specified function does not exist, is disabled, or is not an orchestrator function. |
| System.InvalidOperationException | The current thread is different than the thread which started the orchestrator execution. |
| DurableTask.Core.Exceptions.TaskFailedException | The activity function failed with an unhandled exception. |
CallSubOrchestratorAsync(String, Object[])
Schedules an orchestrator function named functionName
for execution.
Declaration
public Task CallSubOrchestratorAsync(string functionName, params object[] parameters)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | functionName | The name of the orchestrator function to call. |
| System.Object[] | parameters | The JSON-serializeable parameters to pass as input to the function. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task | A durable task that completes when the called function completes or fails. |
Exceptions
| Type | Condition |
|---|---|
| System.ArgumentException | The specified function does not exist, is disabled, or is not an orchestrator function. |
| System.InvalidOperationException | The current thread is different than the thread which started the orchestrator execution. |
| DurableTask.Core.Exceptions.TaskFailedException | The activity function failed with an unhandled exception. |
CallSubOrchestratorAsync<TResult>(String, Object[])
Schedules an orchestration function named functionName
for execution.
Declaration
public Task<TResult> CallSubOrchestratorAsync<TResult>(string functionName, params object[] parameters)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | functionName | The name of the orchestrator function to call. |
| System.Object[] | parameters | The JSON-serializeable parameters to pass as input to the function. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task<TResult> | A durable task that completes when the called function completes or fails. |
Type Parameters
| Name | Description |
|---|---|
| TResult | The return type of the scheduled orchestrator function. |
Exceptions
| Type | Condition |
|---|---|
| System.ArgumentException | The specified function does not exist, is disabled, or is not an orchestrator function. |
| System.InvalidOperationException | The current thread is different than the thread which started the orchestrator execution. |
| DurableTask.Core.Exceptions.TaskFailedException | The activity function failed with an unhandled exception. |
CallSubOrchestratorWithRetryAsync(String, RetryOptions, Object[])
Schedules an orchestrator function named functionName
for execution with retry options.
Declaration
public Task CallSubOrchestratorWithRetryAsync(string functionName, RetryOptions retryOptions, params object[] parameters)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | functionName | The name of the orchestrator function to call. |
| RetryOptions | retryOptions | The retry option for the orchestrator function. |
| System.Object[] | parameters | The JSON-serializeable parameters to pass as input to the function. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task | A durable task that completes when the called function completes or fails. |
Exceptions
| Type | Condition |
|---|---|
| System.ArgumentNullException | The retry option object is null. |
| System.ArgumentException | The specified function does not exist, is disabled, or is not an orchestrator function. |
| System.InvalidOperationException | The current thread is different than the thread which started the orchestrator execution. |
| DurableTask.Core.Exceptions.TaskFailedException | The activity function failed with an unhandled exception. |
CallSubOrchestratorWithRetryAsync<TResult>(String, RetryOptions, Object[])
Schedules an orchestrator function named functionName
for execution with retry options.
Declaration
public Task<TResult> CallSubOrchestratorWithRetryAsync<TResult>(string functionName, RetryOptions retryOptions, params object[] parameters)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | functionName | The name of the orchestrator function to call. |
| RetryOptions | retryOptions | The retry option for the orchestrator function. |
| System.Object[] | parameters | The JSON-serializeable parameters to pass as input to the function. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task<TResult> | A durable task that completes when the called function completes or fails. |
Type Parameters
| Name | Description |
|---|---|
| TResult | The return type of the scheduled orchestrator function. |
Exceptions
| Type | Condition |
|---|---|
| System.ArgumentNullException | The retry option object is null. |
| System.ArgumentException | The specified function does not exist, is disabled, or is not an orchestrator function. |
| System.InvalidOperationException | The current thread is different than the thread which started the orchestrator execution. |
| DurableTask.Core.Exceptions.TaskFailedException | The activity function failed with an unhandled exception. |
ContinueAsNew(Object)
Restarts the orchestration and its history.
Declaration
public void ContinueAsNew(object input)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Object | input | The JSON-serializeable data to re-initialize the instance with. |
CreateTimer(DateTime, CancellationToken)
Creates a durable timer which expires at a specified time.
Declaration
public Task CreateTimer(DateTime fireAt, CancellationToken cancelToken)
Parameters
| Type | Name | Description |
|---|---|---|
| System.DateTime | fireAt | The time at which the timer should expire. |
| System.Threading.CancellationToken | cancelToken | The |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task | A durable task that completes when the durable timer expires. |
Remarks
All durable timers created using this method must either expire or be cancelled
using the cancelToken
before the orchestrator function completes.
Otherwise the underlying framework will keep the instance alive until the timer expires.
CreateTimer<T>(DateTime, T, CancellationToken)
Creates a durable timer which expires at a specified time.
Declaration
public Task<T> CreateTimer<T>(DateTime fireAt, T state, CancellationToken cancelToken)
Parameters
| Type | Name | Description |
|---|---|---|
| System.DateTime | fireAt | The time at which the timer should expire. |
| T | state | Any state to be preserved by the timer. |
| System.Threading.CancellationToken | cancelToken | The |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task<T> | A durable task that completes when the durable timer expires. |
Type Parameters
| Name | Description |
|---|---|
| T | The type of |
Remarks
All durable timers created using this method must either expire or be cancelled
using the cancelToken
before the orchestrator function completes.
Otherwise the underlying framework will keep the instance alive until the timer expires.
GetInput<T>()
Gets the input of the current orchestrator function as a deserialized value.
Declaration
public T GetInput<T>()
Returns
| Type | Description |
|---|---|
| T | The deserialized input value. |
Type Parameters
| Name | Description |
|---|---|
| T | Any data contract type that matches the JSON input. |
GetInputAsJson()
Gets the input of the current orchestrator function instance as a JToken
.
Declaration
public JToken GetInputAsJson()
Returns
| Type | Description |
|---|---|
| Newtonsoft.Json.Linq.JToken | The parsed |
GetRawInput()
Returns the orchestrator function input as a raw JSON string value.
Declaration
public string GetRawInput()
Returns
| Type | Description |
|---|---|
| System.String | The raw JSON-formatted orchestrator function input. |
WaitForExternalEvent<T>(String)
Waits asynchronously for an event to be raised with name name
and returns the event data.
Declaration
public Task<T> WaitForExternalEvent<T>(string name)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | name | The name of the event to wait for. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task<T> | A durable task that completes when the external event is received. |
Type Parameters
| Name | Description |
|---|---|
| T | Any serializeable type that represents the JSON event payload. |


Package b2p.state.bitboard.bitset
Class BitSetState
- java.lang.Object
-
- b2p.state.bitboard.bitset.BitSetState
-
-
Field Summary
-
Fields inherited from interface b2p.model.IState
boardDimension
-
-
Constructor Summary
Constructors Constructor Description BitSetState()
Default constructor method.BitSetState(B2PBitSet blackPawns, B2PBitSet whitePawns, B2PBitSet king, it.unibo.ai.didattica.competition.tablut.domain.State.Turn turn)
Constructor method to create an instance of BitSetState from the given argumentsBitSetState(B2PBitSet blackPawns, B2PBitSet whitePawns, B2PBitSet king, it.unibo.ai.didattica.competition.tablut.domain.State.Turn turn, int turnAmt)
Constructor method to create an instance of BitSetState from the given arguments
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description boolean
blackHasWon()
Checks if the black has won the gameIState
clone()
java.util.List<IAction>
getAvailableKingMoves()
Gets all the available moves for the kingjava.util.List<IAction>
getAvailablePawnMoves()
Gets all the available moves for the pawnsB2PBitSet
getBlackPawns()
Accesses the private field black pawnsB2PBitSet
getBoard()
Accesses the private field boardint
getHeuristicValue()
Returns the heuristic value for a player in the current turnint
getHeuristicValueForPlayer(it.unibo.ai.didattica.competition.tablut.domain.State.Turn player)
Returns the heuristic value for a given player in the current turnB2PBitSet
getKing()
Accesses the private field kingit.unibo.ai.didattica.competition.tablut.domain.State.Turn
getTurn()
Accesses the private field turnB2PBitSet
getWhitePawns()
Accesses the private field white pawnsboolean
isWinningState()
Checks if the current state is a winning statevoid
performMove(int from, int to)
Performs a given action using a specified from and a specified tovoid
performMove(IAction action)
Performs a given action usingBitSetPosition
from andBitSetPosition
tovoid
performMove(java.lang.String from, java.lang.String to)
Performs a given action using a specifiedBitSetPosition
from and a specifiedBitSetPosition
tovoid
setTurn(it.unibo.ai.didattica.competition.tablut.domain.State.Turn turn)
Method to set the private field turn valueIState
simulateMove(IAction action)
Simulates a specified move from a givenIAction
boolean
whiteHasWon()
Checks if the white has won the game
-
-
-
Constructor Detail
-
BitSetState
public BitSetState(B2PBitSet blackPawns, B2PBitSet whitePawns, B2PBitSet king, it.unibo.ai.didattica.competition.tablut.domain.State.Turn turn)
Constructor method to create an instance of BitSetState from the given arguments- Parameters:
blackPawns
- the black pawnswhitePawns
- the white pawnsking
- the kingturn
- the board- See Also:
B2PBitSet
-
BitSetState
public BitSetState(B2PBitSet blackPawns, B2PBitSet whitePawns, B2PBitSet king, it.unibo.ai.didattica.competition.tablut.domain.State.Turn turn, int turnAmt)
Constructor method to create an instance of BitSetState from the given arguments- Parameters:
blackPawns
- the black pawnswhitePawns
- the white pawnsking
- the kingturn
- the boardturnAmt
- the turn number- See Also:
B2PBitSet
-
BitSetState
public BitSetState()
Default constructor method. White player plays first.
-
-
Method Detail
-
isWinningState
public boolean isWinningState()
Checks if the current state is a winning state- Specified by:
isWinningState
in interfaceIState
- Returns:
true
if it is a winning state
-
blackHasWon
public boolean blackHasWon()
Checks if the black has won the game- Specified by:
blackHasWon
in interfaceIState
- Returns:
true
if black has won
-
whiteHasWon
public boolean whiteHasWon()
Checks if the white has won the game- Specified by:
whiteHasWon
in interfaceIState
- Returns:
true
if white has won
-
performMove
public void performMove(IAction action)
Performs a given action usingBitSetPosition
from andBitSetPosition
to- Specified by:
performMove
in interfaceIState
- Parameters:
action
- the action to perform- See Also:
IAction
,BitSetPosition
-
performMove
public void performMove(java.lang.String from, java.lang.String to)
Performs a given action using a specifiedBitSetPosition
from and a specifiedBitSetPosition
to- Specified by:
performMove
in interfaceIState
- Parameters:
from
- the starting positionto
- the final position- See Also:
BitSetPosition
-
performMove
public void performMove(int from, int to)
Performs a given action using a specified from and a specified to- Specified by:
performMove
in interfaceIState
- Parameters:
from
- the starting positionto
- the final position
-
simulateMove
public IState simulateMove(IAction action)
Simulates a specified move from a givenIAction
- Specified by:
simulateMove
in interfaceIState
- Parameters:
action
- the action to simulate- Returns:
- A copy of the
BitSetState
after the move is performed - See Also:
IAction
-
getAvailablePawnMoves
public java.util.List<IAction> getAvailablePawnMoves()
Gets all the available moves for the pawns- Specified by:
getAvailablePawnMoves
in interfaceIState
- Returns:
- A
List
of possible actions - See Also:
IAction
-
getAvailableKingMoves
public java.util.List<IAction> getAvailableKingMoves()
Gets all the available moves for the king- Specified by:
getAvailableKingMoves
in interfaceIState
- Returns:
- A
List
of possible actions - See Also:
IAction
-
getHeuristicValue
public int getHeuristicValue()
Returns the heuristic value for a player in the current turn- Specified by:
getHeuristicValue
in interfaceIState
- Returns:
- the heuristic value for a player in the current turn
- See Also:
State.Turn
-
getHeuristicValueForPlayer
public int getHeuristicValueForPlayer(it.unibo.ai.didattica.competition.tablut.domain.State.Turn player)
Returns the heuristic value for a given player in the current turn- Specified by:
getHeuristicValueForPlayer
in interfaceIState
- Parameters:
player
- the player for which the heuristic value is evaluated- Returns:
- the heuristic value for a given player in the current turn
- See Also:
State.Turn
-
clone
public IState clone()
-
getBlackPawns
public B2PBitSet getBlackPawns()
Accesses the private field black pawns- Specified by:
getBlackPawns
in interfaceIState
- Returns:
B2PBitSet
containing black pawns- See Also:
B2PBitSet
-
getWhitePawns
public B2PBitSet getWhitePawns()
Accesses the private field white pawns- Specified by:
getWhitePawns
in interfaceIState
- Returns:
B2PBitSet
containing white pawns- See Also:
B2PBitSet
-
getKing
public B2PBitSet getKing()
Accesses the private field king
-
getBoard
public B2PBitSet getBoard()
Accesses the private field board
-
getTurn
public it.unibo.ai.didattica.competition.tablut.domain.State.Turn getTurn()
Accesses the private field turn
-
-


The service system is meant to create a common way of using plugins. It is a tiny system, on Server and Client level. In this tutorial I'll tell you how to use services, and how to create your own.
Creating services is really easy - you just have to implement the Service interface. Make sure you don't do anything time consuming since the developer may not be expecting it. Services can choose to support Server, Client, or both. To implement this, use the appropriate constructors:
public class MyExampleService implements Service { public MyExampleService(Server server) { // By adding the constructor with the Server as argument, this service // now supports servers. } public MyExampleService(Client client) { // Same goes for client. I could just leave this constructor out, and // SpiderMonkey would determine this service does not support client mode. } }
The Server and Client class both have a method called getService(). It retrieves a service based on class name, and instantiates it if necessary. From there you can use the service.
The Service system is not a terribly powerful system, neither does it do safety checks and service management - it just provides a way to commonly manage extensions.
That's it! Next tutorial we're going to have a look at how to use the streaming API.


| History of Misdeamanor by Times Of India |
|
| History of Rape in India |
|
| History of False Reporting |
|
| History of crime against children |
|
| History of misuse of section 66A |
|
| History of misuse of 193A |
|
| History of corruption in India |
|
| History of UFO sightings |
|
| History of corporal punishment at schools |
|


Welcome to 🚀 RocketShop
The world's first eva shop where you buy stuff in XLM!!!!
Ajax Cleaner - makes your life cleaner
10 XLM
Buy


".y executes the sentence y .
If the execution results in a noun, the result of ".y
is that noun; if the execution result is a verb, adverb, or conjunction,
or if there is no execution result,
the result of ".y is an empty vector.
|
|
x".y converts character array y into numbers.
The shape of the result is (}:$y),(1=n)}.n where n is
the maximum number of numbers in any row. x is a scalar number
used to replace illegal numbers and to pad narrow rows.
In the conversion, the normal rules for numeric constants are
relaxed as follows:
- the negative sign can be - or _
- commas within numbers are ignored
- fractions need not have a digit 0 before the decimal point
- a number may be preceded by a + sign;
the exponent of a number in exponential format
may be preceded by a + sign
|


I am a freelance HTML & CSS consultant. When I'm not writing code, I like to run the trails.
Follow him on Twitter.


public interface SinchClientBuilder
| Modifier and Type | Method and Description |
|---|---|
SinchClientBuilder
|
applicationKey(java.lang.String applicationKey)
Sets the application key associated with the SinchClient.
|
SinchClientBuilder
|
applicationSecret(java.lang.String applicationSecret)
Sets the application secret associated with the SinchClient.
|
SinchClient
|
build()
Creates the resulting SinchClient.
|
SinchClientBuilder
|
callerIdentifier(java.lang.String callerIdentifier)
Sets the caller identifier used when calling with PSTN.
|
SinchClientBuilder
|
context(android.content.Context context)
Sets the context associated with the SinchClient.
|
SinchClientBuilder
|
environmentHost(java.lang.String environmentHost)
Sets the environment host associated with the SinchClient.
|
SinchClientBuilder
|
userId(java.lang.String userId)
Sets the user id associated with the SinchClient.
|
SinchClientBuilder context(android.content.Context context)
context
- Must not be null.SinchClientBuilder userId(java.lang.String userId)
userId
- Must not be null.SinchClientBuilder applicationKey(java.lang.String applicationKey)
applicationKey
- Must not be null.SinchClientBuilder applicationSecret(java.lang.String applicationSecret)
applicationSecret
- Optional. Must not be null.SinchClientBuilder environmentHost(java.lang.String environmentHost)
environmentHost
- Must not be null.SinchClientBuilder callerIdentifier(java.lang.String callerIdentifier)
callerIdentifier
- Optional. Must not be null.SinchClient build()
Copyright 2016, Sinch AB