text:
CGAL 4.7 - Scale-Space Surface Reconstruction
CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct > Class Template Reference

#include <CGAL/Scale_space_surface_reconstruction_3.h>

## Definition

### template<class Gt, class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag> class CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >

computes a triangulated surface mesh interpolating a point set.

This class stores several of the (intermediate) results. This makes it easier and more efficient to adjust the parameter settings based on preliminary results, or to further increase the scale to improve the results. The class stores the point set at the current scale and the reconstructed surface, possibly with iterators over the shells.

The class also stores the parameters for estimating the optimal neighborhood radius and either the lastest estimate or the manually set radius. This way, the radius can be estimated (again) whenever necessary. Also note that both increasing the scale and reconstructing the surface use this radius. By changing or re-estimating the radius between these operations, they can use separate parameter settings.

The surface can be constructed either for a fixed neighborhood radius, or for a dynamic radius. When constructing the surface for exactly one neighborhood radius, it is faster to set FS to Tag_true. If the correct neighborhood radius should be changed or estimated multiple times, it is faster to set FS to Tag_false.

It is undefined whether a surface with fixed radius may have its radius changed, but if so, this will likely require more computation time than changing the radius of a dynamic surface. In either case, it is possible to change the point set while maintaining the same radius.

The surface can be stored either as an unordered collection of triangles, or as a collection ordered by shells. A shell is a maximally connected component of the surface where connected facets are locally oriented towards the same side of the surface.

Template Parameters
 Gt is the geometric traits class. It must be a model of DelaunayTriangulationTraits_3. It must have a RealEmbeddable field number type. Generally, Exact_predicates_inexact_constructions_kernel is preferred. FS determines whether the surface is expected to be constructed for a fixed neighborhood radius. It must be a Boolean_tag type. The default value is Tag_true. Note that the value of this parameter does not change the result but only has an impact on the run-time. Sh determines whether to collect the surface per shell. It must be a Boolean_tag type. The default value is Tag_true. wA must be a model of WeightedPCAProjection_3 and determines how to approximate a weighted point set. If Eigen 3.1.2 (or greater) is available and CGAL_EIGEN3_ENABLED is defined, then Weighted_PCA_approximation_3 is used by default. Ct indicates whether to use concurrent processing. It must be either Sequential_tag or Parallel_tag (the default value).
Examples:
Scale_space_reconstruction_3/scale_space.cpp, and Scale_space_reconstruction_3/scale_space_incremental.cpp.

## Public Types

typedef Gt::Point_3 Point
defines the point type.

## Types

typedef Gt::FT FT
defines the field number type.

typedef unspecified_type Point_iterator
defines an iterator over the points.

typedef const unspecified_type Point_const_iterator
defines a constant iterator over the points.

typedef CGAL::cpp11::array
< unsigned int, 3 >
Triple
defines a triple of point indices indicating a triangle of the surface.

typedef unspecified_type Triple_iterator
defines an iterator over the triples.

typedef const unspecified_type Triple_const_iterator
defines a constant iterator over the triples.

## Constructors

Scale_space_surface_reconstruction_3 (unsigned int neighbors, unsigned int samples)
constructs a surface reconstructor that will automatically estimate the neighborhood radius. More...

constructs a surface reconstructor with a given neighborhood radius. More...

## Point Set Manipulation

template<class InputIterator >
void insert (InputIterator begin, InputIterator end)
inserts a collection of points into the scale-space at the current scale. More...

void insert (const Point &p)
inserts a point into the scale-space at the current scale. More...

void clear ()
clears the stored scale-space surface reconstruction data. More...

## Neighborhood Size Estimation

FT estimate_neighborhood_squared_radius (unsigned int neighbors, unsigned int samples)
estimates the neighborhood radius based on a number of sample points. More...

sets the squared radius of the neighborhood. More...

gives the squared radius of the neighborhood. More...

checks whether the neighborhood radius has been set. More...

## Neighborhood Size Estimation Parameters

unsigned int mean_number_of_neighbors () const
gives the mean number of neighbors an estimated neighborhood should contain. More...

unsigned int neighborhood_sample_size () const
gives the number of sample points the neighborhood estimation uses. More...

void set_mean_number_of_neighbors (unsigned int neighbors)
sets the mean number of neighbors an estimated neighborhood should contain. More...

void set_neighborhood_sample_size (unsigned int samples)
sets the number of sample points the neighborhood estimation uses. More...

## Scale-Space Manipulation

void increase_scale (unsigned int iterations=1)
increases the scale by a number of iterations. More...

## Surface Reconstruction

void reconstruct_surface ()
constructs a triangle mesh from the point set at a fixed scale. More...

std::size_t number_of_triangles () const
gives the number of triangles of the surface.

std::size_t number_of_points () const
gives the number of points of the surface.

std::size_t number_of_shells () const
gives the number of shells of the surface.

## Iterators

Point_const_iterator points_begin () const
gives an iterator to the first point at the current scale.

Point_iterator points_begin ()
gives an iterator to the first point at the current scale. More...

Point_const_iterator points_end () const
gives a past-the-end iterator of the points at the current scale.

Point_iterator points_end ()
gives a past-the-end iterator of the points at the current scale. More...

Triple_const_iterator surface_begin () const
gives an iterator to the first triple in the surface.

Triple_iterator surface_begin ()
gives an iterator to the first triple in the surface. More...

Triple_const_iterator surface_end () const
gives a past-the-end iterator of the triples in the surface.

Triple_iterator surface_end ()
gives a past-the-end iterator of the triples in the surface. More...

Triple_const_iterator shell_begin (std::size_t shell) const
gives an iterator to the first triple in a given shell. More...

Triple_iterator shell_begin (std::size_t shell)
gives an iterator to the first triple in a given shell. More...

Triple_const_iterator shell_end (std::size_t shell) const
gives a past-the-end iterator of the triples in a given shell. More...

Triple_iterator shell_end (std::size_t shell)
gives a past-the-end iterator of the triples in a given shell. More...

## Constructor & Destructor Documentation

template<class Gt , class FS , class Sh , class wA , class Ct >
 CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::Scale_space_surface_reconstruction_3 ( unsigned int neighbors, unsigned int samples )

constructs a surface reconstructor that will automatically estimate the neighborhood radius.

Parameters
 neighbors is the number of neighbors a point's neighborhood should contain on average. samples is the number of points sampled to estimate the neighborhood radius.
template<class Gt , class FS , class Sh , class wA , class Ct >
 CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::Scale_space_surface_reconstruction_3 ( FT sq_radius)

constructs a surface reconstructor with a given neighborhood radius.

Parameters
Precondition
sq_radius is not negative.

## Member Function Documentation

template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 void CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::clear ( )

clears the stored scale-space surface reconstruction data.

This includes discarding the surface, the scale-space and all its points, and any estimation of the neighborhood radius.

Methods called after this point may have to re-estimate the neighborhood radius. This method does not discard the parameters for estimating this radius (the mean number of neighbors and the sample size).

template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 FT CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::estimate_neighborhood_squared_radius ( )

This method is equivalent to running estimate_neighborhood_squared_radius( mean_number_of_neighbors(), neighborhood_sample_size() ).

This method can be called by the scale-space and surface construction methods if the neighborhood radius is not set when they are called.

Returns
Note
This method processes the point set at the current scale. The points can be set with insert(begin, end).
Warning
set_mean_number_of_neighbors(unsigned int neighbors).
set_neighborhood_sample_size(unsigned int samples).
estimate_neighborhood_squared_radius(unsigned int neighbors, unsigned int samples).
increase_scale(unsigned int iterations).
reconstruct_surface().
template<class Gt , class FS , class Sh , class wA , class Ct >
 Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::FT CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::estimate_neighborhood_squared_radius ( unsigned int neighbors, unsigned int samples )

estimates the neighborhood radius based on a number of sample points.

The neighborhood radius is expressed as the radius of the smallest ball centered on a point such that the ball contains at least a specified number of points, not counting the point itself.

The neighborhood radius is set to the mean of these radii, taken over a number of point samples.

Parameters
 neighbors is the number of neighbors a point's neighborhood should contain on average, not counting the point itself. samples is the number of points sampled to estimate the neighborhood radius.
Returns
Note
This method processes the point set at the current scale. The points can be set with insert(begin, end).
Warning
estimate_neighborhood_squared_radius().
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 bool CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::has_neighborhood_squared_radius ( ) const

checks whether the neighborhood radius has been set.

The radius can be set manually, or estimated automatically.

Returns
true iff the radius has been either set manually or estimated.
set_neighborhood_squared_radius().
estimate_neighborhood_squared_radius().
template<class Gt , class FS , class Sh , class wA , class Ct >
 void CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::increase_scale ( unsigned int iterations = 1)

increases the scale by a number of iterations.

Each iteration the scale is increased, the points set at a higher scale is computed. At a higher scale, the points set is smoother.

If the neighborhood radius has not been set before, it is automatically estimated using estimate_neighborhood_squared_radius().

Parameters
 iterations is the number of iterations to perform. If iterations is 0, nothing happens.
Note
This method processes the point set at the current scale. The points can be set with insert(begin, end).
If the surface was already constructed, increasing the scale will not automatically adjust the surface.
estimate_neighborhood_squared_radius().
reconstruct_surface().
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
template<class InputIterator >
 void CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::insert ( InputIterator begin, InputIterator end )

