2022-01-01
I was pretty lazy with writing longer book reviews in 2021, but here’s a list with mini-reviews of what I’ve read last year.
We read this in one of book clubs we have at work. I found it to be pretty dry, and it wasn’t straightforward to apply any learnings from it to software engineering, or at least that’s how the discussions felt to me. My favourite bits were the examples, but I don’t think I’ve taken much with me that’s actionable, other than the good feeling of having read this classic. Which also isn’t actionable.
My favourite read of the year! I’ve written a longer review about this. We read it in our tech book club, and I’ve learned a lot from it. I’d love to go deeper on the topic by either building a CPU from first principles, do the Nand2Tetris courses, or read Computer Systems: A Programmer’s Perspective.
This book is meant to help better understand patterns you can observe when using Pluralsight Flow, an engineering metrics tool. For my taste, it is biased too much towards an environment where the expectation is that developers do nothing but code, all day every day.
Another work book club book; this has been on my “to read” list for a long time. It was a real slog to get through, and though there’s a ton of repetition in the text, reading it felt like hard work. My main takeaway is the terminology coined by Norman, and being able to point out when somebody mixes up signifiers and affordances. I also pay a lot of attention to doors now.
This is probably the first use of the O’Reilly subscription I get through work. As it turns out, they have basically everything!
True to its title, this book clarifies the fundamentals of software architecture, and in doing so defines a lot of terms everybody seems to have a different idea about. Now, if everybody would just read the book…
Some examples are a bit hand-wavy, but I did like the quantitative approach shown. Maybe the architects who produce a slide deck and then move on without anything ever happening aren’t actually doing a great job after all!
I wanted to read ULSAH for a long time, and seeing it in the O’Reilly catalogue was enough to get me started. It took me quite a long time to get through, but I feel like I’ve learned a lot (DNS! Booting! Virtualization!). Each chapter is a great overview of a topic, and offers tons of references to go deeper if desired. And, unexpectedly, the book was funny in a very subtle way.
The one physical book I’ve read this year! I got this for a promotion at work. I think it holds up extremely well, and it made me want to re-read The Phoenix Project. Unlike the latter, The Goal actually explains why it’s written as a first-person fictional story, and why the main character has seemingly unrelated marriage problems. Without knowing any of this, TPP was kind of strange to read, though still entertaining.
I have started reading old Kernighan books a while ago, but somehow got stuck on Software Tools, mostly because I did the exercises, in Pascal. On this second attempt, I didn’t do the exercises, but I finally understand where you have to put semicolons in Pascal!
I found this a very instructional read, which has changed the way I approach writing small programs myself, and my thinking about what features belong where. It is also a masterclass in writing about programs.
The first edition of this was part of a Humble Bundle I bought a while back, but by the time I considered reading it, the second edition was close to being finished, so I just waited for that.
DSatCL introduces a very structured approach to what I often do already, and I’m excited to adopt some of the practices such as using Makefiles to keep the chaos at bay. I also want to learn more about the R/ggplot-based plotting tools, and use them in some of my projects.
Work on my Pandoc Bash Blog has stalled somewhat recently, but I have a bunch of things I’d like to do with it, many of which require some frontend chops. Since the entire library from A Book Apart is on O’Reilly, why not read some of them? (Or all?)
This is the first book of the entire series, and I only realized when I was done that there is a second edition. And even that one is a few years old, but together with reading lots of MDN documentation, I feel like I’m now more or less up to speed.
The second book from A Book Apart. This time, I read the second edition right away. I think browser support has improved quite a lot since this book was written, but it definitely helped me better understand transitions and animations.
Reading this was mostly because of completionsim, but it turned out to be quite interesting nonetheless. I’m a little less confused about “content strategy” now.
I read this mostly to understand all the buzzwords and getting an idea of the fundamentals of cryptocurrencies. The book mostly got that job done, and also confirmed my disinterest in the space—but now I can better explain why! It also tremendously improved my understanding of the crypto episode of Silicon Valley.
I thought I’d read this before, but apparently not… I was looking for a CSS style guide, and this contains at least a sketch of one. It also describes how to come up with and socialize coding guidelines more generally.
I wanted to much better understand how Docker works, and this helped a bit, but the e-book formatting was so annoying that I almost stopped reading. Docker has also evolved quite a bit since this was written, so I’ll have to read some more anyway.


