TDocument
- The type that this collection will encode documents from and decode documents to.@ThreadSafe
public interface MongoCollection<TDocument>
Note: Additions to this interface will not be considered to break binary compatibility.
MongoCollection is generic allowing for different types to represent documents. Any custom classes must have a
Codec
registered in the CodecRegistry
. The default CodecRegistry
includes built-in support for:
BsonDocument
, Document
and DBObject
.
| Modifier and Type | Method and Description |
|---|---|
AggregateIterable<TDocument> |
aggregate(List<? extends org.bson.conversions.Bson> pipeline)
Aggregates documents according to the specified aggregation pipeline.
|
<TResult> AggregateIterable<TResult> |
aggregate(List<? extends org.bson.conversions.Bson> pipeline,
Class<TResult> resultClass)
Aggregates documents according to the specified aggregation pipeline.
|
com.mongodb.bulk.BulkWriteResult |
bulkWrite(List<? extends com.mongodb.client.model.WriteModel<? extends TDocument>> requests)
Executes a mix of inserts, updates, replaces, and deletes.
|
com.mongodb.bulk.BulkWriteResult |
bulkWrite(List<? extends com.mongodb.client.model.WriteModel<? extends TDocument>> requests,
com.mongodb.client.model.BulkWriteOptions options)
Executes a mix of inserts, updates, replaces, and deletes.
|
long |
count()
Counts the number of documents in the collection.
|
long |
count(org.bson.conversions.Bson filter)
Counts the number of documents in the collection according to the given options.
|
long |
count(org.bson.conversions.Bson filter,
com.mongodb.client.model.CountOptions options)
Counts the number of documents in the collection according to the given options.
|
String |
createIndex(org.bson.conversions.Bson keys)
Create an index with the given keys.
|
String |
createIndex(org.bson.conversions.Bson keys,
com.mongodb.client.model.IndexOptions indexOptions)
Create an index with the given keys and options.
|
List<String> |
createIndexes(List<com.mongodb.client.model.IndexModel> indexes)
Create multiple indexes.
|
com.mongodb.client.result.DeleteResult |
deleteMany(org.bson.conversions.Bson filter)
Removes all documents from the collection that match the given query filter.
|
com.mongodb.client.result.DeleteResult |
deleteMany(org.bson.conversions.Bson filter,
com.mongodb.client.model.DeleteOptions options)
Removes all documents from the collection that match the given query filter.
|
com.mongodb.client.result.DeleteResult |
deleteOne(org.bson.conversions.Bson filter)
Removes at most one document from the collection that matches the given filter.
|
com.mongodb.client.result.DeleteResult |
deleteOne(org.bson.conversions.Bson filter,
com.mongodb.client.model.DeleteOptions options)
Removes at most one document from the collection that matches the given filter.
|
<TResult> DistinctIterable<TResult> |
distinct(String fieldName,
org.bson.conversions.Bson filter,
Class<TResult> resultClass)
Gets the distinct values of the specified field name.
|
<TResult> DistinctIterable<TResult> |
distinct(String fieldName,
Class<TResult> resultClass)
Gets the distinct values of the specified field name.
|
void |
drop()
Drops this collection from the Database.
|
void |
dropIndex(org.bson.conversions.Bson keys)
Drops the index given the keys used to create it.
|
void |
dropIndex(String indexName)
Drops the index given its name.
|
void |
dropIndexes()
Drop all the indexes on this collection, except for the default on _id.
|
FindIterable<TDocument> |
find()
Finds all documents in the collection.
|
FindIterable<TDocument> |
find(org.bson.conversions.Bson filter)
Finds all documents in the collection.
|
<TResult> FindIterable<TResult> |
find(org.bson.conversions.Bson filter,
Class<TResult> resultClass)
Finds all documents in the collection.
|
<TResult> FindIterable<TResult> |
find(Class<TResult> resultClass)
Finds all documents in the collection.
|
TDocument |
findOneAndDelete(org.bson.conversions.Bson filter)
Atomically find a document and remove it.
|
TDocument |
findOneAndDelete(org.bson.conversions.Bson filter,
com.mongodb.client.model.FindOneAndDeleteOptions options)
Atomically find a document and remove it.
|
TDocument |
findOneAndReplace(org.bson.conversions.Bson filter,
TDocument replacement)
Atomically find a document and replace it.
|
TDocument |
findOneAndReplace(org.bson.conversions.Bson filter,
TDocument replacement,
com.mongodb.client.model.FindOneAndReplaceOptions options)
Atomically find a document and replace it.
|
TDocument |
findOneAndUpdate(org.bson.conversions.Bson filter,
org.bson.conversions.Bson update)
Atomically find a document and update it.
|
TDocument |
findOneAndUpdate(org.bson.conversions.Bson filter,
org.bson.conversions.Bson update,
com.mongodb.client.model.FindOneAndUpdateOptions options)
Atomically find a document and update it.
|
org.bson.codecs.configuration.CodecRegistry |
getCodecRegistry()
Get the codec registry for the MongoCollection.
|
Class<TDocument> |
getDocumentClass()
Get the class of documents stored in this collection.
|
com.mongodb.MongoNamespace |
getNamespace()
Gets the namespace of this collection.
|
com.mongodb.ReadConcern |
getReadConcern()
Get the read concern for the MongoCollection.
|
com.mongodb.ReadPreference |
getReadPreference()
Get the read preference for the MongoCollection.
|
com.mongodb.WriteConcern |
getWriteConcern()
Get the write concern for the MongoCollection.
|
void |
insertMany(List<? extends TDocument> documents)
Inserts one or more documents.
|
void |
insertMany(List<? extends TDocument> documents,
com.mongodb.client.model.InsertManyOptions options)
Inserts one or more documents.
|
void |
insertOne(TDocument document)
Inserts the provided document.
|
void |
insertOne(TDocument document,
com.mongodb.client.model.InsertOneOptions options)
Inserts the provided document.
|
ListIndexesIterable<org.bson.Document> |
listIndexes()
Get all the indexes in this collection.
|
<TResult> ListIndexesIterable<TResult> |
listIndexes(Class<TResult> resultClass)
Get all the indexes in this collection.
|
MapReduceIterable<TDocument> |
mapReduce(String mapFunction,
String reduceFunction)
Aggregates documents according to the specified map-reduce function.
|
<TResult> MapReduceIterable<TResult> |
mapReduce(String mapFunction,
String reduceFunction,
Class<TResult> resultClass)
Aggregates documents according to the specified map-reduce function.
|
void |
renameCollection(com.mongodb.MongoNamespace newCollectionNamespace)
Rename the collection with oldCollectionName to the newCollectionName.
|
void |
renameCollection(com.mongodb.MongoNamespace newCollectionNamespace,
com.mongodb.client.model.RenameCollectionOptions renameCollectionOptions)
Rename the collection with oldCollectionName to the newCollectionName.
|
com.mongodb.client.result.UpdateResult |
replaceOne(org.bson.conversions.Bson filter,
TDocument replacement)
Replace a document in the collection according to the specified arguments.
|
com.mongodb.client.result.UpdateResult |
replaceOne(org.bson.conversions.Bson filter,
TDocument replacement,
com.mongodb.client.model.UpdateOptions updateOptions)
Replace a document in the collection according to the specified arguments.
|
com.mongodb.client.result.UpdateResult |
updateMany(org.bson.conversions.Bson filter,
org.bson.conversions.Bson update)
Update all documents in the collection according to the specified arguments.
|
com.mongodb.client.result.UpdateResult |
updateMany(org.bson.conversions.Bson filter,
org.bson.conversions.Bson update,
com.mongodb.client.model.UpdateOptions updateOptions)
Update all documents in the collection according to the specified arguments.
|
com.mongodb.client.result.UpdateResult |
updateOne(org.bson.conversions.Bson filter,
org.bson.conversions.Bson update)
Update a single document in the collection according to the specified arguments.
|
com.mongodb.client.result.UpdateResult |
updateOne(org.bson.conversions.Bson filter,
org.bson.conversions.Bson update,
com.mongodb.client.model.UpdateOptions updateOptions)
Update a single document in the collection according to the specified arguments.
|
MongoCollection<TDocument> |
withCodecRegistry(org.bson.codecs.configuration.CodecRegistry codecRegistry)
Create a new MongoCollection instance with a different codec registry.
|
<NewTDocument> |
withDocumentClass(Class<NewTDocument> clazz)
Create a new MongoCollection instance with a different default class to cast any documents returned from the database into..
|
MongoCollection<TDocument> |
withReadConcern(com.mongodb.ReadConcern readConcern)
Create a new MongoCollection instance with a different read concern.
|
MongoCollection<TDocument> |
withReadPreference(com.mongodb.ReadPreference readPreference)
Create a new MongoCollection instance with a different read preference.
|
MongoCollection<TDocument> |
withWriteConcern(com.mongodb.WriteConcern writeConcern)
Create a new MongoCollection instance with a different write concern.
|
com.mongodb.MongoNamespace getNamespace()
Class<TDocument> getDocumentClass()
org.bson.codecs.configuration.CodecRegistry getCodecRegistry()
CodecRegistry
com.mongodb.ReadPreference getReadPreference()
ReadPreference
com.mongodb.WriteConcern getWriteConcern()
WriteConcern
com.mongodb.ReadConcern getReadConcern()
ReadConcern
<NewTDocument> MongoCollection<NewTDocument> withDocumentClass(Class<NewTDocument> clazz)
NewTDocument
- The type that the new collection will encode documents from and decode documents toclazz
- the default class to cast any documents returned from the database into.MongoCollection<TDocument> withCodecRegistry(org.bson.codecs.configuration.CodecRegistry codecRegistry)
codecRegistry
- the new CodecRegistry
for the collectionMongoCollection<TDocument> withReadPreference(com.mongodb.ReadPreference readPreference)
readPreference
- the new ReadPreference
for the collectionMongoCollection<TDocument> withWriteConcern(com.mongodb.WriteConcern writeConcern)
writeConcern
- the new WriteConcern
for the collectionMongoCollection<TDocument> withReadConcern(com.mongodb.ReadConcern readConcern)
readConcern
- the new ReadConcern
for the collectionlong count()
long count(org.bson.conversions.Bson filter)
filter
- the query filterlong count(org.bson.conversions.Bson filter, com.mongodb.client.model.CountOptions options)
filter
- the query filteroptions
- the options describing the count<TResult> DistinctIterable<TResult> distinct(String fieldName, Class<TResult> resultClass)
TResult
- the target type of the iterable.fieldName
- the field nameresultClass
- the class to cast any distinct items into.<TResult> DistinctIterable<TResult> distinct(String fieldName, org.bson.conversions.Bson filter, Class<TResult> resultClass)
TResult
- the target type of the iterable.fieldName
- the field namefilter
- the query filterresultClass
- the class to cast any distinct items into.FindIterable<TDocument> find()
<TResult> FindIterable<TResult> find(Class<TResult> resultClass)
TResult
- the target document type of the iterable.resultClass
- the class to decode each document intoFindIterable<TDocument> find(org.bson.conversions.Bson filter)
filter
- the query filter<TResult> FindIterable<TResult> find(org.bson.conversions.Bson filter, Class<TResult> resultClass)
TResult
- the target document type of the iterable.filter
- the query filterresultClass
- the class to decode each document intoAggregateIterable<TDocument> aggregate(List<? extends org.bson.conversions.Bson> pipeline)
pipeline
- the aggregate pipeline<TResult> AggregateIterable<TResult> aggregate(List<? extends org.bson.conversions.Bson> pipeline, Class<TResult> resultClass)
TResult
- the target document type of the iterable.pipeline
- the aggregate pipelineresultClass
- the class to decode each document intoMapReduceIterable<TDocument> mapReduce(String mapFunction, String reduceFunction)
mapFunction
- A JavaScript function that associates or "maps" a value with a key and emits the key and value pair.reduceFunction
- A JavaScript function that "reduces" to a single object all the values associated with a particular key.<TResult> MapReduceIterable<TResult> mapReduce(String mapFunction, String reduceFunction, Class<TResult> resultClass)
TResult
- the target document type of the iterable.mapFunction
- A JavaScript function that associates or "maps" a value with a key and emits the key and value pair.reduceFunction
- A JavaScript function that "reduces" to a single object all the values associated with a particular key.resultClass
- the class to decode each resulting document into.com.mongodb.bulk.BulkWriteResult bulkWrite(List<? extends com.mongodb.client.model.WriteModel<? extends TDocument>> requests)
requests
- the writes to executecom.mongodb.MongoBulkWriteException
- if there's an exception in the bulk write operationcom.mongodb.MongoException
- if there's an exception running the operationcom.mongodb.bulk.BulkWriteResult bulkWrite(List<? extends com.mongodb.client.model.WriteModel<? extends TDocument>> requests, com.mongodb.client.model.BulkWriteOptions options)
requests
- the writes to executeoptions
- the options to apply to the bulk write operationcom.mongodb.MongoBulkWriteException
- if there's an exception in the bulk write operationcom.mongodb.MongoException
- if there's an exception running the operationvoid insertOne(TDocument document)
document
- the document to insertcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the insert commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurevoid insertOne(TDocument document, com.mongodb.client.model.InsertOneOptions options)
document
- the document to insertoptions
- the options to apply to the operationcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the insert commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoCommandException
- if the write failed due to document validation reasonscom.mongodb.MongoException
- if the write failed due some other failurevoid insertMany(List<? extends TDocument> documents)
bulkWrite
methoddocuments
- the documents to insertcom.mongodb.MongoBulkWriteException
- if there's an exception in the bulk write operationcom.mongodb.MongoException
- if the write failed due some other failurebulkWrite(java.util.List<? extends com.mongodb.client.model.WriteModel<? extends TDocument>>)
void insertMany(List<? extends TDocument> documents, com.mongodb.client.model.InsertManyOptions options)
bulkWrite
methoddocuments
- the documents to insertoptions
- the options to apply to the operationcom.mongodb.DuplicateKeyException
- if the write failed to a duplicate unique keycom.mongodb.WriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.DeleteResult deleteOne(org.bson.conversions.Bson filter)
filter
- the query filter to apply the the delete operationcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the delete commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.DeleteResult deleteOne(org.bson.conversions.Bson filter, com.mongodb.client.model.DeleteOptions options)
filter
- the query filter to apply the the delete operationoptions
- the options to apply to the delete operationcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the delete commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.DeleteResult deleteMany(org.bson.conversions.Bson filter)
filter
- the query filter to apply the the delete operationcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the delete commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.DeleteResult deleteMany(org.bson.conversions.Bson filter, com.mongodb.client.model.DeleteOptions options)
filter
- the query filter to apply the the delete operationoptions
- the options to apply to the delete operationcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the delete commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.UpdateResult replaceOne(org.bson.conversions.Bson filter, TDocument replacement)
filter
- the query filter to apply the the replace operationreplacement
- the replacement documentcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the replace commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.UpdateResult replaceOne(org.bson.conversions.Bson filter, TDocument replacement, com.mongodb.client.model.UpdateOptions updateOptions)
filter
- the query filter to apply the the replace operationreplacement
- the replacement documentupdateOptions
- the options to apply to the replace operationcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the replace commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.UpdateResult updateOne(org.bson.conversions.Bson filter, org.bson.conversions.Bson update)
filter
- a document describing the query filter, which may not be null.update
- a document describing the update, which may not be null. The update to apply must include only update operators.com.mongodb.MongoWriteException
- if the write failed due some other failure specific to the update commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.UpdateResult updateOne(org.bson.conversions.Bson filter, org.bson.conversions.Bson update, com.mongodb.client.model.UpdateOptions updateOptions)
filter
- a document describing the query filter, which may not be null.update
- a document describing the update, which may not be null. The update to apply must include only update operators.updateOptions
- the options to apply to the update operationcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the update commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.UpdateResult updateMany(org.bson.conversions.Bson filter, org.bson.conversions.Bson update)
filter
- a document describing the query filter, which may not be null.update
- a document describing the update, which may not be null. The update to apply must include only update operators.com.mongodb.MongoWriteException
- if the write failed due some other failure specific to the update commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failurecom.mongodb.client.result.UpdateResult updateMany(org.bson.conversions.Bson filter, org.bson.conversions.Bson update, com.mongodb.client.model.UpdateOptions updateOptions)
filter
- a document describing the query filter, which may not be null.update
- a document describing the update, which may not be null. The update to apply must include only update operators.updateOptions
- the options to apply to the update operationcom.mongodb.MongoWriteException
- if the write failed due some other failure specific to the update commandcom.mongodb.MongoWriteConcernException
- if the write failed due being unable to fulfil the write concerncom.mongodb.MongoException
- if the write failed due some other failureTDocument findOneAndDelete(org.bson.conversions.Bson filter)
filter
- the query filter to find the document withTDocument findOneAndDelete(org.bson.conversions.Bson filter, com.mongodb.client.model.FindOneAndDeleteOptions options)
filter
- the query filter to find the document withoptions
- the options to apply to the operationTDocument findOneAndReplace(org.bson.conversions.Bson filter, TDocument replacement)
filter
- the query filter to apply the the replace operationreplacement
- the replacement documentreturnOriginal
property, this will either be the
document as it was before the update or as it is after the update. If no documents matched the query filter, then null will be
returnedTDocument findOneAndReplace(org.bson.conversions.Bson filter, TDocument replacement, com.mongodb.client.model.FindOneAndReplaceOptions options)
filter
- the query filter to apply the the replace operationreplacement
- the replacement documentoptions
- the options to apply to the operationreturnOriginal
property, this will either be the
document as it was before the update or as it is after the update. If no documents matched the query filter, then null will be
returnedTDocument findOneAndUpdate(org.bson.conversions.Bson filter, org.bson.conversions.Bson update)
filter
- a document describing the query filter, which may not be null.update
- a document describing the update, which may not be null. The update to apply must include only update operators.TDocument findOneAndUpdate(org.bson.conversions.Bson filter, org.bson.conversions.Bson update, com.mongodb.client.model.FindOneAndUpdateOptions options)
filter
- a document describing the query filter, which may not be null.update
- a document describing the update, which may not be null. The update to apply must include only update operators.options
- the options to apply to the operationreturnOriginal
property, this will either be the
document as it was before the update or as it is after the update. If no documents matched the query filter, then null will be
returnedvoid drop()
String createIndex(org.bson.conversions.Bson keys)
keys
- an object describing the index key(s), which may not be null.String createIndex(org.bson.conversions.Bson keys, com.mongodb.client.model.IndexOptions indexOptions)
keys
- an object describing the index key(s), which may not be null.indexOptions
- the options for the indexList<String> createIndexes(List<com.mongodb.client.model.IndexModel> indexes)
indexes
- the list of indexesListIndexesIterable<org.bson.Document> listIndexes()
<TResult> ListIndexesIterable<TResult> listIndexes(Class<TResult> resultClass)
TResult
- the target document type of the iterable.resultClass
- the class to decode each document intovoid dropIndex(String indexName)
indexName
- the name of the index to removevoid dropIndex(org.bson.conversions.Bson keys)
keys
- the keys of the index to removevoid dropIndexes()
void renameCollection(com.mongodb.MongoNamespace newCollectionNamespace)
newCollectionNamespace
- the namespace the collection will be renamed tocom.mongodb.MongoServerException
- if you provide a newCollectionName that is the name of an existing collection, or if the
oldCollectionName is the name of a collection that doesn't existvoid renameCollection(com.mongodb.MongoNamespace newCollectionNamespace, com.mongodb.client.model.RenameCollectionOptions renameCollectionOptions)
newCollectionNamespace
- the name the collection will be renamed torenameCollectionOptions
- the options for renaming a collectioncom.mongodb.MongoServerException
- if you provide a newCollectionName that is the name of an existing collection and dropTarget
is false, or if the oldCollectionName is the name of a collection that doesn't existCopyright © 2017. All rights reserved.