inserts a collection of points into the scale-space at the current scale.

Template Parameters
 InputIterator is an iterator over the point collection. The value type of the iterator must be a Point.
Parameters
 begin is an iterator to the first point of the collection. end is a past-the-end iterator for the point collection.
Note
Inserting the points does not automatically construct or update the surface.
In order to construct the surface, call reconstruct_surface() after inserting the points.
Warning
Inserting new points may invalidate the neighborhood radius if it was previously estimated.
insert(const Point& p).
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 void CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::insert ( const Point & p)

inserts a point into the scale-space at the current scale.

Parameters
 p is the point to insert.
Note
Inserting the point does not automatically construct or update the surface.
In order to construct the surface, call reconstruct_surface().
Warning
Inserting a new point may invalidate the neighborhood radius if it was previously estimated.
insert(InputIterator begin, InputIterator end).
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 unsigned int CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::mean_number_of_neighbors ( ) const

gives the mean number of neighbors an estimated neighborhood should contain.

This number is only used if the neighborhood radius has not been set manually.

When the neighborhood radius is estimated, it should on average contain this many neighbors, not counting the neighborhood center.

Returns
the number of neighbors a neighborhood ball centered on a point should contain on average when the radius is estimated, not counting the point itself.
set_mean_number_of_neighbors(unsigned int neighbors).
has_neighborhood_squared_radius().
neighborhood_sample_size().
estimate_neighborhood_squared_radius().
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 unsigned int CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::neighborhood_sample_size ( ) const

gives the number of sample points the neighborhood estimation uses.

This number is only used if the neighborhood radius has not been set manually.

If the number of samples is larger than the point cloud, every point is used and the optimal neighborhood radius is computed exactly instead of estimated.

Returns
the number of points sampled for neighborhood estimation.
set_neighborhood_sample_size(unsigned int samples).
has_neighborhood_squared_radius().
mean_number_of_neighbors().
estimate_neighborhood_squared_radius().
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 FT CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::neighborhood_squared_radius ( ) const

gives the squared radius of the neighborhood.

The neighborhood radius is used by increase_scale() to compute the point set at the desired scale and by reconstruct_surface() to construct a surface from the point set at the current scale.

Returns
the squared radius of the neighborhood, or -1 if the neighborhood radius has not yet been set.
increase_scale(unsigned int iterations).
reconstruct_surface().
Examples:
Scale_space_reconstruction_3/scale_space.cpp.
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 Point_iterator CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::points_begin ( )

gives an iterator to the first point at the current scale.

Warning
Changes to the scale-space do not cause an automatic update to the surface.
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 Point_iterator CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::points_end ( )

gives a past-the-end iterator of the points at the current scale.

Warning
Changes to the scale-space do not cause an automatic update to the surface.
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 void CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::reconstruct_surface ( )

constructs a triangle mesh from the point set at a fixed scale.

The order of the points at the current scale is the same as the order at the original scale, meaning that the surface can interpolate the point set at the original scale by applying the indices of the surface triangles to the original point set.

After construction, the triangles of the surface can be iterated using surface_begin() and surface_end().

If the neighborhood radius has not been set before, it is automatically estimated using estimate_neighborhood_squared_radius().

Note
This method processes the point set at the current scale. The points can be set with insert(begin, end).
estimate_neighborhood_squared_radius().
increase_scale(unsigned int iterations).
Examples:
Scale_space_reconstruction_3/scale_space.cpp.
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 void CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::set_mean_number_of_neighbors ( unsigned int neighbors)

sets the mean number of neighbors an estimated neighborhood should contain.

This number is only used if the neighborhood radius has not been set manually.

When the neighborhood radius is estimated, it should on average contain this many neighbors, not counting the neighborhood center.

Parameters
 neighbors is the number of neighbors a neighborhood ball centered on a point should contain on average when the radius is estimated, not counting the point itself.
Note
This does not start the estimation process.
mean_number_of_neighbors().
has_neighborhood_squared_radius().
set_neighborhood_sample_size(unsigned int samples).
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 void CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::set_neighborhood_sample_size ( unsigned int samples)

sets the number of sample points the neighborhood estimation uses.

This number is only used if the neighborhood radius has not been set manually.

If the number of samples is larger than the point cloud, every point is used and the optimal neighborhood radius is computed exactly instead of estimated.

Parameters
 samples is the number of points to sample for neighborhood estimation.
Note
This does not start the estimation process.
neighborhood_sample_size().
has_neighborhood_squared_radius().
set_mean_number_of_neighbors(unsigned int neighbors).
estimate_neighborhood_squared_radius().
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 void CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::set_neighborhood_squared_radius ( const FT & sq_radius)

sets the squared radius of the neighborhood.

The neighborhood radius is used by #[increase_scale() to compute the point set at the desired scale and by reconstruct_surface() to construct a surface from the point set at the current scale.

Parameters
Note
If the neighborhood squared radius is negative when the point set is smoothed or when the surface is computed, the neighborhood radius will be computed automatically.
Warning
neighborhood_squared_radius().
has_neighborhood_squared_radius().
increase_scale(unsigned int iterations).
reconstruct_surface().
template<class Gt , class FS , class Sh , class wA , class Ct >
 Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::Triple_const_iterator CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::shell_begin ( std::size_t shell) const

gives an iterator to the first triple in a given shell.

Parameters
 shell is the index of the shell to access.
Precondition
shell is in the range [ 0, number_of_shells() ).
Examples:
Scale_space_reconstruction_3/scale_space.cpp.
template<class Gt , class FS , class Sh , class wA , class Ct >
 Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::Triple_iterator CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::shell_begin ( std::size_t shell)

gives an iterator to the first triple in a given shell.

Parameters
 shell is the index of the shell to access.
Precondition
shell is in the range [ 0, number_of_shells() ).
Warning
Changes to a shell may invalidate the topology of the surface.
template<class Gt , class FS , class Sh , class wA , class Ct >
 Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::Triple_const_iterator CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::shell_end ( std::size_t shell) const

gives a past-the-end iterator of the triples in a given shell.

Parameters
 shell is the index of the shell to access.
Precondition
shell is in the range [ 0, number_of_shells() ).
Examples:
Scale_space_reconstruction_3/scale_space.cpp.
template<class Gt , class FS , class Sh , class wA , class Ct >
 Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::Triple_iterator CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::shell_end ( std::size_t shell)

gives a past-the-end iterator of the triples in a given shell.

Parameters
 shell is the index of the shell to access.
Precondition
shell is in the range [ 0, number_of_shells() ).
Warning
Changes to a shell may invalidate the topology of the surface.
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 Triple_iterator CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::surface_begin ( )

gives an iterator to the first triple in the surface.

Warning
Changes to the surface may change its topology.
template<class Gt , class FS = Tag_true, class Sh = Tag_true, class wA = Default, class Ct = Parallel_tag>
 Triple_iterator CGAL::Scale_space_surface_reconstruction_3< Gt, FS, Sh, wA, Ct >::surface_end ( )

gives a past-the-end iterator of the triples in the surface.

Warning
Changes to the surface may change its topology.


text:
INTERSTELLAR UREA $[(NH_{2})_{2}CO]$

Please use this identifier to cite or link to this item: http://hdl.handle.net/1811/21068

Files Size Format View
2003-WE-05.jpg 266.6Kb JPEG image

 Title: INTERSTELLAR UREA $[(NH_{2})_{2}CO]$ Creators: Snyder, L. E.; Remijan, Anthony J.; Lovas, F. J.; Friedel, D. N.; Liu, Sheng-Yuan Issue Date: 2003 Publisher: Ohio State University Abstract: In 1773, H. M. Rouelle's discovery of urea in human urine supported theories that organic chemicals could be modified by chemistry, but could only be produced through a vital force in living plants and $animals^{a}$. The theory of Vitalism was badly damaged in 1828 when Friedrich W\""{o}hler synthesized urea from inorganic starting materials. Indeed, urea was the first organic compound ever to be synthesized from inorganic compounds. Today, urea is thought to have played a significant role in prebiotic chemistry. Extraterrestrial urea was first detected in two samples of the Murchinson $meteorite^{b}$. In this paper, we report the first detection of gas-phase interstellar urea $[(NH_{2})_{2}CO]$. We used the $BIMA^{c}$ Array to detect urea emission from the hot molecular core Sgr B2(N-LMH) at $\lambda = 3 mm (9_{\ast,9}-8_{\ast,8,} 9_{\ast,8}-8_{\ast,7}$, and $10_{\ast,10}-9_{\ast,9})$, and at $\lambda = 1 mm (20_{\ast,20}-19_{\ast,19,} 20_{\ast,19}-19_{\ast,18}$, and $21_{\ast,21}-20_{\ast,20})$. We will compare the urea column density and distribution with those of other molecules of biological interest in Sgr B2(N-LMH). Description: $^{a}$Current Address: Optical Technology Division, National Institute of Standards and Technology, Gaithersburg, MD $20899-8441 {^{b}}$Current address: Institute of Astronomy and Astrophysics, Academia Sinica, P. O. Box 23-141, 106 Taipei, Taiwan, ROC ${^{a}}Fairall$ 1996, http://smallfry.dmu.ac.uk/chem/mom/urea/urea.html ${^{b}}$Hayatsu et al. 1975, Geochim. et Cosmochim. Acta, 39, 471 ${^{c}}$Operated by the University of California, Berkeley, the University of Illinois, and the University of Maryland with support from the National Science Foundation Author Institution: Department of Astronomy, The University of Illinois; Astronomy Department, California Institute of Technology URI: http://hdl.handle.net/1811/21068 Other Identifiers: 2003-WE-05