Copyright © 2013 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved. W3C liability, trademark and document use rules apply.
CSS Transitions allows property changes in CSS values to occur smoothly over a specified duration.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
The (archived) public mailing list<EMAIL_ADDRESS>(see instructions) is preferred for discussion of this specification. When sending e-mail, please put the text “css3-transitions” in the subject, preferably like this: “[css3-transitions] …summary of comment…”
This document was produced by the CSS Working Group (part of the Style Activity).
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This document is expected to be relatively close to last call. While some issues raised have yet to be addressed, new features are extremely unlikely to be considered for this level.
This section is not normative.
This document introduces new CSS features to enable implicit transitions, which describe how CSS properties can be made to change smoothly from one value to another over a given duration.
Normally when the value of a CSS property changes, the rendered result is instantly updated, with the affected elements immediately changing from the old property value to the new property value. This section describes a way to specify transitions using new CSS properties. These properties are used to animate smoothly from the old state to the new state over time.
For example, suppose that transitions of one second have been defined
on the ‘left
’ and ‘background-color
’ properties. The following
diagram illustrates the effect of updating those properties on an element,
in this case moving it to the right and changing the background from red
to blue. This assumes other transition parameters still have their default
values.
Transitions are a presentational effect. The computed value of a property transitions over time from the old value to the new value. Therefore if a script queries the computed style of a property as it is transitioning, it will see an intermediate value that represents the current animated value of the property.
Only animatable CSS properties can be transitioned. See the table at the end of this document for a list of properties that are animatable.
The transition for a property is defined using a number of new properties. For example:
div { transition-property: opacity; transition-duration: 2s; }The above example defines a transition on the ‘
opacity
’ property that, when a new value is
assigned to it, will cause a smooth change between the old value and the
new value over a period of two seconds.Each of the transition properties accepts a comma-separated list, allowing multiple transitions to be defined, each acting on a different property. In this case, the individual transitions take their parameters from the same index in all the lists. For example:
div { transition-property: opacity, left; transition-duration: 2s, 4s; }This will cause the ‘
opacity
’ property to
transition over a period of two seconds and the left property to
transition over a period of four seconds. In the case where the lists of values in transition
properties do not have the same length, the length of the ‘transition-property
’ list determines the
number of items in each list examined when starting transitions. The lists
are matched up from the first value: excess values at the end are not
used. If one of the other properties doesn't have enough comma-separated
values to match the number of values of ‘transition-property
’, the UA must calculate
its used value by repeating the list of values until there are enough.
This truncation or repetition does not affect the computed value. Note: This is analogous to the behavior of the ‘background-*
’ properties, with ‘background-image
’ analogous to ‘transition-property
’.
div { transition-property: opacity, left, top, width; transition-duration: 2s, 1s; }The above example defines a transition on the ‘
opacity
’ property of 2 seconds duration, a
transition on the ‘left
’ property of 1
second duration, a transition on the ‘top
’
property of 2 seconds duration and a transition on the ‘width
’ property of 1 second duration.While authors can use transitions to create dynamically changing content, dynamically changing content can lead to seizures in some users. For information on how to avoid content that can lead to seizures, see Guideline 2.3: Seizures: Do not design content in a way that is known to cause seizures ([WCAG20]).
transition-property
’ Property The ‘transition-property
’ property specifies the
name of the CSS property to which the transition is applied.
| Name: | transition-property |
| Value: | none | <single-transition-property>
[ ‘, ’ <single-transition-property>
]*
|
| Initial: | all |
| Applies to: | all elements, :before and :after pseudo elements |
| Inherited: | no |
| Animatable: | no |
| Percentages: | N/A |
| Media: | visual |
| Computed value: | Same as specified value. |
| Canonical order: | per grammar |
A value of ‘none
’ means that no property
will transition. Otherwise, a list of properties to be transitioned, or
the keyword ‘all
’ which indicates that all
properties are to be transitioned, is given.
If one of the identifiers listed is not a recognized property name or
is not an animatable property, the implementation must still start
transitions on the animatable properties in the list using the duration,
delay, and timing function at their respective indices in the lists for
‘transition-duration
’, ‘transition-delay
’, and ‘transition-timing-function
’. In other words,
unrecognized or non-animatable properties must be kept in the list to
preserve the matching of indices.
The keywords ‘none
’, ‘inherit
’, and ‘initial
’ are
not permitted as items within a list of more that one identifier; any list
that uses them is syntactically invalid. In other words, the <IDENT>
production in <single-transition-property>
matches any identifier other than these three keywords.
For the keyword ‘all
’, or if one of the
identifiers listed is a shorthand property, implementations must start
transitions for any of its longhand sub-properties that are animatable
(or, for ‘all
’, all animatable properties),
using the duration, delay, and timing function at the index corresponding
to the shorthand.
If a property is specified multiple times in the value of ‘transition-property
’ (either on its own, via a
shorthand that contains it, or via the ‘all
’
value), then the transition that starts uses the duration, delay, and
timing function at the index corresponding to the last item in
the value of ‘transition-property
’ that calls for animating
that property.
Note: The ‘all
’ value and
‘all
’ shorthand property work in similar
ways, so the ‘all
’ value is just like a
shorthand that covers all properties.
transition-duration
’ Property The ‘transition-duration
’ property defines the
length of time that a transition takes.
| Name: | transition-duration |
| Value: | <time> [, <time>]* |
| Initial: | 0s |
| Applies to: | all elements, :before and :after pseudo elements |
| Inherited: | no |
| Animatable: | no |
| Percentages: | N/A |
| Media: | interactive |
| Computed value: | Same as specified value. |
| Canonical order: | per grammar |
This property specifies how long the transition from the old value to
the new value should take. By default the value is ‘0s
’, meaning that the transition is immediate (i.e.
there will be no animation). A negative value for ‘transition-duration
’ renders the declaration
invalid.
transition-timing-function
’ Property The ‘transition-timing-function
’ property describes
how the intermediate values used during a transition will be calculated.
It allows for a transition to change speed over its duration. These
effects are commonly called easing functions. In either case, a
mathematical function that provides a smooth curve is used.
Timing functions are either defined as a stepping function or a cubic Bézier curve. The timing function takes as its input the current elapsed percentage of the transition duration and outputs the percentage of the way the transition is from its start value to its end value. How this output is used is defined by the interpolation rules for the value type.
A stepping function is defined by a number that divides the domain of operation into equally sized intervals. Each subsequent interval is a equal step closer to the goal state. The function also specifies whether the change in output percentage happens at the start or end of the interval (in other words, if 0% on the input percentage is the point of initial change).
A cubic
Bézier curve is defined by four control points, P0 through
P3 (see Figure 1). P0 and P3 are always
set to (0,0) and (1,1). The ‘transition-timing-function
’ property is used
to specify the values for points P1 and P2. These
can be set to preset values using the keywords listed below, or can be set
to specific values using the ‘cubic-bezier
’
function. In the ‘cubic-bezier
’ function,
P1 and P2 are each specified by both an X and Y
value.
| Name: | transition-timing-function |
| Value: | <single-transition-timing-function>
[ ‘, ’ <single-transition-timing-function>
]*
|
| Initial: | ease |
| Applies to: | all elements, :before and :after pseudo elements |
| Inherited: | no |
| Animatable: | no |
| Percentages: | N/A |
| Media: | interactive |
| Computed value: | Same as specified value. |
| Canonical order: | per grammar |
The timing functions have the following definitions.
start
’ or ‘end
’, and
specifies the point at which the change of values occur within the
interval. If the second parameter is omitted, it is given the value
‘end
’.
transition-delay
’ Property The ‘transition-delay
’ property defines when the
transition will start. It allows a transition to begin execution some some
period of time from when it is applied. A ‘transition-delay
’ value of ‘0s
’ means the transition will execute as soon as the
property is changed. Otherwise, the value specifies an offset from the
moment the property is changed, and the transition will delay execution by
that offset.
If the value for ‘transition-delay
’ is a negative time offset
then the transition will execute the moment the property is changed, but
will appear to have begun execution at the specified offset. That is, the
transition will appear to begin part-way through its play cycle. In the
case where a transition has implied starting values and a negative ‘transition-delay
’, the starting values are
taken from the moment the property is changed.
| Name: | transition-delay |
| Value: | <time> [, <time>]* |
| Initial: | 0s |
| Applies to: | all elements, :before and :after pseudo elements |
| Inherited: | no |
| Animatable: | no |
| Percentages: | N/A |
| Media: | interactive |
| Computed value: | Same as specified value. |
| Canonical order: | per grammar |
transition
’ Shorthand Property The ‘transition
’ shorthand property combines the
four properties described above into a single property.
| Name: | transition |
| Value: | <single-transition> [
‘, ’ <single-transition> ]*
|
| Initial: | see individual properties |
| Applies to: | all elements, :before and :after pseudo elements |
| Inherited: | no |
| Animatable: | no |
| Percentages: | N/A |
| Media: | interactive |
| Computed value: | see individual properties |
| Canonical order: | per grammar |
Note that order is important within the items in this property: the first value that can be parsed as a time is assigned to the transition-duration, and the second value that can be parsed as a time is assigned to transition-delay.
If there is more than one <single-transition> in the shorthand,
and any of the transitions has ‘none
’ as the <single-transition-property>,
then the declaration is invalid.
When the computed value of an animatable property changes,
implementations must decide what transitions to start based on the values
of the ‘transition-property
’, ‘transition-duration
’, ‘transition-timing-function
’, and ‘transition-delay
’ properties at the time the
animatable property would first have its new computed value. This means
that when one of these ‘transition-*
’
properties changes at the same time as a property whose change might
transition, it is the new values of the ‘transition-*
’ properties that control the transition.
This provides a way for authors to specify different values of the
‘transition-*
’ properties for the
“forward” and “reverse” transitions (but see below for special reversing behavior when an
incomplete transition is interrupted). Authors can specify the
value of ‘transition-duration
’, ‘transition-timing-function
’, or ‘transition-delay
’ in the same rule where they
specify the value that triggers the transition, or can change these
properties at the same time as they change the property that triggers the
transition. Since it's the new values of these ‘transition-*
’ properties that affect the transition,
these values will be used for the transitions to the associated
transitioning values. For example:
li { transition: background-color linear 1s; background: blue; } li:hover { background-color: green; transition-duration: 2s; /* applies to the transition *to* the :hover state */ }
When a list item with these style rules enters the :hover state, the
computed ‘transition-duration
’ at the time that
‘background-color
’ would have its new
value (‘green
’) is ‘2s
’, so the transition from ‘blue
’ to ‘green
’ takes 2
seconds. However, when the list item leaves the :hover state, the
transition from ‘green
’ to ‘blue
’ takes 1 second.
Various things can cause the computed style of an element to change, or for an element to start or stop having computed style. (For the purposes of this specification, an element has computed style when it is in the document tree, and does not have computed style when it is not in the document tree.) These include insertion and removal of elements from the document tree (which both changes whether those elements have computed styles and can change the styles of other elements through selector matching), changes to the document tree that cause changes to which selectors match elements, changes to style sheets or style attributes, and other things. This specification does not define when computed styles are updated. However, when an implementation updates the computed style for an element to reflect one of these changes, it must update the computed style for all elements to reflect all of these changes at the same time (or at least it must be undetectable that it was done at a different time). This processing of a set of simultaneous style changes is called a style change event. (Implementations typically have a style change event to correspond with their desired screen refresh rate, and when up-to-date computed style is needed for a script API that depends on it.)
Since this specification does not define when a style change event occurs, and thus what changes to computed values are considered simultaneous, authors should be aware that changing any of the transition properties a small amount of time after making a change that might transition can result in behavior that varies between implementations, since the changes might be considered simultaneous in some implementations but not others.
When a style change event occurs, implementations must start transitions based on the computed styles that changed in that event. If an element does not have a computed style either before or after the style change event, then transitions are not started for that element in that style change event. Otherwise, define the before-change style as the computed style for the element as of the previous style change event, except with any styles derived from declarative animations such as CSS Transitions, CSS Animations ([CSS3-ANIMATIONS]), and SMIL Animations ([SMIL-ANIMATION], [SVG11]) updated to the current time. Likewise, define the after-change style as the computed style for the element based on the information known at the start of that style change event, in other words, excluding any changes resulting from CSS Transitions that start during that style change event.
This wording needs to handle already-running transitions better! Need to cancel a transition that hasn't moved yet when we're resetting to its start value! Define cancelling as not firing transition events. And point to other occurrence of cancelling in reversing section.
Note that this definition of the after-change style means that a single
change can start a transition on the same property on both an ancestor
element and its descendant element. This can happen when a property
change is inherited from one element with ‘transition-*
’ properties that say to animate the
changing property to another element with ‘transition-*
’ properties that also say to animate the
changing property.
When this happens, both transitions will run, and the transition on the descendant will override the transition on the ancestor because of the normal CSS cascading and inheritance rules ([CSS3CASCADE]).
If the transition on the descendant completes before the transition on the ancestor, the descendant will then resume inheriting the (still transitioning) value from its parent. This effect is likely not a desirable effect, but it is essentially doing what the author asked for.
For each element with a before-change
style and an after-change style, and
each property (other than shorthands) for which the before-change style is different from the
after-change style, implementations must
start transitions based on the relevant item (see the definition of ‘transition-property
’) in the computed value of
‘transition-property
’. Corresponding to this
item there is a matching transition duration, a
matching transition delay, and a matching transition
timing function in the computed values of ‘transition-duration
’, ‘transition-delay
’, and ‘transition-timing-function
’ (see the rules on matching lists). Define the combined duration of the transition as the sum
of max(matching transition duration, ‘0s
’) and
the matching transition-delay. When the combined duration is greater than
‘0s
’, then a transition starts based on the
values of the matching transition duration, the matching transition delay,
and the matching transition-timing-function; in other cases transitions do
not occur. The start time of this transition is
defined as the time of the style change
event plus the matching transition delay. The end
time of this transition is defined as the start time plus the matching transition duration.
The start value of this transition is defined as
the value of the transitioning property in the before-change style, and the end value of this transition is defined as the value of
the transitioning property in the after-change style. Except in the cases
described in the section on reversing of
transitions, the reversing-adjusted start value is
the same as the start value, and the reversing shortening factor is 1.
Once the transition of a property has started, it must continue running
based on the original timing function, duration, and delay, even if the
‘transition-timing-function
’, ‘transition-duration
’, or ‘transition-delay
’ property changes before the
transition is complete. However, if the ‘transition-property
’ property changes such
that the transition would not have started, the transition must stop (and
the property must immediately change to its final value).
Implementations must not start a transition when the computed value of a property changes as a result of declarative animation (as opposed to scripted animation).
Implementations also must not start a transition when the computed value changes because it is inherited (directly or indirectly) from another element that is transitioning the same property.
Many common transitions effects involve transitions between two states, such as the transition that occurs when the mouse pointer moves over a user interface element, and then later moves out of that element. With these effects, it is common for a running transition to be interrupted before it completes, and the property reset to the starting value of that transition. An example is a hover effect on an element, where a transition starts when the pointer enters the element, and then the pointer exits the element before the effect has completed. If the outgoing and incoming transitions are executed using their specified durations and timing functions, the resulting effect can be distractingly asymmetric because the second transition takes the full specified time to move a shortened distance. Instead, the expected behavior is that the second transition is shorter.
To meet this expectation, when a transition is started for a property on an element (henceforth, the new transition) that has a currently-running transition whose reversing-adjusted start value is the same as the end value of the new transition (henceforth, the old transition), implementations must cancel the old transition link to definition above and adjust the new transition as follows (prior to following the rules for computing the combined duration, start time, and end time):
Note that these rules do not fully address the problem for transition patterns that involve more than two states.
Note that these rules lead to the entire timing function of the new transition being used, rather than jumping into the middle of a timing function, which can create a jarring effect.
This was one of several possibilities that was considered by the working group. See the reversing demo demonstrating a number of them, leading to a working group resolution made on 2013-06-07 and edits made on 2013-11-11.
When a property on an element is undergoing a transition (that is, when or after the transition has started and before the end time of the transition) the transition adds a style to the CSS cascade at the level defined for CSS Transitions in [CSS3CASCADE].
Note that this means that computed values resulting from CSS transitions can inherit to descendants just like any other computed values. In the normal case, this means that a transition of an inherited property applies to descendant elements just as an author would expect.
Implementations must add this value to the cascade if and only if that property is not currently undergoing a CSS Animation ([CSS3-ANIMATIONS]) on the same element.
Note that this behavior of transitions not applying to the cascade when an animation on the same element and property is running does not affect whether the transition has started or ended. APIs that detect whether transitions are running (such as transition events) still report that a transition is running.
If the current time is at or before the start time of the transition (that is, during the delay phase of the transition), this value is a specified style that will compute to the start value of the transition.
If the current time is after the start time of the transition (that is, during the duration phase of the transition), this value is a specified style that will compute to the result of interpolating the property using the start value of the transition as Vstart, using the end value of the transition as Vend, and using (current time - start time) / (end time - start time) as the input to the timing function.
The completion of a CSS Transition generates a corresponding DOM Event. An event is fired for each property that undergoes a transition. This allows a content developer to perform actions that synchronize with the completion of a transition.
Each event provides the name of the property the transition is associated with as well as the duration of the transition.
The TransitionEvent
interface provides specific contextual information associated with
transitions.
[Constructor(DOMString type, optional TransitionEventInit transitionEventInitDict)] interface TransitionEvent : Event { readonly attribute DOMString propertyName; readonly attribute float elapsedTime; readonly attribute DOMString pseudoElement; }; dictionary TransitionEventInit : EventInit { DOMString propertyName = ""; float elapsedTime = 0.0; DOMString pseudoElement = ""; }
propertyName
of
type DOMString
, readonly
elapsedTime
of type
float
, readonly
transition-delay
.
pseudoElement
of
type DOMString
, readonly
TransitionEvent(type,
transitionEventInitDict)
is an event
constructor.
There is one type of transition event available.
transitionend
event
occurs at the completion of the transition. In the case where a
transition is removed before completion, such as if the
transition-property is removed, then the event will not fire.
When interpolating between two values, Vstart and Vend, interpolation is done using the output p of the timing function, which gives the portion of the value space that the interpolation has crossed. Thus the result of the interpolation is Vres = (1 - p) ⋅ Vstart + p ⋅ Vend.
However, if this value (Vres) is outside the allowed range of values for the property, then it is clamped to that range. This can occur if p is outside of the range 0 to 1, which can occur if a timing function is specified with a y1 or y2 that is outside the range 0 to 1.
The following describes how each property type undergoes transition or animation.
calc()
’ function that is the
sum of a length and a percentage (each possibly zero), and these ‘calc()
’ functions have each half interpolated as real
numbers.
visible
’, interpolated as a
discrete step where values of the timing function between 0 and 1 map to
‘visible
’ and other values of the timing
function (which occur only at the start/end of the transition or as a
result of ‘cubic-bezier()
’ functions with Y
values outside of [0, 1]) map to the closer endpoint; if neither value is
‘visible
’ then not interpolable.
inset
’ and the other is not, then the result for that
shadow matches the inputs; otherwise the entire list is not interpolable.
If the lists of shadows have different lengths, then the shorter list is
padded at the end with shadows whose color is ‘transparent
’, all lengths are ‘0
’, and whose ‘inset
’ (or
not) matches the longer list.
background-origin
’ is repeated to the
length of the ‘background-image
’ list) or
repeated infinitely will smoothly transition between any values, and so
that the computed value will properly represent the result (and
potentially be inherited correctly).
Future specifications may define additional types that can be animated.
See the definition of ‘transition-property
’ for how animation of
shorthand properties and the ‘all
’ value is
applied to any properties (in the shorthand) that can be animated.
The definition of each CSS property defines when the values of that property can be interpolated by referring to the definitions of property types in the previous section. Values are animatable when both the from and the to values of the property have the type described. (When a composite type such as "length, percentage, or calc" is listed, this means that both values must fit into that composite type.) When multiple types are listed in the form "either A or B", both values must be of the same type to be interpolable.
For properties that exist at the time this specification was developed, this specification defines whether and how they are animated. However, future CSS specifications may define additional properties, additional values for existing properties, or additional animation behavior of existing values. In order to describe new animation behaviors and to have the definition of animation behavior in a more appropriate location, future CSS specifications should include an "Animatable:" line in the summary of the property's definition (in addition to the other lines described in [CSS21], section 1.4.2). This line should say "no" to indicate that a property cannot be animated or should reference an animation behavior (which may be one of the behaviors in the Animation of property types section above, or may be a new behavior) to define how the property animates. Such definitions override those given in this specification.
The following definitions define the animation behavior for properties in CSS Level 2 Revision 1 ([CSS21]) and in Level 3 of the CSS Color Module ([CSS3COLOR]).
| Property Name | Type |
|---|---|
| background-color | as color |
| background-position | as repeatable list of simple list of length, percentage, or calc |
| border-bottom-color | as color |
| border-bottom-width | as length |
| border-left-color | as color |
| border-left-width | as length |
| border-right-color | as color |
| border-right-width | as length |
| border-spacing | as simple list of length |
| border-top-color | as color |
| border-top-width | as length |
| bottom | as length, percentage, or calc |
| clip | as rectangle |
| color | as color |
| font-size | as length |
| font-weight | as font weight |
| height | as length, percentage, or calc |
| left | as length, percentage, or calc |
| letter-spacing | as length |
| line-height | as either number or length |
| margin-bottom | as length |
| margin-left | as length |
| margin-right | as length |
| margin-top | as length |
| max-height | as length, percentage, or calc |
| max-width | as length, percentage, or calc |
| min-height | as length, percentage, or calc |
| min-width | as length, percentage, or calc |
| opacity | as number |
| outline-color | as color |
| outline-width | as length |
| padding-bottom | as length |
| padding-left | as length |
| padding-right | as length |
| padding-top | as length |
| right | as length, percentage, or calc |
| text-indent | as length, percentage, or calc |
| text-shadow | as shadow list |
| top | as length, percentage, or calc |
| vertical-align | as length |
| visibility | as visibility |
| width | as length, percentage, or calc |
| word-spacing | as length |
| z-index | as integer |
All properties defined as animatable in the SVG specification, provided they are one of the property types listed above.
The following are the substantive changes made since the Working Draft dated 12 February 2013:
transition-*
’ properties and transitionable properties
even clearer.
For more details on these changes, see the version control change logs, which are split in two parts because of a file renaming: change log since 2013 March 28, change log before 2013 March 28.
For changes in previous working drafts, see the ChangeLog, and the above version control logs.
Thanks especially to the feedback from Tab Atkins, Carine Bournez, Aryeh Gregor, Vincent Hardy, Anne van Kesteren, Cameron McCormack, Alex Mogilevsky, and all the rest of the www-style community.
| Property | Values | Initial | Applies to | Inh. | Percentages | Media |
|---|---|---|---|---|---|---|
| transition | <single-transition> [ ‘,’ <single-transition> ]* | see individual properties | all elements, :before and :after pseudo elements | no | N/A | interactive |
| transition-delay | <time> [, <time>]* | 0s | all elements, :before and :after pseudo elements | no | N/A | interactive |
| transition-duration | <time> [, <time>]* | 0s | all elements, :before and :after pseudo elements | no | N/A | interactive |
| transition-property | none | <single-transition-property> [ ‘,’ <single-transition-property> ]* | all | all elements, :before and :after pseudo elements | no | N/A | visual |
| transition-timing-function | <single-transition-timing-function> [ ‘,’ <single-transition-timing-function> ]* | ease | all elements, :before and :after pseudo elements | no | N/A | interactive |