|
Valkyrie Engine Common
|
3D geometric transform. More...
#include <Transform.hpp>
Public Member Functions | |
| Matrix4 | GetMatrix () const |
| brief Gets a transformation matrix representing this transform of this object in local space. | |
| Matrix4 | GetWorldMatrix () const |
| Gets a transformation matrix representing the transform of this object and all it's parent transforms in world space. | |
| const Transform3D * | GetParent () const |
Gets the current parent of this transform object, may be nullptr . | |
| void | SetParent (const Transform3D *tr) |
| Sets the parent of this transform. More... | |
| Vector3 | GetWorldTranslation () const |
| Gets the translation of this transform in world space. | |
| Quaternion | GetWorldRotation () const |
| Gets the rotation of this transform in world space. | |
| Vector3 | GetWorldScale () const |
| Gets the approximate scale of this transform in world space. | |
3D geometric transform.
Combines a scale, rotation and translation into a single operation.
|
inline |
Sets the parent of this transform.
| tr | The new parent of this transform or nullptr to remove the current parent. Additionally, this must not be equal to tr or any parent of tr . |
| std::runtime_error | If this is already a parent of tr . |


| Requirement | User Case | Priority | Completed Status | Contributor(s) |
|---|---|---|---|---|
| The ability to create companies and issue initial shares. | Business User | Must Have | Completed | Andreas Zinonos, Gabriel Vanca, Charles Albert Desbaux |
| Browse through companies on the platform. | Investor User | Must Have | Completed | Charles Albert Desbaux |
| The ability to trade shares between investors. | Investor User | Should Have | Completed | Andreas Zinonos, Gabriel Vanca, Charles Albert Desbaux |
| The ability to tissue more shares. | Business User | Should Have | Completed | Andreas Zinonos, Gabriel Vanca, Charles Albert Desbaux |
| Real time conversion mechanism from GBP to ETH and back. | Investor User & Business User | Could Have | Completed | Gabriel Vanca |
| The ability to vote in company decisions. | Investor User | Would Have | Not Completed | - |
| The ability to issue dividents. | Business User | Would Have | Not Completed | - |
| The possibility to buy different kinds of stocks such as preferential shares or convertible shares. | Investor User | Would Have | Not Completed | - |
| Task | Contributor(s) |
|---|---|
| UI Design | Charles Albert Desbaux |
| Angular Front-End | Charles Albert Desbaux |
| Firebase Database | Charles Albert Desbaux |
| UCL Final Presentation | Charles Albert Desbaux |
| Class Diagram of System | Charles Albert Desbaux |
| Back-End NodeJS Server | Gabriel Vanca |
| Server Deployment and Infrastructure Management | Gabriel Vanca |
| Financial Research and Financial Plan | Gabriel Vanca |
| Real time conversion mechanism from GBP to ETH and back. | Gabriel Vanca |
| UCL & ATOS Documentation Writing | Gabriel Vanca |
| UCL Presentation Website | Gabriel Vanca |
| NodeJS Unit Testing | Gabriel Vanca |
| NodeJS & Angular Integrated Testing | Gabriel Vanca, Charles Albert Desbaux |
| Soldity Research | Andreas Zinonos |
| Soldity Contracts Development | Andreas Zinonos |
| UCL & ATOS Videos | Andreas Zinonos |
| Soldity Contracts Manual and Automatic Testing | Andreas Zinonos |
| Full System Testing | Gabriel Vanca, Charles Albert Desbaux, Andreas Zinonos |
After intensive testing and a lot of time spent on bug fixing, we do not currently know of any bug on our app.
The only features we did not implement are the ones in our "Would Have" section of the MoSCoW. All other features were implemented
| Domain | Critical Evaluation |
|---|---|
| Architecture Design | We are very happy with our robust design that has proved efficient, but also easy to migrate to alrger systems. Having all the data stored externally (external Firebase database and on the Blockchain) provided very easy scalability which is essential if we would want to transform this project into a business. |
| User Interface Design and User Experience | We have achieved a very good user experience and a very robust, simple, but also good looking interface design. We have led several surveys with out colleguaues, but also with our client, which helped us get to where we are. |
| Functionality | Functionality is very good as we have achieved all the Must Have, Should Have and Could Have requirements from the MoSCoW table. We would have preffered though to also do most of the Would Have features as well. Nonetheless, we are very happy with our progress. |
| Stability | After extensive testing (and bug fixing), the system has hsould itself as being extremly stable and it can cope with an average number of user on the infrastructure that we already have in place. We are very happy about it. |
| Efficiency | The system is overall very efficient, and does not use too many resources. Space wise, the project uses maximum 350MBs and RAM wise, an average of 600 MBs. The RAM cost might seem high, but this is only due to the contracts being loaded as strings into memory. RAM usage is not proportionate and will not scale if the system becomes larger, therefore not being an issue. |
| Compatibility | The server application can run on Ubuntu and Mac (we do recoment Ubuntu 16 or alter though). System with at least 1 GB of RAM should be able to run the server. On the client side, there are no operating system or memory specifications, but the app does nto scale well on smaller screens (mobile is a problem) and there are some issues when using Internet Explorer and Mozzila Firefox. Compatibility definetly needs to be improved, but we did not consider it a priority for the purposes of this project. |
| Maintanability | The server application requires almost no maintenance. Even the little that it does (cleaning backups, restarting etc.) is done extremly easy through the use of the Bash scripts included with the project. |
| Evaluation of Testing | We have conducted extensive testing, including unit testing, integration testing, full system testing, automatic testing etc. We have fixed all bugs we found and we are overall very happy with the testing we have conducted. |
| Project Management | Project Management was overall easy. We have used source versioning tools such as Git and GitHub (and GitKraken), and for documentation management we have used Google Drive and Google Docs. |
These are out plans for the future but also what we would have tried to do if we had 6 more months for this module.