format: plain


text:
# The IGBT (Insulated Gate Bipolar Transistor) used in the circuit has the following data:TON = 3 μs, tOFF = 1.2 μs, Duty cycle (D) = 0.7, VCE(sat) = 2 V and fs = 1 kHz.What are the switching power losses during turn-on and turn-off, respectively?

This question was previously asked in
ESE Electrical 2017 Official Paper
View all UPSC IES Papers >
1. 1.98 W and 1.7 W
2. 2.2 W and 1.7 W
3. 1.98 W and 0.792 W
4. 2.2 W and 0.792 W

## Answer (Detailed Solution Below)

Option 3 : 1.98 W and 0.792 W
Free
CT 1: Building Materials
6.8 K Users
10 Questions 20 Marks 12 Mins

## Detailed Solution

Concept:

Power loss during turn-on is,

$${P_{on}} = \frac{{{V_{CE}} \times {I_C}}}{6} \times {t_{on}} \times {f_s}$$

Power loss during turn off is,

$${P_{off}} = \frac{{{V_{CE}} \times {I_C}}}{6} \times {t_{off}} \times {f_s}$$

Calculation:

Given,

$${t_{on}} = 3\;\mu s$$

$${t_{off}} = 1.2\;\mu s$$

$${V_{CE\left( {sat} \right)}} = 2$$V

$${f_s} = 1$$kHz

$${V_{CE}} = 200$$V

$${R_L} = 10$$

From the given circuit

$${I_C} = \frac{{{V_{CE}} - {V_{CE\left( {sat} \right)}}}}{{{R_L}}}$$

$${I_C} = \frac{{200 - 2}}{{10}} = 19.8$$ A

Putting the given value in the above formula the power loss during turn on and turn off process is

$${P_{on}} = \frac{{{V_{CE}} \times {I_C}}}{6} \times {t_{on}} \times {f_s}$$

$${P_{on}} = \frac{{200 \times 19.8}}{6} \times 3 \times {10^{ - 6}} \times {10^3}$$

$${P_{on}} = 1.98$$W

$${P_{off}} = \frac{{{V_{CE}} \times {I_C}}}{6} \times {t_{off}} \times {f_s}$$

$${P_{off}} = \frac{{200 \times 19.8}}{6} \times 1.2 \times {10^{ - 6}} \times {10^3} = 0.792\;W$$

Latest UPSC IES Updates

Last updated on Mar 3, 2023

The Union Public Service Commission released the UPSC IES Result for Prelims on 3rd March 2023. The exam was conducted on 19th February 2023 for both Paper I and Paper II. A total of 327 vacancies were released. The mains examination will be held on 25th June 2023. The candidates applied between 14th September 2022 to 4th October 2022. The candidates must meet the USPC IES Eligibility Criteria to attend the recruitment. Candidates should attempt the UPSC IES mock tests to increase their efficiency. The UPSC IES previous year papers can downloaded here.


text:
The ratio of 4th term to 7th term of G.P. is 8 : 27. What is the common ratio of the G.P.?

This question was previously asked in
UPRVUNL JE ME 2016 Official Paper Shift 2
View all UPRVUNL JE Papers >
1. $$\dfrac{8}{27}$$
2. $$\dfrac{3}{2}$$
3. $$\dfrac{27}{3}$$
4. $$\dfrac{2}{3}$$

Option 2 : $$\dfrac{3}{2}$$
Free
ST 1: General Knowledge
2958
20 Questions 20 Marks 20 Mins

Detailed Solution

Give:

The ratio of 4th term to 7th term of G.P. is 8 : 27.

Formula used:

nth term of GP = arn–1

Where, r = Common ratio

Calculation:

Let first term of the GP be a

4th term of GP = ar4–1 = ar3

7th term of GP = ar7–1 = ar6

According to the question:

ar: ar6  = 8 : 27

⇒ 1 : r= 8 : 27

⇒ r3  = 27/8

⇒ r3  = (3/2)3

⇒ r  = 3/2

∴ The common ratio of the G.P is 3/2.


text:
# Compare how fast two time-series grow

I collected data from Pubmed containing articles published about two different topics.

The first is a yearly series of articles about omega 3 supplements. The second is a yearly series of articles published about probiotics supplements.

I want to understand how fast the research has grown over time (in plain English, capture the scientific interest over time) and specifically whether the scientific interest grew somehow "faster" for a topic rather than the other.

Please find here the data in a public gdoc:

I don't expect a full solution but at least some indication to where to start looking for my answer.

I assume it is something I can check with the time series slope, but I need some more inputs for going deeper in my research because I am kind of lost. Thank you!

• Your linked data shows a large jump in the value of "probiotics" from 1970 to 1974, changing from 59 to 475, but I do not see this on your plot of the data. Both "omega" and "probiotics" show a sudden drop from year 2018 to year 2019 but again I do not see this on your plots. Would you please chech that the posted data link and plots match in this? – James Phillips Jul 31 '19 at 17:49

This is very similar to looking at stock prices and other financial variables in econometric analysis. The way to do this would be to plot $$\log(x_{t+1}) - \log(x_t)$$ at each time period $$t = 1,...,T-1$$. This will show the rate of growth of each of the series, which is a good measure of "how fast they are growing". (Note that if you have any zero values in your data then the growth to the next non-zero value is infinite.)


text:
# Alternatives

## Summing Squares: Finding or Proving a Formula

Last week we looked at problems about counting the squares of all sizes in a checkerboard. Some solutions required finding the sum of consecutive squares, $$1^2+2^2+3^2+\dots+n^2$$, for which we used a formula whose derivation I deferred to this week. Here we’ll see a couple proofs that require knowing the formula ahead of time, and a …

## Application of Vectors: Airplane in the Wind

A recent question about the resultant velocity of an airplane illustrates different ways to make a diagram showing the bearings of air velocity and wind velocity, and to work out angles without getting too dizzy.

## How Many Paths from A to B?

A popular kind of question in combinatorics is to count the number of paths between two points in a grid (following simple constraints). This can be done by very different methods at different levels. We’ll look at several problems of this type, starting with the simplest.

## Sines Without Right Triangles

(A new question of the week) A recent question dealt with an apparent conflict between the right-triangle definition of sines and cosines, and the unit-circle definition, pertaining to multiples of 90° (angles on the axes). This provides an opportunity to look closely at the relationship between those two definitions. Two definitions Recall that the right-triangle …

## Multiplying Fractions by Whole or Mixed Numbers

Last week we looked at how to multiply fractions, and why we do it that way. But what do we do when one of the numbers is a whole number, or when one or both are mixed numbers? And do we have to do it the way we are taught?

## Angles in a Star

(A new question of the week) I like problems that can be solved in multiple ways, which can train us in seeing the world from different perspectives. Late in November we dealt with a pair of such questions involving angles in star-like figures.

## A Geometrical Limit

(A new question of the week) We usually see limits applied to functions in a calculus class. An interesting question from late October deals with a limit in a geometrical construction based on a function. We’ll be seeing how to discover a proof, then several alternative proofs, and finally what the answer means.

## Broken Sticks, Triangles, and Probability II

Last week, we looked at two solutions to the problem of finding the probability that you can make a triangle using three pieces of a stick, if we cut it at two independently chosen, random locations. This time, we look another solution to that problem, and a similar solution to the version in which we …

## Broken Sticks, Triangles, and Probability I

This week we look at questions about how likely it is that you can make a triangle out of three random pieces of a stick. As always in probability, the first issue comes in deciding how the process is to be done (that is, what does it mean to break a stick randomly?); we’ll also …

## Intersecting a Parabola in Two Points

(A new question of the week) A good way to check (and hopefully build) a student’s depth of understanding is to assign non-routine problems, in which familiar ideas are twisted around so you have to come at them from a different direction. Here we’ll look at a question about a graph that can be solved …


text:
22 replies to this topic

### #1SuperPixel

Valued Member

• Members
• 306 posts

Posted 20 March 2012 - 03:00 PM

Hi all,

the topic is quite clear and nothing new I guess .

So I'll keep it straight: My first Idea was to code a predefined set of shaders and let the user that was making materials to select them (so no node based approach like unreal material editor or maya hypershader).
I was thinking to avoid in this way not only the explosion that was resulting from the node based approaches but also the fact that shaders generated with node based approaches are more prone in being not optimized at all, or at least, less mantainable in the long run.
The idea is to let the engine programmers to write shaders and optimize them. So, a typical technical artist is allowed only to create materials with a given set of shaders. I think is the crytek material editor approach and naughty dog material editor too: few shaders, optimized and several materials using them.
I'm realizing now that If I write at hand, for example, bump mapping with no specular map (e.g. for a rock material, or in general for a material that doesn't have specular properties) then when I have to write the shader which has specular map I have to duplicate all the code since they differ only for a texture: the specular map. It's a waste of time and I'm wondering if I'll be constrained in making the usual uber shader or if there is a better and faster way to generate shaders considering that most of the code is shared.
At them moment in the engine I'll have to write a set of function and classes for each new shader added ... not fast at all if I want to add a new shader.