Welcome to the CGI Web UI
redirecting to main page...
Javascript is not enabled..
Please enable javascript in your browser.


A New Joseph Problem
问题描述 :
Newman and Bamboo are good friends.  They stand clockwise according to their numbers (namely 1, 2, 3, 4, …, N). Then, starting from 1, the killer kills every 2nd person he counts until there is only one person left whose number is J(N). We can easily infer that J(1) = 1, J(5) = 3 and J(6) = 5. Bamboo finds this problem intriguing and starts thinking. Suddenly, he finds that if he continually uses J(N) to be the term in J, he can finally get a fixed number. For example, J(2) = 1, so J(J(2)) = 1, J(J(…J(2)…)) = 1. Newman agrees with Bamboo but Bamboo is not satisfied. Furthermore, Bamboo wants to know what the fixed number will be for a specific N. Can you help us?
输入:
Only one line containing n (1 ≤ n ≤ 1010000).
输出:
Only one line containing K such that J(J(J(J…J(N)…))) = K and J(K)=K.
样例输入:
10
样例输出:
3
温馨提示:
J(10) = 5, J(5) = 3, J(3) = 3.
解题代码:
//* @author import java.io.*; import java.util.*; import java.math.*; public class Main { public static int a[]; public static int luckpeople(int n) { if(n==1) return 1; if(n%2==1) return luckpeople((n-1)/2)*2+1; else return luckpeople(n/2)*2-1; } public static int fun(int n) { int b; while(true) { b=a[n]; if(b==n) return b; n=b; } } public static void main(String[] args) { int i,count; //a = new int[110]; //for(i=1;i<=100;i++) //System.out.println(luckpeople(i)); //a[i]=luckpeople(i); //for(i=1;i<=100;i++) //System.out.println(fun(i)); BigInteger n,ans; String s; Scanner cin = new Scanner (System.in); while(cin.hasNext()) { n = cin.nextBigInteger(); s = n.toString(2); count = 0; for(i=0;i< s.length();i++) if(s.charAt(i)=='1') count++; ans=BigInteger.valueOf(2); ans = ans.pow(count); ans = ans.subtract(BigInteger.ONE); System.out.println(ans); } } }
不错，赞一个！
很好的题，还是能做出几道的，嘿嘿
DFS方法的原理还是不太清楚啊
正在练习，很有帮助
写的好····· Pollard Rh
very good solutions.
#!/usr/bin/env python def cou(n): arr = [1]
很强大啊，佩服
多谢支持！
清华也会出这么无聊的题
L（X [0 .. M-1]，Y [0 .. N-1]）= 1 + L（X [0 .. M-2]，Y [0 .. N-1]）这个地方也也有笔误
应改为L（X [0 .. M-1]，Y [0 .. N-1]）= 1 + L（X [0 .. M-2]，Y [0 .. N-2]）
分析的很详细！赞一个
正解，已改正。应该都是protected


iOS
The recommended way to use tangram-es in an iOS project is to add it as a CocoaPods dependency. The library is hosted in CocoaPods under the pod name ‘Tangram-es’. To find the latest version, check CocoaPods: https://cocoapods.org/pods/Tangram-es.
Setup
This project uses CMake (minimum version 3.0), you can download it here or use your favorite installation package tool like homebrew.
brew install cmake
Make sure to update git submodules before you build:
git submodule update --init
You can optionally install xcpretty to produce much prettier and more legible output during the build process:
gem install xcpretty
Build
Building the iOS demo application requires Xcode 8.0 or newer. From the root directory of the project, run:
make ios
You can optionally append DEBUG=1
or RELEASE=1
to choose the build type.
This will generate an Xcode project that you can use to deploy on device or simulator:
open build/ios/tangram.xcodeproj
Make sure to set up the code signing identity and code sign the framework on copy (select target tangram > Build Phases > Copy Files > TangramMap.framework > Code Sign On Copy).
Note on Code Signing and Provisioning Profiles:
* For Simulator: Does not need any code signing identity, so you can ignore any provionining profile failures on target tangram > General > Signing.
* For Device: You will have to modify the Bundle Identifier under target tangram > General > Identity > Bundle Identifier, to something other than com.mapzen.tangram
, since this needs to be unique.
For development, you can use the Makefile option TANGRAM_IOS_FRAMEWORK_SLIM
to build for simulator only and faster your build times.
iOS Binary Framework
An iOS binary framework bundle targeted for ARM architectures can be produced by running the following:
make ios-framework
The framework will be output in ‘/build/ios-framework/lib/’, in a folder named ‘release’ or ‘debug’ according to the build type.
To build a universal binary working on both device and simulator architectures run the following:
make ios-framework-universal
The universal framework will be output in ‘/build/ios-framework-universal/’, in a folder named ‘release’ or ‘debug’ according to the build type.


--- layout: post title: Dashboard Rabbitmq Access Public author: Galuh D Wijatmiko categories: [Server,MessageBroker] tags: [Server,Service] ---
rabbitmqctl add_user tamu tamu
rabbitmqctl set_permissions -p / tamu ".*" ".*" ".*"
rabbitmqctl set_user_tags tamu administrator


{include file='public/head_css' /} {include file='public/head_js' /} {include file='auth/login_bg' /}
请输入账号密码进行登录


