Best to know upfront what images can be used, and where the images will be coming from.
What icons? What activities will need to be highlighted?
Finding/identifying patterns in the content informs design choices.
Effectively present materials for the web and specifically for D2L.
Visual interest and little surprises can engage the learner.
When changing the design and colors re-check for contrast ratios.
Ensure that the html mark-up is optimized for accessibility.
Ensure all images have appropriate alternative text.
When adding interactvity, consider fallbacks.
Email activity?
When adding interactvity, consider fall backs.
Likely work well. To be more creative, one needs more information.
More information helps with this.
The ready toolbox for time crunches and making time for innovation.
/


Beta This is a test version of the layout of this page. Take the survey to help us improve it
Guidance
Materials for administering the Modified Large Print (MLP) and Unified English Braille (UEB) versions of the 2016 key stage 2 mathematics test
Ref: ISBN 978-1-78644-030-3 , STA/16/7449/BRp PDF , 179KB , 6 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Ref: ISBN 978-1-78644-031-0 , STA/16/7450/BRp PDF , 194KB , 12 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Ref: ISBN 978-1-78644-032-7 , STA/16/7451/BRp PDF , 92.5KB , 12 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Ref: ISBN 978-1-78644-183-6 , STA/16/7601/e PDF , 409KB , 8 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Ref: ISBN 978-1-78644-021-1 , STA/16/7440/MLp PDF , 207KB , 18 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Ref: ISBN 978-1-78644-022-8 , STA/16/7441/MLp PDF , 447KB , 26 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Ref: ISBN 978-1-78644-023-5 , STA/16/7442/MLp PDF , 290KB , 24 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Ref: ISBN 978-1-78644-181-2 , STA/16/7600/e PDF , 397KB , 6 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 131KB , 2 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Key stage 2 mathematics tests were administered in schools in May 2016. Modified test materials and Mark Scheme Amendments were also provided.
Please refer to the copyright ownership report for details of how schools, educational establishments and third parties can use these materials.


module Controller:sig
..end
type
command =
| |
Quit |
| |
Continue |
| |
Upgrade |
| |
Disease |
The possible commands a user can input. If the user's input does not match one of these, an exception is thrown.
exception Empty
exception Malformed
exception Disease_Malformed
val disease_parse : string -> Objects.Disease.t -> Objects.Disease.t
disease_parse str disease
parses the string str
given through a read_line
and either changes one of the disease
fields and returns the new disease, exits the
disease menu, or raises an error if the input is not formatted correctly.
val parse : string -> command
parse str
takes the string str
given from a read_line and returns what kind
of command the user wishes to run.
Objects.Disease.t -> Objects.Disease.t
: print_disease_menu_number disease
prints out information about the given
disease disease
.
Objects.Disease.t -> Objects.Disease.t
: print_disease_menu disease
prints out information about the disease
disease
and prompts the user to make any desired modifications
to the disease stats.
State.State.t -> State.State.t
: print_upgrade_menu state
prints out the disease information and allows
the user to select any upgrades that they want to make to the disease.


We provide image design and interactive solutions
to brands and companies with excellent visual
art performance by HTML5,Web3D and AR technology.
copyright© Elloworld
Wechat
<EMAIL_ADDRESS>+86-21-67892070
Rm.706-707,No.86 Sibao Road,Shanghai
CREATIVE | HTML5 | Web3D | AR | Game


At Camunda we have made it our mission to provide developers with the best experience. Our platform and tools are easy to get started and use in your environment right away, with full public access to all our docs, open APIs to integrate with just about anything, and a vibrant community of 100,000 developers.


the above is equivalent to ./setprice VRSC KMD 0.125<PHONE_NUMBER>00000000000000000000
selling VRSC | buying KMD | 0.125 KMD per VRSC
thank you @smk762 - dracocanis ominator
good question about rational number @siu - Chainmakers i'm getting very long decimals recently and was pretending to ignore it for the time-being.
@artem.pikulin#0794 thanks for the detailed answer. interesting set of problems you have to solve in this project


Posted on January 30, 2016
Definition
The group_by method performs an operation on every element of an array and groups them based on the result of the calculation. The method returns a result as a hash, where the keys are the result of the evaluation and the values are the inputs.
Analysis
In order for the method to work properly, the condition that is being applied must be valid to all the elements in the array. If an element in the array does not have the method, or can not perform the passed operation, an error will result. The best way to explore this is through code examples.
String Arrays
string_array = ["this", "is", "a", "string", "array"] string_array.group_by {|str| str.length} => {4=>["this"], 2=>["is"], 1=>["a"], 6=>["string"], 5=>["array"]} string_array.group_by {|str| str * 3} => {"thisthisthis"=>["this"], "isisis"=>["is"], "aaa"=>["a"], "stringstringstring"=>["string"], "arrayarrayarray"=>["array"]} string_array.group_by {|str| str / 3} NoMethodError: undefined method `/' for "this":String from (irb):734:in `block in irb_binding' from (irb):734:in `each' from (irb):734:in `group_by' from (irb):734
Integer Arrays
int_array = [1,2,3,4,5] int_array.group_by {|int| int % 2} => {1=>[1, 3, 5], 0=>[2, 4]} int_array.group_by {|int| int.even?} => {false=>[1, 3, 5], true=>[2, 4]} int_array.group_by {|int| int.length} NoMethodError: undefined method `length' for 1:Fixnum from (irb):737:in `block in irb_binding' from (irb):737:in `each' from (irb):737:in `group_by' from (irb):737
Mixed Arrays
mixed_array = [1, 2, 3, "one", "two", "three", :one, :two, :three] mixed_array.group_by {|element| element} => {1=>[1], 2=>[2], 3=>[3], "one"=>["one"], "two"=>["two"], "three"=>["three"], :one=>[:one], :two=>[:two], :three=>[:three]} mixed_array.group_by {|element| element * 2} NoMethodError: undefined method `*' for :one:Symbol from (irb):740:in `block in irb_binding' from (irb):740:in `each' from (irb):740:in `group_by' from (irb):740 mixed_array.group_by {|element| element.odd?} NoMethodError: undefined method `odd?' for "one":String from (irb):741:in `block in irb_binding' from (irb):741:in `each' from (irb):741:in `group_by' from (irb):741 mixed_array.group_by {|element| element.size} => {8=>[1, 2, 3], 3=>["one", "two", :one, :two], 5=>["three", :three]}


FILM TITLE: RESTORATION DIRECTOR: MICHAEL HOFFMAN COUNTRY: USA 1995 CINEMATOGRAPHY: OLIVER STAPLETON MUSIC: JAMES NEWTON HOWARD and period music CAST: Robert Downey Jr., Sam Neill, David Thewlis, Polly Walker, Meg Ryan, Ian McKellen, Hugh Grant SUPER FEATURES: Excellent Period Film
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
There are films that grab one's attention, and then there are films where one just doesn't know if our attention is supposed to be gotten or not. Many of these films fall into the artsy category, and tend to disappear and not be noticed for much of anything. But every now and then, a film comes by that is actually pretty good, although as far as action goes, it doesn't make the grade.
The period that the story takes place, has a complete theatre dedicated to it, and its affectations. It is called Restoration Theatre, and it is very difficult to do well, unless one is well versed in the manners and styles of the age. The film takes its cue from the its settings, and never lets it go. And this is rare in film making. One could easily fall for the sentimental story, or the period's affectations and its silly ways. Instead one keeps finding out more about the time and what went on.
Unfortunately ( for the main character ) in the middle of all this, a story is born and he has to live with it.
This is the story of the period, before it really is the story of a certain Meryvel, who does not care for his job and work in the medical field. He finds it boring, and not pleasing, not to mention that it ruins much of his social life. As it happens, he develops a new style of healing based on his intuition, and this gets him to the king's chambers. Here he is asked to cure one of the king's favorite pets, a dog. And of course, Meryvel, has no idea what he did, but somehow his way ( not bleeding the patient ) happens to help cure the animal which places Meryvel in the king's favor.
As time goes by, the king decides to use Meryvel.  But there is a larger sub-plot, that will eventually change the course of the film from where it is to another place. It is the plague that is beginning to foster in London, and Charles II has not figured out how to deal with it. He was too worried about his new city instead of taking the advise of his inferiors to create sewers and water mains.
Meryvel, finds that he is attracted to the King's mistress, even if she is not interested in him at all. And a court painter is brought in to paint the lady, and he is held up so that Meryvel can try to convince the mistress. Alas, the painter is also one of the king's stool pigeons, and eventually the little story is found out, and Meryvel has to leave, and does.
He ends up in a Quaker convent, where his brother is the medic. But his brother's ways are the old ones and his efficiency is not evident. Meryvel promptly suggests a few changes, and in the course of affecting one of them, he ends up meeting a woman that is there. She appears crazy, but apparently is not, and he does not see the point in bleeding any patients. Eventually they come together and she gets pregnant. This is not good for the convent and they both have to leave. And they are both in the middle of the London plague. During the nasty birth, the child is saved, but the mother dies. And from here, the story takes on some rather sad, and different moods. All of a sudden, we do not see the court life, we see the street deaths, and the court falling apart as well.
The rest I won't spoil for you... but suffice it to say that some poetic justice does come about, even though the court's style of justice could be thought to be rather boring, and not dependable... but as Charles says, it's the best he can do as long as he is king. But Meryvel's reputation as a doctor is restored, and he is now a valuable member of society, and one that is important in the recovery that London will have to undergo.
Perhaps the very best thing about this film, is that we do not really know who is who, and what parts they are playing. There are no credits at the beginning, and I find that this is great. It takes you directly into the "play" and makes the statement that the situation and the story is the point, not the actors, and the people that created the film, which, REALLY, is the way it should be.
And later we find out that Sam Neill is the king, Robert Downey Jr. is Meryvel, and that Meg Ryan is the crazy woman. Should one remember this before hand, the effect may have not been the same. All the performances are excellent, and the film seems to be really well focused on its themes.
Worth seeing. Beautiful film, and won a couple of Oscars, the costumes being one of them.
4 GIBLOONS Copyright (c) Pedro Sena 1997. All Rights Reserved.
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


 You've probably never even heard of EYE FOR AN EYE. (I hadn't until the screening pass arrived in the mailbox last week.) But you'd think with a cast of Sally Field, Kiefer Sutherland, Ed Harris, Beverly D'Angelo, and Joe Mantegna, the studio would be pushing it a little harder.