What you guys suggest ?

I was thinking of some kind of shader cache that is loaded upfront etc ...

### #2Reedbeta

DevMaster Staff

• 5307 posts
• LocationBellevue, WA

Posted 20 March 2012 - 05:11 PM

For the engine stuff I would try to go with a more data-driven approach, so that you don't have to add functions and classes for every shader, but have some more generic shader code that can read some metadata attached to the shader (e.g. in annotations or comments in the effect file) to tell your engine whatever it needs to know about the shader.

As for permutations in general, ubershaders are a valid approach. You can write a kind of preprocessor to generate all the technique definitions for the different combinations for you (ideally limiting it to only the combinations you actually use in your game), to save you the work of typing and maintaining those yourself. Again, having some metadata in the effect file can be helpful here.

Another approach is to write a library of shader functions to implement each feature, like ApplyBumpMap(), ApplySpecularMap(), etc., then write a generator that strings together a bunch of these functions to make a pixel shader. The functions would have to have a defined order and operate on some common data model for this to work. I haven't tried this approach myself but it seems feasible.

In D3D11 there's also shader dynamic linking, but I don't know much about it. There are some docs on MSDN here.
reedbeta.com - developer blog, OpenGL demos, and other projects

### #3SuperPixel

Valued Member

• Members
• 306 posts

Posted 20 March 2012 - 05:27 PM

When you talk about effect file you mean an actual d3d *.fx file or it's just a general way to indicate a shader ? I do not use fx framework at all ...

### #4Reedbeta

DevMaster Staff

• 5307 posts
• LocationBellevue, WA

Posted 20 March 2012 - 05:30 PM

I meant an actual .fx file. I think it's cleaner to have all the associated shaders (vertex, pixel, etc.) in one file, as that system does.

If you work with bare shaders alone in their own files then you even more badly need some kind of metadata-driven approach to keep them all organized.
reedbeta.com - developer blog, OpenGL demos, and other projects

### #5SuperPixel

Valued Member

• Members
• 306 posts

Posted 20 March 2012 - 05:34 PM

Reedbeta, on 20 March 2012 - 05:30 PM, said:

I meant an actual .fx file. I think it's cleaner to have all the associated shaders (vertex, pixel, etc.) in one file, as that system does.

If you work with bare shaders alone in their own files then you even more badly need some kind of metadata-driven approach to keep them all organized.

Is it still possible to have some metadata stuff (like annotations) in a bare shader ?

I currently have pixel and vertex shader in one file and since the engine is multiplatform I'd like to be decoupled from the fx framework.

Could you provide an example of a use case for your approach ? metada in the shader etc ?

thanks

### #6Reedbeta

DevMaster Staff

• 5307 posts
• LocationBellevue, WA

Posted 20 March 2012 - 05:55 PM

I don't know if annotations are supported in bare shaders. Probably not, though. You could still use comments with a specific format that your tools could parse, something like

// [Metadata]
// RenderPass = Opaque
// Textures = Diffuse, Normal, Specular

Just making up some stuff as an example, but you get the idea of the kind of things you might store in there.
reedbeta.com - developer blog, OpenGL demos, and other projects

### #7SuperPixel

Valued Member

• Members
• 306 posts

Posted 22 March 2012 - 08:41 AM

Reedbeta, on 20 March 2012 - 05:55 PM, said:

I don't know if annotations are supported in bare shaders. Probably not, though. You could still use comments with a specific format that your tools could parse, something like

// [Metadata]
// RenderPass = Opaque
// Textures = Diffuse, Normal, Specular

Just making up some stuff as an example, but you get the idea of the kind of things you might store in there.

What will be the chain from production to actual in engine compiling of a given shader ?

I mean:

1) An artist will create a material, this material will have different options set etc.
2) then this options will be defines in the uber shader ?...

Static branch removal means that if I have:

if( bHasSpecularMap ) I'll replace it with #ifdef HAS_SPECULAR_MAP ?

I've read on the fxc compiler documentation I can define macros to pass to the shader compiler, but they don't look to be like #define WHATEVER (I mean that they don't seem to be preprocessor macros).

Plus, one last question that is tormenting me: Why we can't get away with just a fixed amount of shaders ? Something like: The shaders needed to represent all the known material are, for example, 10 or something constant not too big and use those 10 shaders from a tool GUI editor selecting the shader of interest between those 10 and change just its parametrization !?
Why Uber shaders? Why we need so many permutations in a big game ? I ask this, maybe, silly question because I can't see why we can't just use 10 or 20 shaders (a constant number of them) and share them among several more materials ??

The general trend seems to be loads of permutations ...

Thanks

### #8JarkkoL

Senior Member

• Members
• 475 posts

Posted 22 March 2012 - 05:06 PM

### #9SuperPixel

Valued Member

• Members
• 306 posts

Posted 22 March 2012 - 05:21 PM

JarkkoL, on 22 March 2012 - 05:06 PM, said:

I'm still on the #ifdef thing. I'll actually be on ps3 very soon and I think I'll go with #ifdefs there (as I don't know how much time will steal texture fetches there. The ps3 gpu is not really powerful afaik). Static branching can be avoided I guess still using #ifdefs (I don't know much about static branching and its performances and problems, so I'm not into it for now).
I'm going multiplatform and I'll touch ios too, so I think static branching is really just d3d stuff ...
Btw I'm thinking to have a uber shader per platform, I think is the best way to keep the things separated.
You idea to send white texture if not used is interesting, but I don't think can be applied on all platform.
How expensive could be on ps3, ios, win etc ? Maybe not much on win, as It'll with dx10/dx11 (maybe in that case I'll send a 2x2 texture. It doesn't have to be necessarily 4x4 I guess as long it's power of 2)...

### #10Reedbeta

DevMaster Staff

• 5307 posts
• LocationBellevue, WA

Posted 22 March 2012 - 05:28 PM

I prefer to use uniform bools with if statements rather than #defines. The code looks nicer that way. You should be able to write (or have your code generate) wrapper functions with the appropriate combination of bools. Something like:

// myshader.ps
float4 PixelShader(float2 uv : TEXCOORD0, uniform bool bHasNormalMap, uniform bool bHasSpecularMap)
{
// do some stuff
if (bHasNormalMap) {
// etc.
}
if (bHasSpecularMap) {
// etc.
}
}

{
}

{
}

{
}

Then you'd compile it with one of the PixelShaderBlahBlah functions specified as entry point. The compiler will optimize away the branches and eliminate any unused code. You could compile the same file multiple times with different entry points to get different versions of it. You could also write some code to automatically generate the PixelShaderBlahBlah functions; you could put in some metadata to tell the generator what it needs to know to write that code.

This is not the same thing as static branching; it's really just the same as using #defines, but with nicer syntax.

You could also use #defines and #ifdefs; it conceptually works the same way. "#define HAS_SPECULAR_MAP" turns into "/D HAS_SPECULAR_MAP" on the fxc command line, or "#define HAS_SPECULAR_MAP 1" becomes "/D HAS_SPECULAR_MAP=1". The PS3 shader compiler has similar options.

However, as Jarkko said, having a huge number of permutations may not be necessary and if it is a performance issue, you should establish that it is before actually doing a ton of work on a system like this.
reedbeta.com - developer blog, OpenGL demos, and other projects

### #11SuperPixel

Valued Member

• Members
• 306 posts

Posted 22 March 2012 - 05:45 PM

Reedbeta, on 22 March 2012 - 05:28 PM, said:

I prefer to use uniform bools with if statements rather than #defines. The code looks nicer that way. You should be able to write (or have your code generate) wrapper functions with the appropriate combination of bools. Something like:

// myshader.ps
float4 PixelShader(float2 uv : TEXCOORD0, uniform bool bHasNormalMap, uniform bool bHasSpecularMap)
{
// do some stuff
if (bHasNormalMap) {
// etc.
}
if (bHasSpecularMap) {
// etc.
}
}

{
}

{
}

{
}

Then you'd compile it with one of the PixelShaderBlahBlah functions specified as entry point. The compiler will optimize away the branches and eliminate any unused code. You could compile the same file multiple times with different entry points to get different versions of it. You could also write some code to automatically generate the PixelShaderBlahBlah functions; you could put in some metadata to tell the generator what it needs to know to write that code.

This is not the same thing as static branching; it's really just the same as using #defines, but with nicer syntax.

You could also use #defines and #ifdefs; it conceptually works the same way. "#define HAS_SPECULAR_MAP" turns into "/D HAS_SPECULAR_MAP" on the fxc command line, or "#define HAS_SPECULAR_MAP 1" becomes "/D HAS_SPECULAR_MAP=1". The PS3 shader compiler has similar options.

However, Jarkko that having a huge number of permutations may not be necessary and if it is a performance issue, you should establish that it is before actually doing a ton of work on a system like this.

The uniforms are managed the same way constants in a constant buffer ? Shouldn't constants be treated as uniform too ?

What does it mean: The compiler will optimize away the branches ? I thought it was best to avoid branching at all, I mean standard ifs ...

maybe on some other platform #ifdefs would be more reliable ? I mean we can't be sure that every compiler accross different platform will optimize the branches away ... ?!