Previous Excel Table
Type something in the input field to search the table :
| Last Name | First Name | Date | Branch | Time | Notes |
|---|---|---|---|---|---|
| Couch | Brendan | 2018/10/31 | APLH | 6:05pm | Fighting with other youth patrons. Kept escalating way past staff intervention. 6 month ban issued. |
| Ahmad | Georgiana | 2018/10/30 | APLM | 10:20am | Was found unresponsive in the library, possibly from low blood pressure. 911 was called and he went to the E.R. |
| Livingston | Albert | 2018/10/23 | APLH | 4:15pm | Choked another youth patron and slammed his head into the sidewalk. Staff spoke with him and gave him one more chance. |
| Couch | Brendan | 2018/10/31 | APLH | Was "rough housing" with two other youth patrons. Asked to stop repeatedly but didn’t and then eventually asked to leave for the day. | |
| Bates | Aaron | 2018/10/03 | APLM | 6:05pm | Has been caught drinking in Wash Ave Branch several times, and has been asked to leave for the day each time. CEE (AL) banned him for a week. |


|
OpenM++ runtime library (libopenm)
|
type_dic join to model_type_dic table row. More...
Public Member Functions | |
| TypeDicRow (int i_modelId, int i_typeId) | |
| create row with supplied unique key field values. | |
| TypeDicRow (void) | |
| create row with default empty key values. | |
| bool | isBool (void) const |
| return true if model type is boolean (logical) | |
| bool | isString (void) const |
| return true if model type is string (varchar) | |
| bool | isBigInt (void) const |
| return true if model type is bigint (64 bit) | |
| bool | isInt (void) const |
| return true if model type is integer (not float, string, boolean or bigint) | |
| bool | isFloat (void) const |
| return true if model type is float (float, real, double or time) | |
| bool | isTime (void) const |
| return true if model type is Time | |
| bool | isBuiltIn (void) const |
| return true if model type is built-in, ie: int, double, logical | |
Static Public Member Functions | |
| static bool | isKeyLess (const TypeDicRow &i_left, const TypeDicRow &i_right) |
| less comparator by unique key: model id, model type id. | |
| static bool | isKeyEqual (const TypeDicRow &i_left, const TypeDicRow &i_right) |
| equal comparator by unique key: model id, model type id. | |
| static vector< TypeDicRow >::const_iterator | byKey (int i_modelId, int i_typeId, const vector< TypeDicRow > &i_rowVec) |
| find row by unique key: model id and model type id. | |
| Static Public Member Functions inherited from openm::IMetaRow< TypeDicRow > | |
| static bool | keyLess (const IRowBaseUptr &i_left, const IRowBaseUptr &i_right) |
| less comparator by row primary key. | |
| static bool | keyEqual (const IRowBaseUptr &i_left, const IRowBaseUptr &i_right) |
| equal comparator by row primary key. | |
Public Attributes | |
| int | modelId |
| model_id INT NOT NULL | |
| int | typeId |
| model_type_id INT NOT NULL | |
| string | name |
| type_name VARCHAR(255) NOT NULL, – type name: int, double, etc. | |
| string | digest |
| type_digest VARCHAR(32) NOT NULL | |
| int | dicId |
| dic_id INT NOT NULL, – dictionary id: 0=simple 1=logical 2=classification 3=range 4=partition 5=link | |
| int | totalEnumId |
| total_enum_id INT NOT NULL, – if total enabled this is enum_value of total item =max+1 | |
type_dic join to model_type_dic table row.


