| Application Overview | Data Issues | Application Classes | Account Messages | Holding Messages | Application Cross Reference |
The class Account is a super class of the classes Portfolio, AggAccount, IndexAccount, and CompositeAccount. A Portfolio is defined as an Account whose holdings are created via a feed from an internal accounting system. An AggAccount is defined as an Account whose holdings are created by combining the holdings for the list of Portfolios instances defined for the aggregate. An IndexAccount is defined as an account whose holdings are created starting with a list of Securities and a rule to derive a shares owned value. A CompositeAccount is defined as an Account whose holdings are created as a weighted combination of the holdings in a set of portfolio, aggregate, index and/or other composite accounts defined for the composite.
Messages that apply to all Account subclasses are defined at Account. Messages that address the unique requirements of Portfolio, AggAccount, IndexAccount and CompositeAccount instances are defined at the appropriate subclass. Your installation may define additional subclasses.
You do not directly create instances of the class Account. Instances are created for the different subclasses. In addition to the messages defined directly by the subclass, all instances respond to the messages defined for the class Account.
The following subset of the class hierarchy displays the classes directly related to Account:
Object | Entity | | | |-- Account | | | |-- AggAccount | | | |-- CompositeAccount | | | |-- IndexAccount | | | |-- Portfolio | LinkRecord | |-- CompositeAccount Component | |-- Holding
The naming dictionaries Named Portfolio, Named AggAccount, Named IndexAccount, and Named CompositeAccount, are used for naming individual instances of the Account subclasses. For example:
Named Portfolio XYZaccesses the Portfolio named XYZ and:
Named AggAccount Agg1accesses the AggAccount named Agg1.
An extra naming dictionary is defined at the Account class to allow interchangeable access among the classes. For example, the expression:
Named Account XYZalso returns portfolio XYZ. If the same id is used to identify a Portfolio and an instance of another Account subclass, the value in the Account naming dictionary will return the Portfolio instance. The property uniqueId is used to create a unique identifier for each instance. The expressions:
Named Account P_XYZ = Named Portfolio XYZ Named Account A_XYZ = Named AggAccount XYZ Named Account I_XYZ = Named IndexAccount XYZ and Named Account C_XYZ = Named CompositeAccount XYZall return the value TRUE.
The message locateId: has been redefined at the Account class to use the following search rule:
For example, the expression:
Account locateId: "XYZ"returns Named Account XYZ if it is defined, otherwise it returns Named Portfolio XYZ, otherwise it returns Named AggAccount XYZ, otherwise it returns Named IndexAccount XYZ, otherwise it returns Named CompositeAccount XYZ, other it returns NA.
Account instances respond to all Entity and
Object messages such as code, name, and
baseCurrency.
The message profile has been redefined at Account
and some of the subclasses
to display account-related information. For example:
Named Portfolio XYZ displayInfo ;
displays a summary line of information about the portfolio XYZ and:
Named AggAccount AGG1 profile ;
displays key information about the aggregate AGG1.
The message masterList can be used to return the list of non-default instances for any of the Account subclasses. For example, to display the code and name for each Portfolio instance, use:
Portfolio masterList do: [ code print: 10 ; name printNL ; ] ;To display the number of AggAccount instances, use:
AggAccount masterList countIf you send the masterList message to the Account class, you will get the list of all non-default instances for all of the subclasses. For example:
Account masterList #-- get instances of all subclasses groupedBy: [ whatAmI ] . #-- group by subclass name do: [ printNL ; #-- print subclass name groupList #-- for each instance in class do: do: [ code print: 10 ; #-- print code name printNL ; #-- print name ] ; #-- end of instances in class ] ;
The class Account is used to unify the protocol that is common to all the subclasses.
The following messages return basic Account information:
| Message | Return Class | Description |
|---|---|---|
| baseCurrency | Currency | default currency for storing and accessing monetary data for the account |
| code | String | primary identifier |
| creationDate | Date | date instance was created |
| getHoldingIn: | Holding | returns holding in supplied security if held by recipient account |
| hasHoldings | Boolean | does the recipient have holdings (as of ^date)? |
| holdings | List | list of holdings in recipient (relative to ^date) |
| holdingsDate | Date | effective date of holdings list (relative to ^date) |
| holds: | Boolean | does the recipient hold supplied security? |
| isMemberOf: | Boolean | is account in supplied universe or classification? |
| name | String | account name |
| _totalCost | Number | total cost of holdings (relative to ^date) |
| totalCost | Number | currency adjusted total cost (relative to ^date) |
| _totalMarketValue | Number | market value of holdings (relative to ^date) |
| totalMarketValue | Number | currency adjusted market value (relative to ^date) |
| _totalMarketValueCash | Number | total cash value of holdings (relative to ^date) |
| totalMarketValueCash | Number | currency adjusted cash value (relative to ^date) |
| _totalMarketValueEquity | Number | total equity value of holdings (relative to ^date) |
| totalMarketValueEquity | Number | currency adjusted equity value (relative to ^date) |
| _totalMarketValueFixed | Number | total fixed income value of holdings (relative to ^date) |
| totalMarketValueFixed | Number | currency adjusted fixed income value (relative to ^date) |
| uniqueId | String | code prefixed with subclass indicator |
| universes | List | list of universes containing recipient |
The message getHoldingIn: returns an instance of the Holding class. The message holdings returns a List of instances of the Holding class. These and other related messages are described in the next section.
The total market value of an Account represents the market value of its holdings. This value is tracked over time and is normally recomputed each time holdings are updated. The time series property _totalMarketValue is used to track the total market value over time in the baseCurrency of the Account. The message totalMarketValue returns the market value in the account's base currency by default or a currency override, if defined. For example:
Named Portfolio XYZ do: [ baseCurrency code print: 5 ; #- default currency currency code print: 5 ; #- currency override _totalMarketValue printWithCommas: 18.0 ; #- latest raw value totalMarketValue printWithCommas: 18.0 ; #- currency adjusted ] ; ^today - 1 monthEnds evaluate: [ Named Portfolio XYZ do: [ baseCurrency code print: 5 ; #- default currency currency code print: 5 ; #- currency override _totalMarketValue printWithCommas: 18.0 ; #- eom raw value totalMarketValue printWithCommas: 18.0 ; #- currency adjusted ] ; ] ;displays the latest and prior month-end market value in the portfolio's base currency and the currency override. In this case the values are the same. The expressions:
"DEM" asCurrency evaluate: [ Named Portfolio XYZ do: [ baseCurrency code print: 5 ; #- default currency currency code print: 5 ; #- DEM _totalMarketValue printWithCommas: 18.0 ; #- latest raw value totalMarketValue printWithCommas: 18.0 ; #- value in DEM ] ; ] ; "DEM" asCurrency evaluate: [ ^today - 1 monthEnds evaluate: [ Named Portfolio XYZ do: [ baseCurrency code print: 5 ; #- default currency currency code print: 5 ; #- DEM _totalMarketValue printWithCommas: 18.0 ; #- eom raw value totalMarketValue printWithCommas: 18.0 ; #- value in DEM ] ; ] ; ] ;displays the latest and prior month-end market value in the portfolio's base currency and the currency override of DEM.
The messages totalMarketValueEquity, totalMarketValueCash, and totalMarketValueFixed return the total market values for the different asset categories. For example, to show the total market value and percent cash for each Portfolio use:
Portfolio masterList do: [ code print: 10 ; name print: 25 ; totalMarketValue printWithCommas: 15.0 ; totalMarketValueCash / totalMarketValue * 100 print: 10.2 ; newLine print ; ] ;
For general descriptions of all the Account messages, see the document Vision Application Messages: Account.
The class Holding is used to represent a specific holding by an account in a security as of a specific point in time. Holdings are rarely (if ever) referenced directly. Instead they are accessed via a particular security or account. Holdings are normally created as part of a data upload process.
The following messages return basic Holding information:
| Message | Return Class | Description |
|---|---|---|
| account | Account | account represented by holding |
| _accountingPrice | Number | actual price used to compute market value, if available |
| accountingPrice | Number | price used to compute market value, adjusted for splits and currency |
| adjustmentFactor | Number | split adjustment factor |
| baseCurrency | Currency | currency in which monetary values are stored (initialized to account's value) |
| currencyFactor | Number | currency adjustment relative to date |
| date | Date | Date of holding |
| id | String | security/account indicator |
| percentOfEquity | Number | percent of all equity holdings for account on date represented by this holding |
| percentOfPort | Number | percent of total market value for account on date represented by this holding |
| security | Security | security represented by holding |
| _shares | Number | actual shares held by account in security on date |
| shares | Number | shares adjusted for splits since date |
| _totalCost | Number | actual cost of shares held by account in security on date |
| totalCost | Number | cost adjusted for currency |
| _totalMarketValue | Number | actual market value of shares hold by account in security on date |
| totalMarketValue | Number | market value adjusted for currency |
For general descriptions of all the Holding messages, see the document Vision Application Messages: Holding.
Each Holding responds to the messages security and account by returning an instance of those classes; therefore, any messages defined at Security or Account can be referenced via a specific Holding. The message id has been defined at Holding to return a string in the form securityCode---accountCode. For example, the expression:
Named Portfolio XYZ getHoldingIn: Named Security GM . iddisplays the string 37044210---XYZ.
The message holdings is defined for the Account and Security classes to return the list of Holding instances associated with the security or account as of the current evaluation date. Since the message holdings returns a List, any message defined for the List class can be sent to it (e.g., do:, select: , groupedBy:, sortUp: , etc.). For example:
Named Portfolio XYZ holdings #-- returns List of Holdings do: [ security name print: 30 ; #-- security level security price print: 10 ; #-- security level totalMarketValue printNL: 15 ; #-- holding level ] ; Named Portfolio XYZ holdings groupedBy: [ security company country ] . do: [ code print: 10 ; name printNL ; #-- country level groupList sortDown: [ percentOfPort ] . do: [ security name print: 30 ; #-- security level security price print: 10 ; #-- security level totalMarketValue print: 15 ; #-- holding level percentOfPort printNL ; #-- holding level ] ; newLine print ; ] ;The message getHoldingIn: is used to get an account's Holding in a specific security if it exists. A default Holding is returned otherwise. For example:
Named Portfolio XYZ getHoldingIn: Named Security GM . percentOfPortreturns the percentage of Portfolio XYZ represented by the holding in GM. The message holds: is used to indicate whether or not an account holds a specific security. It returns a Boolean value. For example:
Portfolio masterList select: [ ^self holds: ^global Named Security GM ] . do: [ code print: 10 ; name printNL ] ;displays the code and name of every Portfolio that currently holds GM.
Since holdings are stored over time, you can access a Portfolio's holdings as of a different date using:
9612 evaluate: [ Named Portfolio XYZ holdings do: [ security name print: 30 ; security price print: 10 ; totalMarketValue printNL: 15 ; ] ; ]This displays the holdings information as of Dec 31, 1996. The message holdingsDate can be used to display the effective date of the holdings list being accessed. For example:
9612 evaluate: [ Named Portfolio XYZ do: [ "Holdings As Of: " print; holdingsDate printNL ; holdings do: [ security name print: 30 ; security price print: 10 ; totalMarketValue printNL: 15 ; ] ; ] ] ;The message hasHoldings is defined for the Account class to indicate whether the account has holdings as of the current evaluation date. For example, the expression:
Portfolio masterList select: [ hasHoldings ] . do: [ displayInfo ] ;displays the list of portfolios that have current holdings and the expression:
9612 evaluate: [ Portfolio masterList select: [ hasHoldings ] . do: [ displayInfo ] ; ] ;displays the list of portfolios that had holdings as of Dec 31, 1996.
The message holdings can be used to access the List of Holdings associated with a Security as well. For example:
Named Security GM holdings #-- returns List of Holdings do: [ account code print: 5 ; #-- account level account name print: 20 ; #-- account level security price print: 10 ; #-- security level totalMarketValue printNL: 15 ; #-- holding level ] ;
Holdings access by Security is described in more detail later in this document.
The Holding class structure is illustrated below:
_____________ | Holding |--| |___________| | ______________ |---- security ---> | Security | | |____________| ___________ | | | ... | | |---- holdings ---> | Holding | | | | Holding | | | | ... | | | |_________| | | | |---- code | |---- name | |---- price | |---- company ---> | __________________ |---- account ---> | Account | | |________________| ___________ | | | ... | | |---- holdings ---> | Holding | | | | Holding | | | | ... | | | |_________| |---- date |--- code |---- baseCurrency |--- name |---- percentOfPort |---- baseCurrency |---- shares |---- totalMarketValue |---- totalCost |---- totalMarketValueEquity |---- totalMarketValue |--- totalMarketValueCash | |
A Holding in a Portfolio represents the actual number of shares held by the Portfolio in a Security on a specific date. The Holdings for an AggAccount are created by collecting the holdings associated with each of its member Portfolios and creating a single Holding for each distinct Security represented. The Holdings for an IndexAccount are created starting with a list of securities and a rule to derive shares owned values. The Holdings for a CompositeAccount are created as a weighted combination of the holdings in a set of portfolio, aggregate, index and/or other composite accounts defined for the composite.
Holdings are created using the createHoldingsFrom: message defined for Account. The parameter is a list of securities extended by the messages security, totalMarketValue, shares, totalCost, and optionally, accountingPrice. When executed, this message performs the following steps:
This method is normally not run directly; several DataFeed subclasses have been defined for creating holding data.
The class Portfolio is used to define the messages that are specific to portfolios. In addition to the messages defined for the Account class, Portfolio instances respond to the following messages:
| Message | Return Class | Description |
|---|---|---|
| aggregateList | List | list of AggAccounts that include recipient Portfolio |
A Portfolio can be a member of any number of AggAccount instances. Portfolios can be added to and deleted from aggregates over time. The aggregateList message returns the list of AggAccount instances that include the Portfolio as of the evaluation date. For example:
Named Portfolio XYZ aggregateList #- current agg list do: [ displayInfo ] ;displays the list of current AggAccount instances that include Portfolio XYZ and:
9612 evaluate: [ Named Portfolio XYZ aggregateList #- 12/96 agg list do: [ displayInfo ] ; ] ;displays the list of AggAccount instances as of Dec 31, 1996 that include Portfolio XYZ.
The AggAccount class is discussed in the next section. For general descriptions of all the Portfolio messages, see the document Vision Application Messages: Account.
The PortfolioMaster data feed can be used to create and refresh Portfolio instances:
Interface ExternalFeedManager upload: "PortfolioMaster" using: #-- make sure this is tab-delimited "EntityId Name ShortName PORT1 EQUITY INCOME FUND EI FUND PORT2 GROWTH FUND GR FUND " ;
The HoldingsFeed data feed can be used to create holdings over time for one or more Portfolios. The following tab-delimited feed could be used to create Portfolio holdings for several portfolios on a single date. Market values will be derived for each holding:
Interface ExternalFeedManager upload: "HoldingsFeed" using: #-- make sure this is tab-delimited "date acctId secId shares 9712 PORT1 GM 1000 9712 PORT1 F 2000 9712 PORT1 CASH 20000 9712 PORT2 IBM 10000 9712 PORT2 DELL 15000 9712 PORT2 CASH 20000 " ;The following tab-delimited feed could be used to create Portfolio holdings for several portfolios on several dates. Market values are assigned directly from this feed:
Interface ExternalFeedManager upload: "HoldingsFeed" using: #-- make sure this is tab-delimited "date acctId secId mval 9712 PORT1 GM 1234.56 9712 PORT1 F 2345.67 9712 PORT1 CASH 20000.00 9712 PORT2 IBM 9876.54 9712 PORT2 DELL 8765.43 9712 PORT2 CASH 10000.00 9711 PORT1 GM 1233.21 9711 PORT1 F 2344.32 9711 PORT1 CASH 20000.00 " ;
After running this upload, you can access the holdings using:
Named Portfolio PORT1 holdings #-- returns List of Holdings do: [ security name print: 30 ; #-- security level totalMarketValue print: 15 ; #-- holding level percentOfPort printNL ; #-- holding level ] ;
The class AggAccount is used to define the messages that are specific to aggregate accounts. In addition to the messages defined for the Account class, AggAccount instances respond to the following messages:
| Message | Return Class | Description |
|---|---|---|
| memberList | IndexedList | list of member Portfolios |
An AggAccount can be composed of any number of Portfolio instances. Portfolios can be added to and deleted from aggregates over time. The memberList message returns the list of Portfolio instances in the aggregate as of the evaluation date. For example:
Named AggAccount AGG1 memberList #-- current memberList do: [ displayInfo ] ;displays the list of current Portfolio instances in AggAccount AGG1 and:
9612 evaluate: [ Named AggAccount AGG1 memberList #-- members as of 12/31/96 do: [ displayInfo ] ; ] ;displays the list of Portfolio instances as of Dec 31, 1996 included in AggAccount AGG1.
For general descriptions of all the AggAccount messages, see the document Vision Application Messages: Account.
The Holdings for an AggAccount are created by collecting the holdings associated with each of its member Portfolios and creating a single Holding for each distinct Security represented. AggAccount holdings are normally updated whenever the holdings for any of its member Portfolios are updated and whenever the membership of the AggAccount is changed.
The AggAccountMaster data feed can be used to create and refresh AggAccount instances:
Interface ExternalFeedManager upload: "AggAccountMaster" using: #-- make sure this is tab-delimited "EntityId Name ShortName AGG1 Aggregate Account 1 Agg Acct 1 AGG2 Aggregate Account 2 Agg Acct 2 " ;
The PortfolioAggregates data feed can be used to define memberships over time:
Interface ExternalFeedManager upload: "PortfolioAggregates" using: #-- make sure this is tab-delimited "groupId memberId date #- define AGG1 to have 3 members since earliest possible date AGG1 PORT1 Default AGG1 PORT2 Default AGG1 PORT3 Default #- define AGG2 to have 2 members in 95 and a third added in 96 AGG2 PORT2 1/1/95 AGG2 PORT7 1/1/95 AGG2 PORT2 1/1/96 AGG2 PORT7 1/1/96 AGG2 PORT4 1/1/96 " ;
After running an upload, you can access an AggAccount's holdings just like any other Account. For example:
Named AggAccount AGG2 holdings #-- returns List of Holdings do: [ security name print: 30 ; #-- security level totalMarketValue print: 15 ; #-- holding level percentOfPort printNL ; #-- holding level ] ;
The class IndexAccount is used to define the messages that are specific to index accounts. In addition to the messages defined for the Account class, IndexAccount instances respond to the following messages:
| Message | Return Class | Description |
|---|---|---|
| getMemberWeightsUsingAccount: | List | list of member securities extended by various weighting statistics |
| memberList | IndexedList | list of member Securities |
| style | String | EvenDollar or MCapWeighted indicator |
| universe | Universe | universe from which memberList was derived. |
An IndexAccount is defined based on a list of Security members. This list is stored in the property memberList and can vary over time. For example:
Named IndexAccount INDEX1 memberList #-- current memberList do: [ displayInfo ] ;displays the list of current Security instances in IndexAccount INDEX1 and:
9612 evaluate: [ Named IndexAccount INDEX1 memberList #-- members as of 12/31/96 do: [ displayInfo ] ; ] ;displays the list of Security instances as of Dec 31, 1996 included in IndexAccount INDEX1.
Although this list can be manually set using the setSecuritiesTo:asOf: message, it is normally updated using one of the data feeds defined for IndexAccounts.
The message getMemberWeightsUsingAccount: is used to extend the current list of member securities by their market value and weights based on various weighting schemes. The message returns the member security list extended by the messages: pctEvenDollar, mvalEvenDollar, pctMCapWeighted, mvalMCapWeighted, pctMValWeighted, and mvalMValWeighted.
The MVal-weighted values are computed using the corresponding holding in the supplied Account. This value can be supplied as NA. The even dollar technique assumes that $1,000 is invested in each security in the index. The market cap weighted technique assumes you own all the outstanding shares in the security, valued at the current evaluation date's price. If an Account or valid account id is supplied as a parameter to this message, the market value weighted technique assumes that you own the same number of shares in the security that you own in the supplied account, valued at the current evaluation date's price.
For example, the expression:
Named IndexAccount INDEX1 getMemberWeightsUsingAccount: NA . do: [ ticker print: 10 ; #- security ticker name print: 30 ; #- security name pctEvenDollar print ; #- %held if even dollar weighted pctMCapWeighted print ; #- %held if mkt cap weighted newLine print ; ] ;generates a report that shows the even dollar and market cap weighted percentages held for each security in the the IndexAccount.
For general descriptions of all the IndexAccount messages, see the document Vision Application Messages: Account.
The IndexAccountMaster data feed can be used to create and refresh IndexAccount instances:
Interface ExternalFeedManager upload: "IndexAccountMaster" using: #-- make sure this is tab-delimited "EntityId Name ShortName INDEX1 Index Account 1 Index Acct 1 INDEX2 Index Account 2 Index Acct 2 " ;
Several techniques are available for generating holdings for an
IndexAccount using the
HoldingsFeed data feed.
You can supply explicit shares and/or mval values
to derive the holdings. For example,
the following tab-delimited feed could be used to create IndexAccount
holdings for several accounts on a single date. Market values will be
derived for each holding using the security's price:
Interface ExternalFeedManager upload: "HoldingsFeed" using:
"date acctId secId shares
9712 INDEX1 GM 1000
9712 INDEX1 F 2000
9712 INDEX2 IBM 10000
9712 INDEX2 DELL 15000
" ;
The following tab-delimited feed could be used to create even dollar holdings for several IndexAccounts:
Interface ExternalFeedManager upload: "HoldingsFeed" using: #-- make sure this is tab-delimited "date acctId secId mval 9712 INDEX1 GM 100 9712 INDEX1 F 100 9712 INDEX1 C 100 9712 INDEX2 IBM 100 9712 INDEX2 DELL 100 9712 INDEX2 HWP 100 9711 INDEX1 GM 100 9711 INDEX1 F 100 9711 INDEX1 C 100 " ;
The following tab-delimited feed could be used to create market-cap-weighted holdings for several IndexAccounts:
Interface ExternalFeedManager upload: "HoldingsFeed" using: #-- make sure this is tab-delimited "date acctId secId mval 9712 INDEX1 GM 12345.67 9712 INDEX1 F 9876.54 9711 INDEX1 GM 12345.00 9711 INDEX1 F 9876.00 9712 INDEX2 IBM 23456.78 9712 INDEX2 DELL 8765.43 9712 INDEX2 HWP 9876.54 " ;You can exclude the mval column if the marketCap message has been defined for Security.
The IndexAccountBuilder data feed is used to define a universe and weighting rule from which to derive the securities and shares. The records supplied by this feed are used to update the IndexAccount time series properties universe and style. Whenever a membership is updated, the holdings for the IndexAccount are recreated for that date.
The following tab-delimited feed could be used to derive IndexAccount holdings from existing Universe memberships:
Interface ExternalFeedManager upload: "IndexAccountBuilder" using: #-- make sure this is tab-delimited "entityId date universeId style INDEX1 96 SP500 EVEN INDEX1 97 SP500 MCAP " ;This upload uses the securities in the SP500 Universe as of year-end 1996 to create even-dollar holdings (i.e., each holding will have the same totalMarketValue and the same percentOfPort values) as of 12/31/96. This upload uses the securities in the SP500 Universe as of year-end 1997 to create market-cap-weighted holdings as of 12/31/97. This style assumes that the message marketCap has been defined for Security to return the market capitalization as of the evaluation date.
After running any of these uploads, you can access an IndexAccount's holdings just like any other Account. For example:
Named IndexAccount INDEX1 holdings #-- returns List of Holdings do: [ security name print: 30 ; #-- security level totalMarketValue print: 15 ; #-- holding level percentOfPort printNL ; #-- holding level ] ;
The class CompositeAccount is used to define the messages that are specific to composite accounts. A CompositeAccount is defined as an Account whose holdings are created as a weighted combination of the holdings in a set of portfolio, aggregate, index and/or other composite accounts defined for the composite.
In addition to the messages defined for the Account class, CompositeAccount instances respond to the following messages:
| Message | Return Class | Description |
|---|---|---|
| componentList | IndexedList | list of CompositeAccount Component instances |
CompositeAccount Component instances are use to define a component account for a CompositeAccount on a specific date. These instances respond to the following messages:
| Message | Return Class | Description |
|---|---|---|
| account | Account | account included in composite |
| compositeAccount | CompositeAccount | composite that includes component |
| date | Date | date in componentList that includes component |
| weight | Number | weight of account in composite on date |
A CompositeAccount can be composed of any number of Account instances. Accounts can be added to and deleted from composites over time. The comonentList message returns the list of CompositeAccount Component instances in the composite as of the evaluation date. For example:
Named CompositeAccount COMP1 componentList #-- current components do: [ account code print: 10 ; #-- account code account name print: 25 ; #-- account name weight printNL ; #-- weight ] ;displays the current list of accounts and weights in CompositeAccount COMP1 and:
9612 evaluate: [ Named CompositeAccount COMP1 componentList #-- 12/31/96 components do: [ account code print: 10 ; #-- account code account name print: 25 ; #-- account name weight printNL ; #-- weight ] ; ] ;displays the list of accounts and weights in CompositeAccount COMP1 as of Dec 31, 1996.
For general descriptions of all the CompositeAccount messages, see the document Vision Application Messages: Account.
The Holdings for a CompositeAccount are created by collecting the holdings associated with each of its component Accounts, deriving shares and market value using the component's weight, and creating a single Holding for each distinct Security represented. CompositeAccount holdings are normally updated whenever the membership of the CompositeAccount is changed.
Holdings are normally created for CompositeAccounts using the CompositeAccountMembers data feed described in the next section.
The CompositeAccountMaster data feed can be used to create and refresh CompositeAccount instances:
Interface ExternalFeedManager upload: "CompositeAccountMaster" using: #-- make sure this is tab-delimited "EntityId Name ShortName COMP1 Composite Account 1 Comp Acct 1 COMP2 Composite Account 2 Comp Acct 2 " ;
The CompositeAccountMembers data feed is used to define the weighted combinations of Portfolio, AggAccount, IndexAccount, and/or other CompositeAccount instances that make up a composite over time. The records supplied by this feed are used to update the CompositeAccount time series property componentList. Whenever a membership is updated with this feed, the holdings for the CompositeAccount are recreated for that date.
For example, this tab-delimited string can be used to define memberships over time:
Interface ExternalFeedManager upload: "CompositeAccountMembers" using: #-- make sure this is tab-delimited "date groupId memberId weight #- create a composite representing 50% of PORT1's holdings 97 COMP1 PORT1 50 #- create a composite representing equal amounts of 4 accounts #- in 95, unequal amounts in 96 95 COMP2 PORT7 25 95 COMP2 AGG1 25 95 COMP2 INDEX7 25 95 COMP2 COMP1 25 96 COMP2 PORT7 33 96 COMP2 AGG1 33 96 COMP2 INDEX7 33 96 COMP2 COMP1 1 " ;
After running this upload, you can access CompositeAccount Comp2's holdings just like any other Account. For example:
Named Account COMP2 holdings #-- returns List of Holdings do: [ security name print: 30 ; #-- security level totalMarketValue print: 15 ; #-- holding level percentOfPort printNL ; #-- holding level ] ;
The Interface class ExternalFeedManager has been created to provide a uniform way to create and update any entity-related information. DataFeed subclasses are defined to translate one or more rows of information into the appropriate structures in your Vision database. Data can be supplied from a file, a spreadsheet, a relational database, or any other table-based source. You can also supply data directly as a string, using the tab character to delimit columns and the carriage return to delimit rows.
Several DataFeed classes have been defined to create and update instances of the Account subclasses and to load holdings for these instances over time:
| DataFeed | Description |
|---|---|
| PortfolioMaster | creates Portfolio instances and refreshes basic properties |
| AggAccountMaster | creates AggAccount instances and refreshes basic properties |
| IndexAccountMaster | creates IndexAccount instances and refreshes basic properties |
| CompositeAccountMaster | creates CompositeAccount instances and refreshes basic properties |
| HoldingsFeed | loads holding records for one or more Portfolio or IndexAccount instances for one or more time periods |
| PortfolioAggregates | defines Portfolio memberships in AggAccounts over time and creates holdings for each period |
| IndexAccountBuilder | creates holdings for one or more IndexAccount instances over time using securities from an existing Universe and a weighting rule |
| CompositeAccountMembers | defines weighted combinations of Portfolio, AggAccount, IndexAccount, and/or other CompositeAccount instances that make up a composite over time |
A number of messages are defined at Security to return related Account and Holding information:
| Message | Return Class | Description |
|---|---|---|
| getAggAccounts | List | list of aggregates that hold security (relative to ^date) |
| getHoldingIn: | Holding | returns holding in supplied portfolio (relative to ^date) |
| getIndexAccounts | List | list of index accounts that include security as a member (relative to ^date) |
| heldIn: | Boolean | is security held in supplied portfolio? |
| holdings | List | list of holdings in recipient (relative to ^date) |
| holdingsDate | Date | effective date of holdings list (relative to ^date) |
The message holdings can be used to access the List of Holdings associated with a Security. For example:
Named Security GM holdings #-- returns List of Holdings do: [ account code print: 5 ; #-- account level account name print: 20 ; #-- account level security price print: 10 ; #-- security level totalMarketValue printNL: 15 ; #-- holding level ] ;
Note that this List of Holding instances only includes Portfolios holdings.
Since holdings are stored over time, you can access the holdings in a Security as of a different date using:
9612 evaluate: [ Named Security GM holdings #-- returns List of Holdings do: [ account code print: 5 ; #-- account level account name print: 20 ; #-- account level security price print: 10 ; #-- security level totalMarketValue printNL: 15 ; #-- holding level ] ; ] ;
| Copyright © 1998 Innovative Systems Techniques, Inc. | Created August 31, 1998 |


Rules: At the Double, Forward to Victory, Inspiring Presence
Categories: COGSMITH, DUARDIN, ENGINEER, HERO, IRONWELD ARSENAL, ORDER, Leader
Unit: Cogsmith, Unit Abilities: Engineer, Weapon: Cog Axe, Duardin Pistols, Grudge-Raker
| Unit | Move | Wounds | Bravery | Save | Ref |
|---|---|---|---|---|---|
| Cogsmith | 4" | 5 | 7 | 5+ |
| Unit Abilities | Ability Details | Ref |
|---|---|---|
| Engineer | In your hero phase, a Cogsmith can repair a single WAR MACHINE within 4". That model repairs 1 wound. |
| Weapon | Type | Range | Attacks | To Hit | To Wound | Rend | Damage | Ref |
|---|---|---|---|---|---|---|---|---|
| Cog Axe | Melee | 1" | 4 | 4+ | 4+ | - | 1 | |
| Duardin Pistols | Missile | 8" | 2 | 4+ | 3+ | -1 | 1 | |
| Grudge-Raker | Missile | 16" | D3 | 4+ | 3+ | -1 | 1 |
Categories: CELESTIAL, HERO, HUMAN, KNIGHT-INCANTOR, ORDER, SACROSANCT, STORMCAST ETERNALS, WIZARD, Leader
Magic: Knight-Incantor, Spell: Arcane Bolt, Mystic Shield, Spirit Storm, Unit: Knight-Incantor, Unit Abilities: Spirit Flask, Voidstorm Scroll, Weapon: Incantor’s Staff
| Magic | Cast/Unbind | Spells Known | Ref |
|---|---|---|---|
| Knight-Incantor | 1/1 | Arcane Bolt, Mystic Shield and Spirit Storm |
| Spell | Casting Value | Description | Ref |
|---|---|---|---|
| Arcane Bolt | 5 | If successfully cast, pick an enemy unit within 18" of the caster that is visible to them. That unit suffers 1 mortal wound. If the casting roll was 10 or more, the unit suffers D3 mortal wounds instead. | |
| Mystic Shield | 6 | If successfully cast, pick a friendly unit within 18" of the caster that is visible to them. Re-roll save rolls of 1 for that unit until your next hero phase. | |
| Spirit Storm | 7 | If successfully cast, each enemy unit within 18" of the caster suffers 1 mortal wound. In addition, until your next hero phase, subtract 1 from run and charge rolls for enemy units while they are within 18" of the caster. |
| Unit | Move | Wounds | Bravery | Save | Ref |
|---|---|---|---|---|---|
| Knight-Incantor | 5" | 5 | 9 | 3+ |
| Unit Abilities | Ability Details | Ref |
|---|---|---|
| Spirit Flask | Once per battle, at the start of the combat phase, you can say that this model will shatter 1, 2 or 3 spirit flasks. If you do so, each unit within 3" of this model suffers 1 mortal wound for each spirit flask that was shattered. Units with 10 or more models suffer D3 mortal wounds for each spirit flask that was shattered instead. Allocate the mortal wounds to this model last of all, after allocating them to any other units that are affected. | |
| Voidstorm Scroll | Once per battle, when this model attempts to unbind a spell, instead of making an unbinding roll you can say this model is using its Voidstorm Scroll. If you do so, the spell is automatically unbound (do not roll the dice). |
| Weapon | Type | Range | Attacks | To Hit | To Wound | Rend | Damage | Ref |
|---|---|---|---|---|---|---|---|---|
| Incantor’s Staff | Melee | 2" | 3 | 3+ | 3+ | -1 | D3 |
Selections: General
Categories: CELESTIAL, HUMAN, ORDER, HERO, WIZARD, STORMCAST ETERNALS, SACROSANCT, LORD-ARCANUM, GRYPH-CHARGER, Leader, General
Command Abilities: Soul Energy, Magic: Lord-Arcanum on Gryph-charger, Spell: Arcane Bolt, Healing Light, Mystic Shield, Unit: Lord-Arcanum on Gryph-charger, Unit Abilities: Aethereal Strike, Cycle of the Storm, Mount, Prime Electrids, Ride the Winds Aetheric, Spirit Flask, Weapon: Aetherstave, Razor Beak and Claws
| Command Abilities | Command Ability Details | Ref |
|---|---|---|
| Soul Energy | You can use this command ability in your hero phase, your shooting phase, or the combat phase. Hero Phase: If you use this command ability in your hero phase, pick a friendly unit of Evocators within 6" of this model. That unit can automatically cast Empower in that hero phase (no casting roll is required, and the spell cannot be unbound). Shooting Phase: If you use this command ability in your shooting phase, pick a friendly unit of Castigators within 6" of this model. You can use Aetheric Channelling to increase the accuracy and power of that unit’s Thunderhead Greatbows in that shooting phase instead of choosing only one of those options. Combat Phase: If you use this command ability in the combat phase, pick a friendly unit of Sequitors within 6" of this model. You can use Aetheric Channelling to increase the power of the unit’s weapons and shields in that combat phase instead of choosing only one of those options. |
| Magic | Cast/Unbind | Spells Known | Ref |
|---|---|---|---|
| Lord-Arcanum on Gryph-charger | 1/1 | Arcane Bolt, Mystic Shield and Healing Light |
| Spell | Casting Value | Description | Ref |
|---|---|---|---|
| Arcane Bolt | 5 | If successfully cast, pick an enemy unit within 18" of the caster that is visible to them. That unit suffers 1 mortal wound. If the casting roll was 10 or more, the unit suffers D3 mortal wounds instead. | |
| Healing Light | 5 | If successfully cast, pick a friendly Stormcast Eternal model within 18" of the caster. Heal D3 wounds that have been allocated to that model. If the casting roll was 8+, heal D6 wounds that have been allocated to that model instead. | |
| Mystic Shield | 6 | If successfully cast, pick a friendly unit within 18" of the caster that is visible to them. Re-roll save rolls of 1 for that unit until your next hero phase. |
| Unit | Move | Wounds | Bravery | Save | Ref |
|---|---|---|---|---|---|
| Lord-Arcanum on Gryph-charger | 12" | 7 | 9 | 3+ |
| Unit Abilities | Ability Details | Ref |
|---|---|---|
| Aethereal Strike | If the unmodified hit roll for an attack made with a Gryph-charger’s Razor Beak and Claws is 6, that attack inflicts 1 mortal wound on the target and the attack sequence ends (do not make a wound or save roll). | |
| Cycle of the Storm | Once per turn, when a friendly STORMCAST ETERNAL model is slain within 18" of this model, instead of removing the slain model, you can heal 1 wound allocated to it. This model cannot use this ability on itself. | |
| Mount | This model’s Gryph-charger attacks with its Razor Beak and Claws. | |
| Prime Electrids | If this model successfully casts Arcane Bolt and it is not unbound, then the spell inflicts D3 mortal wounds instead of 1, or D6 mortal wounds instead of D3 if the casting roll was 10+. | |
| Ride the Winds Aetheric | In your movement phase, this model can Ride the Winds Aetheric instead of moving normally. If it does so, choose the direction in which it will move, and roll 6D6. This model can move up to a number of inches equal to the result in the direction chosen, moving over terrain and other models as if it could fly. It must end the move more than 3" from enemy models – if this is impossible, it cannot move at all. This model cannot charge in a turn in which it Rides the Winds Aetheric. | |
| Spirit Flask | Once per battle, at the start of the combat phase, you can say that this model will shatter 1, 2 or 3 spirit flasks. If you do so, each unit within 3" of this model suffers 1 mortal wound for each spirit flask that was shattered. Units with 10 or more models suffer D3 mortal wounds for each spirit flask that was shattered instead. Allocate the mortal wounds to this model last of all, after allocating them to any other units that are affected. |
| Weapon | Type | Range | Attacks | To Hit | To Wound | Rend | Damage | Ref |
|---|---|---|---|---|---|---|---|---|
| Aetherstave | Melee | 2" | 4 | 3+ | 3+ | -1 | D3 | |
| Razor Beak and Claws | Melee | 1" | 3 | 3+ | 3+ | -2 | 1 |
Categories: CANNON, WAR MACHINE, ORDER, Artillery
Crew Table: Crew0, Crew1, Crew2, Crew3, Crew4, Unit: Cannon, Crew, Unit Abilities: Duardin Artillery, Explosive Shells, Rune of Accuracy, Weapon: Cannon Shell, Crew's Tools
| Crew Table | Variable1 | Variable2 | Variable3 | Ref |
|---|---|---|---|---|
| Crew0 | Crew within 1" | Move | Cannon Shell | |
| Crew1 | 3 models | 4" | 2 | |
| Crew2 | 2 models | 3" | 2 | |
| Crew3 | 1 model | 2" | 1 | |
| Crew4 | No models | 0" | 0" |
| Unit | Move | Wounds | Bravery | Save | Ref |
|---|---|---|---|---|---|
| Cannon | * | 4 | - | 4+ | |
| Crew | 4 | 1 | 6 | 5+ |
| Unit Abilities | Ability Details | Ref |
|---|---|---|
| Duardin Artillery | A Cannon can only move if its Crew are within 1" at the start of the movement phase. If its Crew are within 1" of the Cannon in the shooting phase, they can fire the war machine. The war machine cannot make charge moves, does not need to take battleshock tests and is unaffected by any attack or ability the uses Bravery. The Crew are in cover while they are within 1" of their war machine. | |
| Explosive Shells | You can re-roll the damage inflicted by a Cannon Shell if the target unit has 10 or more models. | |
| Rune of Accuracy | You can re-roll failed hit rolls when firing a Cannon Shell if there is an ENGINEER from your army within 1" of the war machine. |
| Weapon | Type | Range | Attacks | To Hit | To Wound | Rend | Damage | Ref |
|---|---|---|---|---|---|---|---|---|
| Cannon Shell | Missile | 32" | * | 4+ | 2+ | -2 | D6 | |
| Crew's Tools | Melee | 1 | 1 | 4+ | 5+ | - | 1 |
Categories: ORGAN GUN, WAR MACHINE, ORDER, Artillery
Crew Table: Crew0, Crew1, Crew2, Crew3, Crew4, Unit: Crew, Organ Gun, Unit Abilities: Duardin Artillery, Organ Fire, Rune of Forging, Weapon: Barrage of Shots, Crew's Tools
| Crew Table | Variable1 | Variable2 | Variable3 | Ref |
|---|---|---|---|---|
| Crew0 | Crew within 1" | Move | Barrage of Shots | |
| Crew1 | 3 models | 4" | 3+ | |
| Crew2 | 2 models | 3" | 4+ | |
| Crew3 | 1 model | 2" | 5+ | |
| Crew4 | No models | 0" | - |
| Unit | Move | Wounds | Bravery | Save | Ref |
|---|---|---|---|---|---|
| Crew | 4 | 1 | 6 | 5+ | |
| Organ Gun | * | 4 | - | 4+ |
| Unit Abilities | Ability Details | Ref |
|---|---|---|
| Duardin Artillery | An Organ Gun can only move if its Crew are within 1" at the start of the movement phase. If its Crew are within 1" of the Organ Gun in the shooting phase, they can fire the war machine. The war machine cannot make charge moves, does not need to take battleshock tests and is unaffected by any attack or ability the uses Bravery. The Crew are in cover while they are within 1" of their war machine. | |
| Organ Fire | In the shooting phase the Organ Gun's Crew can load 1, 2, 3 or 4 barrels. If they 2 or more barrels, roll a dice; if the result is equal to or greater than the number of loaded barrels, make one Barrage of Shots attack for each loaded barrel (roll separately to determine the number of Barrage of Shots attacks made for each barrel being fired). However, if the result is less than the number of loaded barrels, the Organ Gun jams and no shots are fired this phase. | |
| Rune of Forging | You can re-roll the dice rolled to see if an Organ Gun jams if there is an Engineer from your army within 1" of the war machine. |
| Weapon | Type | Range | Attacks | To Hit | To Wound | Rend | Damage | Ref |
|---|---|---|---|---|---|---|---|---|
| Barrage of Shots | Missile | 28" | D6 | * | 3+ | -1 | 1 | |
| Crew's Tools | Melee | 1 | 1 | 4+ | 5+ | - | 1 |
Selections: 5 Sequitors [130pts]
Categories: CELESTIAL, HUMAN, ORDER, SACROSANCT, STORMCAST ETERNALS, SEQUITORS, REDEEMER, Battleline
Unit: Sequitor, Unit Abilities: Greatmace Blast, Sequitor Aetheric Channelling, Sequitor-Prime, Soulshields
| Unit | Move | Wounds | Bravery | Save | Ref |
|---|---|---|---|---|---|
| Sequitor | 5" | 2 | 7 | 4+ |
| Unit Abilities | Ability Details | Ref |
|---|---|---|
| Greatmace Blast | If the unmodified hit roll for an attack made with a Stormsmite Greatmace that targets a DAEMON or NIGHTHAUNT unit is 6, that attack inflicts D3 hits on the target instead of 1. Make a wound and save roll for each hit. | |
| Sequitor Aetheric Channelling | At the start of the combat phase, you must say if this unit will channel aetheric power into its weapons or its shields. If you choose its weapons, you can re-roll failed hit rolls for attacks made by this unit in that combat phase. If you choose its shields, you can re-roll failed save rolls for attacks that target this unit in that combat phase (instead of only re-rolling save rolls of 1). | |
| Sequitor-Prime | The leader of this unit is a Sequitor-Prime. A Sequitor-Prime can replace the unit’s weapon option with a Stormsmite Greatmace, in addition to any other models in the unit that can do so. Add 1 to the Attacks characteristic of a Sequitor-Prime’s melee weapon. If a Sequitor-Prime is armed with a Stormsmite Maul and Soulshield or Tempest Blade and Soulshield, they may also carry a Redemption Cache. | |
| Soulshields | You can re-roll save rolls of 1 for attacks that target this unit if any models from this unit are carrying a Soulshield. |
Selections: 5 Sequitors [130pts]
Categories: CELESTIAL, HUMAN, ORDER, SACROSANCT, STORMCAST ETERNALS, SEQUITORS, REDEEMER, Battleline
Unit: Sequitor, Unit Abilities: Greatmace Blast, Sequitor Aetheric Channelling, Sequitor-Prime, Soulshields
| Unit | Move | Wounds | Bravery | Save | Ref |
|---|---|---|---|---|---|
| Sequitor | 5" | 2 | 7 | 4+ |
| Unit Abilities | Ability Details | Ref |
|---|---|---|
| Greatmace Blast | If the unmodified hit roll for an attack made with a Stormsmite Greatmace that targets a DAEMON or NIGHTHAUNT unit is 6, that attack inflicts D3 hits on the target instead of 1. Make a wound and save roll for each hit. | |
| Sequitor Aetheric Channelling | At the start of the combat phase, you must say if this unit will channel aetheric power into its weapons or its shields. If you choose its weapons, you can re-roll failed hit rolls for attacks made by this unit in that combat phase. If you choose its shields, you can re-roll failed save rolls for attacks that target this unit in that combat phase (instead of only re-rolling save rolls of 1). | |
| Sequitor-Prime | The leader of this unit is a Sequitor-Prime. A Sequitor-Prime can replace the unit’s weapon option with a Stormsmite Greatmace, in addition to any other models in the unit that can do so. Add 1 to the Attacks characteristic of a Sequitor-Prime’s melee weapon. If a Sequitor-Prime is armed with a Stormsmite Maul and Soulshield or Tempest Blade and Soulshield, they may also carry a Redemption Cache. | |
| Soulshields | You can re-roll save rolls of 1 for attacks that target this unit if any models from this unit are carrying a Soulshield. |
Categories: Battalion
Battalion Abilities: Hailstorm Strike
Selections: 2x 3 Castigators [160pts]
Categories: CELESTIAL, HUMAN, ORDER, SACROSANCT, STORMCAST ETERNALS, CASTIGATORS, JUSTICAR, Other
Unit: Castigator, Unit Abilities: Burst of Celestial Energy, Castigator Aetheric Channelling, Castigator-Prime, Weapon: Heavy Stock, Thunderhead Greatbow
Categories: CELESTIAL, HUMAN, ORDER, CELESTAR BALLISTA, SACROSANCT, STORMCAST ETERNALS, WAR MACHINE, ORDINATOS, Artillery
Unit: Celestar Ballista, Unit Abilities: Bastions of Death, Celestar Ballista, Chained Lightning, Versatile Weapon, Weapon: Celestar Stormbolts: Rapid Fire, Celestar Stormbolts: Single Shot, Sigmarite Blades
Selections: Astral Hammers
Categories: CELESTIAL, HERO, HUMAN, LORD-ORDINATOR, ORDER, STORMCAST ETERNALS, SACROSANCT, Leader
Command Abilities: Solemn Duty, Unit: Lord-Ordinator, Unit Abilities: Arcane Engineer, Meteoric Slam, Weapon: Astral Hammers
| Battalion Abilities | Battalion Ability Details | Ref |
|---|---|---|
| Hailstorm Strike | You can re-roll failed hit rolls for attacks made by the CELESTAR BALLISTA from this battalion if the unit of CASTIGATORS from the same battalion inflicted one or more wounds on the target unit in the same turn. |
| Command Abilities | Command Ability Details | Ref |
|---|---|---|
| Solemn Duty | You can use this command ability at the start of the battleshock phase. If you do so, pick a friendly model with this command ability. Until the end of that phase, you do not have to take battleshock tests for friendly STORMCAST ETERNAL units that are wholly within 18" of that model. |
| Unit | Move | Wounds | Bravery | Save | Ref |
|---|---|---|---|---|---|
| Castigator | 5" | 2 | 7 | 4+ | |
| Celestar Ballista | 3" | 7 | 7 | 4+ | |
| Lord-Ordinator | 5" | 5 | 9 | 4+ |
| Unit Abilities | Ability Details | Ref |
|---|---|---|
| Arcane Engineer | Add 1 to hit rolls for attacks made by ORDER WAR MACHINES while they are wholly within 9" of one or more friendly LORD-ORDINATORS. | |
| Bastions of Death | When this unit is targeted by an enemy missile weapon, add 2 to its save rolls if it is in cover instead of 1. | |
| Burst of Celestial Energy | If the unmodified hit roll for an attack made with a Thunderhead Greatbow that targets a DAEMON or NIGHTHAUNT unit is 6, that attack inflicts D3 hits on the target instead of 1. Make a wound and save roll for each hit. | |
| Castigator Aetheric Channelling | At the start of the shooting phase, you must say if this unit will increase the accuracy or the power of their Thunderhead Greatbows. If you choose accuracy, re-roll hit rolls of 1 for attacks made by this unit in that shooting phase. If you choose power, this unit’s Thunderhead Greatbows have a Rend characteristic of -2 instead of -1 in that shooting phase. | |
| Castigator-Prime | The leader of this unit is a Castigator-Prime. Add 1 to hit rolls for attacks made with a Castigator-Prime’s Thunderhead Greatbow. | |
| Celestar Ballista | The Ballista and its crew are treated as a single model. The crew must remain within 1" of the Ballista. | |
| Chained Lightning | If the hit roll for an attack made with a Celestar Stormbolt scores a hit, that attack inflicts D6 hits on the target instead of 1. Make a wound and save roll for each hit. | |
| Meteoric Slam | If the unmodified hit roll for two or more attacks made against the same enemy unit in the same phase with this model’s Astral Hammers is 6, that enemy unit suffers D3 mortal wounds after all of this model’s attacks have been resolved. | |
| Versatile Weapon | Before attacking with Celestar Stormbolts, choose either the Single Shot or Rapid Fire missile weapon characteristics for that shooting attack. |
| Weapon | Type | Range | Attacks | To Hit | To Wound | Rend | Damage | Ref |
|---|---|---|---|---|---|---|---|---|
| Astral Hammers | Melee | 1" | 6 | 4+ | 3+ | - | 1 | |
| Celestar Stormbolts: Rapid Fire | Missile | 18" | 4 | 5+ | 3+ | -2 | 1 | |
| Celestar Stormbolts: Single Shot | Missile | 36" | 1 | 3+ | 3+ | -2 | 1 | |
| Heavy Stock | Melee | 1" | 2 | 4+ | 4+ | - | 1 | |
| Sigmarite Blades | Melee | 1" | 4 | 4+ | 4+ | - | 1 | |
| Thunderhead Greatbow | Missile | 18" | 1 | 3+ | 3+ | -1 | 1 |
Selections: Allegiance: Stormcast Eternals
Categories: Allegiance
Battle Trait: Scions of the Storm, Shock and Awe, Stormhosts
| Battle Trait | Battle Trait Details | Ref |
|---|---|---|
| Scions of the Storm | Instead of setting up a STORMCAST ETERNAL unit on the battlefield, you can place it to one side and say that it is set up in the Celestial Realm as a reserve unit. You can set up one reserve unit in the Celestial Realm for each unit you have set up on the battlefield. At the end of your movement phase, you can set up one or more of the reserve units in the Celestial Realm on the battlefield, more than 9" from any enemy units. Any reserve units in the Celestial Realm that are not set up on the battlefield before the start of the fourth battle round are slain. | |
| Shock and Awe | Subtract 1 from hit rolls for attacks that target friendly STORMCAST ETERNAL units that were set up on the battlefield during the same turn. | |
| Stormhosts | If your army is a Stormcast Eternals army, you can give it a Stormhost keyword. All STORMCAST ETERNAL units in your army gain that keyword. If a model already has a Stormhost keyword, it cannot gain another one, but this does not prevent other units in your army from having a different Stormhost keyword. You can either choose one of the Stormhosts in the list, or choose another Stormhost you've read about or created yourself. If you choose from the list below, all units with that keyword benefit from the extra abilities listed for that Stormhost. If you choose a different Stormhost, simply pick the Stormhost that most closely matches the nature of your own Stormhost. |
Selections: 1000 Points - Vanguard
Categories: Game Options, Vanguard
At the Double: You can use this command ability after you make a run roll for a friendly unit that is within 6" of a friendly HERO, or 12" of a friendly HERO that is a general.  (Core Rules p3)
Forward to Victory: You can use this command ability after you make a charge roll for a friendly unit that is within 6" of a friendly HERO, or 12" of a friendly HERO that is a general. If you do so, re-roll the charge roll. (Core Rules p3)
Inspiring Presence: You can use this command ability at the start of the battleshock phase. If you do so, pick a friendly unit that is within 6" of friendly HERO, or 12" of a friendly HERO that is a general. That unit does not have to take battleshock tests in that phase. (Core Rules p3)
Created with BattleScribe


ADMIN BAR
new contact
help
address book
Toggle navigation
All Contacts
Favorites
Vendors
Customers
Harry Potter
Boy Who Lived
Ron Weasely
Best Friend
Hermione Granger
The Smart One
Voldemort
He Who Must Not Be Named


Click on the map, click search for a new place, or click on get current location to add a new place (marker) to the event. Click on the marker to check current weather conditions.


Latest News, Featured Image, Weather, Facts, and Images
Get The Most Current Data!
{{mars.latest_news['News Content']}}
{{mars.weather['weather']}}


| Top |
| enum | VipsOperationMath |
| enum | VipsOperationMath2 |
| enum | VipsOperationRound |
| enum | VipsOperationRelational |
| enum | VipsOperationBoolean |
| enum | VipsOperationComplex |
| enum | VipsOperationComplex2 |
| enum | VipsOperationComplexget |
These operations perform pixel arithmetic, that is, they perform an arithmetic operation, such as addition, on every pixel in an image or a pair of images. All (except in a few cases noted below) will work with images of any type or any mixture of types, of any size and of any number of bands.
For binary operations, if the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
In the same way, for operations that take an array constant, such as
vips_remainder_const()
, you can mix single-element arrays or single-band
images freely.
Arithmetic operations try to preserve precision by increasing the number of
bits in the output image when necessary. Generally, this follows the ANSI C
conventions for type promotion, so multiplying two
VIPS_FORMAT_UCHAR images together, for example, produces a
VIPS_FORMAT_USHORT image, and taking the vips_cos()
of a
VIPS_FORMAT_USHORT image produces VIPS_FORMAT_FLOAT image.
For binary arithmetic operations, type promotion occurs in two stages. First, the two input images are cast up to the smallest common format, that is, the type with the smallest range that can represent the full range of both inputs. This conversion can be represented as a table:
Table 3. Smallest common format
in2 /in1
|
uchar | char | ushort | short | uint | int | float | double | complex | double complex |
|---|---|---|---|---|---|---|---|---|---|---|
| uchar | ushort | short | ushort | short | uint | int | float | double | complex | double complex |
| char | short | short | short | short | int | int | float | double | complex | double complex |
| ushort | ushort | short | ushort | short | uint | int | float | double | complex | double complex |
| short | short | short | short | short | int | int | float | double | complex | double complex |
| uint | uint | int | uint | int | uint | int | float | double | complex | double complex |
| int | int | int | int | int | int | int | float | double | complex | double complex |
| float | float | float | float | float | float | float | float | double | complex | double complex |
| double | double | double | double | double | double | double | double | double | double complex | double complex |
| complex | complex | complex | complex | complex | complex | complex | complex | double complex | complex | double complex |
| double complex | double complex | double complex | double complex | double complex | double complex | double complex | double complex | double complex | double complex | double complex |
In the second stage, the operation is performed between the two identical types to form the output. The details vary between operations, but generally the principle is that the output type should be large enough to represent the whole range of possible values, except that int never becomes float.
int vips_add (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
This operation calculates in1
+ in2
and writes the result to out
.
If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
The two input images are cast up to the smallest common format (see table Smallest common format in
arithmetic), then thefollowing table is used to determine the output type:
Table 4. VipsAdd type promotion
| input type | output type |
|---|---|
| uchar | ushort |
| char | short |
| ushort | uint |
| short | int |
| uint | uint |
| int | int |
| float | float |
| double | double |
| complex | complex |
| double complex | double complex |
In other words, the output type is just large enough to hold the whole range of possible values.
Operations on integer images are performed using the processor's vector unit, if possible. Disable this with --vips-novector or IM_NOVECTOR.
See also: vips_subtract()
, vips_linear()
.
left |
input image |
|
right |
input image |
|
out |
output image |
|
... |
|
int vips_sum (VipsImage **in
,VipsImage **out
,int n
,...
);
This operation sums all images in in
and writes the result to out
.
If the images differ in size, the smaller images are enlarged to match the largest by adding zero pixels along the bottom and right.
If the number of bands differs, all but one of the images must have one band.
The input images are cast up to the smallest common format (see table Smallest common format in
arithmetic), then thefollowing table is used to determine the output type:
Table 5. VipsSum type promotion
| input type | output type |
|---|---|
| uchar | uint |
| char | int |
| ushort | uint |
| short | int |
| uint | uint |
| int | int |
| float | float |
| double | double |
| complex | complex |
| double complex | double complex |
In other words, the output type is just large enough to hold the whole range of possible values.
See also: vips_add()
.
in |
array of input images |
|
out |
output image |
|
n |
number of input images |
|
... |
|
int vips_subtract (VipsImage *in1
,VipsImage *in2
,VipsImage **out
,...
);
This operation calculates in1
- in2
and writes the result to out
.
If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
The two input images are cast up to the smallest common format (see table Smallest common format in
arithmetic), then thefollowing table is used to determine the output type:
Table 6. VipsSubtract type promotion
| input type | output type |
|---|---|
| uchar | short |
| char | short |
| ushort | int |
| short | int |
| uint | int |
| int | int |
| float | float |
| double | double |
| complex | complex |
| double complex | double complex |
In other words, the output type is just large enough to hold the whole range of possible values.
See also: vips_add()
, vips_linear()
.
in1 |
input image |
|
in2 |
input image |
|
out |
output image |
|
... |
|
int vips_multiply (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
This operation calculates left
* right
and writes the result to out
.
If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
The two input images are cast up to the smallest common format (see table Smallest common format in
arithmetic), then thefollowing table is used to determine the output type:
Table 7. VipsMultiply type promotion
| input type | output type |
|---|---|
| uchar | ushort |
| char | short |
| ushort | uint |
| short | int |
| uint | uint |
| int | int |
| float | float |
| double | double |
| complex | complex |
| double complex | double complex |
In other words, the output type is just large enough to hold the whole range of possible values.
See also: vips_add()
, vips_linear()
.
left |
left-hand image |
|
right |
right-hand image |
|
out |
output image |
|
... |
|
int vips_divide (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
This operation calculates in1
/ in2
and writes the result to out
. If any
pixels in in2
are zero, the corresponding pixel in out
is also zero.
If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
The two input images are cast up to the smallest common format (see table Smallest common format in
arithmetic), then thefollowing table is used to determine the output type:
Table 8. vips_divide()
type promotion
| input type | output type |
|---|---|
| uchar | float |
| char | float |
| ushort | float |
| short | float |
| uint | float |
| int | float |
| float | float |
| double | double |
| complex | complex |
| double complex | double complex |
In other words, the output type is just large enough to hold the whole range of possible values.
See also: vips_multiply()
, vips_linear()
, vips_pow()
.
left |
input image |
|
right |
input image |
|
out |
output image |
|
... |
|
int vips_linear (VipsImage *in
,VipsImage **out
,double *a
,double *b
,int n
,...
);
Optional arguments:
uchar
: output uchar pixels
Pass an image through a linear transform, ie. (out
= in
* a
+ b
). Output
is float for integer input, double for double input, complex for
complex input and double complex for double complex input. Set uchar
to
output uchar pixels.
If the arrays of constants have just one element, that constant is used for all image bands. If the arrays have more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.
See also: vips_linear1()
, vips_add()
.
in |
image to transform |
|
out |
output image |
|
a |
array of constants for multiplication. |
[array length=n] |
b |
array of constants for addition. |
[array length=n] |
n |
length of constant arrays |
|
... |
|
int vips_linear1 (VipsImage *in
,VipsImage **out
,double a
,double b
,...
);
Optional arguments:
uchar
: output uchar pixels
Run vips_linear()
with a single constant.
See also: vips_linear()
.
in |
image to transform |
|
out |
output image |
|
a |
constant for multiplication |
|
b |
constant for addition |
|
... |
|
int vips_remainder (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
This operation calculates left
% right
(remainder after integer division)
and writes the result to out
. The images may have any
non-complex format. For float formats, vips_remainder()
calculates in1
-
in2
* floor (in1
/ in2
).
If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
The two input images are cast up to the smallest common format (see table Smallest common format in
arithmetic), and that format is theresult type.
See also: vips_remainder_const()
, vips_divide()
, vips_round()
.
int vips_remainder_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
This operation calculates in
% c
(remainder after division by an
array of constants)
and writes the result to out
.
The image may have any
non-complex format. For float formats, vips_remainder_const()
calculates
in
- c
* floor (in
/ c
).
If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.
See also: vips_remainder()
, vips_divide()
, vips_round()
.
in |
input image |
|
out |
output image |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_remainder_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
This operation calculates in
% c
(remainder after division by a
constant)
and writes the result to out
.
The image may have any
non-complex format. For float formats, vips_remainder_const()
calculates
in
- c
* floor (in
/ c
).
If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.
See also: vips_remainder()
, vips_divide()
, vips_round()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_invert (VipsImage *in
,VipsImage **out
,...
);
For unsigned formats, this operation calculates (max - in
), eg. (255 -
in
) for uchar. For signed and float formats, this operation calculates (-1
in
).
For complex images, only the real part is inverted. See also vips_conj()
.
See also: vips_linear()
.
int vips_abs (VipsImage *in
,VipsImage **out
,...
);
This operation finds the absolute value of an image. It does a copy for
unsigned integer types, negate for negative values in
signed integer types, fabs(3)
for
float types, and calculates modulus for complex
types.
See also: vips_sign()
.
int vips_sign (VipsImage *in
,VipsImage **out
,...
);
Finds the unit vector in the direction of the pixel value. For non-complex images, it returns a signed char image with values -1, 0, and 1 for negative, zero and positive pixels. For complex images, it returns a complex normalised to length 1.
See also: vips_abs()
.
int vips_round (VipsImage *in
,VipsImage **out
,VipsOperationRound round
,...
);
Round to an integral value.
Copy for integer types, round float and complex types.
The format of out
is always the same as in
, so you may wish to cast to an
integer format afterwards.
See also: vips_cast()
in |
input VipsImage |
|
out |
output VipsImage |
|
round |
VipsOperationRound rounding operation to perform |
|
... |
|
int vips_floor (VipsImage *in
,VipsImage **out
,...
);
Round to an integral value with VIPS_OPERATION_ROUND_FLOOR. See
vips_round()
.
int vips_ceil (VipsImage *in
,VipsImage **out
,...
);
Round to an integral value with VIPS_OPERATION_ROUND_CEIL. See
vips_round()
.
int vips_rint (VipsImage *in
,VipsImage **out
,...
);
Round to an integral value with VIPS_OPERATION_ROUND_RINT. See
vips_round()
.
int vips_math (VipsImage *in
,VipsImage **out
,VipsOperationMath math
,...
);
Perform various functions in -lm, the maths library, on images.
Angles are expressed in degrees. The output type is float unless the input is double, in which case the output is double.
Non-complex images only.
See also: vips_math2()
.
int vips_sin (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_SIN on an image. See vips_math()
.
int vips_cos (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_COS on an image. See vips_math()
.
int vips_tan (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_TAN on an image. See vips_math()
.
int vips_asin (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_ASIN on an image. See vips_math()
.
int vips_acos (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_ACOS on an image. See vips_math()
.
int vips_atan (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_ATAN on an image. See vips_math()
.
int vips_exp (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_EXP on an image. See vips_math()
.
int vips_exp10 (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_EXP10 on an image. See vips_math()
.
int vips_log (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_LOG on an image. See vips_math()
.
int vips_log10 (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH_LOG10 on an image. See vips_math()
.
int vips_complex (VipsImage *in
,VipsImage **out
,VipsOperationComplex cmplx
,...
);
Perform various operations on complex images.
Angles are expressed in degrees. The output type is complex unless the input is double or dpcomplex, in which case the output is dpcomplex.
int vips_polar (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_COMPLEX_POLAR on an image. See vips_complex()
.
int vips_rect (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_COMPLEX_RECT on an image. See vips_complex()
.
int vips_conj (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_COMPLEX_CONJ on an image. See vips_complex()
.
int vips_complex2 (VipsImage *left
,VipsImage *right
,VipsImage **out
,VipsOperationComplex2 cmplx
,...
);
Perform various binary operations on complex images.
Angles are expressed in degrees. The output type is complex unless the input is double or dpcomplex, in which case the output is dpcomplex.
int vips_cross_phase (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_COMPLEX2_CROSS_PHASE on an image.
See vips_complex2()
.
int vips_complexget (VipsImage *in
,VipsImage **out
,VipsOperationComplexget get
,...
);
Get components of complex images.
The output type is the same as the input type, except VIPS_FORMAT_COMPLEX becomes VIPS_FORMAT_FLOAT and VIPS_FORMAT_DPCOMPLEX becomes VIPS_FORMAT_DOUBLE.
int vips_real (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_COMPLEXGET_REAL on an image. See vips_complexget()
.
int vips_imag (VipsImage *in
,VipsImage **out
,...
);
Perform VIPS_OPERATION_COMPLEXGET_IMAG on an image. See vips_complexget()
.
int vips_complexform (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Compose two real images to make a complex image. If either left
or right
are VIPS_FORMAT_DOUBLE, out
is VIPS_FORMAT_DPCOMPLEX. Otherwise out
is VIPS_FORMAT_COMPLEX. left
becomes the real component of out
and
right
the imaginary.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
See also: vips_complexget()
.
left |
input image |
|
right |
input image |
|
out |
output image |
|
... |
|
int vips_relational (VipsImage *left
,VipsImage *right
,VipsImage **out
,VipsOperationRelational relational
,...
);
Perform various relational operations on pairs of images.
The output type is always uchar, with 0 for FALSE and 255 for TRUE.
Less-than and greater-than for complex images compare the modulus.
If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
The two input images are cast up to the smallest common format (see table Smallest common format in
arithmetic).To decide if pixels match exactly, that is have the same value in every
band, use vips_bandbool()
after this operation to AND or OR image bands
together.
See also: vips_boolean()
, vips_bandbool()
, vips_relational_const()
.
int vips_equal (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_RELATIONAL_EQUAL on a pair of images. See
vips_relational()
.
int vips_notequal (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_RELATIONAL_NOTEQ on a pair of images. See
vips_relational()
.
int vips_less (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_RELATIONAL_LESS on a pair of images. See
vips_relational()
.
int vips_lesseq (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_RELATIONAL_LESSEQ on a pair of images. See
vips_relational()
.
int vips_more (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_RELATIONAL_MORE on a pair of images. See
vips_relational()
.
int vips_moreeq (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_RELATIONAL_MOREEQ on a pair of images. See
vips_relational()
.
int vips_relational_const (VipsImage *in
,VipsImage **out
,VipsOperationRelational relational
,double *c
,int n
,...
);
Perform various relational operations on an image and an array of constants.
The output type is always uchar, with 0 for FALSE and 255 for TRUE.
If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.
See also: vips_boolean()
, vips_relational()
.
in |
input image |
|
out |
output image |
|
relational |
relational operation to perform |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_equal_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_RELATIONAL_EQUAL on an image and a constant. See
vips_relational_const()
.
int vips_notequal_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_RELATIONAL_NOTEQ on an image and a constant. See
vips_relational_const()
.
int vips_less_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_RELATIONAL_LESS on an image and a constant. See
vips_relational_const()
.
int vips_lesseq_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_RELATIONAL_LESSEQ on an image and a constant. See
vips_relational_const()
.
int vips_more_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_RELATIONAL_MORE on an image and a constant. See
vips_relational_const()
.
int vips_moreeq_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_RELATIONAL_MOREEQ on an image and a constant. See
vips_relational_const()
.
int vips_relational_const1 (VipsImage *in
,VipsImage **out
,VipsOperationRelational relational
,double c
,...
);
Perform various relational operations on an image and a constant. See
vips_relational_const()
.
See also: vips_boolean()
, vips_relational()
.
in |
input image |
|
out |
output image |
|
relational |
relational operation to perform |
|
c |
constant |
|
... |
|
int vips_equal_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_RELATIONAL_EQUAL on an image and a constant. See
vips_relational_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_notequal_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_RELATIONAL_NOTEQ on an image and a constant. See
vips_relational_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_less_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_RELATIONAL_LESS on an image and a constant. See
vips_relational_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_lesseq_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_RELATIONAL_LESSEQ on an image and a constant. See
vips_relational_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_more_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_RELATIONAL_MORE on an image and a constant. See
vips_relational_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_moreeq_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_RELATIONAL_MOREEQ on an image and a constant. See
vips_relational_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_boolean (VipsImage *left
,VipsImage *right
,VipsImage **out
,VipsOperationBoolean boolean
,...
);
Perform various boolean operations on pairs of images.
The output image is the same format as the upcast input images for integer types. Float types are cast to int before processing. Complex types are not supported.
If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
The two input images are cast up to the smallest common format (see table Smallest common format in
arithmetic).See also: vips_boolean_const()
.
int vips_andimage (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_BOOLEAN_AND on a pair of images. See
vips_boolean()
.
int vips_orimage (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_BOOLEAN_OR on a pair of images. See
vips_boolean()
.
int vips_eorimage (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_BOOLEAN_EOR on a pair of images. See
vips_boolean()
.
int vips_lshift (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_BOOLEAN_LSHIFT on a pair of images. See
vips_boolean()
.
int vips_rshift (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_BOOLEAN_RSHIFT on a pair of images. See
vips_boolean()
.
int vips_boolean_const (VipsImage *in
,VipsImage **out
,VipsOperationBoolean boolean
,double *c
,int n
,...
);
Perform various boolean operations on an image against an array of constants.
The output type is always uchar, with 0 for FALSE and 255 for TRUE.
If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.
See also: vips_boolean()
, vips_boolean_const1()
.
in |
input image |
|
out |
output image |
|
boolean |
boolean operation to perform |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_andimage_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_BOOLEAN_AND on an image and an array of constants.
See vips_boolean_const()
.
See also: vips_boolean()
, vips_boolean_const1()
.
in |
input image |
|
out |
output image |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_orimage_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_BOOLEAN_OR on an image and an array of constants.
See vips_boolean_const()
.
See also: vips_boolean()
, vips_boolean_const1()
.
in |
input image |
|
out |
output image |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_eorimage_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_BOOLEAN_EOR on an image and an array of constants.
See vips_boolean_const()
.
See also: vips_boolean()
, vips_boolean_const1()
.
in |
input image |
|
out |
output image |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_lshift_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_BOOLEAN_LSHIFT on an image and an array of constants.
See vips_boolean_const()
.
See also: vips_boolean()
, vips_boolean_const1()
.
in |
input image |
|
out |
output image |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_rshift_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_BOOLEAN_LSHIFT on an image and an array of constants.
See vips_boolean_const()
.
See also: vips_boolean()
, vips_boolean_const1()
.
in |
input image |
|
out |
output image |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_boolean_const1 (VipsImage *in
,VipsImage **out
,VipsOperationBoolean boolean
,double c
,...
);
Perform various boolean operations on an image with a single constant. See
vips_boolean_const()
.
See also: vips_boolean()
, vips_boolean_const()
.
in |
input image |
|
out |
output image |
|
boolean |
boolean operation to perform |
|
c |
constant |
|
... |
|
int vips_andimage_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_BOOLEAN_AND on an image and a constant.
See vips_boolean_const1()
.
See also: vips_boolean()
, vips_boolean_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_orimage_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_BOOLEAN_OR on an image and a constant.
See vips_boolean_const1()
.
See also: vips_boolean()
, vips_boolean_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_eorimage_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_BOOLEAN_EOR on an image and a constant.
See vips_boolean_const1()
.
See also: vips_boolean()
, vips_boolean_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_lshift_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_BOOLEAN_LSHIFT on an image and a constant.
See vips_boolean_const1()
.
See also: vips_boolean()
, vips_boolean_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_rshift_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_BOOLEAN_RSHIFT on an image and a constant.
See vips_boolean_const1()
.
See also: vips_boolean()
, vips_boolean_const()
.
in |
input image |
|
out |
output image |
|
c |
constant |
|
... |
|
int vips_math2 (VipsImage *left
,VipsImage *right
,VipsImage **out
,VipsOperationMath2 math2
,...
);
This operation calculates a 2-ary maths operation on a pair of images
and writes the result to out
. The images may have any
non-complex format. out
is float except in the case that either of left
or right
are double, in which case out
is also double.
It detects division by zero, setting those pixels to zero in the output. Beware: it does this silently!
If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.
If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.
The two input images are cast up to the smallest common format (see table Smallest common format in
arithmetic), and that format is theresult type.
See also: vips_math2_const()
.
int vips_pow (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH2_POW on a pair of images. See
vips_math2()
.
int vips_wop (VipsImage *left
,VipsImage *right
,VipsImage **out
,...
);
Perform VIPS_OPERATION_MATH2_WOP on a pair of images. See
vips_math2()
.
int vips_math2_const (VipsImage *in
,VipsImage **out
,VipsOperationMath2 math2
,double *c
,int n
,...
);
This operation calculates various 2-ary maths operations on an image and
an array of constants and writes the result to out
.
The image may have any
non-complex format. out
is float except in the case that in
is double, in which case out
is also double.
It detects division by zero, setting those pixels to zero in the output. Beware: it does this silently!
If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.
See also: vips_math2()
, vips_math()
.
in |
input image |
|
out |
output image |
|
math2 |
math operation to perform |
|
c |
array of constants |
|
n |
number of constants in |
|
... |
|
int vips_pow_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_MATH2_POW on an image and a constant. See
vips_math2_const()
.
int vips_wop_const (VipsImage *in
,VipsImage **out
,double *c
,int n
,...
);
Perform VIPS_OPERATION_MATH2_WOP on an image and a constant. See
vips_math2_const()
.
int vips_math2_const1 (VipsImage *in
,VipsImage **out
,VipsOperationMath2 math2
,double c
,...
);
This operation calculates various 2-ary maths operations on an image and
a constant. See vips_math2_const()
.
in |
input image |
|
out |
output image |
|
math2 |
math operation to perform |
|
c |
constant |
|
... |
|
int vips_pow_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_MATH2_POW on an image and a constant. See
vips_math2_const()
.
int vips_wop_const1 (VipsImage *in
,VipsImage **out
,double c
,...
);
Perform VIPS_OPERATION_MATH2_WOP on an image and a constant. See
vips_math2_const()
.
int vips_avg (VipsImage *in
,double *out
,...
);
This operation finds the average value in an image. It operates on all
bands of the input image: use vips_stats()
if you need to calculate an
average for each band. For complex images, return the average modulus.
See also: vips_stats()
, vips_bandmean()
, vips_deviate()
, vips_rank()
int vips_deviate (VipsImage *in
,double *out
,...
);
This operation finds the standard deviation of all pixels in in
. It
operates on all bands of the input image: use vips_stats()
if you need
to calculate an average for each band.
Non-complex images only.
See also: vips_avg()
, vips_stats()
..
int vips_min (VipsImage *in
,double *out
,...
);
Optional arguments:
x
: horizontal position of minimum
y
: vertical position of minimum
size
: number of minima to find
out_array
: return array of minimum values
x_array
: corresponding horizontal positions
y_array
: corresponding vertical positions
This operation finds the minimum value in an image.
By default it finds the single smallest value. If size
is set >1, it will
find the size
smallest values. It will stop searching early if has found
enough values.
It operates on all
bands of the input image: use vips_stats()
if you need to find an
minimum for each band.
For complex images, this operation finds the minimum modulus.
You can read out the position of the minimum with x
and y
. You can read
out arrays of the values and positions of the top size
minima with
out_array
, x_array
and y_array
.
These values are returned sorted from
smallest to largest.
See also: vips_min()
, vips_stats()
.
int vips_max (VipsImage *in
,double *out
,...
);
Optional arguments:
x
: horizontal position of maximum
y
: vertical position of maximum
size
: number of maxima to find
out_array
: return array of maximum values
x_array
: corresponding horizontal positions
y_array
: corresponding vertical positions
This operation finds the maximum value in an image.
By default it finds the single largest value. If size
is set >1, it will
find the size
largest values. It will stop searching early if has found
enough values.
It operates on all
bands of the input image: use vips_stats()
if you need to find an
maximum for each band.
For complex images, this operation finds the maximum modulus.
You can read out the position of the maximum with x
and y
. You can read
out arrays of the values and positions of the top size
maxima with
out_array
, x_array
and y_array
. These values are returned sorted from
largest to smallest.
See also: vips_min()
, vips_stats()
.
int vips_stats (VipsImage *in
,VipsImage **out
,...
);
Find many image statistics in a single pass through the data. out
is a
one-band VIPS_FORMAT_DOUBLE image of at least 10 columns by n + 1
(where n is number of bands in image in
)
rows. Columns are statistics, and are, in order: minimum, maximum, sum,
sum of squares, mean, standard deviation, x coordinate of minimum, y
coordinate of minimum, x coordinate of maximum, y coordinate of maximum.
Later versions of vips_stats()
may add more columns.
Row 0 has statistics for all bands together, row 1 has stats for band 1, and so on.
See also: vips_avg()
, vips_min()
.
in |
image to scan |
|
out |
image of statistics |
|
... |
|
int vips_measure (VipsImage *in
,VipsImage **out
,int h
,int v
,...
);
Optional arguments:
left
: area of image containing chart
top
: area of image containing chart
width
: area of image containing chart
height
: area of image containing chart
Analyse a grid of colour patches, producing an array of patch averages. The mask has a row for each measured patch and a column for each image band. The operations issues a warning if any patch has a deviation more than 20% of the mean. Only the central 50% of each patch is averaged.
If the chart does not fill the whole image, use the optional left
, top
,
width
, height
arguments to indicate the
position of the chart.
See also: vips_avg()
, vips_deviate()
.
in |
image to measure |
|
out |
array of measurements |
|
h |
patches across chart |
|
v |
patches down chart |
|
... |
|
int vips_getpoint (VipsImage *in
,double **vector
,int *n
,int x
,int y
,...
);
Reads a single pixel on an image.
The pixel values are returned in vector
, the length of the
array in n
. You must free the array with g_free()
when you are done with
it.
See also: vips_draw_point()
.
in |
image to read from |
|
vector |
array length=n: output pixel value here |
|
n |
length of output vector |
|
x |
position to read |
|
y |
position to read |
|
... |
|
int vips_hist_find (VipsImage *in
,VipsImage **out
,...
);
Optional arguments:
band
: band to equalise
Find the histogram of in
. Find the histogram for band band
(producing a
one-band histogram), or for all bands (producing an n-band histogram) if
band
is -1.
in
is cast to u8 or u16. out
is always u32.
See also: vips_hist_find_ndim()
, vips_hist_find_indexed()
.
int vips_hist_find_ndim (VipsImage *in
,VipsImage **out
,...
);
Optional arguments:
bins
: number of bins to make on each axis
Make a one, two or three dimensional histogram of a 1, 2 or
3 band image. Divide each axis into bins
bins .. ie.
output is 1 x bins, bins x bins, or bins x bins x bins bands.
bins
defaults to 10.
Images are cast to uchar or ushort before histogramming.
See also: vips_hist_find()
, vips_hist_find_indexed()
.
int vips_hist_find_indexed (VipsImage *in
,VipsImage *index
,VipsImage **out
,...
);
Make a histogram of in
, but use image index
to pick the bins. In other
words, element zero in out
contains the sum of all the pixels in in
whose corresponding pixel in index
is zero.
index
must have just one band and be u8 or u16. in
must be
non-complex. out
always has the same size and format as in
.
This operation is useful in conjunction with vips_labelregions()
. You can
use it to find the centre of gravity of blobs in an image, for example.
See also: vips_hist_find()
, vips_labelregions()
.
in |
input image |
|
index |
input index image |
|
out |
output image |
|
... |
|
int vips_hough_line (VipsImage *in
,VipsImage **out
,...
);
Optional arguments:
width
: horizontal size of parameter space
height
: vertical size of parameter space
Find the line Hough transform for in
. in
must have one band. out
has one
band, with pixels being the number of votes for that line. The X dimension
of out
is the line angle, the Y dimension is the distance of the line from
the origin.
Use width
height
to set the size of the parameter space image (out
),
that is, how accurate the line determination should be.
See also: vips_hough_circle()
.
int vips_hough_circle (VipsImage *in
,VipsImage **out
,...
);
Optional arguments:
scale
: scale down dimensions by this much
min_radius
: smallest radius to search for
max_radius
: largest radius to search for
Find the circular Hough transform of an image. in
must be one band, with
non-zero pixels for image edges. out
is three-band, with the third channel
representing the detected circle radius. The operation scales the number of
votes by circle circumference so circles of differing size are given equal
weight.
Use max_radius
and min_radius
to set the range of radii to search for.
Use scale
to set how in
coordinates are scaled to out
coordinates. A
scale
of 3, for example, will make out
1/3rd of the width and height of
in
, and reduce the number of radii tested (and hence the number of bands
int out
) by a factor of three as well.
See also: vips_hough_line()
.
int vips_project (VipsImage *in
,VipsImage **columns
,VipsImage **rows
,...
);
Find the horizontal and vertical projections of an image, ie. the sum of every row of pixels, and the sum of every column of pixels. The output format is uint, int or double, depending on the input format.
Non-complex images only.
See also: vips_hist_find()
, vips_profile()
.
in |
input image |
|
columns |
sums of columns |
|
rows |
sums of rows |
|
... |
|
int vips_profile (VipsImage *in
,VipsImage **columns
,VipsImage **rows
,...
);
vips_profile() searches inward from the edge of in
and finds the
first non-zero pixel. Pixels in columns
have the distance from the top edge
to the first non-zero pixel in that column, rows
has the distance from the
left edge to the first non-zero pixel in that row.
See also: vips_project()
, vips_hist_find()
.
in |
input image |
|
columns |
distances from top edge |
|
rows |
distances from left edge |
|
... |
|
See also: vips_math()
.


Defines the customizable properties of an ACTileNavigationBar
that control it's look and feel.
More...
Defines the customizable properties of an ACTileNavigationBar
that control it's look and feel.
| ActionComponents.ACTileNavigationBarAppearance.ACTileNavigationBarAppearance |
( |
| ) |
|
Initializes a new instance of the T:ActionComponents.ACTileNavigationBarAppearance class.
| ActionComponents.ACTileNavigationBarAppearance.ACTileNavigationBarAppearance |
( |
ACColor |
background, |
|
|
ACColor |
darkBackground |
|
) |
| |
Initializes a new instance of the T:ActionComponents.ACTileNavigationBarAppearance class.
- Parameters
-
| background | Background. |
| darkBackground | the dark background color. |
| ActionComponents.ACTileNavigationBarAppearance.ACTileNavigationBarAppearance |
( |
ACColor |
background, |
|
|
ACColor |
darkBackground, |
|
|
ACColor |
titleColor |
|
) |
| |
Initializes a new instance of the T:ActionComponents.ACTileNavigationBarAppearance class.
- Parameters
-
| background | Background. |
| darkBackground | the dark background color. |
| titleColor | Title color. |
| bool ActionComponents.ACTileNavigationBarAppearance.autoDarkenBackground |
|
getset |
Gets or sets a value indicating whether the ACTileNavigationBar
will automatically darken background when the tiles scroll under it.
true
if auto darken background; otherwise, false
.
| ACColor ActionComponents.ACTileNavigationBarAppearance.background |
|
getset |
Gets or sets the background color
The background color
| int ActionComponents.ACTileNavigationBarAppearance.barHeight |
|
getset |
Gets or sets the height of the bar.
The height of the bar.
| ACColor ActionComponents.ACTileNavigationBarAppearance.darkBackground |
|
getset |
Gets or sets the dark background.
The dark background.
| ACColor ActionComponents.ACTileNavigationBarAppearance.titleColor |
|
getset |
Gets or sets the color of the title.
The color of the title.
| int ActionComponents.ACTileNavigationBarAppearance.titleSize |
|
getset |
Gets or sets the size of the title.
The size of the title.
| int ActionComponents.ACTileNavigationBarAppearance.topPadding |
|
getset |
Gets or sets the top padding that is applied to the navigation bar.
The top padding.
| int ActionComponents.ACTileNavigationBarAppearance.totalHeight |
|
get |
Gets the total height of the navigation bar.
The total height as the topPadding
plus the barHeight
.