### #12Reedbeta

DevMaster Staff

• 5307 posts
• LocationBellevue, WA

Posted 22 March 2012 - 06:04 PM

Any half-decent compiler should optimize away branches with a constant condition. I'm not aware of any shader compiler in which this wouldn't work. It certainly works in D3D and on PS3.
reedbeta.com - developer blog, OpenGL demos, and other projects

### #13SuperPixel

Valued Member

• Members
• 306 posts

Posted 22 March 2012 - 06:09 PM

Reedbeta, on 22 March 2012 - 06:04 PM, said:

Any half-decent compiler should optimize away branches with a constant condition. I'm not aware of any shader compiler in which this wouldn't work. It certainly works in D3D and on PS3.

Sorry reedbeta for my question about constant buffers, I didn't notice that you where passing constant true or false etc... BTW everything makes more sense to me now. Thanks a lot.

### #14JarkkoL

Senior Member

• Members
• 475 posts

Posted 22 March 2012 - 06:43 PM

### #15SuperPixel

Valued Member

• Members
• 306 posts

Posted 23 March 2012 - 07:27 AM

JarkkoL, on 22 March 2012 - 06:43 PM, said:

With reedbeta approach how many permutations on average we can have ? I was always wondering how it could be possible that one can easily go past the 1000 permutations ! How this can be possible considering that the materials in general are not that many ? Bump, reflection env map, parallax, displacement with tessellation, skin and that's it ! How can be possible to have loads of variants from so few materials? (not considering the ones for particles now and general purpose effects) ...

### #16TheNut

Senior Member

• Moderators
• 1699 posts
• LocationThornhill, ON

Posted 23 March 2012 - 11:13 AM

It can add up depending on how far you want to optimize your shaders. Reed was only giving an example based on your original post of bump mapping with vs without specular reflection. Imagine you have materials that require several kinds of diffuse or specular reflection models, or perhaps you have other reflection models to consider such as Fresnel reflection, or multi-textured scenarios where some models use specular maps vs those without. The list can drag on. In theory, a lot of shader code could be reused. In practice, because of the nature of how shaders were designed, IMO it's not practical to try and maximize that. I use a special pre-compile stage to import extra functions into shaders, but that's about the extent I go with code reuse. If necessary I will handcraft a shader for a specific instance and that's the end of it.
http://www.nutty.ca - Being a nut has its advantages.

### #17Stainless

Member

• Members
• 581 posts
• LocationSouthampton

Posted 23 March 2012 - 01:35 PM

I agree with TheNut, I don't use ubershaders at all.

I would rather have one shader per material if it came to it. After all the disk space required for a 100 shaders won't add up to the space required for a single hires texture.

If you are worried about the complexity of managing lots of shaders, I would move it back a stage in the build process.

Start thinking about maybe using a xml file to define the shader, then in the build phase create a text file containing a valid shader which gets compiled into the game.

It depends on your build environment, but every environment I have used allows custom build stages.

### #18SuperPixel

Valued Member

• Members
• 306 posts

Posted 23 March 2012 - 06:34 PM

Stainless, on 23 March 2012 - 01:35 PM, said:

I agree with TheNut, I don't use ubershaders at all.

I would rather have one shader per material if it came to it. After all the disk space required for a 100 shaders won't add up to the space required for a single hires texture.

If you are worried about the complexity of managing lots of shaders, I would move it back a stage in the build process.

Start thinking about maybe using a xml file to define the shader, then in the build phase create a text file containing a valid shader which gets compiled into the game.

It depends on your build environment, but every environment I have used allows custom build stages.

Ok I understand well now. Once you have your shader variant selected how you expose the constant params that can be set to that given shader without creating a ne function every time that is needed ? Or you actually manage that simply adding a new function to a bunch of functions?

### #19Stainless

Member

• Members
• 581 posts
• LocationSouthampton

Posted 23 March 2012 - 08:36 PM

This is the way I would do it.

1) Have the artist save the material in a format I can parse
2) Add them to the game project as resources with a custom build step
3) Parse the material file to create a shader
4) (Optional) Compile the shader into a binary form.
5) (Optional) Convert the binary shader to source code
6) Parse the material again to create a c++ class, (Optional) attach source code from stage 5

Then in the game all I would do is map the material name stored in the mesh to a class and create a new instance of it.

Sounds complicated, but it really isn't that bad, depending on your development environment.

### #20SuperPixel

Valued Member

• Members
• 306 posts

Posted 24 March 2012 - 07:01 PM

Stainless, on 23 March 2012 - 08:36 PM, said:

This is the way I would do it.

1) Have the artist save the material in a format I can parse
2) Add them to the game project as resources with a custom build step
3) Parse the material file to create a shader
4) (Optional) Compile the shader into a binary form.
5) (Optional) Convert the binary shader to source code
6) Parse the material again to create a c++ class, (Optional) attach source code from stage 5

Then in the game all I would do is map the material name stored in the mesh to a class and create a new instance of it.

Sounds complicated, but it really isn't that bad, depending on your development environment.

Part 2 is the same as part 6 ? The custom build rule will generate something, that I think is a class?
You write a python script or just plain c++ to parse and generate stuff?

#### 1 user(s) are reading this topic

0 members, 1 guests, 0 anonymous users


text:
# Tag Info

0

Note that \begin{align*} dJ_c(s) = dB_s -cJ_c(s) ds. \end{align*} Moreover, $d\langle J_c, J_c\rangle_t = dt$. Then, by Ito's lemma, \begin{align*} \int_0^1J_c(s) dJ_c(s) &= \int_0^1 d\left(J_c^2(s) -s \right)\\ &= J_c^2(1) - 1. \end{align*} Since \begin{align*} J_c(1) &= \int_0^1 e^{-c(1-s)}dB_s \end{align*} is normal with zero mean and the ...

-1

Finally, I found it wrong. The correct way is dB_x = mvnrnd(zeros(K, 1), Omega_xx/n, n); % n-by-m matrix B_x = cumsum(dB_x,1); % n-by-m matrix B_x = [zeros(1,K); B_x]; J_c = exp(C*[1:n]/n)'.*cumsum(exp(-C*[1:n]/n).*[zeros(K,1) dB_x(1:n-1,:)'])'; dJ_c=[J_c(1,:); diff(J_c)]; % m-by-n matrix int_J = J_c'*dJ_c;

0

Define $X_t = -\int_0^t\beta_s\,dW_s$ and $Y_t = -\frac{1}{2}\int_0^t\beta_s^2\,ds$. Then $Z_t = e^{X_t+Y_t}$. Even though you did not mention it I am guessing that there is a condition on $(\beta_s)_{s\geq 0}$ that makes $X$ a local martingale. Since Brownian motion has continuous paths, $X$ is continuous as well, which implies $Z$ is continuous as well. ...

3

