Tap this icon to go to the Global menu, where you can:
Search using SpeedSearch.
Use Quick Actions to quickly add an Account/Contact.
Use Go To to access all of the record types in the Mobile Client.
Use Configure Menu to change the items in the Go To menu and specify the order in which they appear. The first item in the list on the Configure Menu screen becomes your default view and loads first after you log on.
Use Settings to clear saved credentials, clear storage and access error logs.
The "Clear Storage" option under Settings is strictly a trouble-shooting device to clear locally stored configuration.
Find Help.
Log out.
Connection shows whether your Mobile Client is Online (the header bar in records will display as blue) or Offline (the header bar will display as gray).
Tap this icon to go to the Contextual (right) menu. Options available vary by record type.
Available hashtags
Key Performance Indicators (KPIs)
Expand Groups, Configure to select the groups to show on your list views. This is available on Account, Contact, Lead, Opportunity, and Ticket list views.
Select a Layout. This is available on Account, Contact, Lead, Opportunity, and Ticket list views. The layout you select becomes the default when you return to this record type later.
Summary layout shows as 4 fields in 1 column. This is the default.
Detail layout shows fields in 1 to 3 columns depending on the width of your device.
Note: If you have access to the CRM Web or Windows Client, you can modify how some fields display in these Mobile Summary and Detail layouts.
From the Web Client Account, Contact, Lead, Opportunity, or Ticket List view, right-click on a group tab, click Edit, and then click the Layout tab:
Drag and drop columns to change their order.
Display currency fields in green text: select the Potential column, click Edit, expand the Format type field drop-down and select Currency, click OK.
Display phone numbers as a clickable link: select the Phone number click Edit expand the Format type field drop-down and select Phone number, click OK.
See the Web or Windows Client help for more information about editing groups.
This icon indicates that you can expand and collapse panels to show/hide additional details.
This icon indicates that you can add a new record to CRM. It is available on all list views.
When the Refresh button is available, tap it to immediately refresh information. Select a record to limit the refresh to that record. When no record is selected, data for the entire group is refreshed.
Blue text in detail views signifies a link action (such as browsing to a URL or jumping to an Account).
Quick Actions
In list views, tap the record icon avatar to see and access short-cuts to frequently-used features. The options available will vary depending on the record type. (Some quick action icons may be unavailable. For example, in My Activities, the Decline action will be unavailable if you have already accepted the meeting.) My Activities and Attachments are available in Saleslogix 8.0 and later.
Use Configure to change the visibility and order of the items in the Quick Action pane.
Activity Indicators
Past Due
Alarm
Last Touched
Priority
Recurring
Working Offline
Three features allow read-only access to select records and entities when your Mobile Client is offline or loses connectivity.
Recently Viewed shows any detail views visited, so they are available if connectivity is lost. Recently Viewed is available on the Global Menu.
My Briefcase allows you to select records to be available when offline. To add items to My Briefcase, in the detail view, open a record, and then click the briefcase icon located in the header bar. All related data for that record is also moved to the Briefcase. When you open a record from the My Briefcase view, the header bar is gray because the Briefcase is always in offline mode.
My Schedule shows today's activities. My Schedule is available on the Global Menu. You can move all activities in the My Schedule list view into My Briefcase. To do this, open the My Schedule list view and click the briefcase icon located in the header bar.
Search
There are multiple ways to search:
From the Global menu, find all related accounts, contacts, leads, opportunities, activities, notes\history, and tickets. Enter more text to improve the accuracy of your search.
From the Contextual menu, filter list view results using pre-defined hashtag keywords.
For each entity, filter list view results from the lookup bar using the fields specified below.


Characterized as a designer dog, this breed was created by crossing a Golden Retriever with a Poodle.
They have superior intelligence which makes them easy to train and they are not usually considered barkers.
Their coat can be slightly wavy (closer to their Golden Retriever side) or more curly or wiry (closer to the Poodle coat).
In order to avoid matting, brushing your Goldendoodle multiple times throughout the week is a good habit to develop.
A big reason many people purchase goldendoodles is to have an amazing companion without all of the pesky hair everywhere.


Table of Contents - RDoc Documentation
Pages
- CODE_OF_CONDUCT
- Gemfile
- Gemfile.lock
- README
- Rakefile
- artifactory-cleaner.gemspec
- artifactory-cleaner.iml
- setup
- filterlist.yaml
- clean-amzn.yaml
- snapshots.yaml
- test-filter.yaml
- yum-test.yaml
- archive-test-4.log
- buckets-2020-01-31
- clean-test-2.log
- clean-test-3.log
- clean-test-5.log
- clean-test-6.log
- clean-test-7.log
- clean-test-8-real.log
- clean-test-9.log
- clean-test1.log
- yum-test.2020-01-31.log
- yum-test_dry-run.log
Classes and Modules
- Artifactory
- Artifactory::Cleaner
- Artifactory::Cleaner::ArtifactBucket
- Artifactory::Cleaner::ArtifactBucketCollection
- Artifactory::Cleaner::ArtifactFilter
- Artifactory::Cleaner::ArtifactFilterRule
- Artifactory::Cleaner::CLI
- Artifactory::Cleaner::Controller
- Artifactory::Cleaner::DiscoveredArtifact
- Artifactory::Cleaner::DiscoveryWorker
- Artifactory::Cleaner::Error
- Artifactory::Cleaner::SpecHelpers
- Artifactory::Cleaner::Util
- Float
- Object
Methods
- ::default_repo_table_cols — Artifactory::Cleaner::CLI
- ::earliest_date_from — Artifactory::Cleaner::DiscoveredArtifact
- ::filesize — Artifactory::Cleaner::Util
- ::latest_date_from — Artifactory::Cleaner::DiscoveredArtifact
- ::new — Artifactory::Cleaner::ArtifactBucket
- ::new — Artifactory::Cleaner::ArtifactBucketCollection
- ::new — Artifactory::Cleaner::ArtifactFilter
- ::new — Artifactory::Cleaner::ArtifactFilterRule
- ::new — Artifactory::Cleaner::CLI
- ::new — Artifactory::Cleaner::Controller
- ::new — Artifactory::Cleaner::DiscoveryWorker
- ::repo_table_cols — Artifactory::Cleaner::CLI
- #<< — Artifactory::Cleaner::ArtifactBucket
- #<< — Artifactory::Cleaner::ArtifactBucketCollection
- #<< — Artifactory::Cleaner::ArtifactFilter
- #<=> — Artifactory::Cleaner::ArtifactFilterRule
- #[] — Artifactory::Cleaner::ArtifactBucketCollection
- #[] — Artifactory::Cleaner::ArtifactFilter
- #[]= — Artifactory::Cleaner::ArtifactBucket
- #[]= — Artifactory::Cleaner::ArtifactFilter
- #action_for — Artifactory::Cleaner::ArtifactFilter
- #action_for — Artifactory::Cleaner::ArtifactFilterRule
- #add — Artifactory::Cleaner::ArtifactBucketCollection
- #alive? — Artifactory::Cleaner::DiscoveryWorker
- #archive — Artifactory::Cleaner::CLI
- #archive_artifact — Artifactory::Cleaner::Controller
- #artifact_count — Artifactory::Cleaner::ArtifactBucketCollection
- #artifact_usage_search — Artifactory::Cleaner::Controller
- #bsearch — Artifactory::Cleaner::ArtifactFilter
- #bucket — Artifactory::Cleaner::ArtifactBucketCollection
- #bucket_sizes — Artifactory::Cleaner::ArtifactBucketCollection
- #bucketize_artifacts — Artifactory::Cleaner::Controller
- #bucketized_artifact_report — Artifactory::Cleaner::Controller
- #catagorize_old_assets — Artifactory::Cleaner::Controller
- #clean — Artifactory::Cleaner::CLI
- #clear — Artifactory::Cleaner::ArtifactBucketCollection
- #covers? — Artifactory::Cleaner::ArtifactBucket
- #define_buckets — Artifactory::Cleaner::ArtifactBucketCollection
- #delete_artifact — Artifactory::Cleaner::Controller
- #discover_artifacts_from_search — Artifactory::Cleaner::Controller
- #discover_repos — Artifactory::Cleaner::Controller
- #each — Artifactory::Cleaner::ArtifactFilter
- #earliest_date — Artifactory::Cleaner::DiscoveredArtifact
- #excludes? — Artifactory::Cleaner::ArtifactFilterRule
- #filename — Artifactory::Cleaner::DiscoveredArtifact
- #filter — Artifactory::Cleaner::ArtifactFilter
- #first — Artifactory::Cleaner::ArtifactFilter
- #generate_artifact — Artifactory::Cleaner::SpecHelpers
- #generate_rule — Artifactory::Cleaner::SpecHelpers
- #includes? — Artifactory::Cleaner::ArtifactFilterRule
- #kill — Artifactory::Cleaner::DiscoveryWorker
- #last — Artifactory::Cleaner::ArtifactFilter
- #last_downloaded — Artifactory::Cleaner::DiscoveredArtifact
- #latest_date — Artifactory::Cleaner::DiscoveredArtifact
- #list_repos — Artifactory::Cleaner::CLI
- #matches? — Artifactory::Cleaner::ArtifactFilterRule
- #push — Artifactory::Cleaner::ArtifactBucket
- #push — Artifactory::Cleaner::ArtifactFilter
- #recalculate_filesize — Artifactory::Cleaner::ArtifactBucket
- #regex= — Artifactory::Cleaner::ArtifactFilterRule
- #regexp= — Artifactory::Cleaner::ArtifactFilterRule
- #report — Artifactory::Cleaner::ArtifactBucketCollection
- #running? — Artifactory::Cleaner::DiscoveryWorker
- #shutdown — Artifactory::Cleaner::DiscoveryWorker
- #slice — Artifactory::Cleaner::ArtifactFilter
- #sort! — Artifactory::Cleaner::ArtifactFilter
- #start — Artifactory::Cleaner::DiscoveryWorker
- #stop — Artifactory::Cleaner::DiscoveryWorker
- #to_s — Artifactory::Cleaner::DiscoveredArtifact
- #to_s — Artifactory::Cleaner::DiscoveryWorker
- #unshift — Artifactory::Cleaner::ArtifactBucket
- #unshift — Artifactory::Cleaner::ArtifactFilter
- #usage_report — Artifactory::Cleaner::CLI
- #verbose= — Artifactory::Cleaner::Controller
- #verbose? — Artifactory::Cleaner::Controller
- #version — Artifactory::Cleaner::CLI
- #with_discovered_artifacts — Artifactory::Cleaner::Controller
- #working? — Artifactory::Cleaner::DiscoveryWorker
- #yaml_format — Artifactory::Cleaner::Controller


{% extends 'base.html'%} {% block content %}
Smith then proclaims: “don’t ever let somebody tell you that you can’t do something, not even me.”
View More..Last updated 3 mins ago
Sometimes I say ‘I am a treasure hunter and awesomizer’. This causes frowning and questioning. Then the conversations take off.
View More..Last updated 3 mins ago