Overview • User interface • Special tasks ↑ | ↓
The P-31 Mims ENDOR window is intended for the following tasks:
Furthermore, the structure with the paramagnetic center must have phosphorous atoms in it or a bilayer must be defined in this structure (see how to build a bilayer). The ENDOR window will open even if this is not the case, but all distance distributions and simulated spectra will be flat lines.
The sites of the electron spin is selected in the Labels & selected atoms
list box, where all spin labels and selected atoms are listed in MMM's address format.
The first tag in square brackets is the structure tag (often a PDB identifier), the second tag in parentheses the chain identifier, the number in curly brackets a number of the coordinate set (usually always 1, except for NMR structures) and the last number without any brackets the residue number.
For selected atoms, the address is followed by a semi-colon and the residue name. The selected paramagnetic center is displayed in the Spin syste
panel and its position
in current Cartesian coordinates of the structure is shown below the listbox. If a bilayer is defined, the bilayer central plane is the xy plane (last coordinate zero).
Thus, the last coordinate is the distance from the bilayer central plane. For spin labels, the coordinates given are mean coordinates of the N-O bond midpoints of all rotamers.
Note that paramagnetic centers other than spin labels are defined by the location(s) of a single atom. Centers of spin density that are defined by several atoms are not supported in this version. If the selected atom has several alternate locations, all locations will contribute to the distance distribution.
The subset of phosphorous nuclei is selected by radiobuttons in the P-31 nuclei
subpanel of the Spin system
panel.
Selection molecule
considers only "structural" phosphorous, even if a bilayer model is present. Selection bilayer
considers only phosphorous from an MMM bilayer model.
Selection both
considers all phosphorous nuclei. This is the default.
The current lipid bilayer is the DPPC model of Kucerka et al. (N. Kucerka et al., Biophys. J. 2008, 95, 2356-2367) with scaling of the bilayer thickness, aumming a thickness of 35 Å for the DPPC model. The model is defined as a 3D grid of phosphorous locations with spacing of 0.5 Å. All positions within 25 Å are considered. Fractional P-31 populations at these positions are computed from the z-profile (along the bilayer normal) of phosphocholine groups (tag PCN) in the DPPC model. Fractional population is zero for positions within the protein slabs. Protein slabs are computed on a 2D xy grid with 0.2 Å spacing by computing potential collisions with protein atoms at a certain xi, yi coordinate. Lennard-Jones interaction energies (only repulsive part) are computed separately for the top and bottom monolayer by summing over all protein atoms in the z-range of the monolayer, which extends from z=0 to z±d/2, where d is the bilayer thickness. The lipid population at this xi, yi coordinate is computed as a Boltzmann population at 293 K. Populations below 0.05 are assumed to be zero. Holes in the upper and lower monolayer protein slabs are filled, as lipid molecules are not expected to insert into such holes (sometimes they do, but they may then be resolved in the crystal structure).
Only positions with z-profile population larger than 1% are considered in the final model. Typically, these are between 10'000 and 100'000 positions. The populations are scaled so that the integral over a slab of monolayer unblocked by protein with an area equal to the area-per-lipid for DPPC is unity.
Experimental data can be loaded directly in Bruker's Xepr (EleXsys) format via the Load Xepr
button.
A Mims ENDOR spectrum with a frequency axis in MHz is expected. The static field read from the .DSC
file is used to
compute an inital estimate of the P-31 Zeeman frequency. Only the real part of the spectral intensities is considered. It is assumed that zero amplitude corresponds to zero stimulated echo
and stimulated echo amplitude for an off-resonant r.f. pulse is positive. Hence, ENDOR peaks correspond to a decrease in positive spectral intensity.
If in doubt, ask us about a suitable PulseSPEL program.
Data in a generic ASCII format can be read via the Load ASCII
button. The first column must define a frequency axis in MHz, the second column real spectral intensities.
Experimental ENDOR baselines (off-resonant intensities) may not be completely flat. MMM corrects for this on loading data, by assuming that the first and last 10% of data points are baseline (you should measure spectra with at least that much baseline). The first 2.5% of data points are neglected, as baseline may be spoiled here due to thermal effects. Baseline correction is done by fitting al polynomial function to the baseline ranges, extrapolating this function over the whole frequency axis, and dividing the spectrum by this function. This also normalizes baseline intensity to unity. The default baseline polynomial order is 0 (flat line). Polynomial order can be increased up to 5, but note that values above 2 indicate that something is wrong with the spectrum.
Use the <
and >
buttons or direct input into the edit field to adapt polynomial order. Display of the experimental spectrum changes automatically.
The distance distribution is automatically recomputed when you cahnge selection of the paramagnetic center or of the contributing P-31 nuclei. Computation may take long if a bilayer is present and the distance distribution for the selected paramagnetic center was not computed before.
The distance distribution due to structural phosphorous is displayed in blue, the one due to phosphorous from the lipid bilayer in green, and the sum distribution in red. Often you may see only the red line, as one of the contributions may be totally missing or be insignificant.
Display range can be adapted and the plot detached in a separate Matlab window for copying, printing, and further inspection using the corresponding user interface elements in the
Distance distribution
panel.
Conversion from the distance distribution to the Mims ENDOR spectrum depends on the first interpulse delay τ (tau) of the stimulated echo sequence (blind spot behavior)
and on the length of the radiofrequency pulse (power broadening). MMM does not read these values from the .DSC
file. You need to input them directly into the
corresponding edit fields, if simulation needs to match experiment. Sensible default values of τ=600 ns and tr.f.= 10 μs are given.
Matching experiment also requires that the center frequency (P-31 Zeeman frequency) of the experimental spectrum is known. When loading Xepr data, this frequency
is computed from the magnetic field. Note however that the magnetic field is measured by a Hall probe with limited precision and calibration may be surprisingly poor,
as the Hall probe in pulse EPR spectrometers is located far from the magnet center. In many cases, you are better off by checking the Fit center frq.
checkbox.
This is not the default, as it may fail spectacularly if the experimental and simulated distance distributions do not match. The center frequency can also be input manually.
The experimental spectrum as displayed in the plot should be as symmetric as possible with respect to zero frequncy offset (f-f0
).
The maximum ENDOR effect (strongest decrease of stimulated echo intensity in percent) is displayed as it provides a fast estimate of P-31 proximity to the paramagnetic center. Furthermore the full width at 1.5% signal reduction is displayed if the maximum signal reduction is at least 1.5%.
Both plots can be detached as separate Matlab figures via the corresponding Detach
buttons. Use the figure menu to copy or plot (or edit) them.
The Save
button in the left bottom corner of the window can be used to save the simulated data in text (ASCII) format,
similar to the output format of DeerAnalysis. In any case the three files *_res.txt
, *_distr.dat
and *_spc.dat
are written,
where * stands for the basis file name that can be given in a file dialog window. The file *_res.txt
contains information on simulation and fit parameters,
the file *_distr.dat
the distance distribution and the file *_fit.dat
the form factor.
The contents of file *_res.txt
are self-explaining.
In file *_distr.dat
the first column is the distance axis in units of Angstroem. The second column is the predicted distance distribution. The distance range extends from 0 to 25 Å.
In file *_spc.dat
the first column is the frequency offset axis in kHz. The second column is the simulated spectrum.
A third file *_fit.dat
exists if and only if experimental data were loaded. This file contains in the first column the frequency offset axis in kHz,
in the second column the normalized, baseline corrected and center-frequency shifted experimental data, and in the third column the simulated spectrum interpolated to the frequency axis increment of the experimental spectrum.


Install Bubble Anticheat
- First off, download Skript
- Now install SkUtilities
- Restart your Server (don’t reload)
- Download the latest release of Bubble Reborn to plugins/Skript/scripts/getbubble.sk
- Restart your server. Bubble will install itself and restart your server when its done.
IMPORTANT: MineHut:
If you are on Minehut, first off, move to a proper hosting company. If this is
not possible, download this Minehut compatible release:
Bubble Reborn for MineHut
You could also use Sanction Anticheat (legacy) Click Here.
Advanced Setup:
The default perms (these are customizable in plugins/bubble/config.yml)
manage: “bubble.manage” Bypass: “bubble.bypass” CaptchaBypass: “bubble.captcha.bypass” GUI: “bubble.gui” Notify: “bubble.notify” PerformanceRun: “bubble.performance” Player: “bubble.player” ReportSend: “bubble.report.send” ReportReceive: “bubble.staff.report.receive” Status: “bubble.player.status” Theme: “bubble.theme”
Setting up Autoban/Autokick:
- Open plugins/bubble/config.yml.
- Locate the “cheat” category
- Enable your the automated actions you want.
- If you use Autoban, customize it in the “ban” category.
Enabling Captcha
- Open plugins/bubble/config.yml.
- Locate the “Bot Prevention” category
- Change “Captcha” to true
- Customize any other settings to your needs.
Need a better Bans Plugin? Get 10% off Admin Bans Today with Promo Code BUBBLE10


Lectures on Ten British Mathematicians
by
Alexander MacFarlane
Lectures on Ten British Mathematicians is a collection of biographies about famous mathematicians from the 19th century.
The Light Princess
by
George MacDonald
A princess is cursed to have no gravity.
A Lincoln Anthology
by
FCIT
Abraham Lincoln lived and served during a time of conflict and change. This collection brings together a few interesting depictions of the sixteenth…
Little Bear at Work and at…
by
Frances Margaret Fox
Little Bear at Work and at Play is about the adventures of Little Bear and his friends.
The Little Lame Prince
by
Maria Dinah Mulock Craik
The Little Lame Prince and his Travelling Cloak (often published under its shorter title The Little Lame Prince) is a story for children…
A Little Princess
by
Frances Hodgson Burnett
Sara Crewe is left in the care of Miss Minchin's Seminary when her father departs for India.
Little Women
by
Louisa May Alcott
Little Women concerns the lives and loves of four sisters growing up during the American Civil War. It was based on Alcott's own…
Logic: Deductive and Inductive
by
Carveth Read, M.A.
Logic: Deductive and Inductive is a math treatise by the British logician and mathematician Carveth Read.
Lyrics of Love and Laughter
by
Paul Laurence Dunbar
This is a collection of poetry by African American author Paul Laurence Dunbar. Dunbar's work frequently features a conversational tone, innovative rhetorical structure,…
Lyrics of Love and Sorrow
by
Paul Laurence Dunbar
This is a collection of poetry by African American author Paul Laurence Dunbar. Dunbar's work frequently features a conversational tone, innovative rhetorical structure,…
Lyrics of Lowly Life
by
Paul Laurence Dunbar
This is a collection of poetry by African American author Paul Laurence Dunbar. Dunbar's work frequently features a conversational tone, innovative rhetorical structure,…
Lyrics of Sunshine and Shadow
by
Paul Laurence Dunbar
This is a collection of poetry by African American author Paul Laurence Dunbar. Dunbar's work frequently features a conversational tone, innovative rhetorical structure,…
Lyrics of the Hearthside
by
Paul Laurence Dunbar
This is a collection of poetry by African American author Paul Laurence Dunbar.