Unfortunately, I have never really found an explanation for basic stochastic calculus which is both mathematically accessible and technically correct. I will give the usual mathematical treatment, but I concede that it is not particularly accessible. $W$ is a process on $[0,\infty)$ with the following basic properties: $W(0)=0$ $W$ is a Gaussian process. $... 1 Although Brownian paths are not differentiable point wise, we may interpret their time derivative in a distributional sense to get a generalized stochastic process called white noise. We denote it by $$\eta (t,\omega )=\overset{\centerdot }{\mathop{B}}\,(t,\omega )$$ We also use the notation $$d\eta=dB_t$$ The term white noise arises from the spectral ... 1 chi-squared random variable with k degrees of freedom is given as $$\chi^2=\sum\limits_{i=1}^{k}{{{X}_{i}}^{2}}$$ where the$X_i$'s are all independent and have$N(0, 1)$distributions. Also recall that I claimed that$\chi^2$has a gamma distribution with parameters$r=k=2$and$\alpha=\frac{1}{2}$, thus $$M_{\chi^{\,2}}(t)=\left(\frac{1}{1-2t}\right)^{\... 1 I think that if f(t,x)= e^ {\beta t}, we have$$df/dt=\beta f(t,x), df/dx=e^ {\beta t}, d^2f/dx^2=0$$So using Ito formula we can receive the differential of d (e^ {\beta t}R(t)) -$$d (e^ {\beta t}R(t)) = df(t,R(t))= \beta e^ {\beta t}R(t)dt+e^ {\beta t}dR(t)=\beta e^ {\beta t}R(t)dt+e^ {\beta t}adt-\beta e^ {\beta t} R(t) dt +e^ {\beta t} \sigma dW(... 1 Calculate the ito differential: $$dN=\beta N(t)dt-\alpha e^{\beta t}\sin(\alpha W(t))dW-\alpha^2N(t)dt.$$ It follows that if$\beta=\alpha^2$, then$N(t)$is a martingale. Thus surely you know how to calculate$E[N(t)]$and also$\cos(\alpha W(t))=N(t)e^{-\beta t}, so: $$E[N(t)]=E[e^{\beta t}\cos(\alpha W(t))]=e^{\beta t}E[\cos(\alpha W(t))]$$ 1 Your idea is fine, however, there are a few mistakes. Here is another solution. Note that, \begin{align*} u_t &= \int_{t-1}^{t} \int_{0}^{s}e^{-\kappa(t-s)-c(s-r)}dW(r) \,ds \\ &= \int_{0}^{t-1} \int_{t-1}^{t}e^{-\kappa(t-s)-c(s-r)}ds\,dW(r) + \int_{t-1}^{t} \int_{r}^{t}e^{-\kappa(t-s)-c(s-r)}ds\,dW(r)\\ &= e^{-\kappa t} \int_{t-1}^t e^{(\kappa ... 1 Here is my calculation, which may be wrong or not, I am not quite sure... \begin{align} Var(u_t) &= E(u_t^2) = E\left(\int_{t-1}^{t} \int_{0}^{s}e^{-\kappa(t-s)-c(s-r)}dW(r) \,ds\right)^2 \\ &= E\left(\int_{0}^{t} \int_{r}^{t}e^{-\kappa(t-s)-c(s-r)}\,ds\, dW(r) \right)^2 \\ &= \int_{0}^{t} \left(\int_{r}^{t}e^{-\kappa(t-s)-c(s-r)}ds\right)^2\, ... 1 I assume you want to prove it using Ito calculus, otherwise it is just moments of a gaussian random variable. By Ito:W^{n}_t=\int_{0}^t n W^{n-1}_s dW_s+\frac{n(n-1)}{2}\int_{0}^tW^{n-2}_sds $$using induction hypothesis (to get the local martingale part being a true martingale), I have:$$\mathbb{E}[W^{n}_t]=\frac{n(n-1)}{2}\int_{0}^t\mathbb{E}[W^{n-2}... 0 Question 1 (Girsanov's theorem) LetW_t$be a Brownian motion under the physical measure$\mathbb{P}$. Define $$L_t := \exp \left\{-\int_{0}^{t} X_s dW_s - \frac{1}{2} \int_{0}^{t} X_s^2ds \right\},$$ and define an equivalent martingale measure$\mathbb{Q}$by setting$d\mathbb{Q}/d\mathbb{P} = L_t$, then$B_t = W_t + \int_{0}^{t} X_s ds$is a standard ... 2$dX_t = (\beta-\alpha X_t) \, dt + \sigma \, dB_t$Forget a moment about the SDE and consider the associated ordinary differential equation $$dx_t = (\beta- \alpha x_t) \, dt \tag{1}$$ instead. If I would ask you to solve this ODE, you would (hopefully) first solve the homogeneous equation $$dx_t = -\alpha x_t \, dt$$ and find that the solution of this ... 1 Well, simple it is: $$E \left[ \int_0^1 X_t^2 dt\right] = \int_0^1 E\left[X_t^2\right] dt = \int_0^1 \int_0^t E\left[u(s)^2\right]ds\, dt \\= \int_0^1 \int_s^1 E\left[u(s)^2\right]dt\, ds = \int_0^1 E\left[(1-s)u(s)^2\right] ds = \int_0^1 E\left[(1-t)u(t)^2\right] dt.$$ Hence your equality follows, taking into account that$E\left[X_1^2\right] = \...

Top 50 recent answers are included


text:
# overfull hbox when I insert hline

I've got an issue related to table of contents. I want a horizontal line before each section, so I put

    \renewcommand{\cftsecfont}{
\hline
%other stuff that I need
}

This is perfect in terms of what I see, but I get a warning because (I guess) the compiler expects to find \hline within a table. So I replaced it with

line(1,0){length}

The problem now is that if length is long enough (I need the line to arrive on top of the page number), I get an overfull hbox.

Any idea? I already searched related problems with no luck.

-
Welcome to TeX.sx! –  Papiro Jul 3 '13 at 12:49
Please add a minimal working example (MWE) that illustrates your problem. It will be much easier for us to reproduce your situation and find out what the issue is when we see compilable code, starting with \documentclass{...} and ending with \end{document}. –  mafp Jul 3 '13 at 13:07

You are providing only spare information. However I guess you are looking for \hrulefill. So you modification can be:

\documentclass{article}
\usepackage{tocloft}
\usepackage{blindtext}
\renewcommand{\cftsecfont}{\hrulefill\par\nobreak\hskip -\leftskip\bfseries}
\begin{document}
\tableofcontents
\Blinddocument
\end{document}

-
+1 for a really minimum MWE :) –  Harish Kumar Jul 4 '13 at 0:10
Thank you that is what I was looking for (I had tried with \hrulefill only without success) –  ALPI Jul 4 '13 at 9:34


text:
<meta http-equiv="refresh" content="1; url=/nojavascript/"> Volume of Prisms and Cylinders | CK-12 Foundation
You are reading an older version of this FlexBook® textbook: CK-12 Geometry - Basic Go to the latest version.

# 11.4: Volume of Prisms and Cylinders

Created by: CK-12

## Learning Objectives

• Find the volume of prisms and cylinders.

## Review Queue

1. Define volume in your own words.
2. What is the surface area of a cube with 3 inch sides?
3. A regular octahedron has 8 congruent equilateral triangles as the faces.
1. If each edge is 4 cm, what is the slant height for one face?
2. What is the surface area of one face?
3. What is the total surface area?

Know What? Let’s fill the pool it with water. The shallow end is 4 ft. and the deep end is 8 ft. The pool is 10 ft. wide by 25 ft. long. How many cubic feet of water is needed to fill the pool?

## Volume of a Rectangular Prism

Volume: The measure of how much space a three-dimensional figure occupies.

Another way to define volume would be how much a three-dimensional figure can hold. The basic unit of volume is the cubic unit: cubic centimeter $(cm^3)$, cubic inch $(in^3)$, cubic meter $(m^3)$, cubic foot $(ft^3)$.

Volume of a Cube Postulate: $V=s^3$.

$V = s \cdot s \cdot s=s^3$

What this postulate tells us is that every solid can be broken down into cubes. For example, if we wanted to find the volume of a cube with 9 inch sides, it would be $9^3=729 \ in^3$.

Volume Congruence Postulate: If two solids are congruent, then their volumes are congruent.

These prisms are congruent, so their volumes are congruent.

Example 1: Find the volume of the right rectangular prism below.

Solution: Count the cubes. The bottom layer has 20 cubes, or $4 \times 5$, and there are 3 layers. There are 60 cubes. The volume is also $60 \ units^3$.

Each layer in Example 1 is the same as the area of the base and the number of layers is the same as the height. This is the formula for volume.

Volume of a Rectangular Prism: $V=l \cdot w \cdot h$.

Example 2: A typical shoe box is 8 in by 14 in by 6 in. What is the volume of the box?

Solution: We can assume that a shoe box is a rectangular prism.

$V=(8)(14)(6)=672 \ in^2$

## Volume of any Prism

Notcie that $l \cdot w$ is equal to the area of the base of the prism, which we will re-label $B$.

Volume of a Prism: $V=B \cdot h$.

$B$” is not always going to be the same. So, to find the volume of a prism, you would first find the area of the base and then multiply it by the height.

Example 3: You have a small, triangular prism shaped tent. How much volume does it have, once it is set up?

Solution: First, we need to find the area of the base.

$B &= \frac{1}{2} (3)(4)=6 \ ft^2.\\ V &= Bh=6(7)=42 \ ft^3$

Even though the height in this problem does not look like a “height,” it is, according to the formula. Usually, the height of a prism is going to be the last length you need to use.

## Oblique Prisms

Recall that oblique prisms are prisms that lean to one side and the height is outside the prism. What would be the volume of an oblique prism? Consider to piles of books below.

Both piles have 15 books, which means they will have the same volume. Cavalieri’s Principle says that leaning does not matter, the volumes are the same.

Cavalieri’s Principle: If two solids have the same height and the same cross-sectional area at every level, then they will have the same volume.

If an oblique prism and a right prism have the same base area and height, then they will have the same volume.

Example 4: Find the area of the oblique prism below.

Solution: This is an oblique right trapezoidal prism. Find the area of the trapezoid.

$B &= \frac{1}{2} (9)(8+4)=9(6)=54 \ cm^2\\V &= 54(15)=810 \ cm^3$

## Volume of a Cylinder

If we use the formula for the volume of a prism, $V = Bh$, we can find the volume of a cylinder. In the case of a cylinder, the base is the area of a circle. Like a prism, Cavalieri’s Principle holds.

Volume of a Cylinder: $V=\pi r^2 h$.

Example 5: Find the volume of the cylinder.

Solution: If the diameter is 16, then the radius is 8.

$V=\pi 8^2 (21)=1344 \pi \ units^3$

Example 6: Find the volume of the cylinder.

Solution: $V=\pi 6^2 (15)=540 \pi \ units^3$

Example 7: If the volume of a cylinder is $484 \pi \ in^3$ and the height is 4 in, what is the radius?

Solution: Solve for $r$.

$484 \pi &= \pi r^2 (4)\\ 121 &= r^2\\11 &= r$

Example 8: Find the volume of the solid below.

Solution: This solid is a parallelogram-based prism with a cylinder cut out of the middle.

$V_{prism} &= (25 \cdot 25)30=18750 \ cm^3\\V_{cylinder} &= \pi (4)^2 (30)=480 \pi \ cm^3$

The total volume is $18750 - 480 \pi \approx 17242.04 \ cm^3$.

Know What? Revisited Even though it doesn’t look like it, the trapezoid is the base of this prism. The area of the trapezoids are $\frac{1}{2} (4+8)25=150 \ ft^2$. $V=150(10)=1500 \ ft^3$

## Review Questions