Class: Aws::FMS::Types::PolicyComplianceDetail
| 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-fms/lib/aws-sdk-fms/types.rb |
Overview
Describes the noncompliant resources in a member account for a
specific Firewall Manager policy. A maximum of 100 entries are
displayed. If more than 100 resources are noncompliant,
EvaluationLimitExceeded
is set to True
.
Constant Summary
Instance Attribute Summary
-
#evaluation_limit_exceeded ⇒ Boolean
rw
Indicates if over 100 resources are noncompliant with the Firewall Manager policy.
-
#expired_at ⇒ Time
rw
A timestamp that indicates when the returned information should be considered out of date.
-
#issue_info_map ⇒ Hash<String,String>
rw
Details about problems with dependent services, such as
::Aws::WAF
or Config, and the error message received that indicates the problem with the service. -
#member_account ⇒ String
rw
The Amazon Web Services account ID.
-
#policy_id ⇒ String
rw
The ID of the Firewall Manager policy.
-
#policy_owner ⇒ String
rw
The Amazon Web Services account that created the Firewall Manager policy.
-
#violators ⇒ Array<Types::ComplianceViolator>
rw
An array of resources that aren't protected by the
::Aws::WAF
or::Aws::Shield
Advanced policy or that aren't in compliance with the security group policy.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Structure#to_h. |
Instance Attribute Details
#evaluation_limit_exceeded ⇒ Boolean
(rw)
Indicates if over 100 resources are noncompliant with the Firewall Manager policy.
# File 'gems/aws-sdk-fms/lib/aws-sdk-fms/types.rb', line 3171
class PolicyComplianceDetail < Struct.new( :policy_owner, :policy_id, :member_account, :violators, :evaluation_limit_exceeded, :expired_at, :issue_info_map) SENSITIVE = [] include Aws::Structure end
#expired_at ⇒ Time
(rw)
A timestamp that indicates when the returned information should be considered out of date.
# File 'gems/aws-sdk-fms/lib/aws-sdk-fms/types.rb', line 3171
class PolicyComplianceDetail < Struct.new( :policy_owner, :policy_id, :member_account, :violators, :evaluation_limit_exceeded, :expired_at, :issue_info_map) SENSITIVE = [] include Aws::Structure end
#issue_info_map ⇒ Hash
<String
,String
> (rw)
Details about problems with dependent services, such as ::Aws::WAF
or
Config, and the error message received that indicates the problem
with the service.
# File 'gems/aws-sdk-fms/lib/aws-sdk-fms/types.rb', line 3171
class PolicyComplianceDetail < Struct.new( :policy_owner, :policy_id, :member_account, :violators, :evaluation_limit_exceeded, :expired_at, :issue_info_map) SENSITIVE = [] include Aws::Structure end
#member_account ⇒ String
(rw)
The Amazon Web Services account ID.
# File 'gems/aws-sdk-fms/lib/aws-sdk-fms/types.rb', line 3171
class PolicyComplianceDetail < Struct.new( :policy_owner, :policy_id, :member_account, :violators, :evaluation_limit_exceeded, :expired_at, :issue_info_map) SENSITIVE = [] include Aws::Structure end
#policy_id ⇒ String
(rw)
The ID of the Firewall Manager policy.
# File 'gems/aws-sdk-fms/lib/aws-sdk-fms/types.rb', line 3171
class PolicyComplianceDetail < Struct.new( :policy_owner, :policy_id, :member_account, :violators, :evaluation_limit_exceeded, :expired_at, :issue_info_map) SENSITIVE = [] include Aws::Structure end
#policy_owner ⇒ String
(rw)
The Amazon Web Services account that created the Firewall Manager policy.
# File 'gems/aws-sdk-fms/lib/aws-sdk-fms/types.rb', line 3171
class PolicyComplianceDetail < Struct.new( :policy_owner, :policy_id, :member_account, :violators, :evaluation_limit_exceeded, :expired_at, :issue_info_map) SENSITIVE = [] include Aws::Structure end
#violators ⇒ Array
<Types::ComplianceViolator> (rw)
An array of resources that aren't protected by the ::Aws::WAF
or ::Aws::Shield
Advanced policy or that aren't in compliance with the security
group policy.
# File 'gems/aws-sdk-fms/lib/aws-sdk-fms/types.rb', line 3171
class PolicyComplianceDetail < Struct.new( :policy_owner, :policy_id, :member_account, :violators, :evaluation_limit_exceeded, :expired_at, :issue_info_map) SENSITIVE = [] include Aws::Structure end