As well they should, because, put simply, this isn't your typical Sally Field movie.  Ed Harris plays Mack, Karen's second (and very understanding) husband, and Mantegna is the investigator on the case.
The killer is apprehended, but a legal technicality sets him free. Frustrated with the legal system and obsessed with vengeance, Karen decides to take the law into her own hands, with some interesting consequences.
What makes this a really creepy film is not so much the plot and Karen's morbid fascination with the killer, but it's the fact that it's *Sally Field* with a streak of retribution running through her. Adding to the chilly mood is a perfectly cast Sutherland, looking and acting like he's straight out of ten years in Attica.
The movie itself could have been a lot more than it ended up being. The plot turns out to be pretty much open and shut, as not much in the way of a classic "thriller" ever starts you guessing or even makes you jump in your seat. Instead, the slow pace gets the film to evolve into more of an in-depth character study than anything else, which probably isn't the direction this picture needed to take. Put simply, the movie just never *grabs* you.
In the end, EYE FOR AN EYE turns out some good performances in ho-hum roles. And while the tension slowly builds up over the course of the film, it never quite makes it to where it desperately needed to go.
RATING: ***
\-------------------------------\ |* Unquestionably awful | |** Sub-par on many levels | |*** Average, hits and misses | |**** Good, memorable film | |***** Perfection | \-------------------------------\
-Christopher Null /<EMAIL_ADDRESS>-Movie Emporium (reviews) / http://www.notes.tpoint.net/emporium/ -Contributing Editor, FEEDBACK / http://www.eden.com/~feedback/ -E-mail requests to join the movie review mailing list
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


Few words about me,
Full time Software Engineer (Back-End Developer). Always interested in learning new technologies. Loves to solve programming/algorithmic problems and write useful code.
Amd.kom from BSI University.
As a software engineer, though my primary focus is on Back-end development. I have professional expertise on PHP & Laravel Framework and Back-end Service development.
Writing code as a full time software engineer from 2016, I have completed several projects in Laravel Framework.
Slipi, Jakarta Barat
Uses: Laravel Framework
A few words on what I am doing here
Kembangan, Jakarta Barat
Uses: Codeigniter Framework
A few words on what I am doing here
Kalideres, Jakarta Barat
Uses: Codeigniter Framework
A few words on what I am doing here
| PHP | Javascript | Laravel | Codeiginiter |
|---|---|---|---|
| Mysql | Git | Mysql |


Before Change
// Create a new worker instance and bind it with the socket connection.
try:
// Create new worker id
worker_id = str(uuid.uuid4())
// Create a link between worker id and socket descriptor
handler.new_connection(worker_id, socket)
// Create worker instance
worker_manager.create(worker_id)
response[CYCLE.STATUS] = RESPONSE_MSG.SUCCESS
response[MSG_FIELD.WORKER_ID] = worker_id
except Exception as e: // Retrieve exception messages such as missing JSON fields.
response[CYCLE.STATUS] = RESPONSE_MSG.ERROR
response[RESPONSE_MSG.ERROR] = str(e)
After Change
response : String response to the client
response = {}
_auth_token = message.get("auth_token")
model_name = message.get("model_name", None)
verification_result = verify_token(_auth_token, model_name)
if verification_result["status"] == RESPONSE_MSG.SUCCESS:
response = assign_worker({"auth_token": _auth_token}, None)
else:
response[RESPONSE_MSG.ERROR] = verification_result["error"]
return json.dumps(response)
def cycle_request(message: dict, socket) -> str:


This is the galactic age calculator
Please enter your name.
Enter name here:
Please enter your current age.
Enter current age:
Mercury
Venus
Mars
Jupiter
Submit


Hidden entries in a file list are prefixed by "#||~" for identification by Moderate.
This is not a standard file list format, but is documented here in the hope that it will be used by other OLRs in due course and by moderators editing file lists by hand.


9. References¶
| [Dom15] | Stefan Domino. Sierra Low Mach Module: Nalu Theory Manual 1.0. Technical Report SAND2015-3107W, Sandia National Laboratories Unclassified Unlimited Release (UUR), https://github.com/spdomin/NaluDoc, 2015. |
| [FLC+13] | Paul Fleming, Sang Lee, Matthew J. Churchfield, Andrew Scholbrock, John Michalakes, Kathryn Johnson, and Patrick Moriarty. The SOWFA Super-Controller: A High-Fidelity Tool for Evaluating Wind Plant Control Approaches. Technical Report NREL/CP-5000-57175, National Renewable Energy Laboratory, January 2013. |
| [JMJ+13] | B.J. Jonkman, J. Michalakes, J.M. Jonkman, M.L. Buhl, Jr., A. Platt, and M.A. Sprague. Nwtc programmer's handbook: a guide for software development within the fast computer-aided engineering tool. Technical Report, National Renewable Energy Laboratory, July 2013. |
| [Jon13] | Jason M. Jonkman. The New Modularization Framework for the FAST Wind Turbine CAE Tool. Technical Report NREL/CP-5000-57228, National Renewable Energy Laboratory, January 2013. |
| [JJ16] | Jason M. Jonkman and Bonnie J. Jonkman. FAST v8: Changelog. Technical Report, National Renewable Energy Laboratory, April 2016. |
| [JJr05] | Jason M. Jonkman and Marshall L. Buhl Jr. FAST User's Guide. Technical Report NREL/EL-500-38230, National Renewable Energy Laboratory, August 2005. |
| [MPIForum15] | MPI Forum. \textsf MPI: A Message-Passing Interface Standard. Version 3.1. June 2015. available at: http://www.mpi-forum.org (Jun. 2015). |
| [TheHGroup97] | The HDF Group. Hierarchical Data Format, version 5. 1997. http://www.hdfgroup.org/HDF5/. |