• Question 1 uses the volume formula for a cylinder.
• Questions 2-4 are similar to Example 1.
• Questions 5-18 are similar to Examples 2-6.
• Questions 19-24 are similar to Example 7.
• Questions 25-30 are similar to Example 8.
1. Two cylinders have the same surface area. Do they have the same volume? How do you know?
2. How many one-inch cubes can fit into a box that is 8 inches wide, 10 inches long, and 12 inches tall? Is this the same as the volume of the box?
3. A cereal box in 2 inches wide, 10 inches long and 14 inches tall. How much cereal does the box hold?
4. A can of soda is 4 inches tall and has a diameter of 2 inches. How much soda does the can hold? Round your answer to the nearest hundredth.
5. A cube holds $216 \ in^3$. What is the length of each edge?
6. A cube has sides that are 8 inches. What is the volume?
7. A cylinder has $r = h$ and the radius is 4 cm. What is the volume?
8. A cylinder has a volume of $486 \pi \ ft.^3$. If the height is 6 ft., what is the diameter?

Use the right triangular prism to answer questions 9 and 10.

1. What is the length of the third base edge?
2. Find the volume of the prism.
3. Fuzzy dice are cubes with 4 inch sides.
1. What is the volume of one die?
2. What is the volume of both dice?
4. A right cylinder has a 7 cm radius and a height of 18 cm. Find the volume.

Find the volume of the following solids. Round your answers to the nearest hundredth.

Algebra Connection Find the value of $x$, given the surface area.

1. $V=504 \ units^3$
2. $V=6144 \pi \ units^3$
3. $V=2688 \ units^3$
4. The area of the base of a cylinder is $49 \pi \ in^2$ and the height is 6 in. Find the volume.
5. The circumference of the base of a cylinder is $80 \pi \ cm$ and the height is 15 cm. Find the volume.
6. The lateral surface area of a cylinder is $30 \pi \ m^2$ and the circumference is $10 \pi \ m$. What is the volume of the cylinder?

The bases of the prism are squares and a cylinder is cut out of the center.

1. Find the volume of the prism.
2. Find the volume of the cylinder in the center.
3. Find the volume of the figure.

This is a prism with half a cylinder on the top.

1. Find the volume of the prism.
2. Find the volume of the half-cylinder.
3. Find the volume of the entire figure.

1. The amount a three-dimensional figure can hold.
2. $54 \ in^2$
1. $2 \sqrt{3}$
2. $\frac{1}{2} \cdot 4 \cdot 2 \sqrt{3} = 4 \sqrt{3}$
3. $8 \cdot 4 \sqrt{3} = 32 \sqrt{3}$

8 , 9 , 10

Feb 22, 2012

Dec 11, 2014


text:
# Default Stylesheet

When you use the HTML converter to generate a standalone HTML document, Asciidoctor includes a default stylesheet to ensure the HTML looks presentable right out of the box. This feature gets you up and running quickly by giving you a result you can preview or publish without having to do any additional work.

This page covers why the default is necessary, how to apply it, and how to build on it so you don’t have to create a stylesheet from scratch.

 The default stylesheet that Asciidoctor provides is just that, a default. If you prefer a different style, you can customize it, extend it, or replace it with an entirely different one. When replacing the default stylesheet, it’s important to understand that it does provide support for numerous features in AsciiDoc, as covered in the next section. You’ll need to include these required styles when developing your own stylesheet if you want these features to continue to work.

## Why provide a default?

Asciidoctor includes a default stylesheet to provide a nice out-of-the-box experience when generating HTML from AsciiDoc. But there’s more to it. There are elements of AsciiDoc that require stylesheet support.

One example is to honor built-in roles, such as text-center. In order for a role to take effect, it needs a companion CSS class in the stylesheet. To satisfy the expectations of a built-in role, a stylesheet is required.

You may have noticed the floating anchors next to section titles when you hover over them. Although the HTML to make them is there, it’s the stylesheet that brings them to life.

Another example is to implement list marker styles. AsciiDoc allows you to specify the marker for a list using a block style (e.g., loweralpha). However, HTML does not apply these markers by default. Rather, it’s something that the stylesheet provides.

The default stylesheet also applies borders and shading to table cells to support all combinations of the frame, grid, and stripes attributes.

Yet another example is the TOC position. To position the TOC on the left or right requires help from the stylesheet to change the layout of the page so the TOC appears as a sidebar. It’s the stylesheet that handles that task.

In order for the AsciiDoc experience to be complete when generating HTML, a stylesheet is required. The default stylesheet not only completes this experience, but also serves as a reference for the styles a custom stylesheet must provide.

### Web fonts

The default stylesheet ensures that the same fonts are selected across all platforms.

By default, the browser relies on system fonts. But system fonts vary widely by platform, so users end up getting a very different experience. That’s where web fonts come in.

When the default stylesheet is used, the converter adds additional HTML to load open source fonts from Google Fonts. The default stylesheet, in turn, specifies a preference for these fonts.

The web fonts used by the default stylesheet are as follows:

Noto Serif

body text (default)

Open Sans

Droid Sans Mono

monospaced phrases and verbatim blocks

Loading and preferring these web fonts ensures everyone sees the same result.

## Usage

When generating HTML, there’s nothing special you need to do to apply the default stylesheet. Asciidoctor automatically embeds the default stylesheet into the <head> of the generated HTML when you run the asciidoctor command.

$asciidoctor document.adoc Since no stylesheet is specified, Asciidoctor uses the default stylesheet (which is located at data/stylesheets/asciidoctor.css inside the installed gem). When you view the generated HTML file, document.html, you’ll see styled HTML, as shown here: If you want Asciidoctor to generate HTML that links to the default stylesheet instead of embedding it in the HTML, you can instruct it to do so by setting the linkcss and copycss attributes as follows: $ asciidoctor -a linkcss -a copycss document.adoc

When using the API, Asciidoctor already links to the stylesheet by default instead of embedding it (due to the default safe mode). However, Asciidoctor does not copy the stylesheet to the output directory. You would have to put it there yourself. Otherwise, the browser will not be able to find the stylesheet.

To solve this problem, set the safe mode to server or lower (e.g., server, safe, or unsafe) and Asciidoctor will embed the default stylesheet, like when using the asciidoctor command.

require 'asciidoctor'

Asciidoctor.convert_file 'document.adoc', safe: :safe

## Disable or modify the web fonts

When the default stylesheet is used, the converter adds a <link> element specialized by the attribute rel="stylesheet" to load web fonts from Google Fonts. You can disable this link by unsetting the webfonts document attribute from the CLI, API, or document header.

$asciidoctor -a webfonts! document.adoc With the web fonts absent, the browser will drop back to the fallback system fonts specified in the stylesheet. But this also provides an opportunity to use docinfo to load the web fonts from a different source. Rather than disabling the link, you can also use the webfonts attribute to change which fonts are loaded. When set, the value of the webfonts attribute is used as the value of the family query string parameter in the font-loader URL. Let’s say you want to use Ubuntu Mono instead of Droid Sans Mono for monospaced text. You would set the webfonts attribute as follows: $ asciidoctor \
-a webfonts="Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CUbuntu+Mono:400" \
document.adoc

In this case, you would still need to use docinfo to instruct the stylesheet to use the new font.

## Customize the default stylesheet

What if the default stylesheet is not exactly to your liking, but you don’t want to go off and create a custom stylesheet from scratch? Can you customize it? Indeed, you can.

There are at least two ways to customize the default stylesheet. One way is to add auxiliary styles using docinfo. Another way is to create a custom stylesheet, but import the default stylesheet as a starting point.

### Auxiliary styles with docinfo

Adding auxiliary styles is a great use case for docinfo. The docinfo feature in AsciiDoc allows you to inject auxiliary content from a file into various places in the HTML output. In this case, we’re interested in the "head" position, which injects content at the bottom of the <head> element.

Let’s say you want to change the color of headings (and other heading-like titles) to match the color of paragraph text. Start by creating a file named docinfo.html (head is the default location) and populate it with a <style> element with the necessary styles.

Example 1. docinfo.html
<style>
h1, h2, h3, h4, h5, h6, #toctitle,
.sidebarblock > .content > .title {
color: rgba(0, 0, 0, 0.8);
}
</style>

Now tell Asciidoctor to look for and load the docinfo file using the docinfo attribute:

$asciidoctor -a docinfo=shared document.adoc The <style> element in your docinfo file will be inserted directly below the default stylesheet in the generated HTML. ### Make more elements addressable from CSS If you want to style specific elements in your content, you need to make them addressable from CSS. In other words, it must be possible to target them using a CSS selector. There are two mechanisms in AsciiDoc that enable you to do this: id You can add an ID to almost any element in AsciiDoc using the ID attribute. The ID attribute in AsciiDoc translates to the id attribute in HTML. You can then target that element (and only that element) from CSS in order to modify its style using the syntax #<id>, where <id> is the value you specify. Each ID can only be used once in a document. role You can add a role to almost any element in AsciiDoc using the role attribute. The role attribute in AsciiDoc translates to the class attribute in HTML. You can then target that element (and any other elements that share the same role) from CSS in order to modify its style using the syntax .<role>, where <role> is the value you specify. A role can be used many times in the document. You can even target different elements that share the same role individually in the stylesheet by adding the element name (e.g., span.appname) or additional roles (e.g., .varname.global). For any ID or role you introduce, you must provide custom styles for it in order for it to have any visual effect. ### Extend the default stylesheet Instead of writing a custom stylesheet from scratch, you can import the default stylesheet and add overrides for any styles you want to change (leveraging the cascading nature of CSS). This is also a good way to use the default stylesheet, but load web fonts from a different CDN. Let’s again change the color of headings (and other heading-like titles) to match the color of paragraph text. Start by creating a stylesheet named my-asciidoctor.css. Next, add an @import declaration to import the default stylesheet. We use a CDN here to pull the default stylesheet directly out of the repository, but you can put it anywhere the browser can access it. Then, add another @import declaration to import the web fonts the default stylesheet uses (which are not imported by the default stylesheet). Finally, add your overrides below those @import directives. Here’s how that looks altogether. @import "https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400,700"; @import "https://cdn.jsdelivr.net/gh/asciidoctor/asciidoctor@2.0/data/stylesheets/asciidoctor-default.css"; h1, h2, h3, h4, h5, h6, #toctitle, .sidebarblock > .content > .title { color: rgba(0, 0, 0, 0.8); } Now tell Asciidoctor to use your custom stylesheet instead of the default one: $ asciidoctor -a stylesheet=my-asciidoctor.css document.adoc

Asciidoctor will now embed the contents of your custom stylesheet instead of the default one. However, Asciidoctor will not embed the contents of the default stylesheet. Instead, the browser will fetch it from the location specified by the @import directive. You can avoid this network call by putting the default stylesheet in the same directory as your custom stylesheet and linking to it using @import "asciidoctor.css".

To obtain the compiled default stylesheet, you can either download it from the source repository, or you can use the following asciidoctor command (or equivalent) to write it to the current directory:

$echo | asciidoctor -o$TMPDIR/out.html -a linkcss -a copycss - && cp \$TMPDIR/asciidoctor.css .

Alternately, you can use this script to write the default stylesheet to the working directory:

require 'asciidoctor'

Asciidoctor::Stylesheets.instance.write_primary_stylesheet '.'

You can also download the source of the default stylesheet if you want to use it as a starting point for developing a custom stylesheet.


text:
## Thursday, October 20, 2016

### [sunifufr] Function from zero crossings

Given a list of zero-crossings on the X axis, construct a wavy function which is zero at only those points.  (Need to say "only", or else we can simply construct the zero function.  Or perhaps those are the only zeros inside the interval defined by the list; there may be further zeros outside the interval.)  This is an underconstrained problem.  Construct a "nice" function, for some definition of nice.

Splines are the obvious first idea.  An analytic function (infinitely differentiable) would be nicer.  Low order polynomial that has "large" absolute value between zeros but low maximum absolute value on the interval.

What if the list of zero-crossings is infinite, e.g., Riemann-Siegel Z function, or sine, or cosine?  Construct a sum of sines and cosines which, when truncated, get the zeros approximately correct, for some definition of approximate.

Original inspiration, the zero crossings of sin(x) sin(m*x) where m is an irrational number, have no periodic pattern.  The zeros are where a line of irrational slope intersect a regular grid of orthogonal lines.


text:
# 2022-01-23

Refs: ?

## 18:36

• What is the zeta function of a number field?

• Idea: $${\mathbb{Z}}$$ and $${\mathbb{F}}_q[t]$$ are similar. Quotients by maximal ideals are fields, while the characteristics are mixed for $${\mathbb{Z}}$$ and all $$p$$ for the latter.

• Dirichlet’s theorem: for each $$m\in {\mathbb{Z}}_{\geq 1}$$ and $$a$$ coprime to $$m$$, there are infinite many primes $$p\equiv a\operatorname{mod}m$$.

• By Chebotarev density, for a fixed modulus $$m$$ the primes are equidistributed among residue classes.
• The absolute value on $${\mathbb{Q}}$$ inherited from $${\mathbb{R}}$$ is the infinite place $${\left\lvert {{-}} \right\rvert}_\infty$$. The finite places are the $$p{\hbox{-}}$$adic valuations $$v_p$$.

• Recovering a module as an intersection of its local points:

• Important strategy: to show a property holds for an ideal $$I {~\trianglelefteq~}R$$ an integral domain, show that it holds for all of its localizations $$I \left[ { \scriptstyle { { ({{\mathfrak{p}}}^c) }^{-1}} } \right]$$ for $${\mathfrak{p}}\in \operatorname{Spec}R$$, and that the property is preserved under intersections.
#untagged #web/quick-notes


text:
Eplot-package {Eplot} R Documentation

## Plotting longitudinal series.

### Description

The aim is to adjust the graphical parameters to create nicer longitudinal series plots. The default set of graphical parameters is very general, and can be improved upon when we are interested in plotting data points observed over time. Functions facilitate plotting those kind of series, univariate plots, bivariate plots (with vertical axis on both left and right hand sides), multivariate plots and plots which allow to examine whether a new observation is 'unusual' via construction and visualization of prediction intervals around it.

### Details

 Package: Eplot Type: Package Version: 1.0 Date: 2014-07-30 License: GPL-2

The idea is to adjust defult graphical parameters to create nicer longitudinal series plots. The user have the choice to keep the new set of graphical parameters or to revert to the initial set of graphical parameters. Other functions include multivariate plot, plot with vertical axis on both left and right hand sides, and plot which superimpose prediction intervals from an AR-ARCH model.

### Author(s)

Eran Raviv

Maintainer: Eran Raviv

### Examples

par(mfrow = c(2,1))
out <- FCIplot(rnorm(100),plott=TRUE,k=30)
plott(out,main="The out-of-sample standard deviation")

[Package Eplot version 1.0 Index]


text:
# push forward of differential form/ integration over fiber

It is elementary that differential forms can be pulled back via a smooth map between manifolds. However, I was reading a paper and came across a construction about push forward of a differential form via a submersion which I didn't fully understand.

The paper pointed to Differential Forms in Algebraic Topology by Bott and Tu for reference. However, since I have little background in algebraic topology, I would like to know if anyone can show me a more detailed explanation, or point me to some references.

Below is the construction as described in the paper:

If $f: X\rightarrow Y$ is a submersion from an oriented manifold of dimension $n$ to an oriented manifold of dimension $m \leq n$. Then the fibers are manifolds of dimension $r=n-m$.

So far this is OK, and it continues:

Integration over the fibers gives a map $f_*: D^p(X)\rightarrow D^{p-r}(Y)$ defined as follows.

Any $p$-form $\phi$ on $X$ with compact support can be written $\phi = \psi \wedge f^*\omega$, where $\psi$ is an $r$-form with compact support on $X$ and $\omega$ is a $(p-r)$-form on $Y$. To see this, use a partition of unity to write $\phi$ as a sum of forms with support in a coordinate neighborhood, and in local coordinates the decomposition becomes obvious.

We can then consider $f_*\psi$ on $Y$ with compact support defined by $f_*\psi (y)=\int_{f^{-1}(y)} \psi$ and define $f_*\phi = f_* \psi \wedge \omega$.

What I didn't understand is how the $p$-form $\phi$ on $X$ can be decomposed as $\psi \wedge f^*\omega$. (Even though it says it's obvious in local coordinates...) Is this decomposition unique? If not, then the push forward $f_* \phi$ better not depend on the decomposition..?

• Using a partition of unity, you can reduce the statement to the one correspinding to forms $\phi$ with support contained in an open set which is a product, using the local form of a submersion. – Mariano Suárez-Álvarez Sep 15 '15 at 4:57

The decomposition is not unique, because we can replace $$\psi \wedge f^{\ast} \omega$$ with $$(f^{\ast}(g) \psi) \wedge f^{\ast} (g^{-1} \omega)$$ where $$g$$ is some smooth function $$Y \to \mathbb{R}_{>0}$$. Of course, this doesn't effect the pushforward, since $$\int_{f^{-1}(y)} f^{\ast}(g) \psi = g(y) \int_{f^{-1}(y)} f^{\ast}(g)$$ and then $$\left( \int_{f^{-1}(y)} f^{\ast}(g) \psi ) (g^{-1} \omega) \right)= g(y) g(y)^{-1} \omega = \omega$$. More generally, if $$\phi = \alpha \wedge f^{\ast}(\beta \wedge \gamma \wedge \delta)$$ with $$\alpha$$ an $$r-k$$ form, $$\beta$$ and $$\gamma$$ $$k$$-forms and $$\delta$$ a $$p-r-k$$ form, then $$\phi = (\alpha \wedge f^{\ast} \beta) \wedge f^{\ast}(\gamma \wedge \delta) = (-1)^k (\alpha \wedge f^{\ast} \gamma) \wedge f^{\ast}(\beta \wedge \delta)$$ are two such factorizations.
I think the simplest way to prove indepedence of the decomposition is to describe the pushforward in terms of its integrals. For $$\phi$$ any compactly supported $$p$$-form on $$X$$, and $$B$$ any embedding of a closed $$p$$-dimensional ball into $$Y$$, we have $$\int_B f_{\ast} \phi = \int_{f^{-1}(B)} \phi$$ (using Fubini). Since a $$p$$-form is defined by its integrals over all $$p$$-dimensional balls, this proves uniqueness of such a $$f_{\ast} \phi$$ (but not existence, use Bott and Tu's argument for that.)