8 Ancestral State Reconstruction I
This chapter will take you through the code we can use to run ancestral state reconstruction with categorical characters. As always, remember to begin by setting your working directory to wherever you have saved the data files.
8.1 Data
The first thing we need to do is load some data. When you’re doing this, you need to keep in mind that you should keep your workspace as well organised as possible. In practice, this means giving things good names. “RicksDataV1.1” is not a great name depending on how many datasets you want in there. Neither is “data1” if you plan on having multiple datasets (which we do). So give your data object, and all other objects, simple, useful names. My personal preference is to use the name of the group but whatever works is fine. You need to be able to keep track of everything.
In your environment panel there should be a data frame with 16 observations of 2 variables. This command will show us the top 6 rows of data. It’s helpful to have a quick look and see R has loaded what we expected. In this case our data contains 15 species of macaque and one species of baboon alongside data regarding whether they exhibit sexual swellings or not (1/0).
species swelling
1 Macaca_arctoides 0
2 Macaca_assamensis 0
3 Macaca_cyclopis 1
4 Macaca_fascicularis 1
5 Macaca_fuscata 1
6 Macaca_maura 1
8.2 Trees
Now we need to load the tree using the read.nexus function in the package ape (Paradis and Schliep 2018).
Let’s plot the tree to make sure it loaded correctly. I’ve used base graphics here rather than ggtree (annotated to let you know what it does). Feel free to have a mess around with these options so you get a feel for what they do. The second function “tiplabels” adds some extra tip labels containing the data from the second column of our macaque data.
plot(macaque.tree, #Tree object
cex = 0.7, #Font size for tip labels
label.offset = 0.3, #Create a space between tip and label
edge.color = "blue", #Paint the branches blue
edge.width = 2, #Make the branches thicker
no.margin = TRUE) #remove blank margins
tiplabels(macaques[,2], bg = "white", cex = 0.7)
8.3 Parsimony
Let’s first generate the most parsimonious reconstruction of the history of this trait. Remember that the most parsimonious history is the one that has the fewest evolutionary transitions. Parsimony is conceptually based upon Occam’s razor which states that all else being equal, the simplest explanantion is always the correct one.
The function for this is MPR. It takes an unrooted tree and asks you to specify the root. In our case, we’ll have to unroot our tree and then re-root it by specifying that Papio anubis is our outgroup.
When we investigate mp1, we can see a list of results matched up to numbered nodes on the tree. Some nodes are clearly in state 1 and others in state 0. Interestingly some are indeterminate and could be either 0 or 1 such as nodes 19 and 20.
lower upper
17 1 1
18 1 1
19 0 1
20 0 1
21 1 1
22 1 1
23 1 1
24 0 0
25 0 0
26 0 0
27 1 1
28 1 1
29 1 1
30 1 1
To get an idea of what this means, we should plot it on the tree. This loop cycles through our results list and combines the lower and upper estimates for each node into a text string that we can then overlay onto that node.
mp.nodes <- numeric(0)
for(i in 1:length(mp1[,1])){
mp.nodes <- append(mp.nodes, paste(mp1[i,1], ",", mp1[i,2]))
}
Once we’ve done that we can plot those expressions onto the tree with the function nodelabels.
plot(macaque.tree, cex = 0.7, label.offset = 0.3,
edge.color = "blue", edge.width = 2, no.margin = TRUE)
tiplabels(macaques[,2], bg = "white", cex = 0.7)
nodelabels(mp.nodes, c(18:31), bg = "white")
As you can see, the uncertainty in some nodes comes from the fact that there seems to be at least two equally parsimonious histories with gains and losses ocurring in different places. For any serious analysis, this is a highly unsatisfactory outcome!
8.4 Maximum Likelihood
Let’s try a different approach. Maximum likelihood is different from parsimony for many reasons but most significantly, it can make use of branch length information. This is very useful in discriminating between possible histories. A longer branch means more evolutionary change (either in time or character change) and so transitions are more likely to occur on longer branches.
Let’s replot the tree. Here I’ve changed the tiplabels function to plot the character states as colours rather than numbers. The bg argument is what lets me do this. In this argument I list the states (adding 1 because the first is 0) and then the function passes those states to R to assign colours based on a numbered list of standard colours.
plot(macaque.tree, cex = 0.7, label.offset = 0.4, edge.width = 2, no.margin = TRUE)
tiplabels(pch = 21, bg = as.numeric(macaques$swelling)+1, cex = 1.7)
To run an ancestral state reconstruction using maximum likelihood we can use the function ace (ancestral character estimation) in the ape package (Paradis and Schliep 2018). In our first reconstruction, we will make the assumption that the rate of evolution of the trait is equal across the tree by setting the model to ER (equal rates).
m1 <- ace(x = macaques$swelling, #trait data
phy = macaque.tree, #phylogeny
method = "ML", #method (Maximum likelihood)
type = "discrete", #type of data (continuous or discrete)
model = "ER") #Model of evolution
m1
Ancestral Character Estimation
Call: ace(x = macaques$swelling, phy = macaque.tree, type = "discrete",
method = "ML", model = "ER")
Log-likelihood: -6.906593
Rate index matrix:
0 1
0 . 1
1 1 .
Parameter estimates:
rate index estimate std-err
1 0.0319 0.0191
Scaled likelihoods at the root (type '...$lik.anc' to get them for all nodes):
0 1
0.08625654 0.91374346
Looking at the results shows us the likelihood at the root (91% in favour of state 1 here). However, it’s always best to plot the results. We can represent the likelihoods at each node with a piechart. Generally speaking, piecharts are awful but when used in this way, they can actually add useful information to a plot and that’s the most important point about plotting any data. In this plot, the piecharts represent the probability that each node exhibited sexual swelling (red) or concealed estrus (black). We can see that the two uncertain nodes from our parsimony analysis are now more certain. Visual inspection shows that these nodes have a greater than 75% probability of having exhibited sexual swellings.
plot(macaque.tree, cex = 0.7, label.offset = 0.4, edge.width = 2, no.margin = TRUE)
tiplabels(pch = 21, bg = as.numeric(macaques$swelling)+1, cex = 1.7)
nodelabels(pie = m1$lik.anc, piecol = c("black", "red"), cex = 0.8)
Now we can run a similar analysis but let’s assume that rates of evolution can vary by setting model to ARD (All Rates Different).
m2 <- ace(x = macaques$swelling, phy = macaque.tree,
method = "ML", type = "discrete", model = "ARD")
plot(macaque.tree, cex = 0.7, label.offset = 0.4, edge.width = 2, no.margin = TRUE)
tiplabels(pch = 21, bg = as.numeric(macaques$swelling)+1, cex = 1.7)
nodelabels(pie = m2$lik.anc, piecol = c("black", "red"), cex = 0.8)
As you can see, the different model of evolution makes a big difference to the results. Which model you choose to use depends on which assumptions you think are justified. Is it fair to assume that the rate of evolution of conspicuous sexual swelling would be constant across the tree as in the equal rates model?
8.5 Stochastic Character Mapping
Stochastic character mapping uses an MCMC (Markov chain Monte-Carlo) approach to sample possible reconstructions from a posterior probability distribution.
Think of the posterior probability distribution as containing all the possible evolutionary histories of the trait in question. This includes some histories in which everything was in one state right up until a few generations from the present when everything swapped around at the same time to give us the distribution we see today. It also contains a history in which the trait switches between 0 and 1 every other generation essentially at random.
Obviously these kind of histories are biologically absurd but not mathematically impossible. They have low statistical probability. Certain other histories will have a high statistical probability and so there will be many similar histories in the distribution. The distribution can be thought of as a histogram with some parameter that defines each particular history.
8.5.1 An Analogy
Let’s say that we were to plot the entire multiverse as such a distribution using the evil tendencies of one particular occupant (Rick Sanchez) of the multiverse as our parameter. All the different Ricks in all the different universes will vary in their evil tendencies. But overall, Rick’s character is actually a nihilist meaning his mean evilness is around 0 when taken over the whole multiverse. Given all this, the posterior distribution of evil Ricks in the multiverse might look like this.
MCMC samples this distribution of histories in a chain. If a history has a higher likelihood than the previous sampling, it is accepted. If it is lower then it is rejected from the sample. In this way, MCMC quickly narrows down the possibilities and gives us a sample of quite likely histories.
8.5.2 2-State Characters
Let’s see it in action. We’ll need the phytools package (Revell 2012) to create our stochastic character map.
For this analysis (like other phytools functions) we’ll need our data in a named vector rather than a data table. Let’s call it swelling. The names function attaches the species name to each value in our new vector.
Macaca_arctoides Macaca_assamensis Macaca_cyclopis Macaca_fascicularis
0 0 1 1
Macaca_fuscata Macaca_maura Macaca_mulatta Macaca_nemestrina
1 1 1 1
Macaca_nigra Macaca_radiata Macaca_silenus Macaca_sinica
1 0 1 0
Macaca_sylvanus Macaca_thibetana Macaca_tonkeana Papio_anubis
1 0 1 1
Now we can sample character histories assuming an equal rates model of evolution using the make.simmap function.
make.simmap is sampling character histories conditioned on the transition matrix
Q =
0 1
0 -0.03185011 0.03185011
1 0.03185011 -0.03185011
(estimated using likelihood);
and (mean) root node prior probabilities
pi =
0 1
0.5 0.5
Done.
Q here is the matrix of transition rates which we have constrained to be equal (model = “ER”) which explains why the numbers match. As usual with reconstructions, the best thing is to plot them. Here we can use the phytools function plotSimmap to plot the special object we’ve created. It even has a companion function to add a legend. The first line here assigns colours to the traits.
cols <- setNames(c("black", "red"), sort(unique(swelling)))
plotSimmap(scm1, cols, pts = F, lwd = 3, fsize = .8)
add.simmap.legend(colors = cols, vertical = F, prompt = F, x = 0, y = 10, fsize = .8)
Here you can see the single history we have sampled (yours will likely differ). The history contains branches painted according to the trait colour we specified and the position of the transitions on the branch mark the exact position the changes are theorised to have taken place. This is an awful lot of certainty for an ancestral state reconstruction! You should note that the one plotted here is very odd. It says that the ancestor of the group had concealed estrus and then this trait was lost 3 times independently, leaving no trace in the extant species. Given the data and tree we provided, it is hard to see how we can have any confidence in this reconstruction. What evidence have we collected that actually supports this?
However, we need to remember that this only one of the many possible histories! Our next step should be to extract a reasonable sample of these histories!
Let’s sample 500 and when R has done that, we can use describe.simmap to summarize the sample.
make.simmap is sampling character histories conditioned on the transition matrix
Q =
0 1
0 -0.03185011 0.03185011
1 0.03185011 -0.03185011
(estimated using likelihood);
and (mean) root node prior probabilities
pi =
0 1
0.5 0.5
Done.
When we call up the summary, we can see some interesting details about our sample. It seems to be saying that transitions from 1 to 0 (a loss of sexual swelling) happen more frequently than gains of sexual swelling.
500 trees with a mapped discrete character with states:
0, 1
trees have 2.872 changes between states on average
changes are of the following types:
0,1 1,0
x->y 0.758 2.114
mean total time spent in each state is:
0 1 total
raw 17.6835904 71.4988096 89.1824
prop 0.1982857 0.8017143 1.0000
As usual, we’re going to want a summary plot. The backbone of this plot won’t look quite the same as the previous one. You don’t want confusing information on your plot so here it would be better to plot a blank backbone (ie a tree with just one colour of branch that doesn’t match the colour of the traits) and represent the trait transitions as we did previously with pie charts. In this case the pies represent the proportion of histories in each state (1 or 0) at each node.
cols.null <- setNames(c("darkgrey", "darkgrey"), sort(unique(swelling)))
plotSimmap(scm2[[1]], lwd = 3, pts = F, setEnv = T, colors = cols.null, offset = .6)
nodelabels(pie = scm2.sum$ace, piecol = cols, cex = 0.6)
add.simmap.legend(colors = cols, vertical = F, prompt = F, x = 0, y = 10, fsize = .8)
tiplabels(pch = 21, bg = as.numeric(macaques$swelling)+1, cex = 2)
This analysis gives us a very similar output to the maximum likelihood analysis in the previous section. If you’re intrested, give this analysis another try with different models of evolution.
8.5.3 3-State Characters
Stochastic character mapping can also be used for traits with more than one state. For example, burrowing in carnivores can be classified as 0 (no burrowing), 1 (use a burrow dug by another animal) or 2 (dig your own burrow).
<IP_ADDRESS> Data
Let’s load some data from a paper which investigated aposematism in terrestrial carnivores (Stankowich et al. 2011). Don’t forget to assign the species names to rownames to keep everything tidy while we manipulate the data. We also have a tree covering all carnivores (Nyakatura and Bininda-Emonds 2012).
carn.tree <- read.nexus("carnivores_tree.nex")
carn.data <- read.table("carnivores_data.txt", header = T)
rownames(carn.data) <- carn.data$Species
If you look at the new object carn.tree you’ll notice it is a multiPhylo object. This means it actually contains a number of trees rather than just one. For more details about this class of object, see chapter 3.
For now, we just want the first one in the list (based on the best estimates used to date the tree). I’ll also prune it a bit to get rid of some of the species I’m not interested in for now.
Unlike the macaque data from earlier, the carnivore data needs a little more tidying. Now that you’re more comfortable using R, you should make this standard practice whenever you load data and a tree for an analysis!
We can use the function name.check in the package geiger to help us out here (Harmon et al. 2008). This function returns two lists. The first contains all the species that appear in the phylogeny but not in the dataset. The second has the species that occur in the data but not in the tree.
$tree_not_data
[1] "Arctocephalus_australis" "Arctocephalus_forsteri"
[3] "Arctocephalus_galapagoensis" "Arctocephalus_gazella"
[5] "Arctocephalus_philippii" "Arctocephalus_pusillus"
[7] "Arctocephalus_townsendi" "Arctocephalus_tropicalis"
[9] "Bassaricyon_alleni" "Bassaricyon_beddardi"
[11] "Bassaricyon_lasius" "Bassaricyon_pauli"
[13] "Callorhinus_ursinus" "Conepatus_chinga"
[15] "Conepatus_humboldtii" "Conepatus_semistriatus"
[17] "Cystophora_cristata" "Dusicyon_australis"
[19] "Erignathus_barbatus" "Eumetopias_jubatus"
[21] "Halichoerus_grypus" "Histriophoca_fasciata"
[23] "Hydrurga_leptonyx" "Leptonychotes_weddellii"
[25] "Lobodon_carcinophaga" "Lontra_provocax"
[27] "Lutra_nippon" "Lutra_sumatrana"
[29] "Lycalopex_fulvipes" "Lycalopex_griseus"
[31] "Lycalopex_gymnocercus" "Lycalopex_sechurae"
[33] "Lyncodon_patagonicus" "Martes_gwatkinsii"
[35] "Meles_anakuma" "Meles_leucurus"
[37] "Melogale_everetti" "Melogale_orientalis"
[39] "Melogale_personata" "Mirounga_angustirostris"
[41] "Mirounga_leonina" "Monachus_monachus"
[43] "Monachus_schauinslandi" "Monachus_tropicalis"
[45] "Mustela_felipei" "Mustela_itatsi"
[47] "Mustela_kathiah" "Mustela_lutreolina"
[49] "Mustela_nudipes" "Mustela_strigidorsa"
[51] "Mustela_subpalmata" "Nasuella_olivacea"
[53] "Neophoca_cinerea" "Neovison_macrodon"
[55] "Odobenus_rosmarus" "Ommatophoca_rossii"
[57] "Otaria_flavescens" "Pagophilus_groenlandicus"
[59] "Phoca_largha" "Phoca_vitulina"
[61] "Phocarctos_hookeri" "Procyon_pygmaeus"
[63] "Pusa_caspica" "Pusa_hispida"
[65] "Pusa_sibirica" "Spilogale_angustifrons"
[67] "Urocyon_littoralis" "Vulpes_bengalensis"
[69] "Vulpes_ferrilata" "Zalophus_californianus"
[71] "Zalophus_japonicus" "Zalophus_wollebaeki"
$data_not_tree
[1] "Acinonyx_jubatus" "Arctictis_binturong"
[3] "Arctogalidia_trivirgata" "Atilax_paludinosus"
[5] "Bdeogale_crassicauda" "Caracal_caracal"
[7] "Catopuma_temminckii" "Chrotogale_owstoni"
[9] "Civettictis_civetta" "Crocuta_crocuta"
[11] "Crossarchus_obscurus" "Cryptoprocta_ferox"
[13] "Cynictis_penicillata" "Cynogale_bennettii"
[15] "Dologale_dybowskii" "Eupleres_goudotii"
[17] "Felis_chaus" "Felis_manul"
[19] "Felis_margarita" "Felis_nigripes"
[21] "Felis_silvestris" "Fossa_fossana"
[23] "Galerella_sanguinea" "Galidia_elegans"
[25] "Genetta_abyssinica" "Genetta_angolensis"
[27] "Genetta_genetta" "Genetta_servalina"
[29] "Genetta_thierryi" "Helogale_parvula"
[31] "Hemigalus_derbyanus" "Herpestes_ichneumon"
[33] "Herpestes_javanicus" "Herpestes_urva"
[35] "Hyaena_brunnea" "Hyaena_hyaena"
[37] "Ichneumia_albicauda" "Leopardus_geoffroyi"
[39] "Leopardus_guigna" "Leopardus_jacobitus"
[41] "Leopardus_pardalis" "Leopardus_wiedii"
[43] "Leptailurus_serval" "Liberiictis_kuhni"
[45] "Lynx_canadensis" "Lynx_lynx"
[47] "Lynx_pardinus" "Lynx_rufus"
[49] "Macrogalidia_musschenbroekii" "Mungos_gambianus"
[51] "Mungos_mungo" "Mungotictis_decemlineata"
[53] "Nandinia_binotata" "Neofelis_nebulosa"
[55] "Paguma_larvata" "Panthera_leo"
[57] "Panthera_onca" "Panthera_pardus"
[59] "Panthera_tigris" "Paracynictis_selousi"
[61] "Paradoxurus_hermaphroditus" "Paradoxurus_zeylonensis"
[63] "Pardofelis_marmorata" "Poiana_richardsonii"
[65] "Prionailurus_bengalensis" "Prionailurus_iriomotensis"
[67] "Prionailurus_rubiginosus" "Prionodon_linsang"
[69] "Prionodon_pardicolor" "Proteles_cristata"
[71] "Puma_concolor" "Salanoia_concolor"
[73] "Suricata_suricatta" "Uncia_uncia"
[75] "Viverra_megaspila" "Viverra_tangalunga"
[77] "Viverra_zibetha" "Viverricula_indica"
The easiest thing to do first is drop the tips from the tree that we’re not interested in. We can pass the whole list to the drop.tip function in ape for this (Paradis and Schliep 2018).
carn.tree <- drop.tip(carn.tree, geiger::name.check(carn.tree, carn.data)$tree_not_data)
geiger::name.check(carn.tree, carn.data)
$tree_not_data
character(0)
$data_not_tree
[1] "Acinonyx_jubatus" "Arctictis_binturong"
[3] "Arctogalidia_trivirgata" "Atilax_paludinosus"
[5] "Bdeogale_crassicauda" "Caracal_caracal"
[7] "Catopuma_temminckii" "Chrotogale_owstoni"
[9] "Civettictis_civetta" "Crocuta_crocuta"
[11] "Crossarchus_obscurus" "Cryptoprocta_ferox"
[13] "Cynictis_penicillata" "Cynogale_bennettii"
[15] "Dologale_dybowskii" "Eupleres_goudotii"
[17] "Felis_chaus" "Felis_manul"
[19] "Felis_margarita" "Felis_nigripes"
[21] "Felis_silvestris" "Fossa_fossana"
[23] "Galerella_sanguinea" "Galidia_elegans"
[25] "Genetta_abyssinica" "Genetta_angolensis"
[27] "Genetta_genetta" "Genetta_servalina"
[29] "Genetta_thierryi" "Helogale_parvula"
[31] "Hemigalus_derbyanus" "Herpestes_ichneumon"
[33] "Herpestes_javanicus" "Herpestes_urva"
[35] "Hyaena_brunnea" "Hyaena_hyaena"
[37] "Ichneumia_albicauda" "Leopardus_geoffroyi"
[39] "Leopardus_guigna" "Leopardus_jacobitus"
[41] "Leopardus_pardalis" "Leopardus_wiedii"
[43] "Leptailurus_serval" "Liberiictis_kuhni"
[45] "Lynx_canadensis" "Lynx_lynx"
[47] "Lynx_pardinus" "Lynx_rufus"
[49] "Macrogalidia_musschenbroekii" "Mungos_gambianus"
[51] "Mungos_mungo" "Mungotictis_decemlineata"
[53] "Nandinia_binotata" "Neofelis_nebulosa"
[55] "Paguma_larvata" "Panthera_leo"
[57] "Panthera_onca" "Panthera_pardus"
[59] "Panthera_tigris" "Paracynictis_selousi"
[61] "Paradoxurus_hermaphroditus" "Paradoxurus_zeylonensis"
[63] "Pardofelis_marmorata" "Poiana_richardsonii"
[65] "Prionailurus_bengalensis" "Prionailurus_iriomotensis"
[67] "Prionailurus_rubiginosus" "Prionodon_linsang"
[69] "Prionodon_pardicolor" "Proteles_cristata"
[71] "Puma_concolor" "Salanoia_concolor"
[73] "Suricata_suricatta" "Uncia_uncia"
[75] "Viverra_megaspila" "Viverra_tangalunga"
[77] "Viverra_zibetha" "Viverricula_indica"
Dropping species from your dataframe is a little more complex (and in truth not always necessary). One way of doing this is to create a for loop that will cycle through the list above and take a subset of the dataframe each time, removing the species in the list as it goes. There are better ways to do this but it might be helpful to become familiar with for loops which are a useful programming tool!
pruned.data <- carn.data
for(i in 1:length(geiger::name.check(carn.tree, carn.data)$data_not_tree)){
pruned.data <- subset(pruned.data, Species!=geiger::name.check(carn.tree, carn.data)$data_not_tree[i])
}
geiger::name.check(carn.tree, pruned.data)
[1] "OK"
Once your tree and data are cleaned up we’re ready to go!
<IP_ADDRESS> Analysis
As before we need to create a named vector for analysis.
Now we can sample a single history and plot it, this time with three colours!
make.simmap is sampling character histories conditioned on the transition matrix
Q =
Dig a Burrow No Burrowing Use existing Burrows
Dig a Burrow -0.05640412 0.02820206 0.02820206
No Burrowing 0.02820206 -0.05640412 0.02820206
Use existing Burrows 0.02820206 0.02820206 -0.05640412
(estimated using likelihood);
and (mean) root node prior probabilities
pi =
Dig a Burrow No Burrowing Use existing Burrows
0.3333333 0.3333333 0.3333333
Done.
cols <- setNames(c("blue", "red", "green"), sort(unique(burrow)))
plotSimmap(scm3, cols, pts = FALSE, lwd = 2, fsize = 0.5)
add.simmap.legend(colors = cols, vertical = TRUE, prompt = FALSE, x = 2, y = 80, fsize = 1.4, shape = "circle")
Let’s sample 200 possible histories. This may take a few moments. For reports and publications, you should sample more than this. There’s no hard rule but 1000 seems to be a good minimum for a proper analysis.
make.simmap is sampling character histories conditioned on the transition matrix
Q =
Dig a Burrow No Burrowing Use existing Burrows
Dig a Burrow -0.05640412 0.02820206 0.02820206
No Burrowing 0.02820206 -0.05640412 0.02820206
Use existing Burrows 0.02820206 0.02820206 -0.05640412
(estimated using likelihood);
and (mean) root node prior probabilities
pi =
Dig a Burrow No Burrowing Use existing Burrows
0.3333333 0.3333333 0.3333333
Done.
200 trees with a mapped discrete character with states:
Dig a Burrow, No Burrowing, Use existing Burrows
trees have 52 changes between states on average
changes are of the following types:
Dig a Burrow,No Burrowing Dig a Burrow,Use existing Burrows
x->y 7.205 12.19
No Burrowing,Dig a Burrow No Burrowing,Use existing Burrows
x->y 7.05 6.02
Use existing Burrows,Dig a Burrow Use existing Burrows,No Burrowing
x->y 12.195 7.34
mean total time spent in each state is:
Dig a Burrow No Burrowing Use existing Burrows total
raw<PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER> 931
prop 0.3931376 0.2322782 0.3745842 1
Finally we can plot the summary of the analysis as before.
8.6 Further info
For more information about ancestral state reconstruction check out a review of the method by Joy et al. (Joy et al. 2016) and chapter 3 of The comparative approach in evolutionary anthropology and biology (Nunn 2011).
For more information about the phytools package (Revell 2012), the package author Liam Revell maintains an excellent blog here where you’ll find lots of useful tips and demonstrations of the package’s capabilities as well as some helpful troubleshooting.
Bibliography
Harmon, L., Weir, J., Brock, C., Glor, R., and Challenger, W. (2008) ‘GEIGER: Investigating Evolutionary Radiations’. Bioinformatics 24, 129–131
Joy, J.B., Liang, R.H., McCloskey, R.M., Nguyen, T., and Poon, A.F.Y. (2016) ‘Ancestral Reconstruction’. PLOS Computational Biology [online] 12 (7), e1004763. available from <https://doi.org/10.1371/journal.pcbi.1004763>
Nunn, C.L. (2011) The Comparative Approach in Evolutionary Anthropology and Biology [online] University of Chicago Press. available from <https://books.google.co.uk/books?id=qj4cSzJGQJAC>
Nyakatura, K. and Bininda-Emonds, O.R. (2012) ‘Updating the Evolutionary History of Carnivora (Mammalia): A New Species-Level Supertree Complete with Divergence Time Estimates’. BMC Biology [online] 10 (1), 12. available from <https://doi.org/10.1186/1741-7007-10-12>
Paradis, E. and Schliep, K. (2018) ‘Ape 5.0: An Environment for Modern Phylogenetics and Evolutionary Analyses in R’. Bioinformatics 35, 526–528
Revell, L.J. (2012) ‘Phytools: An R Package for Phylogenetic Comparative Biology (and Other Things).’ Methods in Ecology and Evolution 3, 217–223
Stankowich, T., Caro, T., and Cox, M. (2011) ‘Bold Coloration and the Evolution of Aposematism in Terrestrial Carnivores’. Evolution [online] 65 (11), 3090. available from <https://liverpool.idm.oclc.org/login?url=https://search.ebscohost.com/login.aspx?direct=true&db=edsjsr&AN=edsjsr.41317030&site=eds-live&scope=site>