Struct ModOp
A 3-dimensional modification operation implemented as a homogenous matrix 4*3. You can apply such a modification to GeoPoints or GeoVectors or you can use it for GeoObjects Modify(ModOp). If you want to move, rotate, scale reflect or generally modify a GeoObject you will need this class. Use the static methods to create ModOps that do a required modification (like CADability.ModOp.Rotate(System.Int32,CADability.SweepAngle), Translate(Double, Double, Double) etc.
Inherited Members
Namespace: CADability
Assembly: CADability.dll
Syntax
[Serializable]
[JsonVersion(serializeAsStruct = true, version = 1)]
public struct ModOp : ISerializable, IJsonSerialize
Constructors
| Improve this Doc View SourceModOp(IJsonReadStruct)
Declaration
public ModOp(IJsonReadStruct data)
Parameters
| Type | Name | Description |
|---|---|---|
| IJsonReadStruct | data |
ModOp(Double, Double, Double, Double, Double, Double, Double, Double, Double, Double, Double, Double)
Creates a modification according to the given coefficients
Declaration
public ModOp(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | m00 | |
| System.Double | m01 | |
| System.Double | m02 | |
| System.Double | m03 | |
| System.Double | m10 | |
| System.Double | m11 | |
| System.Double | m12 | |
| System.Double | m13 | |
| System.Double | m20 | |
| System.Double | m21 | |
| System.Double | m22 | |
| System.Double | m23 |
ModOp(Double[,])
Declaration
public ModOp(double[, ] m)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | m |
ModOp(Double[,], GeoVector)
Declaration
public ModOp(double[, ] m, GeoVector trans)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | m | |
| GeoVector | trans |
Properties
| Improve this Doc View SourceDeterminant
Returns the determinant of the matrix of this modification.
Declaration
public double Determinant { get; }
Property Value
| Type | Description |
|---|---|
| System.Double |
Factor
Gets the scaling factor if appropriate
Declaration
public double Factor { get; }
Property Value
| Type | Description |
|---|---|
| System.Double |
Identity
Creates a modification that leaves everything unchanged.
Declaration
public static ModOp Identity { get; }
Property Value
| Type | Description |
|---|---|
| ModOp |
IsIsogonal
Same as IsOrthogonal but with scaling allowed
Declaration
public bool IsIsogonal { get; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
IsNull
Returns true for ModOps that are 0.0 in all components. Uninitialized ModOp objects will return true. Usually used for a test, whether it has been initialized, since a 0 ModOp shouldn't occur in normal circumstances.
Declaration
public bool IsNull { get; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
IsOrthogonal
Returns true if orthogonal vectors stay orthogonal after transformation and no scaling is performed
Declaration
public bool IsOrthogonal { get; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
Item[Int32, Int32]
Declaration
public double this[int i, int j] { get; set; }
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | i | |
| System.Int32 | j |
Property Value
| Type | Description |
|---|---|
| System.Double |
Matrix
Gets or sets the Matrix that defines this mmodification
Declaration
public double[, ] Matrix { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Double[,] |
Mode
Gets the kind of operation this ModOp performs.
Declaration
public ModOp.ModificationMode Mode { get; }
Property Value
| Type | Description |
|---|---|
| ModOp.ModificationMode |
Null
Creates a modification that makes everythin to 0
Declaration
public static ModOp Null { get; }
Property Value
| Type | Description |
|---|---|
| ModOp |
Oriented
Gets the orientation of this ModOp. True means orientation is preserved (e.g. lefthanded yields lefthanded), false means orientation is reversed (lefthanded yields righthanded and vice versa) when this ModOp is applied to vectors.
Declaration
public bool Oriented { get; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
Translation
Returns the translation vector of this ModOp
Declaration
public GeoVector Translation { get; set; }
Property Value
| Type | Description |
|---|---|
| GeoVector |
Methods
| Improve this Doc View SourceFit(GeoPoint, GeoVector[], GeoPoint, GeoVector[])
Declaration
public static ModOp Fit(GeoPoint srcLoc, GeoVector[] src, GeoPoint dstLoc, GeoVector[] dst)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoPoint | srcLoc | |
| GeoVector[] | src | |
| GeoPoint | dstLoc | |
| GeoVector[] | dst |
Returns
| Type | Description |
|---|---|
| ModOp |
Fit(GeoPoint[], GeoPoint[], Boolean)
Constructs a ModOp, that transforms the Src points to the Dst points. The length of Src and Dst must be equal and less than 5. If the length is 1, the resulting ModOp is a translation, if the length is 2, the parameter DoScale decides whether the resulting ModOp is a translation and rotation (DoScale==false) or translation, rotation and scaling (DoScale==true). If the length is 3 or 4, the resulting ModOp is any kind of an affinity, that projects the src points to the dst points.
Declaration
public static ModOp Fit(GeoPoint[] Src, GeoPoint[] Dst, bool DoScale)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoPoint[] | Src | source points |
| GeoPoint[] | Dst | destination points |
| System.Boolean | DoScale | scaling if two point pairs are given |
Returns
| Type | Description |
|---|---|
| ModOp | resulting transformation |
GetInverse()
Returns the inverse of this modification.
Declaration
public ModOp GetInverse()
Returns
| Type | Description |
|---|---|
| ModOp | inverse |
ReflectPlane()
Constructs a ModOp, that performs a reflection about the y/z plane
Declaration
public static ModOp ReflectPlane()
Returns
| Type | Description |
|---|---|
| ModOp | resulting transformation |
ReflectPlane(Plane)
Constructs a ModOp, that performs a reflection about the given plane
Declaration
public static ModOp ReflectPlane(Plane pln)
Parameters
| Type | Name | Description |
|---|---|---|
| Plane | pln | plane for reflection |
Returns
| Type | Description |
|---|---|
| ModOp | resulting transformation |
ReflectPoint(GeoPoint)
Constructs a ModOp, that performs a reflection about the given point
Declaration
public static ModOp ReflectPoint(GeoPoint center)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoPoint | center |
Returns
| Type | Description |
|---|---|
| ModOp | resulting transformation |
Rotate(GeoPoint, GeoVector, GeoVector)
Creates a rotation around the fixpoint that moves the vector from
to the vector to
.
Declaration
public static ModOp Rotate(GeoPoint fixPoint, GeoVector from, GeoVector to)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoPoint | fixPoint | |
| GeoVector | from | Source vector |
| GeoVector | to | Destination vector |
Returns
| Type | Description |
|---|---|
| ModOp | The modification that performs the rotation |
Rotate(GeoPoint, GeoVector, SweepAngle)
Creates a modification that performs a rotation about an axis through the given point
Declaration
public static ModOp Rotate(GeoPoint FixPoint, GeoVector Axis, SweepAngle Rotation)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoPoint | FixPoint | point on the axis |
| GeoVector | Axis | direction of the axis |
| SweepAngle | Rotation | rotation angle |
Returns
| Type | Description |
|---|---|
| ModOp | the resulting modification |
Rotate(GeoVector, SweepAngle)
Creates a modification that performs a rotation about an axis through the origina
Declaration
public static ModOp Rotate(GeoVector Axis, SweepAngle Rotation)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoVector | Axis | direction of the axis |
| SweepAngle | Rotation | rotation angle |
Returns
| Type | Description |
|---|---|
| ModOp | the resulting modification |
Rotate(GeoVector, Double, Double)
Declaration
public static ModOp Rotate(GeoVector Axis, double sin, double cos)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoVector | Axis | |
| System.Double | sin | |
| System.Double | cos |
Returns
| Type | Description |
|---|---|
| ModOp |
Scale(GeoPoint, GeoVector, Double)
Creates a modification that performs a scaling in a given direction with a fixpoint
Declaration
public static ModOp Scale(GeoPoint FixPoint, GeoVector Direction, double Factor)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoPoint | FixPoint | fixpoint for the scaling |
| GeoVector | Direction | direction for the scaling |
| System.Double | Factor | scaling factor for the given direction |
Returns
| Type | Description |
|---|---|
| ModOp | the resulting modification |
Scale(GeoPoint, Double)
Creates a modification that performs a scaling about a given point
Declaration
public static ModOp Scale(GeoPoint FixPoint, double Factor)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoPoint | FixPoint | fixpoint for the scaling |
| System.Double | Factor | scaling factor |
Returns
| Type | Description |
|---|---|
| ModOp | the resulting modification |
Scale(GeoVector, Double)
Creates a modification that performs a scaling in a given direction
Declaration
public static ModOp Scale(GeoVector Direction, double Factor)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoVector | Direction | direction for the scaling |
| System.Double | Factor | scaling factor for the given direction |
Returns
| Type | Description |
|---|---|
| ModOp | the resulting modification |
Scale(Double)
Creates a modification that performs a scaling about the origin
Declaration
public static ModOp Scale(double Factor)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | Factor | scaling factor |
Returns
| Type | Description |
|---|---|
| ModOp | the resulting modification |
Scale(Double, Double, Double)
Creates a modification that performs a scaling with different factors in x,y and z direction
Declaration
public static ModOp Scale(double FactorX, double FactorY, double FactorZ)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | FactorX | scaling in the direction of the x-axis |
| System.Double | FactorY | scaling in the direction of the y-axis |
| System.Double | FactorZ | scaling in the direction of the z-axis |
Returns
| Type | Description |
|---|---|
| ModOp | the resulting modification |
To2D()
Declaration
public ModOp2D To2D()
Returns
| Type | Description |
|---|---|
| ModOp2D |
ToMatrix()
Declaration
public Matrix ToMatrix()
Returns
| Type | Description |
|---|---|
| MathNet.Numerics.LinearAlgebra.Double.Matrix |
Transform(CoordSys, CoordSys)
Constructs a ModOp, that maps the Src coordinate system to the Dst coordinate system
Declaration
public static ModOp Transform(CoordSys Src, CoordSys Dst)
Parameters
| Type | Name | Description |
|---|---|---|
| CoordSys | Src | source coordinate system |
| CoordSys | Dst | destination coordinate system |
Returns
| Type | Description |
|---|---|
| ModOp | resulting transformation |
Translate(GeoVector)
Constructs a ModOp, that performs a translation by the given offset vector
Declaration
public static ModOp Translate(GeoVector offset)
Parameters
| Type | Name | Description |
|---|---|---|
| GeoVector | offset | offset vector |
Returns
| Type | Description |
|---|---|
| ModOp | resulting transformation |
Translate(Double, Double, Double)
Constructs a ModOp, that performs a translation by the given offsets
Declaration
public static ModOp Translate(double dx, double dy, double dz)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | dx | offset in direction of the x-axis |
| System.Double | dy | offset in direction of the y-axis |
| System.Double | dz | offset in direction of the z-axis |
Returns
| Type | Description |
|---|---|
| ModOp | resulting transformation |
Operators
| Improve this Doc View SourceMultiply(ModOp, GeoPoint)
Modifies the given point by this modification.
Declaration
public static GeoPoint operator *(ModOp m, GeoPoint p)
Parameters
| Type | Name | Description |
|---|---|---|
| ModOp | m | modification |
| GeoPoint | p | point |
Returns
| Type | Description |
|---|---|
| GeoPoint | modified point |
Multiply(ModOp, GeoPoint2D)
Modifies the given 2d point by this modification. The point is assumed in the x/y plane
Declaration
public static GeoPoint operator *(ModOp m, GeoPoint2D p)
Parameters
| Type | Name | Description |
|---|---|---|
| ModOp | m | modification |
| GeoPoint2D | p | point |
Returns
| Type | Description |
|---|---|
| GeoPoint | modified point |
Multiply(ModOp, GeoVector)
Modifies the given vector by this modification
Declaration
public static GeoVector operator *(ModOp m, GeoVector v)
Parameters
| Type | Name | Description |
|---|---|---|
| ModOp | m | modification |
| GeoVector | v | vector |
Returns
| Type | Description |
|---|---|
| GeoVector | modified vector |
Multiply(ModOp, GeoVector2D)
Modifies the given 2d vector by this modification, The vector is assumed in the x/y plane
Declaration
public static GeoVector operator *(ModOp m, GeoVector2D v)
Parameters
| Type | Name | Description |
|---|---|---|
| ModOp | m | modification |
| GeoVector2D | v | vector |
Returns
| Type | Description |
|---|---|
| GeoVector | modified vector |
Multiply(ModOp, ModOp)
Combines two modification into one modification. If two modifications have to be applied to several GeoPoints or GeoVectors or to IGeoObjects it is faster to use the combination.
Declaration
public static ModOp operator *(ModOp lhs, ModOp rhs)
Parameters
| Type | Name | Description |
|---|---|---|
| ModOp | lhs | second modification |
| ModOp | rhs | first modification |
Returns
| Type | Description |
|---|---|
| ModOp | the combination |
Multiply(ModOp, Plane)
Declaration
public static Plane operator *(ModOp m, Plane pln)
Parameters
| Type | Name | Description |
|---|---|---|
| ModOp | m | |
| Plane | pln |
Returns
| Type | Description |
|---|---|
| Plane |
Multiply(ModOp, Double)
Multiplies the double value by the scaling factor of this modification
Declaration
public static double operator *(ModOp m, double d)
Parameters
| Type | Name | Description |
|---|---|---|
| ModOp | m | modification |
| System.Double | d | input value |
Returns
| Type | Description |
|---|---|
| System.Double | modified value |
Explicit Interface Implementations
| Improve this Doc View SourceIJsonSerialize.GetObjectData(IJsonWriteData)
Declaration
void IJsonSerialize.GetObjectData(IJsonWriteData data)
Parameters
| Type | Name | Description |
|---|---|---|
| IJsonWriteData | data |
IJsonSerialize.SetObjectData(IJsonReadData)
Declaration
void IJsonSerialize.SetObjectData(IJsonReadData data)
Parameters
| Type | Name | Description |
|---|---|---|
| IJsonReadData | data |
ISerializable.GetObjectData(SerializationInfo, StreamingContext)
Declaration
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Runtime.Serialization.SerializationInfo | info | |
| System.Runtime.Serialization.StreamingContext | context |


Query API¶
All Queries¶
API query URLs begin with “https://tumormap.ucsc.edu/query/” followed by the specific query ID. For testing in development, use “https://tumormap.ucsc.edu:8343/query/” followed by the query ID.
API query parameters are sent in the HTTP POST message body in JSON format.
API responses are returned in JSON format.
Query API: overlayNodes¶
Overlay new nodes on a frozen map.
Request
Example:
{
"map": "CKCC/v1",
"layout": "mRNA",
"email": [
<EMAIL_ADDRESS>...
],
"nodes": {
"mySample1": {
"ALK": "0.897645",
"TP53": "0.904140",
"POGZ": "0.792754",
...
},
...
},
}
This curl example using the development server should work:
curl -s -k -d '{"map": "CKCC/v1", "nodes": {"Sample-2": {"CTD-2588J6.1": "0", "RP11-433M22.1":
"0", "CTD-2588J6.2": "0", "CPHL1P": "0", "RP3-415N12.1": "0", "RP11-181G12.4": "0",
"RP11-433M22.2": "0", "SSXP10": "0", "RP11-16E12.2": "2.5424", "PSMA2P3": "0", "CTD-2367A17.1":
"0", "RP11-181G12.2": "5.9940", "AC007272.3": "0"}, "Sample-1": {"CTD-2588J6.1": "0",
"RP11-433M22.1": "0", "CTD-2588J6.2": "0", "CPHL1P": "0", "RP3-415N12.1": "0", "RP11-181G12.4":
"0.5264", "RP11-433M22.2": "0", "SSXP10": "0", "RP11-16E12.2": "2.3112", "PSMA2P3": "0",
"CTD-2367A17.1": "0", "RP11-181G12.2": "6.3579", "AC007272.3": "0"}}, "layout": "mRNA"}' -H \
Content-Type:application/json -X POST -v https://tumormap.ucsc.edu:8112/query/overlayNodes
It should return a bookmark of the form:
{"bookmarks":["https://tumormap.ucsc.edu:8112/?&p=CKCC.v1&node=Sample-1&x=277.5&y=171.5",
"https://tumormap.ucsc.edu:8112/?&p=CKCC.v1&node=Sample-2&x=264&y=151"]}
Definitions
email : optional parameter, one or more email addresses to receive the bookmarklayout : type of values by which the new node will be placed on the map. e.g., “mRNA”mapID : frozen map ID. e.g., “CKCC/v1”nodes : the nodes to be placed on the mapnode : ID of the node to be placed on the map. e.g., TCGA sample IDnode-property : identifier for a node’s property, e.g., “TP53”
Generalized Format:
{
"map": <mapID>,
"layout": <layout>,
"email": [
<email>,
(1 to N email addresses ...)
],
"nodes: {
<node>: {
<node-property>: <node-property value>,
(1 to N properties ...)
},
(1 to N nodes ...)
},
}
Response success
These are returned as HTTP 200.
Example:
{
"bookmark": "https://tumormap.ucsc.edu/?b=18XFlfJG8ijJUVP_CYIbA3qhvCw5pADF651XTi8haPnE",
}
Generalized format:
{
"bookmark": <bookmark>
}
Response errors
These are returned as HTTP 400.
There may be more or less than listed here.
map “pancan44” not foundlayout “sRNA” of map “pancan12” not foundmap missing or malformedlayout missing or malformedlayoutData missing or malformednodes missing or malformednode properties missing or malformedquery malformed


SSS Triangle's Angle Calculator
"SSS" is when we know
three sides of the triangle, and want to find the missing angles.
To solve an SSS triangle:
Use The Law of Cosines first to calculate one of the angles
Use The Law of Cosines again to find another angle
Finally use angles of a triangle add to 180° to find the last ang


The apps used in this repository/website are for study only, any data will be stored, all information are for demonstration used in our college classes. We will not collect, sell or use your information for any purpose, all data are temporary in your browser, once you leave the page all data will be gone until you login again.


This website is a graphical interface to vizualize a part of the datas provided by the Marvel Comics API.
For the moment, you can browse comic book list, comic book creator list, see some informations
about it and filter them with some basics criterias like name or .
This website has been created with AngularJS, Bootstrap, Angular-Ui, Lodash and Spinkit.
The source code of this website is MIT licensed and visible and downloadable on Github.


Across: 1. Novel trivia event aids the products of 27 (15) 9. Close bond made a racier mix (11) 10. Asian coal returned, a ton short (3) 11. It's related, or partly related, in reverse (4) 12. A sheep was found in Peter's settings (10) 14. Armchair golfer's first action (6) 15. Russian leader's dim rival butchered (8) 18. While playing flute, sat being inoffensive (8) 19. Lourdes lupin extract returns a type of power (6) 21. Avoid it with a plentiful 13 concerning request of many (10) 23. Squares of 10, 0 and 7 form spiral (4) 26. Asian principle: give thanks to nothing (3) 27. Fitting together reverse of 28 (11) 28. Picking apart reverse of 27 (15) Down: 1. Turf turncoats! (5) 2. In places of worship, a model models (9) 3. Dash of retro jazz style (4) 4. Spoke like right one to make phone call (6) 5.  Fantastic characters endure most (10) 7. Worth of veal lauded unevenly (5) 8. Ponds rose dramatically with support (9) 13. Range about, for each to anger (10) 14. Full of turds? A tea disaster! (9) 16. Dictator's irregular mission captured union and league leaders (9) 17. It informs you, but it's discrete about it (8) 20. Hot gunplay achieved nothing (6) 22. Quietly cover the mathematicians' goal (5) 24. Russian leader's fallen into partiality (5) 25. Some figures are a bit elevated (4)


How can we Quickly help with big and small projects
Over the years we have helped thousands of folks find a local handyman to help them with there projects on the interior and exterior of their homes.
How can I keep track of my sales team?
Hydra learns your business. By analyzing your sales data, Hydra optimizes your sales process and show you where you should be spending your resources.
How can I forecast the next 90 days?
Hydra learns your business. By analyzing your sales data, Hydra optimizes your sales process and show you where you should be spending your resources.
Was able to get my garage door fixed and they came out the same day for the repair. Friendly and professional.


CIT 2.0 is an XML Schema implementation derived from ISO ISO 19115-1, Geographic Information - Metadata - Part 1: Fundamentals AMENDMENT 1, Clause 6.6.2. It includes utility elements for citation, identification, and web linkage of resources. The XML schema was encoded using the rules described in ISO/TS 19139:2007, Clause 8 and implementation approach from ISO/TS19115-3, Clause 8.
The namespace URI for cit 2.0 is http://standards.iso.org/iso/19115/-3/cit/2.0.
cit.xsd is the XML Schema document to be referenced by XML documents containing XML elements in the cit 2.0 namespace or by XML Schema documents importing the cit 2.0 namespace. This XML schema includes (indirectly) all the implemented concepts of the cit namespace, but it does not contain the declaration of any types.
NOTE: The XML Schema for cit 2.0 are available here. A zip archive including all the XML Schema Implementations defined in ISO/TS 19115-3 and related standards is also available.
citation.xsd implements the UML conceptual schema defined in ISO 19115-1, Geographic Information - Metadata - Part 1: Fundamentals AMENDMENT 1, Clause 6.6.2. It was created using the encoding rules defined in ISO 19118, ISO 19139, and the implementation approach described in ISO 19115-3 and contains the following classes (codeLists are bold): CI_Address, CI_Citation, CI_Contact, CI_Date, CI_DateTypeCode, CI_Individual, CI_OnLineFunctionCode, CI_OnlineResource, CI_Organisation, AbstractCI_Party, CI_PresentationFormCode, CI_Responsibility, CI_RoleCode, CI_Series, CI_Telephone, and CI_TelephoneTypeCode
| Name | Standard Prefix | Namespace Location | Schema Location |
|---|---|---|---|
| Geographic COmmon | gco | http://standards.iso.org/iso/19115/-3/gco/1.0 | ../../../../19115/-3/gco/1.0/gco.xsd |
| Metadata Common Classes | mcc | http://standards.iso.org/iso/19115/-3/mcc/1.0 | ../../../../19115/-3/mcc/1.0/mcc.xsd |
Written by writeHTMLFiles Version: 2015-06-06 at 2018-03-10T10:56:57.622-07:00


Class: Aws::ElasticBeanstalk::Types::PlatformSummary
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb |
Overview
Summary information about a platform version.
Constant Summary
Instance Attribute Summary
-
#operating_system_name ⇒ String
rw
The operating system used by the platform version.
-
#operating_system_version ⇒ String
rw
The version of the operating system used by the platform version.
-
#platform_arn ⇒ String
rw
The ARN of the platform version.
-
#platform_branch_lifecycle_state ⇒ String
rw
The state of the platform version's branch in its lifecycle.
-
#platform_branch_name ⇒ String
rw
The platform branch to which the platform version belongs.
-
#platform_category ⇒ String
rw
The category of platform version.
-
#platform_lifecycle_state ⇒ String
rw
The state of the platform version in its lifecycle.
-
#platform_owner ⇒ String
rw
The AWS account ID of the person who created the platform version.
-
#platform_status ⇒ String
rw
The status of the platform version.
-
#platform_version ⇒ String
rw
The version string of the platform version.
-
#supported_addon_list ⇒ Array<String>
rw
The additions associated with the platform version.
-
#supported_tier_list ⇒ Array<String>
rw
The tiers in which the platform version runs.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Structure#to_h. |
Instance Attribute Details
#operating_system_name ⇒ String
(rw)
The operating system used by the platform version.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#operating_system_version ⇒ String
(rw)
The version of the operating system used by the platform version.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#platform_arn ⇒ String
(rw)
The ARN of the platform version.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#platform_branch_lifecycle_state ⇒ String
(rw)
The state of the platform version's branch in its lifecycle.
Possible values: beta
| supported
| deprecated
| retired
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#platform_branch_name ⇒ String
(rw)
The platform branch to which the platform version belongs.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#platform_category ⇒ String
(rw)
The category of platform version.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#platform_lifecycle_state ⇒ String
(rw)
The state of the platform version in its lifecycle.
Possible values: recommended
| empty
If an empty value is returned, the platform version is supported but isn't the recommended one for its branch.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#platform_owner ⇒ String
(rw)
The AWS account ID of the person who created the platform version.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#platform_status ⇒ String
(rw)
The status of the platform version. You can create an environment from the platform version once it is ready.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#platform_version ⇒ String
(rw)
The version string of the platform version.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#supported_addon_list ⇒ Array
<String
> (rw)
The additions associated with the platform version.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end
#supported_tier_list ⇒ Array
<String
> (rw)
The tiers in which the platform version runs.
# File 'gems/aws-sdk-elasticbeanstalk/lib/aws-sdk-elasticbeanstalk/types.rb', line 3515
class PlatformSummary < Struct.new( :platform_arn, :platform_owner, :platform_status, :platform_category, :, :, :supported_tier_list, :supported_addon_list, :platform_lifecycle_state, :platform_version, :platform_branch_name, :platform_branch_lifecycle_state) SENSITIVE = [] include Aws::Structure end


CocoaAsyncSocket 0.0.1 Reference
CocoaAsyncSocket provides easy-to-use and powerful asynchronous socket libraries for Mac and iOS. The classes are described below.
TCP
GCDAsyncSocket and AsyncSocket are TCP/IP socket networking libraries. Here are the key features available in both:
Native objective-c, fully self-contained in one class.
No need to muck around with sockets or streams. This class handles everything for you.Full delegate support
Errors, connections, read completions, write completions, progress, and disconnections all result in a call to your delegate method.Queued non-blocking reads and writes, with optional timeouts.
You tell it what to read or write, and it handles everything for you. Queueing, buffering, and searching for termination sequences within the stream - all handled for you automatically.Automatic socket acceptance.
Spin up a server socket, tell it to accept connections, and it will call you with new instances of itself for each connection.Support for TCP streams over IPv4 and IPv6.
Automatically connect to IPv4 or IPv6 hosts. Automatically accept incoming connections over both IPv4 and IPv6 with a single instance of this class. No more worrying about multiple sockets.Support for TLS / SSL
Secure your socket with ease using just a single method call. Available for both client and server sockets.
GCDAsyncSocket is built atop Grand Central Dispatch:
Fully GCD based and Thread-Safe
It runs entirely within its own GCD dispatch_queue, and is completely thread-safe. Further, the delegate methods are all invoked asynchronously onto a dispatch_queue of your choosing. This means parallel operation of your socket code, and your delegate/processing code.The Latest Technology & Performance Optimizations
Internally the library takes advantage of technologies such as kqueue’s to limit system callscall) and optimize buffer allocations. In other words, peak performance._
AsyncSocket wraps CFSocket and CFStream:
- Fully Run-loop based
Use it on the main thread or a worker thread. It plugs into the NSRunLoop with configurable modes.
UDP
GCDAsyncUdpSocket and AsyncUdpSocket are UDP/IP socket networking libraries. Here are the key features available in both:
Native objective-c, fully self-contained in one class.
No need to muck around with low-level sockets. This class handles everything for you.Full delegate support.
Errors, send completions, receive completions, and disconnections all result in a call to your delegate method.Queued non-blocking send and receive operations, with optional timeouts.
You tell it what to send or receive, and it handles everything for you. Queueing, buffering, waiting and checking errno - all handled for you automatically.Support for IPv4 and IPv6.
Automatically send/recv using IPv4 and/or IPv6. No more worrying about multiple sockets.
GCDAsyncUdpSocket is built atop Grand Central Dispatch:
- Fully GCD based and Thread-Safe
It runs entirely within its own GCD dispatch_queue, and is completely thread-safe. Further, the delegate methods are all invoked asynchronously onto a dispatch_queue of your choosing. This means parallel operation of your socket code, and your delegate/processing code.
AsyncUdpSocket wraps CFSocket:
- Fully Run-loop based
Use it on the main thread or a worker thread. It plugs into the NSRunLoop with configurable modes.
Can’t find the answer to your question in any of the wiki articles? Try the mailing list.
Love the project? Wanna buy me a coffee? (or a beer :D) _US/i/btn/btn_donate_SM.gif)@!~_s-xclick&hosted_button_id=2M8C699FQ8AW2)