All Tables
Entry Lookup
Key
Lookup
Get Erlang Code
Help
Query for entries matching a pattern
Match object Ex. {123, '_', ...
Query
Get Erlang Code
Help
Query for entries with conditions
Match Ex. {[$5,$5,$5,$- |'$1'],'$2'}
Query
Get Erlang Code
Help
Select Query
fun with 1 arg Ex. fun({M,N}) when N > 3 -> M end
Query
Get Erlang Code
Help
Get entries
Results per page
3
20
50
100
500
Next Results
Toggle Entries/JSON
Continuation:
Data type:
ETS table entries/JSON


Home
Blog
Photos
Photo by Alena Koval from Pexels
Photo by wannapha062
Photo by Deva Darshan from Pexels
Photo by Fancycrave from Pexels


FEM Interface Module¶
This module contains a basic environment for conducting finite element analysis.
The primary purpose of this library is to fascilitate the creation of a FEM within the AeroComBAT package.
| SUMARRY OF THE CLASSES: | |
|---|---|
- Model: The Model class has two main purposes. The first is that it is meant
to serve as an organizational class. Once an aircraft part has been loaded into the model by using the addAircraftPart() method, the aircraft part can be loaded and constrained by the user. Once all parts have been loaded into the model and all loads and constraints have been applied, the user can choose to execute the plotRigidModel() method to visualize the model and make sure it accurately represents their problem. If the model appears as it should, the user can elect to run a static, buckling, normal mode, static aeroelastic, or dynamic flutter analysis.
- LoadSet: This class is used to fascilitate the created of many loads that
cal be individually applied to a finite element model. Typically this class is not explicitly used. Instead the are created by the applyLoads method of the Model class.
- FlutterPoint: Primarily as a way to fascilitate the interpolation of
flutter results generated from the flutterAnalysis method of Model.
Note
Currently the only avaliable part in the AeroComBAT package are wing parts, however this is likely to change as parts such as masses, fuselages and other types of aircraft parts are added.
MODEL¶
-
class
AeroComBAT.FEM.
Model
[source]¶ Creates a Model which is used to organize and analyze FEM.
The primary used of Model objects are to organize FEM’s and analyze them. The Model object doesn’t create any finite elements. Instead, it loads aircraft parts which contain various types of finite element structural models as well as aerodynamic models. The type of model will depend on the type of aircraft part added. Once all of the models are created and added to the model object, the model object will serve as the analysis primary interface used to manipulate the generated model.
Attributes: Kg (DOFxDOF np.array[float]): This is the global stiffness matrix.
- Kgr ((DOF-CON)x(DOF-CON) np.array[float]): This is the global reduced
stiffness matrix. In other words, the global stiffness matrix with the rows and columns corresponding to the constraints (CON) removed.
Fg (DOFx1 np.array[float]): The global force vector.
- Fgr ((DOF-CON)x1 np.array[float]): The global reduced force vector. In
other words, the global force vector with the rows corresponding to the constraints (CON) removed.
Mg (DOFxDOF np.array[float]): The global mass matrix.
- Mgr ((DOF-CON)x(DOF-CON) np.array[float]): The global reduced mass
matrix. In other words, the global mass matrix with the rows and columns corresponding to the constraints (CON) removed.
- Qg (DOFx1 np.array[float]): The global force boundary condition vector.
This is where all of the nodal loads are stored before the system is assembled.
- nids (Array[int]): This array contains all of the node IDs used within
the model.
- nodeDict (dict[NID,node]): This dictionary is a mapping of the node IDs
used within the model to the corresponding node objects.
- elems (Array[obj]): This array contains all of the element objects used
in the model.
- const (dict[NID,Array[DOF]): This dictionary is a mapping of the node
IDs constrained and the corresponding degrees of freedom that are constrained.
- parts (dict[PID, part]): This dictionary is a mapping of part ID’s
(PID) and the aircraft part objects that are added to the model. Currently the only suported parts are wings.
- loads (dict[LID,int]): This dictionary is a mapping of the load ID
(LID) and the load set objects.
- aeroBox (dict[PANID,panel]): This dictionary is a mapping of the
aerodynamic panel ID’s (PANID) and the aerodynamic panel objects used in the flutter analysis.
- SuperBeams (array[obj]): This array contains all of the superbeam’s
added to the model through addElements. In otherwords, this superbeam object is without an associated part.
- u (dict[str,1xDOF np.array[float]]): This dictionary maps analysis
names to displacement results for a static analysis.
- freqs (1x(DOF-CON) np.array[float]): This is a 1D array which holds the
frequencies of a normal modes analysis.
Methods: addElements: A method to add individual elements to the model.
- addAircraftParts: A method to add an Aircraft part to the model. This
is a much more effective method than addElements as when a part is added, the model can utilize all of the organizational and post processing methods built into the part.
- resetPointLoads: A convenient way to reset all of the nodal loads in
the model to zero.
- resetResults: A convenient way to clear the results in all of the
elements from a previous analysis. This method is subject to change as the way in which results are stored is likely to change.
- applyLoads: A method to apply nodal loads as well as distributed loads
to a range of elements, all of the elements in a part, or all of the elements in the model.
applyConstraints: A method to apply nodal constraints to the model.
staticAnalysis: A method which conducts a linear static analysis.
- normalModesAnalysis: A method which conducts a normal modes analysis on
the model.
- flutterAnalysis: A method which conducts a linearized flutter pk-method
analysis on the model.
plotRigidModel: A method to plot and visualize the model.
- plotDeformedModel: A method to plot and visualize the results from an
analysis on the model.
-
addAircraftParts
(parts)[source]¶ A method to add an array of aircraft parts to the model.
This method is a more robust version of addElements. Provided an array of part objects, this method will add the parts to the model. This includes adding all of the elements and nodes to the model, as well as a few other pieces of information. In addition, if a wing has aerodynamic panels associated with it, these will also be added to the model.
Args: - parts (Array[obj]): An array of part objects.
Returns: - None
-
addElements
(elemarray)[source]¶ A method to add elements to the model.
Provided an array of elements, this method can add those elements to the model for analysis. This is a rather rudementary method as the post processing methods utilized by the parts are not at the users disposal for the elements added to the model in this way.
Args: - elemarray (Array[obj]): Adds all of the elements in the array to
the model.
Returns: - None
Note
Currently supported elements include: SuperBeam, Tbeam.
-
applyConstraints
(NID, const)[source]¶ A method for applying nodal constraints to the model.
This method is the primary method for applying nodal constraints to the model.
Args: NID (int): The node ID of the node to be constrained.
- const (str, np.array[int]): const can either take the form of a
string in order to take advantage of the two most common constraints being ‘pin’ or ‘fix’. If a different constraint needs to be applied, const could also be a numpy array listing the DOF (integers 1-6) to be constrained.
Returns: - None
Note
When constraining nodes, only 0 displacement and rotation
constraints are currently supported.
-
applyLoads
(LID, **kwargs)[source]¶ A method to apply nodal and distributed loads to the model.
This method allows the user to apply nodal loads to nodes and distributed loads to elements within the model.
Args: - f (func): A function which, provided the provided a length 3 numpy
array representing a point in space, calculates the distributed load value at that point. See an example below:
- F (dict[NID,1x6 np.array[float]]): A dictionary mapping a node ID
to the loads to be applied at that node ID.
- allElems (bool): A boolean value used to easily load all of the
elements which have been added to the model.
- PIDs (Array[int]): An array containing part ID’s, signifying that
all elements used by that part should be loaded.
- eids (Array[int]): An array containing all of the element ID’s
corresponding to all of the elements which should be loaded.
Returns: - None
Distributed load function example:
def f(x): vx = (1/10)*10*x[2]**2-7*x[2]-2.1 vy = 10*x[2]**2-7*x[2] pz = 0 mx = 0 my = 0 tz = (10*x[2]**2-7*x[2])/10+3*x[0]**2 return np.array([vx,vy,pz,mx,my,tz])
Nodal load dictionary example:
F[NID] = np.array([Qx,Qy,P,Mx,My,T])
-
flutterAnalysis
(U_vec, kr_vec, M_vec, b, rho_0, nModes, **kwargs)[source]¶ Conducts a flutter analysis.
This method calculates the flutter modes and damping provided velocities, reduced frequencies, Mach numbers, and the reference semi-chord.
Args: - U_vec (1xN np.array[float]): A vector of trial velocities where the
damping and frequency of all of the respective mode shapes will be calculated.
- kr_vec (1xM np.array[float]): A vector of reduced frequencies for
which the AIC’s will be calculated. The minimum possible value can be 0.
- M_vec (1xM np.array[float]): A vector of mach numbers at which the
AIC’s will be calculated. Currently interpolating results by Mach number aren’t possible. As such, select mach numbers to be close to the suspected instability.
b (float): The reference semi-chord.
rho_0 (float): The reference density at sea level.
- nmodes (int): The number of modes to be considered for the flutter
analysis. For a composite cantilevered wing, 6 modes should usually be sufficient.
- g (float): A proportional structural damping term. Acceptable
ranges of g can be approximated between 0. and 0.05.
- symxz (bool): A boolean value indicating whether the aerodynamics
should be mirrored over the xz-plane.
- rho_rat (1xN np.array[float]): An array of density ratios to allow
for flutter calculations at different altitudes.
- analysis_name (str): The string name to be associated with this
analysis. By default, this is chosen to be ‘analysis_untitled’.
Returns: - None
Note
Currently static aeroelastic instability (divergence) cannot
be captured by AeroComBAT.
-
normalModesAnalysis
(**kwargs)[source]¶ Conducts normal mode analysis.
This method conducts normal mode analysis on the model. This will calculate all of the unknown frequency eigenvalues and eigenvectors for the model, which can be plotted later.
Args: - analysis_name (str): The string name to be associated with this
analysis. By default, this is chosen to be ‘analysis_untitled’.
Returns: - None
Note
There are internal loads that are calculated and stored within the model elements, however be aware that these loads are meaningless and are only retained as a means to display cross section warping.
-
plotDeformedModel
(**kwargs)[source]¶ Plots the deformed model.
This method plots the deformed model results for a given analysis in the mayavi environement.
Args: analysis_name (str): The string identifier of the analysis.
- figName (str): The name of the figure. This is ‘Rigid Model’ by
default.
- clr (1x3 tuple(int)): The color tuple or RGB values to be used for
plotting the reference axis for all beam elements. By default this color is black.
- numXSects (int): The number of cross-sections desired to be plotted
for all wing sections. The default is 2.
- contour (str): A string keyword to determine what analysis should
be plotted.
- contLim (1x2 Array[float]): An array containing the lower and upper
contour limits.
- warpScale (float): The scaling factor used to magnify the cross
section warping displacement factor.
- displScale (float): The scaling fator used to magnify the beam
element displacements and rotations.
- mode (int): If the analysis name refers to a modal analysis, mode
refers to which mode from that analysis should be plotted.
Returns: - mayavi figure
-
plotRigidModel
(**kwargs)[source]¶ Plots the rigid model.
This method plots the rigid model in the mayavi environement.
Args: - figName (str): The name of the figure. This is ‘Rigid Model’ by
default.
- clr (1x3 tuple(int)): The color tuple or RGB values to be used for
plotting the reference axis for all beam elements. By default this color is black.
- numXSects (int): The number of cross-sections desired to be plotted
for all wing sections. The default is 2.
Returns: - mayavi figure
-
resetPointLoads
()[source]¶ A method to reset the point loads applied to the model.
This is a good method to reset the nodal loads applied to a model. This method will be useful when attempting to apply a series different analysis.
Args: - None
Returns: - None
-
resetResults
()[source]¶ A method to reset the results in a model.
This is a good method to reset the results in the model from a given analysis. This method will be useful when attempting to apply a series different analysis.
Args: - None
Returns: - None
-
staticAnalysis
(LID, **kwargs)[source]¶ Linear static analysis.
This method conducts a linear static analysis on the model. This will calculate all of the unknown displacements in the model, and save not only dispalcements, but also internal forces and moments in all of the beam elements.
Args: - LID (int): The ID corresponding to the load set to be applied to
the model.
- analysis_name (str): The string name to be associated with this
analysis. By default, this is chosen to be ‘analysis_untitled’.
Returns: - None
LOAD SET¶
-
class
AeroComBAT.FEM.
LoadSet
(LID)[source]¶ Creates a Model which is used to organize and analyze FEM.
The primary use of LoadSet is to fascilitate the application of many different complex loads to a finite element model.
Attributes: LID (int): The integer identifier for the load set object.
- pointLoads (dict[pointLoads[NID,F]): A dictionary mapping applied point
loads to the node ID’s of the node where the load is applied.
- distributedLoads (dict[EID,f]): A dictionary mapping the distributed
load vector to the element ID of the element where the load is applied.
Methods: - __init__: The constructor of the class. This method initializes the
dictionaries used by the loads
addPointLoad: Adds point loads to the pointLoads dictionary attribute.
- addDictibutedLoad: Adds distributed loads to the distributedLoads
dictionary attribute.
FLUTTER POINT¶
-
class
AeroComBAT.FEM.
FlutterPoint
(FPID, U_vec, nModes)[source]¶ Creates a flutter point object.
The primary purpose for the flutter point class is to allow for easier post processing of the data from the flutter modes.
Attributes: - FPID (int): The integer identifier associated with the flutter point
object.
- U_vec (1xN np.array[float]): A vector of the velocities where the
flutter point frequency and damping have been solved.
- omegaAeroDict(dict[U,array[float]): This dictionary maps velocities to
the aerodynamic frequencies used to generate the AIC matricies.
- omegaRootDict(dict[U,array[float]): This dictionary maps velocities to
the root frequencies of the flutter mode solution for particular reduced frequencies.
- gammaDict(dict[U,array[float]): This dictionary maps velocities to
the root damping of the flutter mode solution for particular reduced frequencies.
- gammaDict(dict[U,array[float]): This dictionary maps velocities to
the root mode shape of the flutter mode solution for particular reduced frequencies.
- omega (array[float]): An array of floats which are the
flutter mode frequencies corresponding to the velocities in U_vec.
- gamma (array[float]): An array of floats which are the
flutter mode damping values corresponding to the velocities in U_vec.
- shape (array[MxN np.array[float]]): An MxL numpy array which
contain the eigenvector solutions of the flutter mode. The values in the eigenvectors are the coefficient weighting factors for the normal mode shapes.
Methods: - __init__: The constructor of the class. This method initializes the
attributes of the model, as well as the flutter
- saveSol: Saves solutions to the flutter equation for the particular
mode.
- interpOmegaRoot: Interpolates the flutter mode frequency, damping and
mode shapes for the different velocities.
-
__init__
(FPID, U_vec, nModes)[source]¶ Creates a flutter point object.
This is the constructor for the flutter point object.
Args: FPID (int): The integer ID linked with the flutter point object.
- U_vec (1xN np.array[float]): An array of velocities where the
flutter problem will be solved.
- nModes (int): The number of modes that are used for the flutter
solution.
Returns: - None
-
interpOmegaRoot
()[source]¶ Interpolates correct dynamic frequencies and damping.
From the data saved using the saveSol method, this method interpolates the correct dynamic frequencies and damping for the different flutter velocities.
Args: - None
Returns: - None
-
saveSol
(U, omega_aero, omega_root, gamma_root, shape)[source]¶ Saves data from the flutter solutions.
This method saves the damping, frequencies and mode shapes for the different flutter velocities and reduced frequencies.
Args: U (float): The flutter velocity of the data.
- omega_aero (float): The aerodynamic frequency corresponding to the
reduced frequency.
- omega_root (float): The root frequency corresponding to the
flutter solution of the particular aerodynamic frequency.
gamma_root (float): The root damping of the flutter solution
- shape (1xM np.array[float]): The mode shape of the flutter
solution.
Returns: - None


This page shows automated results of the kappa-Cygnids 2010, based on visual observations reported by citizen scientists through the report form of the International Meteor Organization (IMO). The information on this page is generated automatically; for scientific use please refer to manual analyses published in scientific journals (such as WGN). Send your feedback regarding this page to Geert Barentsen.
Page contents:
Note that the data will finally go into the Visual Meteor Database (VMDB) with manual inspection and rectifications. We are curretly completing the files of 2008-2011. The VMDB is an enormous project - any help will be greatly appreciated.
Page generated: 2015 November 4 at 12:38 UTC.
The graph below shows the ZHR (Zenithal Hourly Rate), which is the number of meteors an observer would see under a very dark sky with the radiant of the shower in zenith.
ZHRmax = 2.5 based on 840 kappa-Cygnids reported in 2275 intervals, assuming population index r = 2.5
| Time (UTC) | Solarlon | nINT | nKCG | ZHR | Particle density | |
|---|---|---|---|---|---|---|
| 2010-08-12 07:18 | 139.348 | 415 | 100 | 1.4 | ±0.1 | 8 / 109·km3 |
| 2010-08-12 22:34 | 139.959 | 798 | 241 | 1.9 | ±0.1 | 11 / 109·km3 |
| 2010-08-13 03:51 | 140.170 | 393 | 100 | 1.9 | ±0.2 | 11 / 109·km3 |
| 2010-08-13 22:03 | 140.898 | 217 | 102 | 2.1 | ±0.2 | 12 / 109·km3 |
| 2010-08-14 07:59 | 141.296 | 198 | 101 | 1.8 | ±0.2 | 10 / 109·km3 |
| 2010-08-15 06:21 | 142.191 | 80 | 44 | 1.5 | ±0.2 | 8 / 109·km3 |
| 2010-08-16 06:48 | 143.170 | 32 | 25 | 2.1 | ±0.4 | 12 / 109·km3 |
| 2010-08-17 05:37 | 144.085 | 44 | 32 | 2.1 | ±0.4 | 12 / 109·km3 |
| 2010-08-18 06:02 | 145.062 | 44 | 35 | 1.8 | ±0.3 | 10 / 109·km3 |
| 2010-08-19 07:30 | 146.083 | 22 | 29 | 2.1 | ±0.4 | 12 / 109·km3 |
| 2010-08-20 08:33 | 147.088 | 32 | 31 | 2.5 | ±0.4 | 14 / 109·km3 |
The reported intervals are automatically added together into the bins shown above, based on the number of meteors and the distribution of the intervals. For each bin, the following parameters are computed:
Data has been received from 130 observers in 23 countries. Thank you for your efforts!
Note: click on the map for an interactive version.
| Observer | Country | Teff | nKCG |
|---|---|---|---|
| Tomasz Adam | Poland | 5.50h | 11 |
| Salvador Aguirre | Mexico | 10.32h | 15 |
| Mina Alizadeh | Iran | 1.92h | 5 |
| Rainer Arlt | Germany | 1.63h | 0 |
| Pierre Bader | Germany | 6.28h | 7 |
| János Bakos | Hungary | 8.07h | 22 |
| Ricardas Balciunas | Lithuania | 2.66h | 2 |
| Manca Behric | Slovenia | 5.14h | 10 |
| Zsombor Békési | Hungary | 8.02h | 19 |
| Orlando Benitez Sanchez | Spain | 7.55h | 11 |
| Felix Bettonvil | Netherlands | 5.77h | 7 |
| Jean-marie Biets | Belgium | 5.16h | 8 |
| Frederick Bove | Belgium | 1.86h | 0 |
| Emil Brezina | Czech Republic | 3.26h | 2 |
| Andreas Buchmann | Switzerland | 6.17h | 10 |
| Jakub Cerny | Czech Republic | 4.53h | 2 |
| Simiao Cheng | China | 3.44h | 2 |
| Marcin Chwala | Poland | 15.33h | 15 |
| Primoz Cigler | Slovenia | 1.71h | 4 |
| Mark Davis | United States | 3.63h | 0 |
| Goedele Deconinck | Belgium | 2.42h | 5 |
| Sietse Dijkstra | Netherlands | 8.28h | 4 |
| Todor Dimitrov | Bulgaria | 2.98h | 11 |
| Dariusz Dorosz | Poland | 1.67h | 1 |
| Audrius Dubietis | Lithuania | 4.75h | 5 |
| Garry Dymond | Canada | 1.58h | 2 |
| Elena Evdokimova | Russia | 3.02h | 3 |
| Svetlana Evdokimova | Russia | 1.45h | 1 |
| Balázs Fodor | Hungary | 8.08h | 9 |
| Adam Gaca | Poland | 2.56h | 3 |
| Christoph Gerber | Germany | 8.68h | 1 |
| Andraz Gnidovec | Slovenia | 3.53h | 3 |
| William Godley | United States | 4.50h | 0 |
| Michal Goraus | Poland | 4.33h | 3 |
| Sylvie Gorkova | Czech Republic | 5.86h | 5 |
| Mitja Govedic | Slovenia | 2.09h | 2 |
| Aleksey Grigorchuk | Russia | 2.88h | 0 |
| Pavol Habuda | Slovakia | 3.32h | 0 |
| Barbara Handzlik | Poland | 9.80h | 8 |
| Vilem Heblik | Czech Republic | 13.16h | 19 |
| Ken Hodonsky | United States | 4.83h | 3 |
| Kamil Hornoch | Czech Republic | 1.85h | 2 |
| Petr Horalek | Czech Republic | 1.99h | 2 |
| Michiel Hubeau | Belgium | 4.68h | 6 |
| Lars Jacobs | Belgium | 1.58h | 1 |
| Milosz Jakubek | Poland | 1.23h | 3 |
| Zoltán Jankovics | Hungary | 5.42h | 11 |
| Carl Johannink | Netherlands | 8.85h | 4 |
| Javor Kac | Slovenia | 30.20h | 39 |
| Maihtili Kalamkar | India | 1.00h | 0 |
| Gyula Kiss | Hungary | 7.75h | 4 |
| Stanislav Korotkiy | Russia | 2.49h | 11 |
| Petar Kostic | Serbia | 4.74h | 4 |
| Peter Kosec | Czech Republic | 0.67h | 0 |
| Jakub Koukal | Czech Republic | 25.86h | 57 |
| Richard Kramer | United States | 1.81h | 2 |
| Delyan Lafchiev | Bulgaria | 6.15h | 2 |
| Greet Lembregts | Belgium | 3.14h | 1 |
| Jan Lembregts | Belgium | 1.74h | 0 |
| Mariusz Lemiecha | Poland | 2.92h | 4 |
| Florin Leu | Romania | 3.23h | 0 |
| Peter Van Leuteren | Netherlands | 9.27h | 6 |
| Mike Linnolt | United States | 1.38h | 1 |
| Tomasz Lojek | Poland | 3.50h | 2 |
| Grigoris Maravelias | Greece | 1.38h | 0 |
| Pierre Martin | Canada | 12.12h | 15 |
| Mikhail Maslov | Russia | 0.95h | 1 |
| Aleksandar Matic | Serbia | 1.53h | 1 |
| Batlomiej Matuszkiewicz | Poland | 3.91h | 1 |
| Bruce Mccurdy | Canada | 2.50h | 6 |
| Yanina Metodieva | Bulgaria | 1.70h | 4 |
| Ivo Micek | Czech Republic | 3.02h | 6 |
| Mihail Mihov | Bulgaria | 3.06h | 3 |
| Jakub Mirocha | Poland | 14.40h | 14 |
| Koen Miskotte | Netherlands | 8.86h | 5 |
| Konstantin Morozov | Belarus | 18.22h | 43 |
| Jadwiga Moskal | Poland | 4.50h | 2 |
| Maciej Myszkiewicz | Poland | 23.04h | 37 |
| Aleksandar Nachev | Bulgaria | 3.66h | 4 |
| Adrienn Nagy | Hungary | 5.09h | 5 |
| Filip Nikodem | Poland | 0.20h | 0 |
| Mohammad Nilforoushan | Iran | 2.00h | 10 |
| Artyom Novichonok | Russia | 0.41h | 1 |
| Arkadiusz Olech | Poland | 3.32h | 3 |
| Anna Palasz | Poland | 1.90h | 3 |
| Lovro Pavletic | Croatia | 0.58h | 1 |
| Pavlina Pavlova | Bulgaria | 4.85h | 6 |
| Katerina Piekarzova | Czech Republic | 6.69h | 17 |
| Krzysztof Pieszczoch | Poland | 24.73h | 32 |
| Konstantin Polyakov | Russia | 4.75h | 2 |
| Radoslaw Poleski | Poland | 0.59h | 1 |
| Sasha Prokofyev | Russia | 3.32h | 2 |
| Szaniszló Prohászka | Hungary | 6.37h | 9 |
| Jurgen Rendtel | Germany | 5.10h | 8 |
| Anna Rieth | Hungary | 8.02h | 6 |
| Agnieszka Ruminska | Poland | 0.83h | 2 |
| Branislav Savic | Serbia | 9.28h | 10 |
| Sergei Schmalz | Germany | 2.00h | 1 |
| Magdalena Sieniawska | Poland | 21.64h | 27 |
| Andrea Sipka | Serbia | 4.71h | 4 |
| Andrzej Skoczewski | Poland | 0.75h | 1 |
| Szymon Skorupinski | Poland | 2.31h | 1 |
| Jiri Srba | Czech Republic | 1.71h | 2 |
| Toni Stipec | Croatia | 1.94h | 1 |
| Olivera Stojanovic | Serbia | 1.17h | 0 |
| Wesley Stone | United States | 6.82h | 7 |
| Jury Suetin | Russia | 5.12h | 4 |
| Martina Supak | Croatia | 1.53h | 0 |
| Pavel Svozil | Czech Republic | 3.22h | 4 |
| Ágnes Szabó | Hungary | 8.02h | 9 |
| Prohászka Szaniszló | Hungary | 1.65h | 3 |
| Csilla Tepliczky | Hungary | 5.41h | 4 |
| Anatoliy Vasylenko | Ukraine | 3.25h | 2 |
| Lachezar Todorov | Bulgaria | 6.03h | 19 |
| Veljko Tomic | Croatia | 1.70h | 1 |
| Raul Cosmin Truta | Romania | 3.40h | 0 |
| Shigeo Uchiyama | Japan | 0.67h | 0 |
| Hendrik Vandenbruaene | Belgium | 1.43h | 1 |
| Ini Vanwesenbeeck | Belgium | 0.68h | 0 |
| Michel Vandeputte | Belgium | 27.99h | 21 |
| Valentin Velkov | Bulgaria | 11.46h | 22 |
| Jan Verbert | Belgium | 2.42h | 4 |
| Myriam Vingerhoets | Belgium | 4.58h | 3 |
| Ewa Wala | Poland | 14.65h | 29 |
| William Watson | United States | 7.56h | 4 |
| Thomas Weiland | Austria | 19.75h | 6 |
| Lukasz Wozniak | Poland | 4.75h | 13 |
| Oliver Wusk | Germany | 3.70h | 0 |
| Kamil Zloczewski | Poland | 3.24h | 7 |
| Przemyslaw Zoladek | Poland | 0.80h | 0 |
Create your own analysis. The files below can be opened using Excel:
kcg2010_rate.csv (number of meteors per interval per observer)
kcg2010_magn.csv (number of meteors per magnitude bin per observer)
The information on this page may be distributed freely provided credit is given to the International Meteor Organization (IMO) and, when possible, to the individual observers. The computer facilities to generate this page are provided by ESA/RSSD and Armagh Observatory.
References:


|
Bullet Collision Detection & Physics Library
|
The btConvexHullShape implements an implicit convex hull of an array of vertices. More...
#include <btConvexHullShape.h>
Public Member Functions | |
| BT_DECLARE_ALIGNED_ALLOCATOR () | |
| btConvexHullShape (const btScalar *points=0, int numPoints=0, int stride=sizeof(btVector3)) | |
| this constructor optionally takes in a pointer to points. More... | |
| void | addPoint (const btVector3 &point, bool recalculateLocalAabb=true) |
| btVector3 * | getUnscaledPoints () |
| const btVector3 * | getUnscaledPoints () const |
| const btVector3 * | getPoints () const |
| getPoints is obsolete, please use getUnscaledPoints More... | |
| void | optimizeConvexHull () |
| btVector3 | getScaledPoint (int i) const |
| int | getNumPoints () const |
| virtual btVector3 | localGetSupportingVertex (const btVector3 &vec) const |
| virtual btVector3 | localGetSupportingVertexWithoutMargin (const btVector3 &vec) const |
| virtual void | batchedUnitVectorGetSupportingVertexWithoutMargin (const btVector3 *vectors, btVector3 *supportVerticesOut, int numVectors) const |
| virtual void | project (const btTransform &trans, const btVector3 &dir, btScalar &minProj, btScalar &maxProj, btVector3 &witnesPtMin, btVector3 &witnesPtMax) const |
| virtual const char * | getName () const |
| virtual int | getNumVertices () const |
| virtual int | getNumEdges () const |
| virtual void | getEdge (int i, btVector3 &pa, btVector3 &pb) const |
| virtual void | getVertex (int i, btVector3 &vtx) const |
| virtual int | getNumPlanes () const |
| virtual void | getPlane (btVector3 &planeNormal, btVector3 &planeSupport, int i) const |
| virtual bool | isInside (const btVector3 &pt, btScalar tolerance) const |
| virtual void | setLocalScaling (const btVector3 &scaling) |
| in case we receive negative scaling More... | |
| virtual int | calculateSerializeBufferSize () const |
| virtual const char * | serialize (void *dataBuffer, btSerializer *serializer) const |
| fills the dataBuffer and returns the struct name (and 0 on failure) More... | |
| Public Member Functions inherited from btPolyhedralConvexAabbCachingShape | |
| void | getNonvirtualAabb (const btTransform &trans, btVector3 &aabbMin, btVector3 &aabbMax, btScalar margin) const |
| virtual void | getAabb (const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const |
| getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version More... | |
| void | recalcLocalAabb () |
| Public Member Functions inherited from btPolyhedralConvexShape | |
| BT_DECLARE_ALIGNED_ALLOCATOR () | |
| btPolyhedralConvexShape () | |
| virtual | ~btPolyhedralConvexShape () |
| virtual bool | initializePolyhedralFeatures (int shiftVerticesByMargin=0) |
| optional method mainly used to generate multiple contact points by clipping polyhedral features (faces/edges) experimental/work-in-progress More... | |
| virtual void | setPolyhedralFeatures (btConvexPolyhedron &polyhedron) |
| const btConvexPolyhedron * | getConvexPolyhedron () const |
| virtual void | calculateLocalInertia (btScalar mass, btVector3 &inertia) const |
| Public Member Functions inherited from btConvexInternalShape | |
| BT_DECLARE_ALIGNED_ALLOCATOR () | |
| virtual | ~btConvexInternalShape () |
| const btVector3 & | getImplicitShapeDimensions () const |
| void | setImplicitShapeDimensions (const btVector3 &dimensions) |
| warning: use setImplicitShapeDimensions with care changing a collision shape while the body is in the world is not recommended, it is best to remove the body from the world, then make the change, and re-add it alternatively flush the contact points, see documentation for 'cleanProxyFromPairs' More... | |
| void | setSafeMargin (btScalar minDimension, btScalar defaultMarginMultiplier=0.1f) |
| void | setSafeMargin (const btVector3 &halfExtents, btScalar defaultMarginMultiplier=0.1f) |
| virtual void | getAabbSlow (const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const |
| virtual const btVector3 & | getLocalScaling () const |
| const btVector3 & | getLocalScalingNV () const |
| virtual void | setMargin (btScalar margin) |
| virtual btScalar | getMargin () const |
| btScalar | getMarginNV () const |
| virtual int | getNumPreferredPenetrationDirections () const |
| virtual void | getPreferredPenetrationDirection (int index, btVector3 &penetrationVector) const |
| Public Member Functions inherited from btConvexShape | |
| BT_DECLARE_ALIGNED_ALLOCATOR () | |
| btConvexShape () | |
| not supported on IBM SDK, until we fix the alignment of btVector3 More... | |
| virtual | ~btConvexShape () |
| btVector3 | localGetSupportVertexWithoutMarginNonVirtual (const btVector3 &vec) const |
| btVector3 | localGetSupportVertexNonVirtual (const btVector3 &vec) const |
| btScalar | getMarginNonVirtual () const |
| void | getAabbNonVirtual (const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const |
| Public Member Functions inherited from btCollisionShape | |
| BT_DECLARE_ALIGNED_ALLOCATOR () | |
| btCollisionShape () | |
| virtual | ~btCollisionShape () |
| virtual void | getBoundingSphere (btVector3 ¢er, btScalar &radius) const |
| virtual btScalar | getAngularMotionDisc () const |
| getAngularMotionDisc returns the maximum radius needed for Conservative Advancement to handle time-of-impact with rotations. More... | |
| virtual btScalar | getContactBreakingThreshold (btScalar defaultContactThresholdFactor) const |
| void | calculateTemporalAabb (const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btVector3 &temporalAabbMin, btVector3 &temporalAabbMax) const |
| calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep) result is conservative More... | |
| bool | isPolyhedral () const |
| bool | isConvex2d () const |
| bool | isConvex () const |
| bool | isNonMoving () const |
| bool | isConcave () const |
| bool | isCompound () const |
| bool | isSoftBody () const |
| bool | isInfinite () const |
| isInfinite is used to catch simulation error (aabb check) More... | |
| int | getShapeType () const |
| virtual btVector3 | getAnisotropicRollingFrictionDirection () const |
| the getAnisotropicRollingFrictionDirection can be used in combination with setAnisotropicFriction See Bullet/Demos/RollingFrictionDemo for an example More... | |
| void | setUserPointer (void *userPtr) |
| optional user data pointer More... | |
| void * | getUserPointer () const |
| void | setUserIndex (int index) |
| int | getUserIndex () const |
| virtual void | serializeSingleShape (btSerializer *serializer) const |
Private Attributes | |
| btAlignedObjectArray< btVector3 > | m_unscaledPoints |
Additional Inherited Members | |
| Protected Member Functions inherited from btPolyhedralConvexAabbCachingShape | |
| void | setCachedLocalAabb (const btVector3 &aabbMin, const btVector3 &aabbMax) |
| void | getCachedLocalAabb (btVector3 &aabbMin, btVector3 &aabbMax) const |
| btPolyhedralConvexAabbCachingShape () | |
| Protected Member Functions inherited from btConvexInternalShape | |
| btConvexInternalShape () | |
| Protected Attributes inherited from btPolyhedralConvexShape | |
| btConvexPolyhedron * | m_polyhedron |
| Protected Attributes inherited from btConvexInternalShape | |
| btVector3 | m_localScaling |
| btVector3 | m_implicitShapeDimensions |
| btScalar | m_collisionMargin |
| btScalar | m_padding |
| Protected Attributes inherited from btCollisionShape | |
| int | m_shapeType |
| void * | m_userPointer |
| int | m_userIndex |
The btConvexHullShape implements an implicit convex hull of an array of vertices.
Bullet provides a general and fast collision detector for convex shapes based on GJK and EPA using localGetSupportingVertex.
Definition at line 25 of file btConvexHullShape.h.
| btConvexHullShape::btConvexHullShape | ( | const btScalar * | points = 0 , |
| int | numPoints = 0 , |
||
| int | stride = sizeof(btVector3) |
||
| ) |
this constructor optionally takes in a pointer to points.
Each point is assumed to be 3 consecutive btScalar (x,y,z), the striding defines the number of bytes between each point, in memory. It is easier to not pass any points in the constructor, and just add one point at a time, using addPoint. btConvexHullShape make an internal copy of the points.
Definition at line 28 of file btConvexHullShape.cpp.
| void btConvexHullShape::addPoint | ( | const btVector3 & | point, |
| bool | recalculateLocalAabb = true |
||
| ) |
Definition at line 51 of file btConvexHullShape.cpp.
|
virtual |
Reimplemented from btPolyhedralConvexShape.
Definition at line 74 of file btConvexHullShape.cpp.
| btConvexHullShape::BT_DECLARE_ALIGNED_ALLOCATOR | ( | ) |
|
inlinevirtual |
Reimplemented from btConvexInternalShape.
Definition at line 111 of file btConvexHullShape.h.
Implements btPolyhedralConvexShape.
Definition at line 140 of file btConvexHullShape.cpp.
|
inlinevirtual |
Implements btCollisionShape.
Definition at line 75 of file btConvexHullShape.h.
|
virtual |
Implements btPolyhedralConvexShape.
Definition at line 135 of file btConvexHullShape.cpp.
|
virtual |
Implements btPolyhedralConvexShape.
Definition at line 153 of file btConvexHullShape.cpp.
|
inline |
Definition at line 63 of file btConvexHullShape.h.
|
virtual |
Implements btPolyhedralConvexShape.
Definition at line 130 of file btConvexHullShape.cpp.
|
virtual |
Implements btPolyhedralConvexShape.
Definition at line 158 of file btConvexHullShape.cpp.
|
inline |
getPoints is obsolete, please use getUnscaledPoints
Definition at line 51 of file btConvexHullShape.h.
|
inline |
Definition at line 58 of file btConvexHullShape.h.
|
inline |
Definition at line 40 of file btConvexHullShape.h.
|
inline |
Definition at line 45 of file btConvexHullShape.h.
|
virtual |
Implements btPolyhedralConvexShape.
Definition at line 148 of file btConvexHullShape.cpp.
Implements btPolyhedralConvexShape.
Definition at line 164 of file btConvexHullShape.cpp.
Reimplemented from btConvexInternalShape.
Definition at line 99 of file btConvexHullShape.cpp.
|
virtual |
Reimplemented from btPolyhedralConvexShape.
Definition at line 58 of file btConvexHullShape.cpp.
| void btConvexHullShape::optimizeConvexHull | ( | ) |
Definition at line 116 of file btConvexHullShape.cpp.
|
virtual |
Reimplemented from btConvexShape.
Definition at line 207 of file btConvexHullShape.cpp.
|
virtual |
fills the dataBuffer and returns the struct name (and 0 on failure)
Reimplemented from btConvexInternalShape.
Definition at line 171 of file btConvexHullShape.cpp.
|
virtual |
in case we receive negative scaling
Reimplemented from btPolyhedralConvexAabbCachingShape.
Definition at line 45 of file btConvexHullShape.cpp.
|
private |
Definition at line 28 of file btConvexHullShape.h.


| Package | Description |
|---|---|
| com.opensymphony.xwork2.config.entities |
Configuration entity classes.
|
| com.opensymphony.xwork2.config.providers |
Configuration provider classes.
|
| com.opensymphony.xwork2.util |
XWork util classes.
|
| com.opensymphony.xwork2.util.location |
Classes and utilities used to track location information.
|
| com.opensymphony.xwork2.validator |
XWork validation subsystem.
|
| org.apache.struts2 | |
| org.apache.struts2.config |
Classes for Struts configuration and property handling.
|
| org.apache.struts2.dispatcher |
This package contains a reimagining of the traditional Struts filter dispatchers.
|
| Modifier and Type | Method and Description |
|---|---|
InterceptorStackConfig.Builder |
InterceptorStackConfig.Builder.location(Location loc) |
ExceptionMappingConfig.Builder |
ExceptionMappingConfig.Builder.location(Location loc) |
ResultTypeConfig.Builder |
ResultTypeConfig.Builder.location(Location loc) |
PackageConfig.Builder |
PackageConfig.Builder.location(Location loc) |
ResultConfig.Builder |
ResultConfig.Builder.location(Location loc) |
InterceptorConfig.Builder |
InterceptorConfig.Builder.location(Location loc) |
ActionConfig.Builder |
ActionConfig.Builder.location(Location loc) |
| Constructor and Description |
|---|
UnknownHandlerConfig(String name,
Location location) |
| Modifier and Type | Method and Description |
|---|---|
static List<InterceptorMapping> |
InterceptorBuilder.constructInterceptorReference(InterceptorLocator interceptorLocator,
String refName,
Map<String,String> refParams,
Location location,
ObjectFactory objectFactory)
Builds a list of interceptors referenced by the refName in the supplied PackageConfig (InterceptorMapping object).
|
protected boolean |
XmlConfigurationProvider.verifyAction(String className,
String name,
Location loc) |
protected Class |
XmlConfigurationProvider.verifyResultType(String className,
Location loc) |
| Modifier and Type | Method and Description |
|---|---|
static Location |
DomHelper.getLocationObject(Element element) |
| Modifier and Type | Class and Description |
|---|---|
class |
LocationImpl
A simple immutable and serializable implementation of
Location . |
| Modifier and Type | Field and Description |
|---|---|
protected Location |
Located.location |
static Location |
Location.UNKNOWN
Constant for unknown locations.
|
| Modifier and Type | Method and Description |
|---|---|
Location |
Locatable.getLocation()
Get the location of this object
|
Location |
LocatableProperties.getLocation() |
Location |
Located.getLocation()
Get the location of this object
|
static Location |
LocationAttributes.getLocation(Attributes attrs,
String description)
Returns the
Location of an element (SAX flavor). |
static Location |
LocationAttributes.getLocation(Element elem)
Same as
getLocation(elem, null) . |
static Location |
LocationAttributes.getLocation(Element elem,
String description)
Returns the
Location of an element (DOM flavor). |
static Location |
LocationUtils.getLocation(Object obj)
Get the location of an object.
|
static Location |
LocationUtils.getLocation(Object obj,
String description)
Get the location of an object.
|
Location |
LocationUtils.LocationFinder.getLocation(Object obj,
String description)
Get the location of an object
|
Location |
LocatableProperties.getPropertyLocation(String key) |
| Modifier and Type | Method and Description |
|---|---|
static LocationImpl |
LocationImpl.get(Location location)
Obtain a
LocationImpl from a Location . |
static boolean |
LocationUtils.isKnown(Location location)
Checks if a location is known, i.e.
|
static boolean |
LocationUtils.isUnknown(Location location)
Checks if a location is unknown, i.e.
|
void |
Located.setLocation(Location loc)
Set the location of this object
|
static String |
LocationUtils.toString(Location location)
Builds a string representation of a location, in the
"
descripton - uri:line:column "
format (e.g. |
| Constructor and Description |
|---|
LocatableProperties(Location loc) |
LocationImpl(Location location)
Copy constructor.
|
LocationImpl(String description,
Location location)
Create a location from an existing one, but with a different description
|
| Modifier and Type | Method and Description |
|---|---|
ValidatorConfig.Builder |
ValidatorConfig.Builder.location(Location loc) |
| Modifier and Type | Method and Description |
|---|---|
Location |
StrutsException.getLocation()
Gets the location of the error, if available
|
| Modifier and Type | Method and Description |
|---|---|
Location |
DefaultSettings.getLocation(String name) |
| Modifier and Type | Method and Description |
|---|---|
Location |
Dispatcher.Locator.getLocation(Object obj) |
Copyright © 2000–2020 Apache Software Foundation. All rights reserved.


Timer: 90
Coding Quiz!
Welcome to this Coding Quiz! You will see 10 multiple choice questions that are based on JavaScript fundamentals! Keep in mind that you will only have 90 seconds, and you will be penalized 5 seconds for every wrong answer that you click! At the end, enter in your initials to be added to the scoreboard! Good luck!
❌ Wrong! Please Try Again!
✔ Correct!
You ran out of time! Game Over!
You Finished the Quiz!
Your score is:


CUSTOM CELBRATION CAKES
We are now able to offer custom celebration cakes made from our unsurpassed selection of artisanal cheeses. Our cheesemongers will work with you to create a beautiful, edible centerpiece for any size occasion; from an intimate gathering to a grand gala.
Two week lead time required.
Call us for more details.<PHONE_NUMBER>


1 write to Job
System.Management.Automation (1)
engine\debugger\debugger.cs (1)
201
this.
Job
= job;
10 references to Job
System.Management.Automation (10)
engine\debugger\debugger.cs (10)
3178
jobArgs.
Job
.StateChanged += HandleJobStateChanged;
3179
if (jobArgs.
Job
.IsPersistentState(jobArgs.
Job
.JobStateInfo.State))
3181
jobArgs.
Job
.StateChanged -= HandleJobStateChanged;
3185
if (!_runningJobs.ContainsKey(jobArgs.
Job
.InstanceId))
3192
jobArgs.
Job
.OutputProcessingStateChanged += HandleOutputProcessingStateChanged;
3193
jobArgs.
Job
.MonitorOutputProcessing = true;
3195
_runningJobs.Add(jobArgs.
Job
.InstanceId, jobArgs);
3310
RemoveFromRunningJobList(item.
Job
);
4015
Job job = item.
Job
;


App Features
Corona Cases
In this app you will find Global And Country wise Corona Statistics.
Preventions
You will find Prevention Measures one should take to be safe.
Symptoms
It includes What are the Symptoms that can be serious in Corona Virus.
FAQ's
Some of the Frequently Asked Questions are being answered.
Sign In using Firebase
You can access all the features by Signing in using different methods.
Helpline Number
Helpline Number that can be very helpful in any case of emergency.
Gallery
A glimpse of Covid 19 app.


Western Balkan countries participation in ECDC-supported laboratory external quality assessment schemes offered to EU pre-accession countries, by target pathogen, testing area, and year.
*
EQA was not offered.


This is a task list manager based on Spring Framework, OAuth2 and Bootstrap. This is a sample application to show you how to access oauth2 protected data.
This is the client application part, Enjoy !
The Spring Framework provides a comprehensive programming and configuration model for modern Java-based enterprise applications - on any kind of deployment platform.
OAuth 2.0 is the next evolution of the OAuth protocol which was originally created in late 2006. OAuth 2.0 focuses on client developer simplicity while providing specific authorization flows for web applications, desktop applications, mobile phones, and living room devices.
Bootstrap, a sleek, intuitive, and powerful mobile first front-end framework for faster and easier web development.