Just as much present to us during the making of this Documentary were the camera and sound teams – Sandi, Elizabeth, Rebecca, Mel and Helen. Sandi, Elizabeth and Rebecca had, in fact, stayed in our Enclosure before the filming started in order to get the feel of our life, and they immediately fitted in very well. While they were here they became known as the ‘Tiggers’, the diminutive form of the Company – Tiger Aspect Productions. We miss them and are always pleased to see them when they visit. Here are some pictures of them at work:


Amazing people are making amazing designs in a fun environment.
Amazing people are making amazing designs in a fun environment.
When you work with us, you are part of a team ofcommitted collaborations. All aspects pf our software development process are integrated, interactive and agile.
Our approach unifies design, development and product management to create exceptional products.
We start each project by understanding your business goals, the user's needs and the product requirements.
Then we help translate them into effective and elegant solutions.
Before we sign a contract or write a line of code our team will spend the necessary time needed to understand your product vision
The outcome of this scoping session is proposal or high-level statement of work
ased on your requirements, we can provide acomplete offering or just the pieces you need.


ElectricDiscoTech (edt)
Modern web applications (circa 2015) treat the browser as a full runtime environment. The explosion of open source, freely available frameworks, the cloud, containerization, devops and tooling enable any developer with a spark of an idea to "create", build, package and deploy functional, scalable, data driven web applications by simply investing a little bit of time and energy in learning the "right" set of stuff. The trick then is to know how to quickly provision a usable development environment so that the focus remains on the content and not the technology.