This my dog, Jagger
(It's actually a picture of another dog that looks like him)
Jagger is 6 years old and 120 pounds
Jagger is kind of a brat and will whimper until he gets what he wants
Here are some things he likes to do:
Chase his tail
Run into walls
He often sprints into them
Eat out of the trash
Bark at neighbors


Orbit information may be exchanged between two participants by sending a state vector for a specified epoch using an Orbit Parameter Message (OPM). The message recipient must have an orbit propagator available that is able to propagate the OPM state vector to compute the orbit at other desired epochs. For this propagation, additional ancillary information (spacecraft properties such as mass, area, and maneuver planning data, if applicable) may be included with the message.
CCSDS Reference documentation: 502x0b2c1e2.
| Predicate | Description |
|---|---|
| OBJECT_NAME | Satellite Name(s) |
| OBJECT_ID | International Designator (YYYY-NNNAAA) |
| CENTER_NAME | Origin of reference frame (EARTH, MARS, MOON, etc.) |
| REF_FRAME | Name of the reference frame (TEME, EME2000, etc.) |
| REF_FRAME_EPOCH | Epoch of reference frame, if not intrinsic to the definition of the reference frame |
| TIME_SYSTEM | Time system used for the orbit state and covariance matrix. (UTC) |
| COMMENT | Plain-Text Comment |
| EPOCH | Epoch of state vector & optional Keplerian elements (ISO 8601) |
| X | Position vector X-component km |
| Y | Position vector Y-component km |
| Z | Position vector Z-component km |
| X_DOT | Velocity vector X-component km/s |
| Y_DOT | Velocity vector Y-component km/s |
| Z_DOT | Velocity vector Z-component km/s |
| SEMI_MAJOR_AXIS | Semi-major axis km |
| ECCENTRICITY | Eccentricity |
| INCLINATION | Inclination deg |
| RA_OF_ASC_NODE | Right ascension of ascending node deg |
| ARG_OF_PERICENTER | Argument of pericenter deg |
| TRUE_ANOMALY or MEAN_ANOMALY | True anomaly or mean anomaly deg |
| GM | Gravitational Coefficient (Gravitational Constant x Central Mass) km**3/s**2 |
| MASS | S/C Mass kg |
| SOLAR_RAD_AREA | Solar Radiation Pressure Area (AR) m**2 |
| SOLAR_RAD_COEFF | Solar Radiation Pressure Coefficient (CR) |
| DRAG_AREA | Drag Area (AD) m**2 |
| DRAG_COEFF | Drag Coefficient (CD) |
| COV_REF_FRAME | Reference frame for the covariance matrix (may be omitted if it is the same as the metadata REF_FRAME) |
| CX_X | Covariance matrix [1,1] km**2 |
| CY_X | Covariance matrix [2,1] km**2 |
| CY_Y | Covariance matrix [2,2] km**2 |
| CZ_X | Covariance matrix [3,1] km**2 |
| CZ_Y | Covariance matrix [3,2] km**2 |
| CZ_Z | Covariance matrix [3,3] km**2 |
| CX_DOT_X | Covariance matrix [4,1] km**2/s |
| CX_DOT_Y | Covariance matrix [4,2] km**2/s |
| CX_DOT_Z | Covariance matrix [4,3] km**2/s |
| CX_DOT_X_DOT | Covariance matrix [4,4] km**2/s**2 |
| CY_DOT_X | Covariance matrix [5,1] km**2/s |
| CY_DOT_Y | Covariance matrix [5,2] km**2/s |
| CY_DOT_Z | Covariance matrix [5,3] km**2/s |
| CY_DOT_X_DOT | Covariance matrix [5,4] km**2/s**2 |
| CY_DOT_Y_DOT | Covariance matrix [5,5] km**2/s**2 |
| CZ_DOT_X | Covariance matrix [6,1] km**2/s |
| CZ_DOT_Y | Covariance matrix [6,2] km**2/s |
| CZ_DOT_Z | Covariance matrix [6,3] km**2/s |
| CZ_DOT_X_DOT | Covariance matrix [6,4] km**2/s**2 |
| CZ_DOT_Y_DOT | Covariance matrix [6,5] km**2/s**2 |
| CZ_DOT_Z_DOT | Covariance matrix [6,6] km**2/s**2 |
| MANEPOCHIGNITION | Epoch of ignition (ISO 8601) |
| MAN_DURATION | Maneuver duration (If = 0, impulsive maneuver) s |
| MANDELTAMASS | Mass change during maneuver (value is < 0) kg |
| MANREFFRAME | Coordinate system for velocity increment vector |
| MANDV1 | 1st component of the velocity increment km/s |
| MANDV2 | 2nd component of the velocity increment km/s |
| MANDV3 | 3rd component of the velocity increment km/s |
| USER_DEFINED_x | User defined parameter, where "x" is replaced by a variable. Must be described in an ICD. |


Base class For all type of Collision Object.
更多...
#include <Collision.h>
|
| enum | Type { CT_SPHERE3 = 0,
CT_SCENE,
CT_NUM_COLLISION
} |
| | enum supported Collision Shape(Type) 更多...
|
| |
Base class For all type of Collision Object.
This is the base class for all type of Collision Object. The collision type can be extended by inheritance. If setPhysicsBody(Physics::Body *physicsbody) is called with a valid physicsbody pointer, the Transform of the Collision is controlled by that of physicsbody. Otherwise, its Transform is controlled by Collision::setTransform(const Matrix4 &transform_);
| Collision::Collision |
( |
Type |
type_ | ) |
|
| void Collision::defaultCollisionResponse |
( |
const ContactInfo & |
info | ) |
|
preform default Response when this Instance collide with other
When this function is called, the Position of this instance will be changed. It will displaced by info.contactNormal * info.penetrationDepth / 2 This function is supposed to be called during Collision::Handler::onCollision(); If both the handler of info.this_obj and info.other_obj have called this function, Both info.this_obj and info.other_obj will not intersected
If setPhysicsBody(Physics::Body *physicsbody_) is called once with a non-zero physicsbody_, The Physics::Body::defaultImpulseResponse of physicsbody_ will be called as well. physicsbody_ will sync the Position/Rotation, and bounce back, afterward
- 參數
-
| unsigned int Collision::getAttribute |
( |
| ) |
const |
get the Attribute of this Collision Instance
- 傳回值
- unsigned int the Attribute of this Collision Instance
get the Collision Event Handler
This function is to get the Collision::Handler for handling the collision event
- 傳回值
- Collision::Handler the Collision handler
| unsigned int Collision::getID |
( |
| ) |
const |
get the ID of this Instance of Collision.
- 傳回值
- unsigned int ID of this Instance of Collision.
| Vector3 Collision::getPosition |
( |
| ) |
const |
get the Position of this Instance of Collision.
If setPhysicsBody(Physics::Body *physicsbody_) is called once with a non-zero physicsbody_, The returned position is the Position of physicsbody_.
- 傳回值
- Vector3 the Position of this Instance of Collision.
| unsigned int Collision::getSubID |
( |
| ) |
const |
get the subID of this Instance of Collision.
- 傳回值
- unsigned int subID of this Instance of Collision.
| const Matrix4 & Collision::getTransform |
( |
| ) |
const |
get the Position/Rotation of this Instance of Collision.
If setPhysicsBody(Physics::Body *physicsbody_) is called once with a non-zero physicsbody_, The returned transform is the Transform of physicsbody_.
- 傳回值
- Matrix4 the Position/Rotation of this Instance of Collision.
| const Vector3 & Collision::getVelocity |
( |
| ) |
const |
get the Velocity of this Instance of Collision.
If setPhysicsBody(Physics::Body *physicsbody_) is called once with a non-zero physicsbody_, The returned velocity is the Velocity of physicsbody_.
- 傳回值
- Vector3 the Velocity of this Instance of Collision.
| virtual bool Magnum::Collision::isInside |
( |
const Vector3 & |
world_point | ) |
|
|
inlinevirtual |
This is a pure virtual function.
The function checks if a point, defined in world space, is inside the collision shape
- 參數
-
| world_point | the coordinates, defined in world space, to be checked against the collider |
- 傳回值
- true if world_point is inside collision false if world_point is not inside collision
在Magnum::Sphere3Collision重新實作.
| void Collision::setAttribute |
( |
unsigned int |
attribute_ | ) |
|
set the Attribute of this Collision Instance
This function is to set the 32-bit Attribute of this Collision Instance. Collision Detecion only performs on a pair of Collision Instance if they have at least 1 common bit set in their attri_bit. The default value of attri_bit is 0xffffffff
- 參數
-
set the Collision Event Handler
This function is to set the Collision::Handler for handling the collision event
- 參數
-
| handler_ | the Collision::Handler |
| void Collision::setID |
( |
unsigned int |
ID_ | ) |
|
| void Collision::setPosition |
( |
const Vector3 & |
position_ | ) |
|
set the Position of this Instance of Collision.
If setPhysicsBody(Physics::Body *physicsbody_) is called once with a non-zero physicsbody_, The Position of physicsbody_ will be set equal to position_.
- 參數
-
| position_ | the Position of this Instance of Collision. |
| void Collision::setSubID |
( |
unsigned int |
subID_ | ) |
|
set the subID of this Instance of Collision.
- 參數
-
| void Collision::setTransform |
( |
const Matrix4 & |
transform_ | ) |
|
set the Position/Rotation of this Instance of Collision.
If setPhysicsBody(Physics::Body *physicsbody_) is called once with a non-zero physicsbody_, The Transform of physicsbody_ will be set equal to transform_.
- 參數
-
| transform_ | the Position/Rotation of this Instance of Collision. |
| void Collision::setVelocity |
( |
const Vector3 & |
velocity_ | ) |
|
set the Velocity of this Instance of Collision.
If setPhysicsBody(Physics::Body *physicsbody_) is called once with a non-zero physicsbody_, The Velocity of physicsbody_ will be set equal to velocity_.
- 參數
-
| velocity_ | the Velocity of this Instance of Collision. |
This is a pure virtual function.
The function is a core function for calculate collision
This function should be implemented by sub class of Collision. It should get the type of other_ in the parameter and perform collision calculation with all possible type of other_ enummerated by Collision::Type
- 參數
-
| other | the other collision instance to be checked with |
| collided_ | set by this function, true if collision occurs, false other wise |
| contactPoint_ | set by this function, the calculated Contact Point of the Collided surface |
| contactNormal_ | set by this function, the calculated Contact Normal of the Collided surface |
| penetrationDepth_ | set by this function, the depth in which this instance penetrate with the other. |
- 傳回值
- true if collision detection is calculated false if collision detection is not calculated, i.e. no implemnetation
在Magnum::Sphere3Collision重新實作.
此類別(class) 文件是由下列檔案中產生:
- C:/EpicForceBackup/EpicForceEngine/EpicForceEngine/MagnumEngineLib/MagnumCore/Collision.h
- C:/EpicForceBackup/EpicForceEngine/EpicForceEngine/MagnumEngineLib/MagnumCore/Collision.cpp


Ever wondered how to put a desired text-content in a specific location in the HTML page? Ever got frustrated that the image you placed mis-aligns with the rest of the content. Well here is the answer.
My blog on JavaScript and DOM.
Find my thoughts on Problem Solving.
Please find my learning plan here.
Please find my reflection on values and strengths here.
Find my thoughts on emotional intelligence here.
My reflections on Neuroplasticity and Growth mind-set.
Foundations Reflection.


Protection Privacy - Web Map
Home
(current)
Login
Signup
Favorite List
Website Map
Search
Search in Website
Home
Login
Signup
Favorite List
DataSearch
E-mail is danger
Saftly to use web drive
Be a businessman saftly


Page 1 of 1
Installing error
Posted:
Sun Mar 22, 2009 10:58 am
by sourceofprovidence
I'm running a ACER Aspireone laptop 1gig ram, onboard graphics.
LAPTOP
Re: Installing error
Posted:
Sun Mar 22, 2009 11:45 am
by Karl G.
I take it you've downloaded several times with no success on any?
Here are some things to try:
- Run Windows Updates and be sure to upgrade to Windows Installer v. 3
- Download to a different media (such as a thumbdrive) and run from there
Re: Installing error
Posted:
Sun Mar 22, 2009 12:09 pm
by sourceofprovidence
I think i figured it out...... i'll let you know in a bit, #### GOOGLE CHROME, didn't prompt for download correectly only downloaded the image like a .msi or something... i'll know in a mninute.


Generates a set of 3D ellipse objects, with both polyline ellipse edges and a surface linking the ellipses together.
EllipseParams Parameters
Name Type Description UI Control num_ellipses int number of ellipses UIslider num_points int number of points per ellipse UIslider aboutxc float x-coord of stack centre - aboutyc float y-coord of stack centre - RandomNumParams Parameters
Name Type Description UI Control min_val float minimum ellipse radius UIslider max_val float maximum ellipse radius UIslider Output Ports
Name Type Description out_polyline_mesh Mesh ellipse edge mesh out_quad_mesh Mesh ellipse connections mesh out_obj GroupObject directly renderable output object
The ellipse user macro generates a series of randomly sized and shaped ellipses connected by a surface into a tube like structure. Each ellipse is created in the X-Y plane and offset a fixed distance from the adjacent ellipses along the Z-axis. The major and minor axes of the generated ellipses are always aligned with the X and Y axes. The mesh defining the ellipse edges is a polyline mesh. The connecting surface is a quadrilateral mesh. The actual size and shape of each ellipse is generated by using a sequence of random numbers. These numbers are generated from a set seed value. Hence the elliptical tube will have the same shape each time it is used. Parameters allow control over the number of ellipses, the accuracy of the model, base position for the stack of ellipses and the range of ellipse sizes.
The Ellipse project is primarily designed to be an illustration of how geometric objects can be created with the AVS/Express Visualization system. The technique of using a combination of custom code and Field Mapping modules has many applications. To assist in learning from this code both the V script code and the C++ source code are well documented. Practically this module could be used as the basis of a data visualization method that uses ellipses. Alternatively the basic method could be used to generate other geometric shapes.
The Ellipse project uses the RandomNumCore module to generate the required sequence of random numbers. More information on this module can be found in the Common project documentation.
(none)
num_ellipses
A member of the EllipseParams parameter block group, this integer value is used to specify the number of ellipses that should be generated. The UI slider component sets a maximum of 50 ellipses and a minimum of 2 ellipses. To generate the connecting surface at least 2 ellipses are required. If more ellipses are required the parameter can be directly modified. Depending upon memory usage the macro should be able to generate any number of ellipses.
num_points
A member of the EllipseParams parameter block group, this integer value is used to specify the number of points that should be generated per ellipse. This sets the accuracy of the resulting mesh. The UI slider component sets a maximum of 60 points and a minimum of 4 points. To generate a meaningful ellipse at least 4 points must be generated per ellipse. If higher accuracy is required the parameter can be directly modified. Depending upon memory usage the macro should be able to generate any number of points.
aboutxc aboutyc
Members of the EllipseParams parameter block group, these float values specify the coordinates of the centre point of the stack of ellipses. They define how far the stack is offset horizontally from the origin.
Only two of the parameters from this block are directly alterable from the ellipse User macro. The number of random numbers generated is automatically set to equal the number of ellipses to be generated. The seed values are set internally within the Functional Macro. This was done so that different sequences of random numbers could be used for both x and y dimensions.
min_val max_val
Members of the RandomNumParams parameter block group, these float values specify the range of random numbers that should be generated. Therefore they also specify the minimum and maximum possible radii of the generated ellipses. If the specified minimum value is greater than the maximum value the parameters will be swapped internally.
out_polyline_mesh
Polyline mesh containing the edges of each ellipse.
out_quad_mesh
Quadrilateral mesh containing the surface connecting the ellipses.
out_obj
The directly renderable output of the ellipse macro. This contains a GroupObject object that can be rendered by the standard data viewers. This GroupObject contains DataObjects representing both the polyline ellipse edges and the quadrilateral surface. If this object is viewed both of these sets of data will be visible. If only one of these objects is required to be viewed then a DataObject can be generated from the appropriate mesh output. Alternatively the original DataObjects can be exported from the Ellipse Functional macro.
The User Macro ellipse combines the Functional Macro Ellipse with the UI Macro EllipseUI. The User macro also makes use of the common parameter blocks EllipseParams and RandomNumParams to tie the Functional Macro and UI macro together. The Functional Macro uses the RandomNumCore module from the Common project to generate ellipse coordinate data.
An example application EllipseEg is provided that uses a set of random data to generate a elliptical tube. It shows how the size and shape of the ellipse can altered through a User Interface. The random data is generated using a set seed value hence the same data will be generated each time the example application is used.
xp_comm_proj/ellipse/ell_macs.v contains the V definitions of the Functional Macro Ellipse, the User macro ellipse, the UI macro EllipseUI and the example application EllipseEg.
The Functional and User Interface macros of this project rely on the successful installation of the following components. Without them they will not function correctly.
The EllipseMacs library inherits its process. As this library contains no procedural code, the process is not important. The modules in the low-level EllipseMods library execute under the process specified in that library, not the process defined in the high-level library.
Steve Larkin Advanced Visual Systems, Ltd. Hanworth Lane, Chertsey Surrey, UK KT16 9JX
Andrew Dodd International AVS Centre
EllipseCore, RandomNumCore, Ellipse, EllipseEg, Mesh mappers library


If The Culture Doesn't Work
“You have to be strong enough to say if the culture doesn’t work, don’t buy it”
― Morrie from Mitch Albom’s Tuesdays with Morrie
Gender inequality was always something I knew was a thing.
However, it wasn’t something that affected my life until I went to college and started to enter into the professional world. As a woman, who had big ambitions professionally, I became aware of the lack of female CEOs. I realized that a women’s traditional role as the primary caregiver, for example, made people hesitant to promote them. I even met one guy on OKCupid, a trading assistant at Bank of America Merril Lynch, who straight up said that he thinks women on average are not as smart as men.
But it’s not that we’re powerless victims either. Much, if not most, of the fight for equality is on us as females. Sheryl Sandberg’s renowned novel, Lean In, illustrates this point.
But after spending a year away from the Western World, I’ve found a new source of objectivity in how our culture functions.
Within a few weeks of being back in the States, for the first time in 2 years, I went to temple with my parents for Rosh Hashanah and was a little horrified frankly.
Why had I never questioned this before?
I am Jewish culturally, the temple community is great, and even my Rabbi is one of the most open-minded and thoughtful people I know.
But it’s not enough.
During temple, we recounted the story of Isaac and Abraham - the story of when God tells Isaac to slay his only son. It’s a powerful story but the message screams “Oppressive man wrote this to try to make people behave the way he wants.”
Abraham must follow God (the ultimate leader’s) orders no matter what, even if it means slaying his child.
God is a man.
The main characters are men. Women, although showing enourmous strength at times in Biblical history, are mainly on the sideline.
Who says God is a man!!?
Another example:
My family and I, including my older brother of 2 years, were all hanging out the other day. He mentioned how he’s responsible for carrying out the “Stroh” name because “I can’t”.
My gut reaction was “Why not?! - that is bullshit.”
He didn’t mean anything by it and it was a completely reasonable thing to say by many liberal minded New Yorkers’ standards. But it shouldn’t be. It’s just been drilled into our heads (and I think this is changing slowly) that women can’t do certain things- for no real reason.
The past year or two has made me aware that despite how far we have come we are still very easy to accept traditions that reinforce a mindset that bring us down.
Those are my thoughts - but in sum, what I’ll leave you with is this:
Don’t take anything for granted when it comes to what you can and can’t do. Question everything… even this post.


--- layout: post title: Skype Spam/Phishing categories: [] tags: - geek - skype status: publish type: post published: true meta: _original_post_id: '' _original_import_author: John Duprey author: ---
When you get texted in skype by a contact not in your contacts list and it is obvious a spam/malware/phishing attack, simply block them and check "Report abuse from this person". Hopefully, Skype will be able to block this contact from duping anyone else.


Dionysus Roadmap
Target: 2.1.x
- Full documentation of current code
- Complete rspecs for current code
rake doc:release
to generate and deploy updated documentation
- integrate with
rake release
Target: 2.2
rake version
tasks:
rake version:bump:(major,minor,patch)
rake version:set[number]
rake spec
should run and pass before rake release
rake release
should then update documentation site with code coverage
- Add back String encoding helpers
- Add back String sanitization method(s)
Target 2.3
- Add back String digest helpers
Target 2.4
- Add back PasswordSalt class
- Integrate with String digest helpers
Target 2.5
- Password generation functionality
Target 2.6
- Password strength testing functionality
- ActiveModel validations for password strength
Future/Ongoing
- Edge rails testing (i.e. Rails 4)
- Edge ruby testing (i.e. Ruby 2)


You can attach this attribute to any page element that is a container of other page elements and it will define the html element to use as a container for each of the children.
[IsRegion("menu_region")] [Container("ul", "{ns}_menu")] [ChildContainer("li", "{ns}_menu-item")] public class MenuRegion { }
The [ChildContainer()] attribute has the following properties you can set.
This property must contain the tag name of an Html container element. If you attach a ChildContainer attribute without setting the Tag property, then it will default to <div>.
If you do not attach a ChildContainer attribute to a page element that has children, then the children will be rendered bare, without any container element.
Setting this property adds a class attribute to the container that is rendered around each child element.
You can include multiple class names separated by spaces.
If you are using CSS prefixes for package namespaces (recommended) then you can add the appropriate package namespace prefix to your class names by using the special {ns}_ marker in front of each class name that you want to be prefixed.


--- layout: illustrations brand: illustrations-backgrounds title: Backgrounds description: Discover IRA backgrounds to power up your project. img: ira_elements.png meta_title: Illustrations Backgrounds meta_description: Discover IRA backgrounds to power up your project. canonical: https://iradesign.io/illustrations/backgrounds keywords: illustration, app, website illustration, app illustration, design component, custom illustration, illustration component, color gradient, gradients, gallery, best illustrations, colorful illustrations fb_app_id:<PHONE_NUMBER>37471 og_url: https://iradesign.io/illustrations/backgrounds permalink: /illustrations/backgrounds --- {% include path/path-assets.html %}


{% extends "conferences/form_base.html" %}
{% load crispy_forms_tags %}
{% block title %}{{ block.super }}Add Submission Remark{% endblock %}
{% block form_heading %}Here you can add any remark you have regarding this submission{% endblock %}
{% block form %}
{% crispy form %}
{% endblock form %}


Statistical
Computing
Lec02 Dev Environment
Xi (Rossi) LUO
Department of Biostatistics and Data Science
School of Public Health
The University of Texas Health Science Center at Houston
Today's Plan
- Docker
- Unix/Linux
- Git
- R Markdown
Typical Programs
Source code
#include <iostream>
int main() {
std::cout << "Hi!";
return 0;
}
Compiler/linker (e.g. gcc)
Machine code
0110110010100100101010.....
Note: this program also calls other other pieces of code for iostream which you
have
no
control of
If others decided to change their code or running on a differnet machine, different behaviors might
arise
Virtualization
- Machine virtualization
- Software to simulate cpu, mem, net, etc
- Same as other software, e.g. Word
- Examples: VMware, VirtualBox, Parallel
- "Env" virtualization: Docker, Singularity
Docker vs VM
Docker Ecosystem
Docker Usage
- Package software and library
- reproducible, no dependency bugs
- Easy deployment
- deploy multiple app instances
- Hardware and system updates (no dep impact)
- Security (running within container)
- Additional flexibility by singularity, used by TACC
Docker and R
Install: https://hub.docker.com/_/r-base and run the
following in
Terminals
docker pull r-base
You may specify older version of R by adding tags
Run interactive:
docker run -ti --rm r-base
Run in batch mode:
docker run -ti --rm -v "$PWD":/home/docker -w /home/docker \
-u docker r-base R CMD check .
Interactive
% docker run -ti --rm r-base
R version 4.1.1 (2021-08-10) -- "Kick Things"
Copyright (C) 2021 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)
...
Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
> sum(1:10)
[1] 55
Plotting may not work but you can save plots as files
Basic Concepts
- Image: collection of OS and apps (e.g. R)
- Container: running (or stopped) instance of a image
- Docker hub: storage of images created for different purposes and versions
Other Docker Commands
- Run: docker run/exec
- List local images: docker images
- Manage local image: docker image [command]
- Start/stop container start, attach, stop
- Import/export images: docker pull/push
Unix/Linux
- UNIX was originally developed at Bell Laboratories
- Linux is a clone of the operating system Unix, written from
scratch by Linus Torvalds with community efforts
- Modern Linux distributions: Ubuntu, CentOS, Suse, Redhat, Mint, ...
Linux Features
- Multitasking
- Multiuser
- Portability
- Modular Structure
- Library of application software (usually free)
- Work environment “of unusual simplicity, power, and elegance"
Linux Organization
- kernel: controls the hardware, turns part of the system on and
off at the programmer’s command, schedules tasks, and
manages storage;
- shell: connects and interprets users’ commands, calls
programs from memory, and executes them;
- tools and applications: offer additional functionality to the
operating system.
Essential Concepts
- Process: everything that “runs” under linux is a process,
e.g. commands, codes, spreadsheets, terminal windows, etc.
- Hierarchical file system: directories (folders), data files,
applications. Files are not processes!
- Shell: A shell is a process that accepts command lines and
feeds them to the linux kernel. Ex. Bash, Zsh
- Standard input/output. All processes have a standard input
and a standard output.
Command
- Syntax: command [option] parameter
- Command: ls, wc, man, rm, cd, ...
- Options telling Linux to perform a command in
a particular way, e.g. -f
- Parameter: e.g. file names
- Wildcards: ? matches any single character, * matches
any number of ?
- Review linux commands on Ubuntu web
File System as Tree
Pipe
-
command < file feed file as input to command
-
command > file save command output to file (overwritten)
-
command >> file save command output to file amd append to file if it exists
-
command1 | command2 use output of command1 as input to command2
Linux using Docker
Run under terminal and output
% docker run -ti --rm r-base bash
root@5ba24a4f8aec:/# ls
bin dev home lib64 mnt proc run srv tmp var
boot etc lib media opt root sbin sys usr
root@5ba24a4f8aec:/# ls -l lib/* | wc -l
127
root@5ba24a4f8aec:/# exit
exit
Version Control
Key idea: no need to store multiple copies of the file from different versions, only need to store
the differences between versions and the revision history.
Git Model
Git
- Created by Linus Torvalds in 2005
- Github, Bitbucket provide servers to host code repo
- Each collaborator stores a full-fledged copy of the project
- Resolve differences before pushing updates to the server
Almost Auto-Merging
- Each collaborator can make edits concurrently
- At the end, Git will usually resolve the conflicts in edits and make a merged copy with all
edits
Git Workflow: Central
- Simplest for a couple of collaborators
- One evolving version only
- Suitable for small projects
Git and R
- Git command line already installed on linux/mac
- Graphic user interfaces of Git available
- Rstudio has Git integration
Markdown and YAML
- Markdown: lightweight marked language started in 2004
- MD can be translated into other formats, such as PDF, HTML, DOCX, by e.g. pandoc
- YAML: human readable data in text started in 2001, vs json, xml
- R Markdown includes ingredients of both, and adds a few more features
R Markdown
YAML header
---
title: "Diamond sizes"
date: 2016-08-25
output: html_document
---
R code chunk
```{r setup, include = FALSE}
library(ggplot2)
library(dplyr)
smaller <- diamonds %>%
filter(carat <= 2.5)
```
R Markdown II
Markdown and R
We have data about `r nrow(diamonds)` diamonds. Only
`r nrow(diamonds) - nrow(smaller)` are larger than
2.5 carats. The distribution of the remainder is shown
below:
Two-step Process
- R markdown (.Rmd) converted to pure markdown (.md, inlcuding R computation and output as texts)
by R
packages like knitr.
- Markdown (.md) then converted to any formats that it supports
How to Learn
- Learn markdown syntax
- Learn YAML syntax
- Learn inline code, chunk and options
- (Optional) learn pretty-formatted table by kable
- Learn other advanced RMarkdown options (caching) for improved performance and customized
behavior
- Other advanced use (e.g. interactive)
- Reading: R for Data Science, ch 21, 23, 24
References
- Linux commands at
https://ubuntu.com/tutorials/command-line-for-beginners#1-overview
- Rstudio Git:
- https://support.rstudio.com/hc/en-us/articles/200532077-Version-Control-with-Git-and-SVN
- https://cfss.uchicago.edu/setup/git-with-rstudio/
- https://happygitwithr.com/rstudio-git-github.html
- Github: https://guides.github.com/activities/hello-world/
- Docker: https://docs.docker.com/get-started/
- Git workflow: https://www.atlassian.com/git/tutorials/comparing-workflows
- R Markdown: https://r4ds.had.co.nz/r-markdown.html