We sell mices!
- incentivize viral solutions
- integrate leading-edge e-business
- aggregate B2C experiences
- expedite back-end models
- extend visionary partnerships
- monetize scalable synergies
- mesh real-time vortals
- disintermediate back-end users
- e-enable one-to-one e-business
- e-enable end-to-end eyeballs
- exploit enterprise niches
- maximize intuitive architectures


code

container,
so it remains indexable by search engines.

container, and dynamically adds line numbers that
do not interfere with text selection.

For publishing source code on the web.

Published source code conventionally deployed in the traditional
code
 container, so it remains indexable by search engines.

JavaScript widget overlays on top of the
 container, and dynamically adds line numbers that do not interfere with text selection.

Works consistently on Firefox, Chrome, Safari, and IE6/7/8.

Open-sourced under BSD.

Create directory /dojo_dcodeview/
in the root of
your site, so that it is accessible as
http://yoursite.com/dojo_dcodeview/
from the web.
Copy DCodeView.js to the directory created in the previous step.
Download a Dojo Toolkit release from dojotoolkit.org/download
Unpack the Dojo Toolkit archive file into the root of your
site so that it is accessible as, for example,
http://yoursite.com/dojo-release-1.5.0/
from the
web.
Include the Dojo Toolkit main JavaScript file in the