Registration
Login:
First name:
Last name:
Sign up
Open chat
Logout
Receiver's login:
Open chat
Chat
Close chat
Text message:
Send
Messages:


Qtwebkit is a Qt based web browser engine.
This package is known to build and work properly using an LFS-8.0 platform.
Download (HTTP): http://download.qt.io/community_releases/5.8/5.8.0-final/qtwebkit-opensource-src-5.8.0.tar.xz
Download MD5 sum: 60a6935aca4a7c553d0ec4646ceed3b4
Download size: 34 MB
Estimated disk space required: 766 MB (50 MB installed)
Estimated build time: 11 SBU (using parallelism=4)
ICU-58.2, libjpeg-turbo-1.5.1, libpng-1.6.28, libwebp-0.6.0, libxslt-1.1.29, Qt-5.8.0, Ruby-2.4.0, and SQLite-3.17.0
gst-plugins-base-1.10.3 (HTML5 Video Support)
User Notes: http://wiki.linuxfromscratch.org/blfs/wiki/qtwebkit
Install Qtwebkit by running the following commands:
SAVEPATH=$PATH && export PATH=$PWD/bin:$PATH && mkdir -p build && cd build && qmake ../WebKit.pro && make && export PATH=$SAVEPATH && unset SAVEPATH
This package does not come with a test suite.
Now, as the root
user:
make install
The installation is automatically made to the $QT5DIR directory tree.
Remove references to the build directory from the installed
.pc
files by running the following
command as the root
user:
find $QT5DIR/lib/pkgconfig -name "*.pc" -exec perl -pi -e "s, -L$PWD/?\S+,,g" {} \;
Remove references to the build directory from installed library
dependency (prl) and profile include (pri) files by running the
following commands as the root
user:
find $QT5DIR/ -name qt_lib_bootstrap_private.pri \ -exec sed -i -e "s:$PWD/qtbase:/$QT5DIR/lib/:g" {} \; && find $QT5DIR/ -name \*.prl \ -exec sed -i -e '/^QMAKE_PRL_BUILD_DIR/d' {} \;
export PATH=$PWD/bin:$PATH: sets a temporary path needed to complete the build and install process.
qmake: is a Qt tool that automates the generation of Makefiles.
Last updated on 2017-02-20 12:59:39 -0800