This series will be a read-through of Herbert S. Wilf's short (text?)book Generatingfunctionology, third edition. The book is indeed all about generating functions, and since I did not receive a formal introduction to the topic at the University of Minnesota, I thought it a decent target to clean out the math-brain cobwebs since graduation.
The book appears to fall cleanly in the "combinatorics" category. Leafing through the pages, it is clear that it is accessible (at least in bulk) to anyone with a few university math classes under their belt.
I plan to make this series most readable to those with at least an undergraduate degree (in math).
Generating functions are introduced in the context of a sequence \((a_n)_{n=1}^\infty\). Presented as a kind of stand-in for an explicit formula \(a_n=\ldots\), Wilf lists a bunch of ways that generating functions can be useful. The basic idea is "generating functions are useful for proving things," which is all the "real-world applicability" that I need to hear. But let's cut to the chase. What is a generating function?
(Generating Function) A generating function \(f\) for a sequence \( (a_n)_{n=0}^\infty \) is a complex-valued function on \(\mathbb{C}\) so that \( f(x)=\sum_{n=0}^\infty a_n x^n \).
Here Wilf pulls the age-old trick of not specifying the domain of either \(f\) or \( (a_n)_n \). I believe the intent is to allow readers to specify the most general domain that they are comfortable with. I'll attempt to keep intentional ambiguity to a minimum. (But hey, we'll give Wilf a break; it's just the first chapter). EDIT: So it appears that it is standard to view \( f \) as a formal power series. Probably should have guessed this, but it won't matter for this introductory post.
The idea of a generating function is immediately attractive. After all, the much-revered "explicit form" \( a_n = f(n) \) for some hopefully well-behaved function \(f\) is a similar embedding of \( (a_n)_n \) into a function space. It is often the case that \( f \) has an unusually short description, at least in the context of a first-year university student's homework. A generating function is a non-trivial embedding of \( (a_n)_n \) into a function space, which, if you know anything about power series, should at least feel more natural than the usual explicit form. Indeed, since we know a power series is smooth within its radius of convergence, even relatively fast-growing sequences have smooth generating functions. Moreover, power series in \( \mathbb{C} \) are holomorphic functions, and that is one heck of a place to land for your back-of-the-napkin scribblings! Right away we can see that this embedding is at the very least a group-homomorphism under addition.
Anyway, before getting into it (which, going by Wilf, is to jump into some examples), it's worth at least mentioning the origin of the power series. To be precise, let's say \( \varphi_0((a_n)_n) \) is the "embedding" operator that yields the generating function \(f_0 \) for \((a_n)_n\) defined above. Let \( \varphi_c((a_n)_n) \) yield the function \( f_c \) that satisfies \[ f_c(x)=\sum_{n=0}^\infty a_n (x-c)^n\,. \] The question is whether \(f_c\) is any different than \(f_{c'}\), or whether \(c=0\) is canonical in some way. A moment's thought (or maybe a little longer, if you're as slow as me) shows that this question does not contain a lot of content. Any holomorphic function \(f\) is the embedding \(\varphi_0((a_n)_n) \) for some suitable sequence, and since holomorphic functions form quite a broad class, we can't expect \(f_0\) and \(f_{c'}\) to be related other than being simple translates of each other. Moreover, the relationship between \(f_0\) and \(f_c\) is so un-mysterious that it is clear that, convenience aside, the choice of origin doesn't matter in the slightest.
But while we're on the topic of complex analysis, we know that a generating function \(f=\varphi_0((a_n)_n)\) extends to a holomophic function on some domain \(D\subset\mathbb{C}\). Say \((a_n)_n\sim (b_n)_n\) if there exists some \( z\in D \) so that \( f'=\varphi_z((b_n)_n) \) coincides with \(f \) within its disk of convergence. By the identity principle, we know that \(f'=f\) so that \(\sim\) is an equivalence relation, and indeed complex sequences that grow sufficiently slowly have classes corresponding to the unique holomophic function which they describe(!). Before I get lost in this rabbit hole (perhaps recalling some tidbit from my complex analysis days which makes this observation embarrassingly trivial), let's get a move-on to our first example.
Wilf asks us to find an explicit form for the recurrence relation \[ \begin{cases} a_{n+1} = 2a_n + 1 \\ n\geq 0,\,\, a_0 = 0 \end{cases}\,. \] We are to suppose that \( f(x)=\sum_{n=0}^\infty a_n x^n \) converges when \(|x|<r \) for sufficiently small, positive \(r\). Wilf chooses to ignore convergence issues altogether (probably because it won't be an issue with the introduction of formal power series), but it isn't particularly difficult to show that \(f\) converges (uniformly) on such a disk. It is clear that \(a_n\) is non-negative for all \(n\), and in that case \( a_{n+1}\geq 3a_n \) whenever \( n\geq 1 \). In particular, the sequence \( \{ b_0=1, \,\, b_{n+1}=3b_n \} \) is element-wise strictly greater than \( a_n \). Since we know the explicit form of \( (b_n)_n \) to be \( b_n=3^n \), we can see for \( |x|<1/6 \) \[ \left|f(x)\right|= \left| \sum_{n=0}^\infty a_nx^n \right| \leq \sum_{n=0}^\infty \left|a_n\right|x^n \leq \sum_{n=0}^\infty (1/2)^n=2 \,. \] The way to proceed here is slightly tricky, but once you know it you won't forget: \[ \begin{align*} a_{n+1}=2a_n+1&\implies \sum_{n=0}^\infty a_{n+1}x^n=\sum_{n=0}^\infty (2a_n+1)x^n &\text{for all }|x|\text{ small} \\ &\implies (1/x)\sum_{n=1}^\infty a_nx^n=2\sum_{n=0}^\infty a_nx^n + \sum_{n=0}^\infty x^n \\ &\implies f(x)/x=2f(x)+1/(1-x) \\ &\implies f(x)=\frac{x}{(1-x)(1-2x)}\,. \end{align*} \] You can perhaps tell right away that all the convergence issues are not potent since we have an exponential bound for \(a_n\). Here, we just showed that if there is some sequence \((a_n)_n\) satisfying the aforementioned recurrence relation, AND if \(f\) is a well-defined and exists, then \( f(x)=\frac{x}{(1-x)(1-2x)} \). Hence, we have found our generating function.
NB: Wilf, again deploying another masterful move, completely ignores the "issues" of whether \(f\) is well-defined or \((a_n)_n\) exists.
More manipulation reminiscent of your calc I (or intro complex analysis?) days provides a path to an explicit form: \[ \begin{align*} \sum_{n=0}^\infty a_n x^n=f(x)=\frac{x}{(1-x)(1-2x)}&=x\left(\frac{-1}{1-x}+\frac{2}{1-2x}\right) \\ &= -x\sum_{n=0}^\infty x^n + 2x\sum_{n=0}^\infty (2x)^n \\ &= \sum_{n=1}^\infty (2^n-1)x^n\,. \end{align*} \] Thus we have \( a_n = 2^n -1 \).
Now this calculation was not especially painful. But before putting this to bed, I find it extremely instructive to "pull-back" operations done in some sort of dual space back to the origin space. This serves a few purposes. First it shows when a map to a dual space is not very deep. This is the case when the pull-back operation is something you should have seen but didn't. Secondly, it has the possibility of expanding your knowledge of the original space, by porting features of the dual space. Here, we will rediscover the discrete convolution and relate it to the "shift" operator.
Recall our first step above was a summation: \( a_{n+1}=2a_n+1\implies \sum_n a_{n+1}x^n=2\sum_n a_n x^n+\sum_n x^n \). Broadly speaking, this doesn't really accomplish anything; it takes the implicit "for all \(n\)" contained in \( a_{n+1}=2a_n+1 \) and makes it explicit in a sum. Instead, we can write our recurrence relation element-wise: \[ \mathcal{L}(A)=2A+\mathbf{1}\,. \] Here \(\mathcal{L}\) is the left-shift operator taking a sequence \(A=(a_0, a_1, a_2,\ldots) \) to \( (a_1,a_2,a_3,\ldots) \) and \( \mathbf{1} \) is the constant sequence \( (1,1,1,\ldots) \). We take multiplication and addition to be element-wise. (For a more formal methodology for this "pull-back", apply the map \( \sum_n a_n x^n\mapsto (a_0,a_1,\ldots) \) to both sides of each step.) Keeping in mind what addition and scalar multiplication mean in \(\mathbb{C}^\infty\), we can rearrange and "factor" using a unique kind of convolution that we denote \(\star\): \[ \begin{align*} \mathcal{L}(A)=2A+\mathbf{1} &\implies \mathcal{L}(A)-2A=\mathbf{1} \\ &\implies A\star(-2,1,0,0,\ldots)=\mathbf{1}\,. \end{align*} \] Our star operator (\(\star\)) satisfies \(A\star B=\sum_{n=0}^\infty b_n \mathcal{L}^{(n)}(A) \). Unfortunately, \( \star\) is not associative, meaning we can't apply \((-2,1,0,0,\ldots)^{-1}\) to both sides above (if such an inverse even existed). To get a useful (i.e. associative) operator, we fall back to the wonderful (regular-old) discrete convolution. Avoiding strenuous bookkeeping requires extending \(A\) and \(B\) to two-sided sequences: \[ A=(\ldots, a_{-2}, a_{-1}, [a_0], a_1, a_2,\ldots) \\ B=(\ldots, b_{-2}, a_{-1}, [b_0], b_1, b_2,\ldots)\,. \] We surround the zero'th entry with brackets to distinguish its location. Then the discrete convolution \(A\star B\) is defined \[(A\star B)_k = \sum_{n=-\infty}^\infty a_n b_{k-n}\,.\] This operation is commutative and associative -- not to mention distributive over addition -- and we may rewrite \(\mathcal{L}(A)=2A+\mathbf{1}\) as \[ \begin{align*} \mathcal{L}(A)-2A=\mathbf{1} &\iff (\ldots,0,[a_0],a_1,a_2,\ldots)\star (\ldots, 0, 1,[-2],0,\ldots)=(\ldots,0,[1],1,\ldots) \\ &\iff A\star (\ldots, 0, 1,[-2],0,\ldots)=\mathbf{1}\,. \end{align*} \] Since \(\star\) is distributive over addition, we can relate the left shift operator to convolution with \((\ldots,1,[0],0,\ldots)\) and scalar multiplication with \((\ldots,0,[\alpha],0,\ldots)\). Then it's not too hard to construct at least this particular inverse: \[(\ldots, 0, 1,[-2],0,\ldots)\star (\ldots,[0],1,2,4,8,\ldots)=(\ldots,0,0,[1],0,0,\ldots)\] so that \[ \begin{align*} a_k&=((\ldots,[1],1,\ldots)\star(\ldots,0,[0],1,2,4,\ldots))_k \\ &= \sum_{n=0}^{k-1} 2^{k-n-1} = \sum_{n=0}^{k-1} 2^n \\ &= 2^k - 1\,. \end{align*} \] Interestingly, we encountered no convergence issues at all with this method. In addition, the partial fraction decomposition completely vanished, though this is certainly due to the explicit computation of the convolution-wise inverse. If instead we had expanded \(1/(1-2x)\) and \(1/(1-x)\) as power series we would have recovered a similar sum for \(a_k\) without the decomposition.
Much could be said about the above calculation; here are three starting points:


Have you ever had this problem? You have a set of coordinates and you know where they are (building, intersection, etc.) but you have no idea in what projection they are. Don't you wish you could try every projection in existance and see what lines up? Now you can, Enter the Projective Detective!
The number in parenthesis at the end is the distance in meters between the unknown point, projected in the given coordinate system, and the known Lat/Lng location. Smaller is better.


This is a proof-of-concept post based on the TensorFlow library developed by Google. The idea is simple: using a publicly available microbiome dataset, we wish to apply deep-learning algorithms for potential diagnostic platform development.
Copyright Declaration
The author asserts his copyright over this file and all files written by him containing links to this copyright declaration under the terms of the copyright laws in force in the country you are reading this work in.
This work is copyright © Ali A. Faruqi 2016. All rights reserved.
Introduction
What is the Human Microbiome?
A succinct answer to the question asked above is as follows, obtained from the Human Microbiome Project website:
- The Human Microbiome is the collection of all the microorganisms living in association with the human body.
- These communities consist of a variety of microorganisms including eukaryotes, archaea, bacteria and viruses.
- Bacteria in an average human body number ten times more than human cells, for a total of about 1000 more genes than are present in the human genome.
Many of these microbes are essentially helpful for human beings and can help in the following ways:
- Producing vitamins that we do not have the genes to make.
- Breaking down our food to extract nutrients we need to survive.
- Teaching our immune systems how to recognize dangerous invaders.
- Producing helpful anti-inflammatory compounds that fight off other disease-causing microbes.
The business of microbiome
According to a new market research report titled: “Human Microbiome Market by Indication (Obesity, Cancer), Application (Therapeutic, Diagnostic), Product (Prebiotics, Food, Drugs), Product Research (Instruments, Consumables), Technology Research (High Throughput, Omics Technology) - Global Forecast to 2023”, published by MarketsandMarkets, the microbiome market is expected to reach USD 658 Million by 2023 from USD 294 Million in 2019 growing at a CAGR of 22.3% during the forecast period (2019-2023).
There is great potential for growth in and capitalization of the microbiome market. Large companies such as DuPont, JNJ and Merck along with small startups such as Second Genome, Whole Biome, Phylagen and ubiome, to name a few, are catering to this market.
Microbiome-based diagnostics
The composition of our microbiomes has been shown to be correlated with numerous disease states by growing amount of scientific literature. The human microbiome, therefore, has an important role in the diagnosis and early detection of various diseases.
Microbiome data can be leveraged to achieve one of the goals of systems biology in making medicine predictive, preventive, personalized and participatory. This is known P4 medicine.
In the following sections, I have developed a simple deep-learning model using the microbiome data to predict the HIV status of individuals using a simple Softmax Regression model.
Technical Details
Data collection
For the purpose of demonstration, I will focus on a single study carried out by Lozupone et al. The study by Lozupone et al showed an association of the gut microbiome with HIV-1 infection. Using this knowledge, I obtained the dataset for this study, which is made publicly available by the Qiita microbiome data storage platform.
The dataset obtained from Qiita for Lozupone’s study had HIV-1 status information available for 51 individuals. __ individuals are HIV-1 positive and __ individuals are HIV-1 negative.
Model building
Given the limited human and computational resources I had access to i.e., myself and my laptop, I built a fairly simplistic softmax-based regression model.
A microbiome dataset consists of a count matrix in which the bacteria characterized by Next Generation Sequencing (NGS) are the rows and the samples from which the bacterial count information is obtained are columns. Additionally, there is meta-data associated with the samples. On a technical note, the bacterial count here refers to OTUs.
It is beyond the scope of this post to go into the definition of OTUs. Suffice to say, I am treating bacteria/OTUs as input features in the model.
The response variable is the disease state. In this particular dataset, it is the status of HIV-1, which is either positive or negative.
Model evaluation
Using the input data for Lozupone’s study, I wrote a simple Python script that ran softmax-regression. The script and further technical specs are on my GitHub repository called TFMicrobiome.
Even though the dataset was small and the model simple, I ended up getting an accuracy of 91%! This demonstrates that even the most simplistic of deep-learning system is very powerful in dealing with real-life noisy data and has the potential to be developed into a diagnostic platform.
Future Directions
Moving forward, there are two areas where effort needs to be put in.
Other biological datasets
I have made use of only a small microbiome dataset. From a statistical perspective, the sample size is small and there is a need for larger datasets to train the models on. As a product manager, I’d like my team to put effort in collecting more data.
Additionally, and from a biological point-of-view, microbiome is part of the picture. At a molecular level, there are other high-throughput datasets available such as that of the genome, transcriptome, proteome and metabolome. By integrating the various ‘omics’ datasets for a given individual, we can develop a truly systems level understanding of various biological diseases and achieve the objectives of P4 medicine.
Other deep learning algorithms
As a simple POC, I made use of the simplistic softmax regression model. It is not the most powerful method out there. Moving forward, I’d like to see some more sophisticated algorithms being employed such as convolutional neural networks and recurrant neural networks, to name a few.


Groups#
Permutation groups#
A permutation group is a subgroup of some symmetric group
\(S_n\). Sage has a Python class PermutationGroup
, so you
can work with such groups directly:
sage: G = PermutationGroup(['(1,2,3)(4,5)'])
sage: G
Permutation Group with generators [(1,2,3)(4,5)]
sage: g = G.gens()[0]; g
(1,2,3)(4,5)
sage: g*g
(1,3,2)
sage: G = PermutationGroup(['(1,2,3)'])
sage: g = G.gens()[0]; g
(1,2,3)
sage: g.order()
3
For the example of the Rubik’s cube group (a permutation subgroup of \(S_{48}\), where the non-center facets of the Rubik’s cube are labeled \(1,2,...,48\) in some fixed way), you can use the GAP-Sage interface as follows.
sage: cube = "cubegp := Group(
( 1, 3, 8, 6)( 2, 5, 7, 4)( 9,33,25,17)(10,34,26,18)(11,35,27,19),
( 9,11,16,14)(10,13,15,12)( 1,17,41,40)( 4,20,44,37)( 6,22,46,35),
(17,19,24,22)(18,21,23,20)( 6,25,43,16)( 7,28,42,13)( 8,30,41,11),
(25,27,32,30)(26,29,31,28)( 3,38,43,19)( 5,36,45,21)( 8,33,48,24),
(33,35,40,38)(34,37,39,36)( 3, 9,46,32)( 2,12,47,29)( 1,14,48,27),
(41,43,48,46)(42,45,47,44)(14,22,30,38)(15,23,31,39)(16,24,32,40) )"
sage: gap(cube)
'permutation group with 6 generators'
sage: gap("Size(cubegp)")
43252003274489856000'
Another way you can choose to do this:
Create a file
cubegroup.py
containing the lines:cube = "cubegp := Group( ( 1, 3, 8, 6)( 2, 5, 7, 4)( 9,33,25,17)(10,34,26,18)(11,35,27,19), ( 9,11,16,14)(10,13,15,12)( 1,17,41,40)( 4,20,44,37)( 6,22,46,35), (17,19,24,22)(18,21,23,20)( 6,25,43,16)( 7,28,42,13)( 8,30,41,11), (25,27,32,30)(26,29,31,28)( 3,38,43,19)( 5,36,45,21)( 8,33,48,24), (33,35,40,38)(34,37,39,36)( 3, 9,46,32)( 2,12,47,29)( 1,14,48,27), (41,43,48,46)(42,45,47,44)(14,22,30,38)(15,23,31,39)(16,24,32,40) )"
Then place the file in the subdirectory
$SAGE_ROOT/local/lib/python2.4/site-packages/sage
of your Sage home directory. Last, read (i.e.,import
) it into Sage:sage: import sage.cubegroup sage: sage.cubegroup.cube 'cubegp := Group(( 1, 3, 8, 6)( 2, 5, 7, 4)( 9,33,25,17)(10,34,26,18) (11,35,27,19),( 9,11,16,14)(10,13,15,12)( 1,17,41,40)( 4,20,44,37) ( 6,22,46,35),(17,19,24,22)(18,21,23,20)( 6,25,43,16)( 7,28,42,13) ( 8,30,41,11),(25,27,32,30)(26,29,31,28)( 3,38,43,19)( 5,36,45,21) ( 8,33,48,24),(33,35,40,38)(34,37,39,36)( 3, 9,46,32)( 2,12,47,29) ( 1,14,48,27),(41,43,48,46)(42,45,47,44)(14,22,30,38)(15,23,31,39) (16,24,32,40) )' sage: gap(sage.cubegroup.cube) 'permutation group with 6 generators' sage: gap("Size(cubegp)") '43252003274489856000'
(You will have line wrap instead of the above carriage returns in your Sage output.)
Use the
CubeGroup
class:sage: rubik = CubeGroup() sage: rubik The Rubik's cube group with generators R,L,F,B,U,D in SymmetricGroup(48). sage: rubik.order()<PHONE_NUMBER>4489856000
(1) has implemented classical groups (such as \(GU(3,\GF{5})\)) and matrix groups over a finite field with user-defined generators.
(2) also has implemented finite and infinite (but finitely generated) abelian groups.
Conjugacy classes#
You can compute conjugacy classes of a finite group using “natively”:
sage: G = PermutationGroup(['(1,2,3)', '(1,2)(3,4)', '(1,7)'])
sage: CG = G.conjugacy_classes_representatives()
sage: gamma = CG[2]
sage: CG; gamma
[(), (4,7), (3,4,7), (2,3)(4,7), (2,3,4,7), (1,2)(3,4,7), (1,2,3,4,7)]
(3,4,7)
You can use the Sage-GAP interface:
sage: gap.eval("G := Group((1,2)(3,4),(1,2,3))")
'Group([ (1,2)(3,4), (1,2,3) ])'
sage: gap.eval("CG := ConjugacyClasses(G)")
'[ ()^G, (2,3,4)^G, (2,4,3)^G, (1,2)(3,4)^G ]'
sage: gap.eval("gamma := CG[3]")
'(2,4,3)^G'
sage: gap.eval("g := Representative(gamma)")
'(2,4,3)'
Or, here’s another (more “pythonic”) way to do this type of computation:
sage: G = gap.Group('[(1,2,3), (1,2)(3,4), (1,7)]')
sage: CG = G.ConjugacyClasses()
sage: gamma = CG[2]
sage: g = gamma.Representative()
sage: CG; gamma; g
[ ConjugacyClass( SymmetricGroup( [ 1, 2, 3, 4, 7 ] ), () ),
ConjugacyClass( SymmetricGroup( [ 1, 2, 3, 4, 7 ] ), (4,7) ),
ConjugacyClass( SymmetricGroup( [ 1, 2, 3, 4, 7 ] ), (3,4,7) ),
ConjugacyClass( SymmetricGroup( [ 1, 2, 3, 4, 7 ] ), (2,3)(4,7) ),
ConjugacyClass( SymmetricGroup( [ 1, 2, 3, 4, 7 ] ), (2,3,4,7) ),
ConjugacyClass( SymmetricGroup( [ 1, 2, 3, 4, 7 ] ), (1,2)(3,4,7) ),
ConjugacyClass( SymmetricGroup( [ 1, 2, 3, 4, 7 ] ), (1,2,3,4,7) ) ]
ConjugacyClass( SymmetricGroup( [ 1, 2, 3, 4, 7 ] ), (4,7) )
(4,7)
Normal subgroups#
If you want to find all the normal subgroups of a permutation group \(G\) (up to conjugacy), you can use Sage’s interface to GAP:
sage: G = AlternatingGroup( 5 )
sage: gap(G).NormalSubgroups()
[ AlternatingGroup( [ 1 .. 5 ] ), Group( () ) ]
or
sage: G = gap("AlternatingGroup( 5 )")
sage: G.NormalSubgroups()
[ AlternatingGroup( [ 1 .. 5 ] ), Group( () ) ]
Here’s another way, working more directly with GAP:
sage: print(gap.eval("G := AlternatingGroup( 5 )"))
Alt( [ 1 .. 5 ] )
sage: print(gap.eval("normal := NormalSubgroups( G )"))
[ Alt( [ 1 .. 5 ] ), Group(()) ]
sage: G = gap.new("DihedralGroup( 10 )")
sage: G.NormalSubgroups()
[ Group( [ f1, f2 ] ), Group( [ f2 ] ), Group( <identity> of ... ) ]
sage: print(gap.eval("G := SymmetricGroup( 4 )"))
Sym( [ 1 .. 4 ] )
sage: print(gap.eval("normal := NormalSubgroups( G );"))
[ Sym( [ 1 .. 4 ] ), Alt( [ 1 .. 4 ] ), Group([ (1,4)(2,3), ... ]),
Group(()) ]
Centers#
How do you compute the center of a group in Sage?
Although Sage calls GAP to do the computation of the group center,
center
is “wrapped” (i.e., Sage has a class PermutationGroup with
associated class method “center”), so the user does not need to use
the gap
command. Here’s an example:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(3,4)'])
sage: G.center()
Subgroup generated by [()] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)])
A similar syntax for matrix groups also works:
sage: G = SL(2, GF(5) )
sage: G.center()
Subgroup with 1 generators (
[4 0]
[0 4]
) of Special Linear Group of degree 2 over Finite Field of size 5
sage: G = PSL(2, 5 )
sage: G.center()
Subgroup generated by [()] of (The projective special linear group of degree 2 over Finite Field of size 5)
Note
center
can be spelled either way in GAP, not so in Sage.
The group id database#
The function group_id
uses the Small Groups Library of
E. A. O’Brien, B. Eick, and H. U. Besche, which is a part of GAP.
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(3,4)'])
sage: G.order()
120
sage: G.group_id()
[120, 34]
Another example of using the small groups database: group_id
sage: gap_console()
┌───────┐ GAP 4.10.0 of 01-Nov-2018
│ GAP │ https://www.gap-system.org
└───────┘ Architecture: x86_64-pc-linux-gnu-default64
Configuration: gmp 6.0.0, readline
Loading the library and packages ...
Packages: GAPDoc 1.6.2, PrimGrp 3.3.2, SmallGrp 1.3, TransGrp 2.0.4
Try '??help' for help. See also '?copyright', '?cite' and '?authors'
gap> G:=Group((4,6,5)(7,8,9),(1,7,2,4,6,9,5,3));
Group([ (4,6,5)(7,8,9), (1,7,2,4,6,9,5,3) ])
gap> StructureDescription(G);
"(C3 x C3) : GL(2,3)"
Construction instructions for every group of order less than 32#
AUTHORS:
Davis Shurbert
Every group of order less than 32 is implemented in Sage as a permutation group. They can all be created easily. We will first show how to build direct products and semidirect products, then give the commands necessary to build all of these small groups.
Let G1
, G2
, …, Gn
be permutation groups already initialized in
Sage. The following command can be used to take their direct product (where,
of course, the ellipses are simply being used here as a notation, and you
actually must enter every factor in your desired product explicitly).
sage: G = direct_product_permgroups([G1, G2, ..., Gn])
The semidirect product operation can be thought of as a generalization of the direct product operation. Given two groups, \(H\) and \(K\), their semidirect product, \(H \ltimes_{\phi} K\), (where \(\phi : H \rightarrow Aut(K)\) is a homomorphism) is a group whose underlying set is the cartersian product of \(H\) and \(K\), but with the operation:
The output is not the group explicitly described in the definition of the
operation, but rather an isomorphic group of permutations. In the routine
below, assume H
and K
already have been defined and initialized in
Sage. Also, phi
is a list containing two sublists that define the
underlying homomorphism by giving the images of a set of generators of H
.
For each semidirect product in the table below we will show you how to build
phi
, then assume you have read this passage and understand how to go
from there.
sage: G = H.semidirect_product(K, phi)
To avoid unnecessary repetition, we will now give commands that one can use to create the cyclic group of order \(n\), \(C_n\), and the dihedral group on \(n\) letters, \(D_n\). We will present one more example of each to ensure that the reader understands the command, then it will be withheld.
sage: G = CyclicPermutationGroup(n)
sage: G = DihedralGroup(n)
Note that exponential notation will be used for the direct product operation. For example, \({C_2}^2 = C_2 \times C_2\). This table was crafted with the help of Group Tables, by AD Thomas and GV Wood (1980, Shiva Publishing).
Order |
Group Description |
Command(s) |
GAP ID |
|---|---|---|---|
1 |
The Trivial Group |
sage: G = SymmetricGroup(1)
|
[1,1] |
2 |
\(C_2\) |
sage: G = SymmetricGroup(2)
|
[2,1] |
3 |
\(C_3\) |
sage: G = CyclicPermutationGroup(3)
|
[3,1] |
4 |
\(C_4\) |
[4,1] |
|
4 |
\(C_2 \times C_2\) |
sage: G = KleinFourGroup()
|
[4,2] |
5 |
\(C_5\) |
[5,1] |
|
6 |
\(C_6\) |
[6,2] |
|
6 |
\(S_3\) (Symmetric Group on 3 letters) |
sage: G = SymmetricGroup(3)
|
[6,1] |
7 |
\(C_7\) |
[7,1] |
|
8 |
\(C_8\) |
[8,1] |
|
8 |
\(C_4 \times C_2\) |
[8,2] |
|
8 |
\(C_2\times C_2\times C_2\) |
[8,5] |
|
8 |
\(D_4\) |
sage: G = DihedralGroup(4)
|
[8,3] |
8 |
The Quaternion Group (Q) |
sage: G = QuaternionGroup()
|
[8,4] |
9 |
\(C_9\) |
[9,1] |
|
9 |
\(C_3 \times C_3\) |
[9,2] |
|
10 |
\(C_{10}\) |
[10,2] |
|
10 |
\(D_5\) |
[10,1] |
|
11 |
\(C_{11}\) |
[11,1] |
|
12 |
\(C_{12}\) |
[12,2] |
|
12 |
\(C_6 \times C_2\) |
[12,5] |
|
12 |
\(D_6\) |
[12,4] |
|
12 |
\(A_4\) (Alternating Group on 4 letters) |
sage: G = AlternatingGroup(4)
|
[12,3] |
12 |
\(Q_6\) (DiCyclic group of order 12) |
sage: G = DiCyclicGroup(3)
|
[12,1] |
13 |
\(C_{13}\) |
[13,1] |
|
14 |
\(C_{14}\) |
[14,2] |
|
14 |
\(D_{7}\) |
[14,1] |
|
15 |
\(C_{15}\) |
[15,1] |
|
16 |
\(C_{16}\) |
[16,1] |
|
16 |
\(C_8 \times C_2\) |
[16,5] |
|
16 |
\(C_4 \times C_4\) |
[16,2] |
|
16 |
\(C_4\times C_2\times C_2\) |
[16,10] |
|
16 |
\({C_2}^4\) |
[16,14] |
|
16 |
\(D_4 \times C_2\) |
[16,11] |
|
16 |
\(Q \times C_2\) |
[16,12] |
|
16 |
\(D_8\) |
[16,7] |
|
16 |
\(Q_{8}\) (Dicyclic group of order 16) |
sage: G = DiCyclicGroup(4)
|
[16,9] |
16 |
Semidihedral Group of order \(2^4\) |
sage: G = SemidihedralGroup(4)
|
[16,8] |
16 |
Split Metacyclic Group of order \(2^4\) |
sage: G = SplitMetacyclicGroup(2,4)
|
[16,6] |
16 |
\((C_4 \times C_2) \rtimes_{\phi} C_2\) |
sage: C2 = SymmetricGroup(2); C4 = CyclicPermutationGroup(4)
sage: A = direct_product_permgroups([C2,C4])
sage: alpha = PermutationGroupMorphism(A,A,[A.gens()[0],A.gens()[0]^2*A.gens()[1]])
sage: phi = [[(1,2)],[alpha]]
|
[16,13] |
16 |
\((C_4 \times C_2) \rtimes_{\phi} C_2\) |
sage: C2 = SymmetricGroup(2); C4 = CyclicPermutationGroup(4)
sage: A = direct_product_permgroups([C2,C4])
sage: alpha = PermutationGroupMorphism(A,A,[A.gens()[0]^3*A.gens()[1],A.gens()[1]])
sage: phi = [[(1,2)],[alpha]]
|
[16,3] |
16 |
\(C_4 \rtimes_{\phi} C_4\) |
sage: C4 = CyclicPermutationGroup(4)
sage: alpha = PermutationGroupMorphism(C4,C4,[C4.gen().inverse()])
sage: phi = [[(1,2,3,4)],[alpha]]
|
[16,4] |
17 |
\(C_{17}\) |
[17,1] |
|
18 |
\(C_{18}\) |
[18,2] |
|
18 |
\(C_6 \times C_3\) |
[18,5] |
|
18 |
\(D_9\) |
[18,1] |
|
18 |
\(S_3 \times C_3\) |
[18,3] |
|
18 |
\(Dih(C_3 \times C_3)\) |
sage: G = GeneralDihedralGroup([3,3])
|
[18,4] |
19 |
\(C_{19}\) |
[19,1] |
|
20 |
\(C_{20}\) |
[20,2] |
|
20 |
\(C_{10} \times C_2\) |
[20,5] |
|
20 |
\(D_{10}\) |
[20,4] |
|
20 |
\(Q_{10}\) (Dicyclic Group of order 20) |
[20,1] |
|
20 |
\(Hol(C_5)\) |
sage: C5 = CyclicPermutationGroup(5)
sage: G = C5.holomorph()
|
[20,3] |
21 |
\(C_{21}\) |
[21,2] |
|
21 |
\(C_7 \rtimes_{\phi} C_3\) |
sage: C7 = CyclicPermutationGroup(7)
sage: alpha = PermutationGroupMorphism(C7,C7,[C7.gen()**4])
sage: phi = [[(1,2,3)],[alpha]]
|
[21,1] |
22 |
\(C_{22}\) |
[22,2] |
|
22 |
\(D_{11}\) |
[22,1] |
|
23 |
\(C_{23}\) |
[23,1] |
|
24 |
\(C_{24}\) |
[24,2] |
|
24 |
\(D_{12}\) |
[24,6] |
|
24 |
\(Q_{12}\) (DiCyclic Group of order 24) |
[24,4] |
|
24 |
\(C_{12} \times C_2\) |
[24,9] |
|
24 |
\(C_6 \times C_2 \times C_2\) |
[24,15] |
|
24 |
\(S_4\) (Symmetric Group on 4 letters) |
sage: G = SymmetricGroup(4)
|
[24,12] |
24 |
\(S_3 \times C_4\) |
[24,5] |
|
24 |
\(S_3 \times C_2 \times C_2\) |
[24,14] |
|
24 |
\(D_4 \times C_3\) |
[24,10] |
|
24 |
\(Q \times C_3\) |
[24,11] |
|
24 |
\(A_4 \times C_2\) |
[24,13] |
|
24 |
\(Q_6 \times C_2\) |
[24,7] |
|
24 |
\(Q \rtimes_{\phi} C_3\) |
sage: Q = QuaternionGroup()
sage: alpha = PermutationGroupMorphism(Q,Q,[Q.gens()[0]*Q.gens()[1],Q.gens()[0].inverse()])
sage: phi = [[(1,2,3)],[alpha]]
|
[24,3] |
24 |
\(C_3 \rtimes_{\phi} C_8\) |
sage: C3 = CyclicPermutationGroup(3)
sage: alpha = PermutationGroupMorphism(C3,C3,[C3.gen().inverse()])
sage: phi = [[(1,2,3,4,5,6,7,8)],[alpha]]
|
[24,1] |
24 |
\(C_3 \rtimes_{\phi} D_4\) |
sage: C3 = CyclicPermutationGroup(3)
sage: alpha1 = PermutationGroupMorphism(C3,C3,[C3.gen().inverse()])
sage: alpha2 = PermutationGroupMorphism(C3,C3,[C3.gen()])
sage: phi = [[(1,2,3,4),(1,3)],[alpha1,alpha2]]
|
[24,8] |
25 |
\(C_{25}\) |
[25,1] |
|
25 |
\(C_5 \times C_5\) |
[25,2] |
|
26 |
\(C_{26}\) |
[26,2] |
|
26 |
\(D_{13}\) |
[26,1] |
|
27 |
\(C_{27}\) |
[27,1] |
|
27 |
\(C_9 \times C_3\) |
[27,2] |
|
27 |
\(C_3 \times C_3 \times C_3\) |
[27,5] |
|
27 |
Split Metacyclic Group of order \(3^3\) |
sage: G = SplitMetacyclicGroup(3,3)
|
[27,4] |
27 |
\((C_3 \times C_3) \rtimes_{\phi} C_3\) |
sage: C3 = CyclicPermutationGroup(3)
sage: A = direct_product_permgroups([C3,C3])
sage: alpha = PermutationGroupMorphism(A,A,[A.gens()[0]*A.gens()[1].inverse(),A.gens()[1]])
sage: phi = [[(1,2,3)],[alpha]]
|
[27,3] |
28 |
\(C_{28}\) |
[28,2] |
|
28 |
\(C_{14} \times C_2\) |
[28,4] |
|
28 |
\(D_{14}\) |
[28,3] |
|
28 |
\(Q_{14}\) (DiCyclic Group of order 28) |
[28,1] |
|
29 |
\(C_{29}\) |
[29,1] |
|
30 |
\(C_{30}\) |
[30,4] |
|
30 |
\(D_{15}\) |
[30,3] |
|
30 |
\(D_5 \times C_3\) |
[30,2] |
|
30 |
\(D_3 \times C_5\) |
[30,1] |
|
31 |
\(C_{31}\) |
[31,1] |
Table By Kevin Halasz
Construction instructions for every finitely presented group of order 15 or less#
Sage has the capability to easily construct every group of order 15 or less as a finitely presented group. We will begin with some discussion on creating finitely generated abelian groups, as well as direct and semidirect products of finitely presented groups.
All finitely generated abelian groups can be created using the
groups.presentation.FGAbelian(ls)
command, where ls
is a list of
non-negative integers which gets reduced to invariants defining the group
to be returned. For example, to construct
\(C_4 \times C_2 \times C_2 \times C_2\) we can simply use:
sage: A = groups.presentation.FGAbelian([4,2,2,2])
The output for a given group is the same regardless of the input list of integers. The following example yields identical presentations for the cyclic group of order 30.
sage: A = groups.presentation.FGAbelian([2,3,5])
sage: B = groups.presentation.FGAbelian([30])
If G
and H
are finitely presented groups, we can use the following
code to create the direct product of G
and H
, \(G \times H\).
sage: D = G.direct_product(H)
Suppose there exists a homomorphism \(\phi\) from a group \(G\) to the automorphism group of a group \(H\). Define the semidirect product of \(G\) with \(H\) via \(\phi\), as the Cartesian product of \(G\) and \(H\), with the operation \((g_1, h_1)(g_2, h_2) = (g_1 g_2, \phi_{h_1}(g_2) h_2)\) where \(\phi_h = \phi(h)\). To construct this product in Sage for two finitely presented groups, we must define \(\phi\) manually using a pair of lists. The first list consists of generators of the group \(G\), while the second list consists of images of the corresponding generators in the first list. These automorphisms are similarly defined as a pair of lists, generators in one and images in the other. As an example, we construct the dihedral group of order 16 as a semidirect product of cyclic groups.
sage: C2 = groups.presentation.Cyclic(2)
sage: C8 = groups.presentation.Cyclic(8)
sage: hom = (C2.gens(), [ ([C8([1])], [C8([-1])]) ])
sage: D = C2.semidirect_product(C8, hom)
The following table shows the groups of order 15 or less, and how to construct them in Sage. Repeated commands have been omitted but instead are described by the following examples.
The cyclic group of order \(n\) can be created with a single command:
sage: C = groups.presentation.Cyclic(n)
Similarly for the dihedral group of order \(2n\):
sage: D = groups.presentation.Dihedral(n)
This table was modeled after the preceding table created by Kevin Halasz.
Order |
Group Description |
Command(s) |
GAP ID |
|---|---|---|---|
1 |
The Trivial Group |
sage: G = groups.presentation.Symmetric(1)
|
[1,1] |
2 |
\(C_2\) |
sage: G = groups.presentation.Symmetric(2)
|
[2,1] |
3 |
\(C_3\) |
sage: G = groups.presentation.Cyclic(3)
|
[3,1] |
4 |
\(C_4\) |
[4,1] |
|
4 |
\(C_2 \times C_2\) |
sage: G = groups.presentation.Klein()
|
[4,2] |
5 |
\(C_5\) |
[5,1] |
|
6 |
\(C_6\) |
[6,2] |
|
6 |
\(S_3\) (Symmetric Group on 3 letters) |
sage: G = groups.presentation.Symmetric(3)
|
[6,1] |
7 |
\(C_7\) |
[7,1] |
|
8 |
\(C_8\) |
[8,1] |
|
8 |
\(C_4 \times C_2\) |
sage: G = groups.presentation.FGAbelian([4,2])
|
[8,2] |
8 |
\(C_2\times C_2\times C_2\) |
sage: G = groups.presentation.FGAbelian([2,2,2])
|
[8,5] |
8 |
\(D_4\) |
sage: G = groups.presentation.Dihedral(4)
|
[8,3] |
8 |
The Quaternion Group (Q) |
sage: G = groups.presentation.Quaternion()
|
[8,4] |
9 |
\(C_9\) |
[9,1] |
|
9 |
\(C_3 \times C_3\) |
[9,2] |
|
10 |
\(C_{10}\) |
[10,2] |
|
10 |
\(D_5\) |
[10,1] |
|
11 |
\(C_{11}\) |
[11,1] |
|
12 |
\(C_{12}\) |
[12,2] |
|
12 |
\(C_6 \times C_2\) |
[12,5] |
|
12 |
\(D_6\) |
[12,4] |
|
12 |
\(A_4\) (Alternating Group on 4 letters) |
sage: G = groups.presentation.Alternating(4)
|
[12,3] |
12 |
\(Q_6\) (DiCyclic group of order 12) |
sage: G = groups.presentation.DiCyclic(3)
|
[12,1] |
13 |
\(C_{13}\) |
[13,1] |
|
14 |
\(C_{14}\) |
[14,2] |
|
14 |
\(D_{7}\) |
[14,1] |
|
15 |
\(C_{15}\) |
[15,1] |