of your page with the following

Add a second
The DCodeView widget can now be instantiated / overlayed on
top of any

tag code container on
the site with the
dojoType='dcodeview.DCodeView'
attribute:

 ... ... ... ... your code here ... ... ... ...

The font_size
attribute is optional, but
recommended. Most CSS styles also accepted via the
class
and style
attributes.
In addition, the height of the DCodeView viewport may be
limited with the height
attribute. This allows
the user to scroll to any position within long listings of
source code and still be able to simultaneously refer to other
page content within the browser viewport.
/** * Copyright (c) 2010-2011 Marat Nepomnyashy maratbn@gmail * All rights reserved. * * Module: dojo_dcodeview/DCodeView.js * * Description: A Dojo-based widget for embedding arbitrary source code * views inside web pages. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the <organization> nor the * names of its contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ dojo.provide('dcodeview.DCodeView'); dojo.require('dijit._Templated'); dojo.require('dijit._Widget'); dojo.declare( 'dcodeview.DCodeView', [dijit._Widget, dijit._Templated], { font_size: "", width: "", height: "", templateString: [ "
", "", "
", "
", "
", "", "
", "
", "	", "", "
", "
", "
", "
", "

", "	", "
", "
", "
", "", "
"].join(""), postCreate: function() { this.inherited(arguments); if (dojo.isIE <= 7) { dojo.style(this._divStripes, 'display', 'none'); } if (this.font_size) { dojo.style(this.domNode, 'fontSize', this.font_size); } if (this.height) { dojo.style(this._spanBorder, 'height', this.height); dojo.style(this._spanBorder, 'overflowX', 'hidden'); dojo.style(this._spanBorder, 'overflowY', 'auto'); dojo.style(this._preCode, 'marginRight', '2em'); } if (this.width) { dojo.style(this._spanBorder, 'width', this.width); dojo.style(this._preCode, 'width', this.width); dojo.style(this._spanBorder, 'overflowX', 'hidden'); } var strCode = (dojo.isIE ? this.srcNodeRef.innerText : this.srcNodeRef.textContent) || ""; // This will produce a consistent array on both FF and IE // with a line separator at each odd index. var arrLinesCode = strCode.split(/($)/m); // This will get rid of the odd indices as well as line // separators at the start of each even-endex line. var arrLinesCodeUse = []; for (var i = 0; i < arrLinesCode.length; i+= 2) { arrLinesCodeUse.push(arrLinesCode[i].replace( /\r\n|\r|\n/, "")); } // This removes the trailing blank lines from the source // code. while (arrLinesCodeUse.length > 0 && (!arrLinesCodeUse[arrLinesCodeUse.length - 1] || arrLinesCodeUse[arrLinesCodeUse.length - 1] .match(/^\s+$/))) arrLinesCodeUse.pop(); // Different line break sequences work / do not work on // different browsers. // // The sequence \r\n causes an extra line on IE, and an extra // line of clipboard text in FF. // // The sequence \n works well on FF, but not IE. // // The sequence \r works well on IE. var strLineBreak = dojo.isIE ? "\r" : "\n"; for (var i = 0; i < arrLinesCodeUse.length; i++) { var strLineNumber = "" + (i + 1); dojo.place( document.createTextNode(strLineNumber), this._preLineNumbers); dojo.place( document.createTextNode(strLineBreak), this._preLineNumbers); dojo.place( document.createTextNode(arrLinesCodeUse[i]), this._preCode); dojo.place( document.createTextNode(strLineBreak), this._preCode); dojo.place( dojo.create( "div", { style: { backgroundColor: (i % 2 ? "#efefef" : "#edfded") }, innerHTML: " " }), this._divStripes); } } });
The width
attribute can be used to limit or
extend the DCodeView viewport width.


Developer Student Clubs are university based community groups for students interested in Google developer technologies. Students from all undergraduate or graduate programs with an interest in growing as a developer are welcome. By joining a DSC, students grow their knowledge in a peer-to-peer learning environment and build solutions for local businesses and their community.
Lorem ipsum dolor sit amet consectetur adipisicing elit. Dolores quaerat voluptatibus ex vel nemo illo quibusdam quam labore amet? Quia maxime esse laudantium inventore voluptas assumenda, ad fuga et deserunt?..
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Accusantium quod, voluptate odit labore voluptates fugiat ducimus deserunt ullam aliquid inventore nisi itaque totam ut dolore molestias harum sequi sit. Quam!..


@Mylo I found these ones when tried to reproduce some issue, but not very old
Windows:
https://agama.komodoplatform.com/file/supernet/files/AgamaApp-0.2.41-beta-windows-installer.zip
Mac:
https://agama.komodoplatform.com/file/supernet/files/AgamaApp-0.2.41-beta-osx-installer.zip
Linux:
https://agama.komodoplatform.com/file/supernet/files/AgamaApp-0.2.41-beta-linux-portable.zip


Click on the Start Tests button below to download a couple of bundles created using the jbb
compiler and the jbb-profile-three
. You can also click on the bundle name to browse it's contents.
NOTE: The average is calculated by discarding the 2 worst numbers out of 12 samples.
| Bundle | Source (.jbbsrc) | Compact Bundle (.jbb) | Sparse Bundle (.jbbp) |
|---|---|---|---|
| obj | --- | --- | --- |
| vrml | --- | --- | --- |
| animated | --- | --- | --- |
| heavy | --- | --- | --- |
| md2 | --- | --- | --- |


In this project, you'll use generative adversarial networks to generate new images of faces.
You'll be using two datasets in this project:
Since the celebA dataset is complex and you're doing GANs in a project for the first time, we want you to test your neural network on MNIST before CelebA. Running the GANs on MNIST will allow you to see how well your model trains sooner.
If you're using FloydHub, set data_dir
to "/input" and use the FloydHub data ID "R5KrjnANiKVhLWAkpXhNBe".
data_dir = './data'
# FloydHub - Use with data ID "R5KrjnANiKVhLWAkpXhNBe"
#data_dir = '/input'
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import helper
helper.download_extract('mnist', data_dir)
helper.download_extract('celeba', data_dir)
show_n_images = 25
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
%matplotlib inline
import os
from glob import glob
from matplotlib import pyplot
mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'mnist/*.jpg'))[:show_n_images], 28, 28, 'L')
pyplot.imshow(helper.images_square_grid(mnist_images, 'L'), cmap='gray')
The CelebFaces Attributes Dataset (CelebA) dataset contains over 200,000 celebrity images with annotations. Since you're going to be generating faces, you won't need the annotations. You can view the first number of examples by changing show_n_images
.
show_n_images = 25
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'img_align_celeba/*.jpg'))[:show_n_images], 28, 28, 'RGB')
pyplot.imshow(helper.images_square_grid(mnist_images, 'RGB'))
Since the project's main focus is on building the GANs, we'll preprocess the data for you. The values of the MNIST and CelebA dataset will be in the range of -0.5 to 0.5 of 28x28 dimensional images. The CelebA images will be cropped to remove parts of the image that don't include a face, then resized down to 28x28.

You'll build the components necessary to build a GANs by implementing the following functions below:
model_inputs
discriminator
generator
model_loss
model_opt
train
This will check to make sure you have the correct version of TensorFlow and access to a GPU
from distutils.version import LooseVersion
import warnings
import tensorflow as tf
# Check TensorFlow Version
assert LooseVersion(tf.__version__) >= LooseVersion('1.0'), 'Please use TensorFlow version 1.0 or newer. You are using {}'.format(tf.__version__)
print('TensorFlow Version: {}'.format(tf.__version__))
# Check for a GPU
if not tf.test.gpu_device_name():
warnings.warn('No GPU found. Please use a GPU to train your neural network.')
else:
print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))
Implement the model_inputs
function to create TF Placeholders for the Neural Network. It should create the following placeholders:
image_width
, image_height
, and image_channels
.z_dim
.Return the placeholders in the following the tuple (tensor of real input images, tensor of z data)
import problem_unittests as tests
def model_inputs(image_width, image_height, image_channels, z_dim):
"""
Create the model inputs
:param image_width: The input image width
:param image_height: The input image height
:param image_channels: The number of image channels
:param z_dim: The dimension of Z
:return: Tuple of (tensor of real input images, tensor of z data, learning rate)
"""
images = tf.placeholder(tf.float32, (None, image_width, image_height, image_channels))
latents = tf.placeholder(tf.float32, (None, z_dim))
lr = tf.placeholder(tf.float32)
return images, latents, lr
tests.test_model_inputs(model_inputs)
Implement discriminator
to create a discriminator neural network that discriminates on images
. This function should be able to reuse the variables in the neural network. Use tf.variable_scope
with a scope name of "discriminator" to allow the variables to be reused. The function should return a tuple of (tensor output of the discriminator, tensor logits of the discriminator).
def discriminator(images, reuse=False):
"""
Create the discriminator network
:param images: Tensor of input image(s)
:param reuse: Boolean if the weights should be reused
:return: Tuple of (tensor output of the discriminator, tensor logits of the discriminator)
"""
with tf.variable_scope('discriminator', reuse=reuse):
training=True
# 28 x 28 x X
c1_z = tf.layers.conv2d(images, 128, 5, strides=2, padding='same')
# works better without batch normalization in the first layer
c1_y = tf.maximum(c1_z, c1_z * 0.2)
# 14 x 14 x 128
c2_z = tf.layers.conv2d(c1_y, 256, 5, strides=2, padding='same')
c2_zn = tf.layers.batch_normalization(c2_z, training=training)
c2_y = tf.maximum(c2_zn, c2_zn * 0.2)
# 7 x 7 x 256
c2_yf = tf.reshape(c2_y, (-1, 7*7*128))
# 7*7*64
d3_z = tf.layers.dense(c2_yf, 1)
d3_zn = tf.layers.batch_normalization(d3_z, training=training)
d3_y = tf.sigmoid(d3_zn)
return d3_y, d3_z
tests.test_discriminator(discriminator, tf)
Implement generator
to generate an image using z
. This function should be able to reuse the variables in the neural network. Use tf.variable_scope
with a scope name of "generator" to allow the variables to be reused. The function should return the generated 28 x 28 x out_channel_dim
images.
def generator(z, out_channel_dim, is_train=True):
"""
Create the generator network
:param z: Input z
:param out_channel_dim: The number of channels in the output image
:param is_train: Boolean if generator is being used for training
:return: The tensor output of the generator
"""
reuse = not is_train
with tf.variable_scope('generator', reuse=reuse):
# ?
d1_z = tf.layers.dense(z, 7 * 7 * 256)
# 4*4*128
d1_zr = tf.reshape(d1_z, (-1, 7, 7, 256))
d1_zn = tf.layers.batch_normalization(d1_zr, training=is_train)
d1_y = tf.maximum(d1_zn, d1_zn*0.1)
# 7 x 7 x 256
c1_z = tf.layers.conv2d_transpose(
d1_y,
filters=128,
kernel_size=5,
strides=2,
padding='same',
use_bias=False,
activation=None)
c1_zn = tf.layers.batch_normalization(c1_z, training=is_train)
c1_y = tf.maximum(c1_zn, c1_zn*0.1)
# 14 x 14 x 256
c2_z = tf.layers.conv2d_transpose(
c1_y,
filters=128,
kernel_size=5,
strides=1,
padding='same',
use_bias=False,
activation=None)
c2_zn = tf.layers.batch_normalization(c2_z, training=is_train)
c2_y = tf.maximum(c2_zn, c2_zn*0.1)
# 14 x 14 x 256
c3_z = tf.layers.conv2d_transpose(
c2_y,
filters=out_channel_dim,
kernel_size=5,
strides=2,
padding='same',
use_bias=False,
activation=None)
c3_y = tf.tanh(c3_z)
# 28 x 28 x out_channel_dim
return c3_y
tests.test_generator(generator, tf)
Implement model_loss
to build the GANs for training and calculate the loss. The function should return a tuple of (discriminator loss, generator loss). Use the following functions you implemented:
discriminator(images, reuse=False)
generator(z, out_channel_dim, is_train=True)
def model_loss(input_real, input_z, out_channel_dim):
"""
Get the loss for the discriminator and generator
:param input_real: Images from the real dataset
:param input_z: Z input
:param out_channel_dim: The number of channels in the output image
:return: A tuple of (discriminator loss, generator loss)
"""
image_fake = generator(input_z, out_channel_dim, is_train=True)
verdicts_real, logits_real = discriminator(input_real, reuse=False)
verdicts_fake, logits_fake = discriminator(image_fake, reuse=True)
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=logits_real, labels=(tf.ones_like(verdicts_real) * 0.9)))
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=logits_fake, labels=tf.zeros_like(verdicts_fake)))
g_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=logits_fake, labels=tf.ones_like(verdicts_fake)))
d_loss = d_loss_real + d_loss_fake
return d_loss, g_loss #, image_fake
tests.test_model_loss(model_loss)
Implement model_opt
to create the optimization operations for the GANs. Use tf.trainable_variables
to get all the trainable variables. Filter the variables with names that are in the discriminator and generator scope names. The function should return a tuple of (discriminator training operation, generator training operation).
def model_opt(d_loss, g_loss, learning_rate, beta1):
"""
Get optimization operations
:param d_loss: Discriminator loss Tensor
:param g_loss: Generator loss Tensor
:param learning_rate: Learning Rate Placeholder
:param beta1: The exponential decay rate for the 1st moment in the optimizer
:return: A tuple of (discriminator training operation, generator training operation)
"""
t_vars = tf.trainable_variables()
d_vars = [var for var in t_vars if var.name.startswith('discriminator')]
g_vars = [var for var in t_vars if var.name.startswith('generator')]
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
d_train_opt = tf.train.AdamOptimizer(learning_rate, beta1).minimize(d_loss, var_list=d_vars)
g_train_opt = tf.train.AdamOptimizer(learning_rate, beta1).minimize(g_loss, var_list=g_vars)
return d_train_opt, g_train_opt
tests.test_model_opt(model_opt, tf)
import numpy as np
def show_generator_output(sess, n_images, input_z, out_channel_dim, image_mode):
"""
Show example output for the generator
:param sess: TensorFlow session
:param n_images: Number of Images to display
:param input_z: Input Z Tensor
:param out_channel_dim: The number of channels in the output image
:param image_mode: The mode to use for images ("RGB" or "L")
"""
cmap = None if image_mode == 'RGB' else 'gray'
z_dim = input_z.get_shape().as_list()[-1]
example_z = np.random.uniform(-1, 1, size=[n_images, z_dim])
samples = sess.run(
generator(input_z, out_channel_dim, False),
feed_dict={input_z: example_z})
images_grid = helper.images_square_grid(samples, image_mode)
pyplot.imshow(images_grid, cmap=cmap)
pyplot.show()
Implement train
to build and train the GANs. Use the following functions you implemented:
model_inputs(image_width, image_height, image_channels, z_dim)
model_loss(input_real, input_z, out_channel_dim)
model_opt(d_loss, g_loss, learning_rate, beta1)
Use the show_generator_output
to show generator
output while you train. Running show_generator_output
for every batch will drastically increase training time and increase the size of the notebook. It's recommended to print the generator
output every 100 batches.
import datetime
def train(epoch_count, batch_size, z_dim, learning_rate, beta1, get_batches,
data_shape, data_image_mode):
"""
Train the GAN
:param epoch_count: Number of epochs
:param batch_size: Batch Size
:param z_dim: Z dimension
:param learning_rate: Learning Rate
:param beta1: The exponential decay rate for the 1st moment in the optimizer
:param get_batches: Function to get batches
:param data_shape: Shape of the data
:param data_image_mode: The image mode to use for images ("RGB" or "L")
"""
now = datetime.datetime.now()
LOGDIR = ("/tmp/dlnd_p5/" + data_image_mode +
'_{:02}:{:02}'.format(now.hour, now.minute) +
'_ec{}'.format(epoch_count) +
'_bs{}'.format(batch_size) +
'_zd{}'.format(z_dim) +
'_lr{}'.format(learning_rate) +
'_be{}'.format(beta1))
image_channels = 3 if data_image_mode == "RGB" else 1
input_real, input_z, lr = model_inputs(28, 28, image_channels, z_dim)
d_loss, g_loss = model_loss(input_real, input_z, image_channels)
d_train_opt, g_train_opt = model_opt(d_loss, g_loss, lr, beta1)
tf.summary.scalar('d_loss', d_loss)
tf.summary.scalar('g_loss', g_loss)
#value_range = [-1.0, 1.0]
#nbins = 100
#hist_g = tf.histogram_fixed_width(image_fake, value_range, nbins=nbins, dtype=tf.float32) / nbins
#hist_images = tf.histogram_fixed_width(input_real, value_range, nbins=nbins, dtype=tf.float32) / nbins
#chi_square = tf.reduce_mean(tf.div(tf.square(hist_g - hist_images), hist_g + hist_images))
#tf.summary.scalar('chi_square', chi_square)
summ = tf.summary.merge_all()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
writer = tf.summary.FileWriter(LOGDIR)
writer.add_graph(sess.graph)
b_i = 0
for epoch_i in range(epoch_count):
for batch_images in get_batches(batch_size):
#scale from [-0.5,0.5] -> [-1,1]
batch_images *= 2
b_i += 1
batch_z = np.random.uniform(-1, 1, size=(batch_size, z_dim))
#batch_z = np.random.normal(0, 0.33, size=(batch_size, z_dim))
feed_dict = {
input_real: batch_images,
input_z: batch_z,
lr: learning_rate
}
sess.run(d_train_opt, feed_dict=feed_dict)
sess.run(g_train_opt, feed_dict=feed_dict)
if b_i % 10 == 0:
[dl, gl, s] = sess.run(
[d_loss, g_loss, summ], feed_dict=feed_dict)
writer.add_summary(s, b_i)
writer.flush()
if b_i % 500 == 0:
print("Discriminator Loss: {:.4f}...".format(dl),
"Generator Loss: {:.4f}".format(gl))
show_generator_output(sess, 25, input_z, image_channels,
data_image_mode)
Test your GANs architecture on MNIST. After 2 epochs, the GANs should be able to generate images that look like handwritten digits. Make sure the loss of the generator is lower than the loss of the discriminator or close to 0.
batch_size = 32
z_dim = 100
learning_rate = 0.0003
beta1 = 0.5
epochs = 2
mnist_dataset = helper.Dataset('mnist', glob(os.path.join(data_dir, 'mnist/*.jpg')))
with tf.Graph().as_default():
train(epochs, batch_size, z_dim, learning_rate, beta1, mnist_dataset.get_batches,
mnist_dataset.shape, mnist_dataset.image_mode)
Run your GANs on CelebA. It will take around 20 minutes on the average GPU to run one epoch. You can run the whole epoch or stop when it starts to generate realistic faces.
batch_size = 32
z_dim = 100
learning_rate = 0.0003
beta1 = 0.5
epochs = 1
celeba_dataset = helper.Dataset('celeba', glob(os.path.join(data_dir, 'img_align_celeba/*.jpg')))
with tf.Graph().as_default():
train(epochs, batch_size, z_dim, learning_rate, beta1, celeba_dataset.get_batches,
celeba_dataset.shape, celeba_dataset.image_mode)
When submitting this project, make sure to run all the cells before saving the notebook. Save the notebook file as "dlnd_face_generation.ipynb" and save it as a HTML file under "File" -> "Download as". Include the "helper.py" and "problem_unittests.py" files in your submission.


About
Alejandro Aristizábal is a musician and sound engineer, with knowledge in Programming and Deep Learning. As a passionate learner, Alejandro has spent most of his free time developing skills that allow him to create bigger and more creative projects, such as programming, electronics and mechanics. Throughout his career, Alejandro has been actively looking for ways in which he can merge his passion for music and technology. With this in mind, he has worked on projects that involve the Music Industry, Music Generation and Interactive Arts.


One of my hobbies is watching movies while I have nothing to do. I love different genres of movies including action, love, thrilling, and fiction. My favorite movie is Pulp Fiction.
Whenever there are some new movies on the show, I'll go to IMDb to look for some reviews about that movie and decide whether it worths a movie ticket to watch. I believe IMDb is one of the most objective movie review websites and it also provides information about cast, actors and plot.


| Path: | README |
| Last Update: | Fri May 01 08:04:57 -0600 2009 |
atom-tools is an all-in-one library for parsing, creating and manipulating Atom <www.w3.org/2005/Atom> feeds and entries. It handles all the nasty XML and HTTP details so that you don‘t have to.
require "atom/feed" require "open-uri" feed = Atom::Feed.new "http://www.tbray.org/ongoing/ongoing.atom" # => <http://www.tbray.org/ongoing/ongoing.atom entries: 0 title=''> feed.update! feed.entries.length # => 20 feed.title.to_s # => "ongoing" feed.authors.first.name # => "Tim Bray" entry = feed.entries.first # => #<Atom::Entry id:'http://www.tbray.org/ongoing/When/200x/2006/11/07/Munich'> entry.title.to_s # => "M\303\274nchen" entry.links.last # => {"href"=>"http://www.tbray.org/ongoing/When/200x/2006/11/07/Munich#comments", "rel"=>"replies", "type" => "application/xhtml+xml"} entry.summary.to_s # => "That local spelling is nicer than the ugly English [...]"
Things are explained in more detail in the RDoc.
require "atom/service" service = Atom::Service.new "http://necronomicorp.com/app.xml" coll = service.workspaces.first.collections.first # => <http://necronomicorp.com/testatom?app entries: 0 title='testing: entry endpoint'> coll.feed.update! # => <http://necronomicorp.com/testatom?app entries: 10 title='testing the APP'> entry = coll.feed.entries.first entry.title # => 'html entities'#text # modify the title entry.title = "HTML entities" # store the modified entry coll.put! entry # => #<Net::HTTPOK 200 OK readbody=true> coll.feed.entries.first.title # => 'HTML entities'#text
For details on authentication, see the documentation for Atom::HTTP.


--- title: Date And Time layout: component ---
A component responsible for giving quick and reliable information. Like a watch, it must be constantly accessible with a simple glance, while also leaving people doubtless.
If a component is sufficiently widespread that it takes on a recognizable look across multiple platforms, provide it here. If its appearance varies extremely widely, say so and direct the reader to platform-specific instances.
If a component is sufficiently widespread that some form of typical behavior can be described, describe it here. As with the “Typical Appearance” section, if there is no such consistent behavior, say as much and direct the reader to the platform-specific sections.
Helpful subsections include:
An event is something that can happen to a user interface component. They are both conceptual and highly concrete in that events very frequently translate directly into a user interface component’s API.
The most relevant button event is the click
. A click
event indicates that the user has
triggered the button. Secondary events include hover
, indicating that a pointing device is explicitly
within the button’s bounds.
A state diagram indicating the actions and states of a user interface component.
This is most likely an image. Bonus props if you use SVG.
And also, a state diagram implies, well, states. So be sure to describe them. Note also that there will usually be overlap between a component’s events and its state diagram. A sufficiently detailed state diagram, however, may have more activities than the “public” events that can be reported by a component.
Most button designs have the following states. The enabled
and disabled
states can be
viewed as “dormant” button states—they are the only states that a button can have when a user is not interacting with
it. The enabled
state means that a user can interact with it, while the disabled
state means that a user cannot do so.
When a button is enabled
, additional states may be triggered. Not all states are present in all button
implementations, but in general they are:
hover
: For platforms with an explicit pointing element, positioning that element over a button may
change the button’s appearance. This provides a form of feedback that states that the button will respond if
additional activity is performed.armed
: If the user initiates button-triggered behavior, such as a click on mouse-capable systems,
the button may enter a state indicating that it is ready to be invoked. Many button implementations allow an “out”
from this state, in case the user changes his or her mind in mid-action.Embedded or linked video (by you or by others [and if by others give credit]) showing the component in action.
For components that are available on a web platform, you can embed an actual component right here, such as:
There is almost never just one form of a user interface component. Use this section to address variations on this theme. Some variations are sufficiently different that they are considered to be a different component entirely, despite very similar behavior. Meanwile some variations are due to appearance only.
Talk about the five usability metrics in relation to this component. Not all components will have the same metric priorities. For example:
Because the button is such a fundamental part of virtually every user interface available today, it can be said that all usability metrics are equally important for this component. Users who are seeing a button in a given platform for the first time must not have any issues recognizing it and knowing what to do with it (learnability). The high priority of learnability also implies that memorability is a given.
Users must also never experience undue delays with using a button (efficiency), particularly because using a button almost always involves an instantaneous, immediate-result action. Users should almost never trigger a button by mistake (errors)—especially buttons whose actions result in significant changes to data or the real world.
If any metric at all can be considered as a “low priority” for buttons, it would be satisfaction. The button is such a utilitarian component that “fun” or “enjoyment” is hardly associated with its use. One exception to this prioritization may be for buttons in applications whose primary metric is satisfaction (e.g., games, entertainment). As a part of that overall system, making buttons “fun” may then become more important than in other situations.
This section is for describing “what makes for a good your component here?” Most likely, this is an amalgam of guidelines documents and platform-independent interaction design principles.


We offer top-class comprehensive preparation services for various competitive entrance examinations
Competitive Edge is the only coaching institute which provides manual as well as online practice tests Many people got benefited from our spoken english classes Many organisations have utilised our expertised training in softskills. our team we have Executives/professionals from the fields of Banking. Business administration and Information Technology with rich and wide experience as our promoter members. Our well experienced and well qualified teaching faculty is excellent and committed for the betterment of the learning of the students. They are student friendly. Our approach is completely exam focused and job oriented.
Competitive Edge is committed……. to the vision to exemplify in quality education to provide a platform where skills are improved, thereby goals are achieved to provide the student with a personalized guidance and mentoring feedback on a regular basis to make competitive entrance exam preparation guidance affordable for those students who have lot of talent but remain deprived of quality study material due to high cost
Competitive Edge will combine the talent and dedication of the best professionals /teachers to provide the best possible learning platform to students for competitive exams as well as increasing employability through skill development. To ensure the students get timely, precise, effective and qualitative learning at his convenience matching his learning ability and interest at an affordable price


Allows you to specify another job to use as a template.
The implementation overwrites its config with that of the template except the parameters, which retain their default values, and items covered by specific flags.
Synchronisation happens whenever an implementation job or its template is saved.


FILM TITLE: FRENCH TWIST DIRECTOR: JOSIANE BALASKO COUNTRY: FRANCE 1995 MUSIC: MANUEL MALOU CAST: Victoria Abril, Josiane Balasko, Alain Chabat, Ticky Holgado SUPER FEATURES: Crazy story all the way through. Film afraid to end it.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 Well, for American audiences, anyway.
Unlike the American attitudes towards sex, France seems to take a more lackadaisical attitude towards it, and by doing so, it is able to create films like this one. And this type of situation, is not one that the majority of America, away from the big cities, is likely to appreciate on any level, least of all a sexual competitive situation.
But if one can get out of the inner turmoils that religion, or any form of idealism can add to a relationship, then this film is funny and spends more time discussing the commitments that people make to themselves and each other, than it does anything else. And in this case, the two people who are better decided on their sexual preferences are the ones that seem to do better.... well, they are also the two extremes in this story.
 And she wastes no time making friends of the wife. As the film wears on, the wife is enjoying her probably as much as the husband, but there is one problem. The opposites are trying to create problems for each other, by confusing the woman in the middle. The husband is having to swallow his male ego, and the woman is having to swallow her female ego. Caught in between, of course, is the one that can not make a decision, and can not figure out what she really wants to do. On one hand she has a family and husband, and on the other she wants to better fulfill the sedate life that she obviously has been a part of.
As the film moves on, it really becomes a sort of boring farce, and all the characters are getting worn down. No one can win the battle, and no one is prepared to lose it. And when one has a victory, the wife feels guilty and moves in the other direction.
This film might have been better suited, and accomplished its aims, if the director might have placed someone else in the role of the woman that comes in between the married couple. Her staying in the middle of it all, is really a problem in that the film never really provides an objective enough choice for anyone... these are always subjectively made emotional decisions, which at least the film shows that can not be good and long term decisions... that is, they don't last. A director on the outside checking it as she goes along, might have made the film less emotional and at the same time more interesting... as it is at this point, it is just a farce, with many bumbling and crazy decisions, that no one seems to have any desire to hold up, which, for this reviewer, just makes the whole thing more confusing... what's the point? Lead a mix-married life?
Funny film in that the situations are crazy, and the characters are crazier still... other than that, don't take the whole thing too serious, as I don't think it is meant to be.
3 GIBLOONS Copyright (c) Pedro Sena 1997. All Rights Reserved. Member of the Internet Movie Critics Association
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Copyright (c) Gigamic Games
This game is one of the beautiful board games of Gigamic Games company. I present here a variant played on a 8x8 board (check their website for the original rules). You can try to buy the game at Ancient Games or at ToysGamesPuzzles.
|
| An example
If Black shifts the 6th row to the left, the Black stone at f6 goes to e6, and the empty cell a6 goes to h6. Since h6 is empty, Black drops a stone there. |


Changing your answer may affect any project costs already entered.
Question not answered.
Need help with this service? Contact us


Love create new experiences, and make interfaces. I used HTML5, CSS and I'm learning Javascript now.
I enjoy writing front-end code with these technologies:
The easiest way to contact me is via Mail: natali.bogarin@gmail.com


Book Search
Author:
Title:
Tag Match:
Yearly Reports
Reports
Pages
Books
Add and Edit Book Records
Add Book with ISBN:


--- layout: post authors: ["Philipp Bayer"] title: "Our First Bootcamp in Adelaide" date: 2013-11-08 time: "13:30:00" tags: ["Bootcamps", "University of Adelaide"] ---
We ran our first bootcamp at the University of Adelaide from the 24th to the 26th of September 2013. Teachers and helpers came from all over the place: Ben Morris from the University of North Carolina acted as Principal Instructor, along with Jerico Revote from Monash University, Diego Barneche from Macquarie University, Philipp Bayer from the University of Queensland, Nicholas Crouch from Flinders University, and Nathan Watson-Haigh from the Australian Centre for Plant Functional Genomics (ACPFG), who also acted as the main organizer (thanks for that!).
The bootcamp was held in a "collaborative teaching suite" in the Ingkarni Wardli building at the University of Adelaide, a great room for this kind of workshop - lots of space, an overkill of projectors so that every corner could see what was going on on the instructor's workspace, *plus* monitors displaying the instructor's workspace on every group-table. Since students used remote Virtual Machines there were no problems with setting up software or anything else - using VMs is something to come back to in future workshops, since the VMs saved the hassle of getting all needed software running on all participants' machines. This saved half a day, not to speak of sanity.
Since the workshop was primarily for NGS bioinformaticians, Python was chosen as the main language. Along with an introduction to Python (which was cut short by a fire-alarm, no time for modules in Python), there was a short introduction to documentation, half a day on the principles of testing, a few hours on using make-files for reproducible research, and most importantly, an introduction to version control and collaborative work using Git and GitHub. For the first time (at least known to me), this workshop also featured a group-exercise at the end, which was only possible for two reasons: 1) this workshop ran for three days instead of the usual two; 2) most students were already used to programming in at least another language (e.g. C, Python, Perl). I was particularly impressed with the group-exercise, first because most students incorporated their own ideas and work, and second because students immediately started to incorporate everything they learned, from make-files to using GitHub to collaborate.
Luckily, most of the students were on roughly the same level when it came to prior knowledge, so we didn't have to split up the groups into "beginners" and "advanced".
In the end, I think the workshop went well and students learned a lot - I base this assumption mostly on the way students applied their newly minted knowledge during the group exercise. Also, we asked students to provide feedback immediately after each session, and, overall, comments were very positive.


Source files: 11
Click here to show/hide file namesSource files:
pavement.py,
setup.py,
currentcost/__init__.py,
currentcost/connector.py,
currentcost/messager.py,
currentcost/utils.py,
bin/phase-currentcost,
tests/__init__.py,
tests/test_messager.py,
tests/test_utils.py,
features/steps/currentcost_steps.py
Clones detected: 17
117 of 699 lines are duplicates (16.74%)
Parameters
clustering_threshold = 10
distance_threshold = 5
size_threshold = 5
hashing_depth = 1
clusterize_using_hash = False
clusterize_using_dcup = False
Clone # 1
Distance between two fragments = 2
Clone size = 12
| Source file "features/steps/currentcost_steps.py" The first line is 310 | Source file "features/steps/currentcost_steps.py" The first line is 390 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, BAD_TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | |
| context.process = subprocess.Popen(shlex.split(commands)) | context.process = subprocess.Popen(shlex.split(commands)) | |
| sleep(1) | sleep(3) |
Clone # 2
Distance between two fragments = 0
Clone size = 11
| Source file "features/steps/currentcost_steps.py" The first line is 446 | Source file "features/steps/currentcost_steps.py" The first line is 347 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | |
| context.process = subprocess.Popen(shlex.split(commands)) | context.process = subprocess.Popen(shlex.split(commands)) |
Clone # 3
Distance between two fragments = 0
Clone size = 11
| Source file "features/steps/currentcost_steps.py" The first line is 446 | Source file "features/steps/currentcost_steps.py" The first line is 390 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | |
| context.process = subprocess.Popen(shlex.split(commands)) | context.process = subprocess.Popen(shlex.split(commands)) |
Clone # 4
Distance between two fragments = 1
Clone size = 11
| Source file "features/steps/currentcost_steps.py" The first line is 446 | Source file "features/steps/currentcost_steps.py" The first line is 310 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, BAD_TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | |
| context.process = subprocess.Popen(shlex.split(commands)) | context.process = subprocess.Popen(shlex.split(commands)) |
Clone # 5
Distance between two fragments = 0
Clone size = 11
| Source file "features/steps/currentcost_steps.py" The first line is 347 | Source file "features/steps/currentcost_steps.py" The first line is 390 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | |
| context.process = subprocess.Popen(shlex.split(commands)) | context.process = subprocess.Popen(shlex.split(commands)) |
Clone # 6
Distance between two fragments = 1
Clone size = 11
| Source file "features/steps/currentcost_steps.py" The first line is 347 | Source file "features/steps/currentcost_steps.py" The first line is 310 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, BAD_TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | |
| context.process = subprocess.Popen(shlex.split(commands)) | context.process = subprocess.Popen(shlex.split(commands)) |
Clone # 7
Distance between two fragments = 2
Clone size = 10
| Source file "features/steps/currentcost_steps.py" The first line is 446 | Source file "features/steps/currentcost_steps.py" The first line is 268 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, BAD_TTY_PORT, ARGUMENT_MQ_CREDENTIAL, BAD_MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) |
Clone # 8
Distance between two fragments = 2
Clone size = 10
| Source file "features/steps/currentcost_steps.py" The first line is 347 | Source file "features/steps/currentcost_steps.py" The first line is 268 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, BAD_TTY_PORT, ARGUMENT_MQ_CREDENTIAL, BAD_MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) |
Clone # 9
Distance between two fragments = 2
Clone size = 10
| Source file "features/steps/currentcost_steps.py" The first line is 390 | Source file "features/steps/currentcost_steps.py" The first line is 268 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, BAD_TTY_PORT, ARGUMENT_MQ_CREDENTIAL, BAD_MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) |
Clone # 10
Distance between two fragments = 1
Clone size = 10
| Source file "features/steps/currentcost_steps.py" The first line is 310 | Source file "features/steps/currentcost_steps.py" The first line is 268 | |
| commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, BAD_TTY_PORT, ARGUMENT_MQ_CREDENTIAL, MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) | commands = ('%s %s %s %s %s %s %s %s %s') % ((BIN, VAR_NAME, SITE_NAME, ARGUMENT_TTY_PORT, BAD_TTY_PORT, ARGUMENT_MQ_CREDENTIAL, BAD_MQ_CREDENTIAL, ARGUMENT_LOG_CONF, LOG_CONF)) |
Clone # 11
Distance between two fragments = 3
Clone size = 7
| Source file "features/steps/currentcost_steps.py" The first line is 149 | Source file "features/steps/currentcost_steps.py" The first line is 161 | |
|
def check_cc_incorrect(channel, method, properties, body): expected_message = (CC_INCORRECT_MESSAGE) % ((VAR_NAME, SITE_NAME, WRONG_CURRENTCOST_MESSAGE)) verify_json_message(body, expected_message) channel.close() |
def check_cc_unreachable(channel, method, properties, body): expected_message = (TTY_CONNECTION_PROBLEM) % ((VAR_NAME, SITE_NAME, BAD_TTY_PORT)) verify_json_message(body, expected_message) channel.close() |
Clone # 12
Distance between two fragments = 2
Clone size = 7
| Source file "features/steps/currentcost_steps.py" The first line is 161 | Source file "features/steps/currentcost_steps.py" The first line is 173 | |
|
def check_cc_unreachable(channel, method, properties, body): expected_message = (TTY_CONNECTION_PROBLEM) % ((VAR_NAME, SITE_NAME, BAD_TTY_PORT)) verify_json_message(body, expected_message) channel.close() |
def check_cc_disconnected(channel, method, properties, body): expected_message = (TTY_CONNECTION_PROBLEM) % ((VAR_NAME, SITE_NAME, TTY_PORT)) verify_json_message(body, expected_message) channel.close() |
Clone # 13
Distance between two fragments = 3
Clone size = 7
| Source file "features/steps/currentcost_steps.py" The first line is 149 | Source file "features/steps/currentcost_steps.py" The first line is 173 | |
|
def check_cc_incorrect(channel, method, properties, body): expected_message = (CC_INCORRECT_MESSAGE) % ((VAR_NAME, SITE_NAME, WRONG_CURRENTCOST_MESSAGE)) verify_json_message(body, expected_message) channel.close() |
def check_cc_disconnected(channel, method, properties, body): expected_message = (TTY_CONNECTION_PROBLEM) % ((VAR_NAME, SITE_NAME, TTY_PORT)) verify_json_message(body, expected_message) channel.close() |
Clone # 14
Distance between two fragments = 2
Clone size = 5
| Source file "currentcost/connector.py" The first line is 99 | Source file "currentcost/connector.py" The first line is 113 | |
| info = (TTY_CONNECTION_SUCCESS) % ((self.variable_name, self.site_name, self.tty_port)) | error = (TTY_DISCONNECTED) % ((self.variable_name, self.site_name, self.tty_port)) | |
| LOGGER.info(info) | LOGGER.info(error) |
Clone # 15
Distance between two fragments = 2
Clone size = 5
| Source file "tests/test_utils.py" The first line is 52 | Source file "tests/test_utils.py" The first line is 44 | |
| topic, message = data_validator(WRONG_CURRENTCOST_MESSAGE, VAR_NAME, SITE_NAME) | topic, message = data_validator(CURRENTCOST_MESSAGE, VAR_NAME, SITE_NAME) | |
| self.assertEqual(topic, ERROR) | self.assertEqual(topic, SUCCESS) |
Clone # 16
Distance between two fragments = 1
Clone size = 5
| Source file "bin/phase-currentcost" The first line is 119 | Source file "bin/phase-currentcost" The first line is 95 | |
| error = (TTY_DISCONNECTED) % ((variable_name, site_name, tty_port)) | error = (TTY_CONNECTION_SUCCESS) % ((variable_name, site_name, tty_port)) | |
| LOGGER.info(error) | LOGGER.info(error) |
Clone # 17
Distance between two fragments = 1
Clone size = 5
| Source file "currentcost/messager.py" The first line is 62 | Source file "currentcost/messager.py" The first line is 54 | |
| error = (RABBIT_MQ_CONNECTION_PROBLEM) % ((username, password, host)) | error = (RABBIT_MQ_CREDENTIAL_PROBLEM) % ((username, password, host)) | |
| self.logger.error(error) | self.logger.error(error) |


title
to /api/books to add a book and returned will be the object with the
title
and a unique _id
.title
,
_id
, & commentcount
.title
,
_id
, & an array of comments
(empty array if no comments present).comment
to /api/books/{_id} to add a comment to a book and returned will be
the books object similar to get /api/books/{_id}.


ddl.elf.ELFHeaders
Authors:
Lars Ivar Igesund
License:
BSD Derivative (see source for details)
const uint EI_NIDENT;
Constants from the ELF specification.
Size of the e_ident array.
const uint EI_MAG0;
Indices in the e_ident array.
const uint ELFCLASSNONE;
Values defining the class of the file.
const uint ELFDATANONE;
Values defining the encoding of data.
const uint EV_NONE;
Defined version of the ELF specification.
const uint DDL_ELFVERSION_SUPP;
The version currently supported by DDL
const uint ET_NONE;
Values defining the object file type.
const uint EM_NONE;
Values defining machine architectures.
const uint SHT_NULL;
Values defining section types.
const uint PT_NULL;
Values defining segment types.
struct Elf32_Ehdr;
This struct can hold an ELF object file header.
struct Elf32_Shdr;
This struct can hold a section header table entry from an ELF object
file.
struct Elf32_Phdr;
This struct can hold a program header table entry from an ELF object
file.
struct Elf32_Sym;
This struct can hold a symbol table entry from an ELF object file.
struct Elf32_Rel;
This struct can hold a relocation entry from an ELF object file.
struct Elf32_Rela;
This struct can hold a relocation entry from an ELF object file,
including an addend.


Parent Schedule
8:30am
: Continental Breakfast -
Webster Commons
10am
: Dedication Service -
Sawyer
11:30am
: Lunch on Your Own
11:30am
: International Student Lunch and Orientation -
Hills Classroom
Parents are free to leave anytime after the Dedication Service


Module flower.Event
A class for events, which are communicated to, and handled by, event handlers
Holds the data of the Event.
Info:
- Release: V3.0.0
- Author: Makoto
Functions
-
Event:init (eventType)
-
Event's constructor.
Parameters:
- eventType
(option)The type of event.
-
Event:setListener (callback, source)
-
INTERNAL USE ONLY -- Sets the event listener via EventDispatcher.
Parameters:
- callback
callback function
- source
source object.
-
Event:stop ()
-
Stop the propagation of the event.
Fields
-
CREATE
-
Event: create
-
OPEN
-
Event: open
-
CLOSE
-
Event: close
-
OPEN_COMPLETE
-
Event: openComplete
-
CLOSE_COMPLETE
-
Event: closeComplete
-
START
-
Event: start
-
STOP
-
Event: stop
-
UPDATE
-
Event: update
-
DOWN
-
Event: down
-
UP
-
Event: up
-
MOVE
-
Event: move
-
CLICK
-
Event: click
-
CANCEL
-
Event: cancel
-
KEY_DOWN
-
Event: keyDown
-
KEY_UP
-
Event: keyUp
-
COMPLETE
-
Event: complete
-
TOUCH_DOWN
-
Event: touchDown
-
TOUCH_UP
-
Event: touchUp
-
TOUCH_MOVE
-
Event: touchMove
-
TOUCH_CANCEL
-
Event: touchCancel
-
MOUSE_CLICK
-
Event: mouseClick
-
MOUSE_RIGHT_CLICK
-
Event: mouseRightClick
-
MOUSE_MIDDLE_CLICK
-
Event: mouseMiddleClick
-
MOUSE_WHEEL
-
Event: mouseWheel
-
MOUSE_MOVE
-
Event: mouseMove
-
MOUSE_OVER
-
Event: mouseOver
-
MOUSE_OUT
-
Event: mouseOut
-
ENTER_FRAME
-
Event: enterFrame
-
RESIZE
-
Event: resize


The Dhrystone benchmark is intended to give a raw processor speed number indicating how many dhrystones can be executed in one scecond.
- Dhrystone contains no floating point operations
- Dhrystone is small enough to fit entirely into L1 cache
Input: (Number of Iterations) (CPU clock speed in KHz)
Output: Dhrystones per Second / DMIPS/MHz


Using the issues you've identified and your location in the city, JustFix.nyc will suggest things To Do so issues can start to be fixed.
As you work on your case, check out the Timeline, which will keep track of everything you've done. Be sure to show it to lawyers, judges, and even your landlord!


Mathematics and Computer Science Hotlist
The Franklin Institute's Online Math Collection
ScienceMaster's Tech Learning Home Page
The MacTutor History of Mathematics archive
Mathematics: Ancient Science and Its Modern Fates
History of Mathematics
General Mathematics
Math Goodies
Ole Miss Problems of the Week
Math in Daily Life
Exponential and Logarithmic Functions
Statistics: Cast Your Vote
Math Power
Math Puzzles
7th. Grade Math
A+ Math
Word Problems for Kids
Favorite Mathematical Constants
Olympiad Math Madness
Mathland
Basket Math
Measure 4 Measure
- Universal Conversions
Monty Hall Problem
Problems of The Week
Convert It
Math League Help Topics
Plane Math
Circles of Light: The Mathematics of Rainbows
Abacus: The Art of Calculation with Beads
Math Resources for Elementary Teachers
Helping Your Child Learn Math
Mathmania
The Math Man
Mathcounts
Smile Program Math Index
Math from The Chicago Systemic Initiative
Knot A Braid of Links
Magic Squares
Appetizers and Lessons for Math and Reason
Helping Your Child Learn Math
Fun With Numbers
Math Magic
Math Puzzles
Math Puzzles
Knot Theory
Clever Games for Clever People
Area and Perimeter Software
HTML Mazes
The Slide Rule Page
Puzzle Archive
The Math Forum
Mega-Mathematics
The Pi Page
Math Puzzles
Ask Dr. Math
Calculus-Help.com
MASSIVE
(Math and Science Song Information, Viewable Everywhere)
The Maths Internet Guide
Mathematicians
Archimedes
Erastosthenes
Biographies of Women Mathematicians
Geometry, symmetry, pattern
The Encyclopedia of Polyhedra
Ancient Geometry
Symmetry and The Shape of Space
Geometry - Symmetry
Gallery of Interactive Geometry
WWW Spirograph
Symmetry and Pattern: The Art of Oriental Carpets
: from
Swarthmore Math Forum
Fractal Gallery
Computing
History
The History of Computers
Computing History from 350 Million BC to 1997 CE
Chronology of Events in The History of Microcomputers
Computer History
The Museum of HP Calculators
The History of Computing
Museum of Obsolete Computers
Computer Scientists
Past Notable Women of Computing
Internet
Internet Architecture
Back to Hotlists