Monitoring Options
Monitoring Support
xntpd
includes a comprehensive monitoring facility
suitable for continuous, long term recording of server and client
timekeeping performance. See the statistics
command below
for a listing and example of each type of statistics currently
supported. Statistic files are managed using file generation sets and
scripts in the ./scripts directory of this distribution. Using these
facilities and Unix cron
jobs, the data can be
automatically summarized and archived for retrospective analysis.
Monitoring Commands
statistics name [ ... ]
- Enables writing of statistics records. Currently, three kinds of
name statistics are supported.
loopstats
- Enables recording of loop filter statistics information. Each update
of the local clock outputs a line of the following form to the file
generation set named
loopstats
:
48773 10847.650 0.0001307 17.3478 2
- The first two fields show the date (Modified Julian Day) and time
(seconds and fraction past UTC midnight). The next three fields show
time offset in seconds, frequency offset in parts-per-million and time
constant of the clock-discipline algorithm at each update of the clock.
peerstats
- Enables recording of peer statistics information. This includes
statistics records of all peers of a NTP server and of special signals,
where present and configured. Each valid update appends a line of the
following form to the current element of a file generation set named
peerstats
:
48773 10847.650 <IP_ADDRESS> 9714 -0.001605 0.00000 0.00142
- The first two fields show the date (Modified Julian Day) and time
(seconds and fraction past UTC midnight). The next two fields show the
peer address in dotted-quad notation and status, respectively. The
status field is encoded in hex in the format described in Appendix A of
the NTP specification RFC 1305. The final three fields show the offset,
delay and dispersion, all in seconds.
clockstats
- Enables recording of clock driver statistics information. Each
update received from a clock driver outputs a line of the following form
to the file generation set named
clockstats
:
49213 525.624 <IP_ADDRESS> 93 226 00:08:29.606 D
- The first two fields show the date (Modified Julian Day) and time
(seconds and fraction past UTC midnight). The next field shows the clock
address in dotted-quad notation, The final field shows the last timecode
received from the clock in decoded ASCII format, where meaningful. In
some clock drivers a good deal of additional information can be gathered
and displayed as well. See information specific to each clock for
further details.
statsdir directory_path
- Indicates the full path of a directory where statistics files should
be created (see below). This keyword allows the (otherwise constant)
filegen
filename prefix to be modified for file generation
sets, which is useful for handling statistics logs.
filegen name [ file filename ] [ type
typename ] [ flag flagval ] [ link | nolink ] [ enable |
disable ]
- Configures setting of generation file set name. Generation
file sets provide a means for handling files that are continuously
growing during the lifetime of a server. Server statistics are a typical
example for such files. Generation file sets provide access to a set of
files used to store the actual data. At any time at most one element of
the set is being written to. The type given specifies when and how data
will be directed to a new element of the set. This way, information
stored in elements of a file set that are currently unused are available
for administrational operations without the risk of disturbing the
operation of
xntpd
. (Most important: they can be removed to
free space for new data produced.)
- Filenames of set members are built from three elements:
prefix
- This is a constant filename path. It is not subject to modifications
via the
filegen
option. It is defined by the server,
usually specified as a compile-time constant. It may, however, be
configurable for individual file generation sets via other commands. For
example, the prefix used with loopstats
and
peerstats
generation can be configured using the
statsdir
option explained above.
filename
- This string is directly concatenated to the prefix mentioned above
(no intervening
/
(slash)). This can be modified using the
file
argument to the filegen
statement. No
..
elements are allowed in this component to prevent
filenames referring to parts outside the filesystem hierarchy denoted by
prefix
.
suffix
- This part is reflects individual elements of a file set. It is
generated according to the type of a file set.
- A file generation set is characterized by its type. The following
types are supported:
none
- The file set is actually a single plain file.
pid
- One element of file set is used per incarnation of a
xntpd
server. This type does not perform any changes to
file set members during runtime, however it provides an easy way of
separating files belonging to different xntpd
server
incarnations. The set member filename is built by appending a
.
(dot) to concatenated prefix and filename
strings, and appending the decimal representation of the process ID of
the xntpd
server process.
day
- One file generation set element is created per day. A day is defined
as the period between 00:00 and 24:00 UTC. The file set member suffix
consists of a
.
(dot) and a day specification in the form
YYYYMMDD. YYYY
is a 4-digit year number (e.g., 1992).
MM
is a two digit month number. DD
is a two
digit day number. Thus, all information written at 10 December 1992
would end up in a file named prefix
filename.19921210
.
week
- Any file set member contains data related to a certain week of a
year. The term week is defined by computing day-of-year modulo 7.
Elements of such a file generation set are distinguished by appending
the following suffix to the file set filename base: A dot, a 4-digit
year number, the letter
W
, and a 2-digit week number. For
example, information from January, 10th 1992 would end up in a file with
suffix .1992W1
.
month
- One generation file set element is generated per month. The file
name suffix consists of a dot, a 4-digit year number, and a 2-digit
month.
year
- One generation file element is generated per year. The filename
suffix consists of a dot and a 4 digit year number.
age
- This type of file generation sets changes to a new element of the
file set every 24 hours of server operation. The filename suffix
consists of a dot, the letter
a
, and an 8-digit number.
This number is taken to be the number of seconds the server is running
at the start of the corresponding 24-hour period.
- Information is only written to a file generation by specifying
enabl
; output is prevented by specifying
disable
.
- It is convenient to be able to access the current element of a
file generation set by a fixed name. This feature is enabled by
specifying
link
and disabled using nolink
. If
link
is specified, a hard link from the current file set
element to a file without suffix is created. When there is already a
file with this name and the number of links of this file is one, it is
renamed appending a dot, the letter C
, and the pid of the
xntpd
server process. When the number of links is greater
than one, the file is unlinked. This allows the current file to be
accessed by a constant name.
David L. Mills (mills@udel.edu)


CWC discusses Maharashtra situation, final decision likely to be announced Friday
Another meeting between Congress and NCP is to happen Thursday night and a final meeting with Shiv Sena will happen Friday in Mumbai.
by PTIThe Congress Working Committee on Thursday reviewed the political scenario in Maharashtra, a day after it held a marathon meeting with the NCP on forming an alliance together with Shiv Sena to form a government in the state.
Congress general secretary KC Venugopal told the media after a meeting at party chief Sonia Gandhi’s 10 Janpath residence that the CWC was briefed on the discussion between NCP and Congress on Wednesday.
However, Congress sources said a final decision on Maharashtra is expected by tomorrow.
The CWC, the sources said, has broadly agreed to go ahead with government formation with Shiv Sena and the NCP.
Another meeting between Congress and NCP is to happen Thursday night and a final meeting with Shiv Sena will happen Friday in Mumbai.
The decision on government formation in Maharashtra will be announced in Mumbai on Friday, the sources said.


Sudoku Technique No.4
Fitting In - Hard Level
Let's continue with Fitting In technique, in Hard level. In Fitting In Medium level, we only used cell as fitters. Why, units can be fitters too!
See the board below, in box 2 we have three empty cells 23, 26 and 29, three missing numbers 4, 6 and 9. We can see there a fitter of 4 in 32, but where is the other fitter?
Look at box 1, although there is no 9 in it, there is a 9 in 42. After pointing 42 to box 1, we know 9 in box 1 must be in 11 or 13, so box 1 can be used as a fitter that fits a 9 into box 2. Now we have two fitters 4 and 9 fit into box 2, the solution: 236. Click the board to see the animations.
Another example of box fitter fitting into column.
Again columns and rows can be unit fitters too, here is a column fitter fitting into column:
Things could get complicated:
More complicated:
Even more complicated:
I will stop here, but believe me, things could get further more complicated because, as pointers relay, fitters relay too.
So there you go, Fitting In technique at Hard level, pointing out then fitting in, which is a hint to my next blog.
The puzzles in this post are from http://school.maths.uwa.edu.au/~gordon/sudokumin.php The work is licensed under a Creative Commons Attribution 2.5 License. Attribution goes to Gordon Royle and The University of Western Australia.


{% extends "base.html" %} {% block style %}{% endblock style %} {% block breadcrumbs %}{{ super() }} › Bill Tracker › Legislators › {{response.chamber|capfirst}}{% endblock breadcrumbs %} {% block content %}
Here are the legislators that have served {{response.chamber|capfirst}} district {{response.district}}.


Here is my first Google My Map, created at the beggining of the term.
The iframe element was used <iframe src="{url}" width="#" height="#" style="float:right;">.
I added a position description to the embedded code (style="float:right;").
Here is my first Google My Map, created at the beggining of the term.
The iframe element was used <iframe src="{url}" width="#" height="#" style="float:right;">.
I added a position description to the embedded code (style="float:right;").
I have used my GEO 266 Final Project as the image.
Move the mouse over the map elements, notice how different areas of the image have different links.
This is were an explanation of the datasets used and analysis can be documented for further study.
This is were a meaningful explanation of the final analysis would be put.