text:
org.apache.commons.math3.geometry.euclidean.threed

## Class FieldVector3D<T extends RealFieldElement<T>>

• java.lang.Object
• org.apache.commons.math3.geometry.euclidean.threed.FieldVector3D<T>
• Type Parameters:
T - the type of the field elements
All Implemented Interfaces:
Serializable

public class FieldVector3D<T extends RealFieldElement<T>>
extends Object
implements Serializable
This class is a re-implementation of Vector3D using RealFieldElement.

Instance of this class are guaranteed to be immutable.

Since:
3.2
Serialized Form
• ### Constructor Summary

Constructors
Constructor and Description
FieldVector3D(double a, FieldVector3D<T> u)
Multiplicative constructor Build a vector from another one and a scale factor.
FieldVector3D(double a1, FieldVector3D<T> u1, double a2, FieldVector3D<T> u2)
Linear constructor Build a vector from two other ones and corresponding scale factors.
FieldVector3D(double a1, FieldVector3D<T> u1, double a2, FieldVector3D<T> u2, double a3, FieldVector3D<T> u3)
Linear constructor Build a vector from three other ones and corresponding scale factors.
FieldVector3D(double a1, FieldVector3D<T> u1, double a2, FieldVector3D<T> u2, double a3, FieldVector3D<T> u3, double a4, FieldVector3D<T> u4)
Linear constructor Build a vector from four other ones and corresponding scale factors.
FieldVector3D(T[] v)
Simple constructor.
FieldVector3D(T a, FieldVector3D<T> u)
Multiplicative constructor Build a vector from another one and a scale factor.
FieldVector3D(T a1, FieldVector3D<T> u1, T a2, FieldVector3D<T> u2)
Linear constructor Build a vector from two other ones and corresponding scale factors.
FieldVector3D(T a1, FieldVector3D<T> u1, T a2, FieldVector3D<T> u2, T a3, FieldVector3D<T> u3)
Linear constructor Build a vector from three other ones and corresponding scale factors.
FieldVector3D(T a1, FieldVector3D<T> u1, T a2, FieldVector3D<T> u2, T a3, FieldVector3D<T> u3, T a4, FieldVector3D<T> u4)
Linear constructor Build a vector from four other ones and corresponding scale factors.
FieldVector3D(T alpha, T delta)
Simple constructor.
FieldVector3D(T x, T y, T z)
Simple constructor.
FieldVector3D(T a, Vector3D u)
Multiplicative constructor Build a vector from another one and a scale factor.
FieldVector3D(T a1, Vector3D u1, T a2, Vector3D u2)
Linear constructor Build a vector from two other ones and corresponding scale factors.
FieldVector3D(T a1, Vector3D u1, T a2, Vector3D u2, T a3, Vector3D u3)
Linear constructor Build a vector from three other ones and corresponding scale factors.
FieldVector3D(T a1, Vector3D u1, T a2, Vector3D u2, T a3, Vector3D u3, T a4, Vector3D u4)
Linear constructor Build a vector from four other ones and corresponding scale factors.
• ### Method Summary

Methods
Modifier and Type Method and Description
FieldVector3D<T> add(double factor, FieldVector3D<T> v)
Add a scaled vector to the instance.
FieldVector3D<T> add(double factor, Vector3D v)
Add a scaled vector to the instance.
FieldVector3D<T> add(FieldVector3D<T> v)
Add a vector to the instance.
FieldVector3D<T> add(T factor, FieldVector3D<T> v)
Add a scaled vector to the instance.
FieldVector3D<T> add(T factor, Vector3D v)
Add a scaled vector to the instance.
FieldVector3D<T> add(Vector3D v)
Add a vector to the instance.
static <T extends RealFieldElement<T>> T angle(FieldVector3D<T> v1, FieldVector3D<T> v2)
Compute the angular separation between two vectors.
static <T extends RealFieldElement<T>> T angle(FieldVector3D<T> v1, Vector3D v2)
Compute the angular separation between two vectors.
static <T extends RealFieldElement<T>> T angle(Vector3D v1, FieldVector3D<T> v2)
Compute the angular separation between two vectors.
FieldVector3D<T> crossProduct(FieldVector3D<T> v)
Compute the cross-product of the instance with another vector.
static <T extends RealFieldElement<T>> FieldVector3D<T> crossProduct(FieldVector3D<T> v1, FieldVector3D<T> v2)
Compute the cross-product of two vectors.
static <T extends RealFieldElement<T>> FieldVector3D<T> crossProduct(FieldVector3D<T> v1, Vector3D v2)
Compute the cross-product of two vectors.
FieldVector3D<T> crossProduct(Vector3D v)
Compute the cross-product of the instance with another vector.
static <T extends RealFieldElement<T>> FieldVector3D<T> crossProduct(Vector3D v1, FieldVector3D<T> v2)
Compute the cross-product of two vectors.
T distance(FieldVector3D<T> v)
Compute the distance between the instance and another vector according to the L2 norm.
static <T extends RealFieldElement<T>> T distance(FieldVector3D<T> v1, FieldVector3D<T> v2)
Compute the distance between two vectors according to the L2 norm.
static <T extends RealFieldElement<T>> T distance(FieldVector3D<T> v1, Vector3D v2)
Compute the distance between two vectors according to the L2 norm.
T distance(Vector3D v)
Compute the distance between the instance and another vector according to the L2 norm.
static <T extends RealFieldElement<T>> T distance(Vector3D v1, FieldVector3D<T> v2)
Compute the distance between two vectors according to the L2 norm.
T distance1(FieldVector3D<T> v)
Compute the distance between the instance and another vector according to the L1 norm.
static <T extends RealFieldElement<T>> T distance1(FieldVector3D<T> v1, FieldVector3D<T> v2)
Compute the distance between two vectors according to the L1 norm.
static <T extends RealFieldElement<T>> T distance1(FieldVector3D<T> v1, Vector3D v2)
Compute the distance between two vectors according to the L1 norm.
T distance1(Vector3D v)
Compute the distance between the instance and another vector according to the L1 norm.
static <T extends RealFieldElement<T>> T distance1(Vector3D v1, FieldVector3D<T> v2)
Compute the distance between two vectors according to the L1 norm.
T distanceInf(FieldVector3D<T> v)
Compute the distance between the instance and another vector according to the L norm.
static <T extends RealFieldElement<T>> T distanceInf(FieldVector3D<T> v1, FieldVector3D<T> v2)
Compute the distance between two vectors according to the L norm.
static <T extends RealFieldElement<T>> T distanceInf(FieldVector3D<T> v1, Vector3D v2)
Compute the distance between two vectors according to the L norm.
T distanceInf(Vector3D v)
Compute the distance between the instance and another vector according to the L norm.
static <T extends RealFieldElement<T>> T distanceInf(Vector3D v1, FieldVector3D<T> v2)
Compute the distance between two vectors according to the L norm.
T distanceSq(FieldVector3D<T> v)
Compute the square of the distance between the instance and another vector.
static <T extends RealFieldElement<T>> T distanceSq(FieldVector3D<T> v1, FieldVector3D<T> v2)
Compute the square of the distance between two vectors.
static <T extends RealFieldElement<T>> T distanceSq(FieldVector3D<T> v1, Vector3D v2)
Compute the square of the distance between two vectors.
T distanceSq(Vector3D v)
Compute the square of the distance between the instance and another vector.
static <T extends RealFieldElement<T>> T distanceSq(Vector3D v1, FieldVector3D<T> v2)
Compute the square of the distance between two vectors.
T dotProduct(FieldVector3D<T> v)
Compute the dot-product of the instance and another vector.
static <T extends RealFieldElement<T>> T dotProduct(FieldVector3D<T> v1, FieldVector3D<T> v2)
Compute the dot-product of two vectors.
static <T extends RealFieldElement<T>> T dotProduct(FieldVector3D<T> v1, Vector3D v2)
Compute the dot-product of two vectors.
T dotProduct(Vector3D v)
Compute the dot-product of the instance and another vector.
static <T extends RealFieldElement<T>> T dotProduct(Vector3D v1, FieldVector3D<T> v2)
Compute the dot-product of two vectors.
boolean equals(Object other)
Test for the equality of two 3D vectors.
T getAlpha()
Get the azimuth of the vector.
T getDelta()
Get the elevation of the vector.
T getNorm()
Get the L2 norm for the vector.
T getNorm1()
Get the L1 norm for the vector.
T getNormInf()
Get the L norm for the vector.
T getNormSq()
Get the square of the norm for the vector.
T getX()
Get the abscissa of the vector.
T getY()
Get the ordinate of the vector.
T getZ()
Get the height of the vector.
int hashCode()
Get a hashCode for the 3D vector.
boolean isInfinite()
Returns true if any coordinate of this vector is infinite and none are NaN; false otherwise
boolean isNaN()
Returns true if any coordinate of this vector is NaN; false otherwise
FieldVector3D<T> negate()
Get the opposite of the instance.
FieldVector3D<T> normalize()
Get a normalized vector aligned with the instance.
FieldVector3D<T> orthogonal()
Get a vector orthogonal to the instance.
FieldVector3D<T> scalarMultiply(double a)
Multiply the instance by a scalar.
FieldVector3D<T> scalarMultiply(T a)
Multiply the instance by a scalar.
FieldVector3D<T> subtract(double factor, FieldVector3D<T> v)
Subtract a scaled vector from the instance.
FieldVector3D<T> subtract(double factor, Vector3D v)
Subtract a scaled vector from the instance.
FieldVector3D<T> subtract(FieldVector3D<T> v)
Subtract a vector from the instance.
FieldVector3D<T> subtract(T factor, FieldVector3D<T> v)
Subtract a scaled vector from the instance.
FieldVector3D<T> subtract(T factor, Vector3D v)
Subtract a scaled vector from the instance.
FieldVector3D<T> subtract(Vector3D v)
Subtract a vector from the instance.
T[] toArray()
Get the vector coordinates as a dimension 3 array.
String toString()
Get a string representation of this vector.
String toString(NumberFormat format)
Get a string representation of this vector.
Vector3D toVector3D()
Convert to a constant vector without derivatives.
• ### Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait
• ### Constructor Detail

• #### FieldVector3D

public FieldVector3D(T x,
T y,
T z)
Simple constructor. Build a vector from its coordinates
Parameters:
x - abscissa
y - ordinate
z - height
getX(), getY(), getZ()
• #### FieldVector3D

public FieldVector3D(T[] v)
throws DimensionMismatchException
Simple constructor. Build a vector from its coordinates
Parameters:
v - coordinates array
Throws:
DimensionMismatchException - if array does not have 3 elements
toArray()
• #### FieldVector3D

public FieldVector3D(T alpha,
T delta)
Simple constructor. Build a vector from its azimuthal coordinates
Parameters:
alpha - azimuth (α) around Z (0 is +X, π/2 is +Y, π is -X and 3π/2 is -Y)
delta - elevation (δ) above (XY) plane, from -π/2 to +π/2
getAlpha(), getDelta()
• #### FieldVector3D

public FieldVector3D(T a,
FieldVector3D<T> u)
Multiplicative constructor Build a vector from another one and a scale factor. The vector built will be a * u
Parameters:
a - scale factor
u - base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(T a,
Vector3D u)
Multiplicative constructor Build a vector from another one and a scale factor. The vector built will be a * u
Parameters:
a - scale factor
u - base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(double a,
FieldVector3D<T> u)
Multiplicative constructor Build a vector from another one and a scale factor. The vector built will be a * u
Parameters:
a - scale factor
u - base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(T a1,
FieldVector3D<T> u1,
T a2,
FieldVector3D<T> u2)
Linear constructor Build a vector from two other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(T a1,
Vector3D u1,
T a2,
Vector3D u2)
Linear constructor Build a vector from two other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(double a1,
FieldVector3D<T> u1,
double a2,
FieldVector3D<T> u2)
Linear constructor Build a vector from two other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(T a1,
FieldVector3D<T> u1,
T a2,
FieldVector3D<T> u2,
T a3,
FieldVector3D<T> u3)
Linear constructor Build a vector from three other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2 + a3 * u3
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
a3 - third scale factor
u3 - third base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(T a1,
Vector3D u1,
T a2,
Vector3D u2,
T a3,
Vector3D u3)
Linear constructor Build a vector from three other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2 + a3 * u3
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
a3 - third scale factor
u3 - third base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(double a1,
FieldVector3D<T> u1,
double a2,
FieldVector3D<T> u2,
double a3,
FieldVector3D<T> u3)
Linear constructor Build a vector from three other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2 + a3 * u3
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
a3 - third scale factor
u3 - third base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(T a1,
FieldVector3D<T> u1,
T a2,
FieldVector3D<T> u2,
T a3,
FieldVector3D<T> u3,
T a4,
FieldVector3D<T> u4)
Linear constructor Build a vector from four other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
a3 - third scale factor
u3 - third base (unscaled) vector
a4 - fourth scale factor
u4 - fourth base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(T a1,
Vector3D u1,
T a2,
Vector3D u2,
T a3,
Vector3D u3,
T a4,
Vector3D u4)
Linear constructor Build a vector from four other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
a3 - third scale factor
u3 - third base (unscaled) vector
a4 - fourth scale factor
u4 - fourth base (unscaled) vector
• #### FieldVector3D

public FieldVector3D(double a1,
FieldVector3D<T> u1,
double a2,
FieldVector3D<T> u2,
double a3,
FieldVector3D<T> u3,
double a4,
FieldVector3D<T> u4)
Linear constructor Build a vector from four other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4
Parameters:
a1 - first scale factor
u1 - first base (unscaled) vector
a2 - second scale factor
u2 - second base (unscaled) vector
a3 - third scale factor
u3 - third base (unscaled) vector
a4 - fourth scale factor
u4 - fourth base (unscaled) vector
• ### Method Detail

• #### toVector3D

public Vector3D toVector3D()
Convert to a constant vector without derivatives.
Returns:
a constant vector
• #### getNorm1

public T getNorm1()
Get the L1 norm for the vector.
Returns:
L1 norm for the vector
• #### getNorm

public T getNorm()
Get the L2 norm for the vector.
Returns:
Euclidean norm for the vector
• #### getNormSq

public T getNormSq()
Get the square of the norm for the vector.
Returns:
square of the Euclidean norm for the vector
• #### getNormInf

public T getNormInf()
Get the L norm for the vector.
Returns:
L norm for the vector

public FieldVector3D<T> add(FieldVector3D<T> v)
Add a vector to the instance.
Parameters:
v - vector to add
Returns:
a new vector

public FieldVector3D<T> add(Vector3D v)
Add a vector to the instance.
Parameters:
v - vector to add
Returns:
a new vector

public FieldVector3D<T> add(T factor,
FieldVector3D<T> v)
Add a scaled vector to the instance.
Parameters:
factor - scale factor to apply to v before adding it
v - vector to add
Returns:
a new vector

public FieldVector3D<T> add(T factor,
Vector3D v)
Add a scaled vector to the instance.
Parameters:
factor - scale factor to apply to v before adding it
v - vector to add
Returns:
a new vector

public FieldVector3D<T> add(double factor,
FieldVector3D<T> v)
Add a scaled vector to the instance.
Parameters:
factor - scale factor to apply to v before adding it
v - vector to add
Returns:
a new vector

public FieldVector3D<T> add(double factor,
Vector3D v)
Add a scaled vector to the instance.
Parameters:
factor - scale factor to apply to v before adding it
v - vector to add
Returns:
a new vector
• #### subtract

public FieldVector3D<T> subtract(FieldVector3D<T> v)
Subtract a vector from the instance.
Parameters:
v - vector to subtract
Returns:
a new vector
• #### subtract

public FieldVector3D<T> subtract(Vector3D v)
Subtract a vector from the instance.
Parameters:
v - vector to subtract
Returns:
a new vector
• #### subtract

public FieldVector3D<T> subtract(T factor,
FieldVector3D<T> v)
Subtract a scaled vector from the instance.
Parameters:
factor - scale factor to apply to v before subtracting it
v - vector to subtract
Returns:
a new vector
• #### subtract

public FieldVector3D<T> subtract(T factor,
Vector3D v)
Subtract a scaled vector from the instance.
Parameters:
factor - scale factor to apply to v before subtracting it
v - vector to subtract
Returns:
a new vector
• #### subtract

public FieldVector3D<T> subtract(double factor,
FieldVector3D<T> v)
Subtract a scaled vector from the instance.
Parameters:
factor - scale factor to apply to v before subtracting it
v - vector to subtract
Returns:
a new vector
• #### subtract

public FieldVector3D<T> subtract(double factor,
Vector3D v)
Subtract a scaled vector from the instance.
Parameters:
factor - scale factor to apply to v before subtracting it
v - vector to subtract
Returns:
a new vector
• #### normalize

public FieldVector3D<T> normalize()
throws MathArithmeticException
Get a normalized vector aligned with the instance.
Returns:
a new normalized vector
Throws:
MathArithmeticException - if the norm is zero
• #### orthogonal

public FieldVector3D<T> orthogonal()
throws MathArithmeticException
Get a vector orthogonal to the instance.

There are an infinite number of normalized vectors orthogonal to the instance. This method picks up one of them almost arbitrarily. It is useful when one needs to compute a reference frame with one of the axes in a predefined direction. The following example shows how to build a frame having the k axis aligned with the known vector u :

Vector3D k = u.normalize();
Vector3D i = k.orthogonal();
Vector3D j = Vector3D.crossProduct(k, i);

Returns:
a new normalized vector orthogonal to the instance
Throws:
MathArithmeticException - if the norm of the instance is null
• #### angle

public static <T extends RealFieldElement<T>> T angle(FieldVector3D<T> v1,
FieldVector3D<T> v2)
throws MathArithmeticException
Compute the angular separation between two vectors.

This method computes the angular separation between two vectors using the dot product for well separated vectors and the cross product for almost aligned vectors. This allows to have a good accuracy in all cases, even for vectors very close to each other.

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
angular separation between v1 and v2
Throws:
MathArithmeticException - if either vector has a null norm
• #### angle

public static <T extends RealFieldElement<T>> T angle(FieldVector3D<T> v1,
Vector3D v2)
throws MathArithmeticException
Compute the angular separation between two vectors.

This method computes the angular separation between two vectors using the dot product for well separated vectors and the cross product for almost aligned vectors. This allows to have a good accuracy in all cases, even for vectors very close to each other.

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
angular separation between v1 and v2
Throws:
MathArithmeticException - if either vector has a null norm
• #### angle

public static <T extends RealFieldElement<T>> T angle(Vector3D v1,
FieldVector3D<T> v2)
throws MathArithmeticException
Compute the angular separation between two vectors.

This method computes the angular separation between two vectors using the dot product for well separated vectors and the cross product for almost aligned vectors. This allows to have a good accuracy in all cases, even for vectors very close to each other.

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
angular separation between v1 and v2
Throws:
MathArithmeticException - if either vector has a null norm
• #### negate

public FieldVector3D<T> negate()
Get the opposite of the instance.
Returns:
a new vector which is opposite to the instance
• #### scalarMultiply

public FieldVector3D<T> scalarMultiply(T a)
Multiply the instance by a scalar.
Parameters:
a - scalar
Returns:
a new vector
• #### scalarMultiply

public FieldVector3D<T> scalarMultiply(double a)
Multiply the instance by a scalar.
Parameters:
a - scalar
Returns:
a new vector
• #### isNaN

public boolean isNaN()
Returns true if any coordinate of this vector is NaN; false otherwise
Returns:
true if any coordinate of this vector is NaN; false otherwise
• #### isInfinite

public boolean isInfinite()
Returns true if any coordinate of this vector is infinite and none are NaN; false otherwise
Returns:
true if any coordinate of this vector is infinite and none are NaN; false otherwise
• #### equals

public boolean equals(Object other)
Test for the equality of two 3D vectors.

If all coordinates of two 3D vectors are exactly the same, and none of their real part are NaN, the two 3D vectors are considered to be equal.

NaN coordinates are considered to affect globally the vector and be equals to each other - i.e, if either (or all) real part of the coordinates of the 3D vector are NaN, the 3D vector is NaN.

Overrides:
equals in class Object
Parameters:
other - Object to test for equality to this
Returns:
true if two 3D vector objects are equal, false if object is null, not an instance of Vector3D, or not equal to this Vector3D instance
• #### hashCode

public int hashCode()
Get a hashCode for the 3D vector.

All NaN values have the same hash code.

Overrides:
hashCode in class Object
Returns:
a hash code value for this object
• #### dotProduct

public T dotProduct(FieldVector3D<T> v)
Compute the dot-product of the instance and another vector.

The implementation uses specific multiplication and addition algorithms to preserve accuracy and reduce cancellation effects. It should be very accurate even for nearly orthogonal vectors.

Parameters:
v - second vector
Returns:
the dot product this.v
MathArrays.linearCombination(double, double, double, double, double, double)
• #### dotProduct

public T dotProduct(Vector3D v)
Compute the dot-product of the instance and another vector.

The implementation uses specific multiplication and addition algorithms to preserve accuracy and reduce cancellation effects. It should be very accurate even for nearly orthogonal vectors.

Parameters:
v - second vector
Returns:
the dot product this.v
MathArrays.linearCombination(double, double, double, double, double, double)
• #### crossProduct

public FieldVector3D<T> crossProduct(FieldVector3D<T> v)
Compute the cross-product of the instance with another vector.
Parameters:
v - other vector
Returns:
the cross product this ^ v as a new Vector3D
• #### crossProduct

public FieldVector3D<T> crossProduct(Vector3D v)
Compute the cross-product of the instance with another vector.
Parameters:
v - other vector
Returns:
the cross product this ^ v as a new Vector3D
• #### distance1

public T distance1(FieldVector3D<T> v)
Compute the distance between the instance and another vector according to the L1 norm.

Calling this method is equivalent to calling: q.subtract(p).getNorm1() except that no intermediate vector is built

Parameters:
v - second vector
Returns:
the distance between the instance and p according to the L1 norm
• #### distance1

public T distance1(Vector3D v)
Compute the distance between the instance and another vector according to the L1 norm.

Calling this method is equivalent to calling: q.subtract(p).getNorm1() except that no intermediate vector is built

Parameters:
v - second vector
Returns:
the distance between the instance and p according to the L1 norm
• #### distance

public T distance(FieldVector3D<T> v)
Compute the distance between the instance and another vector according to the L2 norm.

Calling this method is equivalent to calling: q.subtract(p).getNorm() except that no intermediate vector is built

Parameters:
v - second vector
Returns:
the distance between the instance and p according to the L2 norm
• #### distance

public T distance(Vector3D v)
Compute the distance between the instance and another vector according to the L2 norm.

Calling this method is equivalent to calling: q.subtract(p).getNorm() except that no intermediate vector is built

Parameters:
v - second vector
Returns:
the distance between the instance and p according to the L2 norm
• #### distanceInf

public T distanceInf(FieldVector3D<T> v)
Compute the distance between the instance and another vector according to the L norm.

Calling this method is equivalent to calling: q.subtract(p).getNormInf() except that no intermediate vector is built

Parameters:
v - second vector
Returns:
the distance between the instance and p according to the L norm
• #### distanceInf

public T distanceInf(Vector3D v)
Compute the distance between the instance and another vector according to the L norm.

Calling this method is equivalent to calling: q.subtract(p).getNormInf() except that no intermediate vector is built

Parameters:
v - second vector
Returns:
the distance between the instance and p according to the L norm
• #### distanceSq

public T distanceSq(FieldVector3D<T> v)
Compute the square of the distance between the instance and another vector.

Calling this method is equivalent to calling: q.subtract(p).getNormSq() except that no intermediate vector is built

Parameters:
v - second vector
Returns:
the square of the distance between the instance and p
• #### distanceSq

public T distanceSq(Vector3D v)
Compute the square of the distance between the instance and another vector.

Calling this method is equivalent to calling: q.subtract(p).getNormSq() except that no intermediate vector is built

Parameters:
v - second vector
Returns:
the square of the distance between the instance and p
• #### dotProduct

public static <T extends RealFieldElement<T>> T dotProduct(FieldVector3D<T> v1,
FieldVector3D<T> v2)
Compute the dot-product of two vectors.
Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the dot product v1.v2
• #### dotProduct

public static <T extends RealFieldElement<T>> T dotProduct(FieldVector3D<T> v1,
Vector3D v2)
Compute the dot-product of two vectors.
Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the dot product v1.v2
• #### dotProduct

public static <T extends RealFieldElement<T>> T dotProduct(Vector3D v1,
FieldVector3D<T> v2)
Compute the dot-product of two vectors.
Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the dot product v1.v2
• #### crossProduct

public static <T extends RealFieldElement<T>> FieldVector3D<T> crossProduct(FieldVector3D<T> v1,
FieldVector3D<T> v2)
Compute the cross-product of two vectors.
Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the cross product v1 ^ v2 as a new Vector
• #### crossProduct

public static <T extends RealFieldElement<T>> FieldVector3D<T> crossProduct(FieldVector3D<T> v1,
Vector3D v2)
Compute the cross-product of two vectors.
Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the cross product v1 ^ v2 as a new Vector
• #### crossProduct

public static <T extends RealFieldElement<T>> FieldVector3D<T> crossProduct(Vector3D v1,
FieldVector3D<T> v2)
Compute the cross-product of two vectors.
Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the cross product v1 ^ v2 as a new Vector
• #### distance1

public static <T extends RealFieldElement<T>> T distance1(FieldVector3D<T> v1,
FieldVector3D<T> v2)
Compute the distance between two vectors according to the L1 norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNorm1() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L1 norm
• #### distance1

public static <T extends RealFieldElement<T>> T distance1(FieldVector3D<T> v1,
Vector3D v2)
Compute the distance between two vectors according to the L1 norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNorm1() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L1 norm
• #### distance1

public static <T extends RealFieldElement<T>> T distance1(Vector3D v1,
FieldVector3D<T> v2)
Compute the distance between two vectors according to the L1 norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNorm1() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L1 norm
• #### distance

public static <T extends RealFieldElement<T>> T distance(FieldVector3D<T> v1,
FieldVector3D<T> v2)
Compute the distance between two vectors according to the L2 norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNorm() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L2 norm
• #### distance

public static <T extends RealFieldElement<T>> T distance(FieldVector3D<T> v1,
Vector3D v2)
Compute the distance between two vectors according to the L2 norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNorm() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L2 norm
• #### distance

public static <T extends RealFieldElement<T>> T distance(Vector3D v1,
FieldVector3D<T> v2)
Compute the distance between two vectors according to the L2 norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNorm() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L2 norm
• #### distanceInf

public static <T extends RealFieldElement<T>> T distanceInf(FieldVector3D<T> v1,
FieldVector3D<T> v2)
Compute the distance between two vectors according to the L norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNormInf() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L norm
• #### distanceInf

public static <T extends RealFieldElement<T>> T distanceInf(FieldVector3D<T> v1,
Vector3D v2)
Compute the distance between two vectors according to the L norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNormInf() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L norm
• #### distanceInf

public static <T extends RealFieldElement<T>> T distanceInf(Vector3D v1,
FieldVector3D<T> v2)
Compute the distance between two vectors according to the L norm.

Calling this method is equivalent to calling: v1.subtract(v2).getNormInf() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the distance between v1 and v2 according to the L norm
• #### distanceSq

public static <T extends RealFieldElement<T>> T distanceSq(FieldVector3D<T> v1,
FieldVector3D<T> v2)
Compute the square of the distance between two vectors.

Calling this method is equivalent to calling: v1.subtract(v2).getNormSq() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the square of the distance between v1 and v2
• #### distanceSq

public static <T extends RealFieldElement<T>> T distanceSq(FieldVector3D<T> v1,
Vector3D v2)
Compute the square of the distance between two vectors.

Calling this method is equivalent to calling: v1.subtract(v2).getNormSq() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the square of the distance between v1 and v2
• #### distanceSq

public static <T extends RealFieldElement<T>> T distanceSq(Vector3D v1,
FieldVector3D<T> v2)
Compute the square of the distance between two vectors.

Calling this method is equivalent to calling: v1.subtract(v2).getNormSq() except that no intermediate vector is built

Type Parameters:
T - the type of the field elements
Parameters:
v1 - first vector
v2 - second vector
Returns:
the square of the distance between v1 and v2
• #### toString

public String toString()
Get a string representation of this vector.
Overrides:
toString in class Object
Returns:
a string representation of this vector
• #### toString

public String toString(NumberFormat format)
Get a string representation of this vector.
Parameters:
format - the custom format for components
Returns:
a string representation of this vector


text:
To install click the Add extension button. That's it.

The source code for the WIKI 2 extension is being checked by specialists of the Mozilla Foundation, Google, and Apple. You could also do it yourself at any point in time.

4,5
Kelly Slayton
Congratulations on this excellent venture… what a great idea!
Alexander Grigorievskiy
I use WIKI 2 every day and almost forgot how the original Wikipedia looks like.
Live Statistics
English Articles
Improved in 24 Hours
What we do. Every page goes through several hundred of perfecting techniques; in live mode. Quite the same Wikipedia. Just better.
.
Leo
Newton
Brights
Milds

# Eternity

Eternity, in common parlance, means infinite time that never ends (or the quality, condition or fact of being eternal).[1] Classical philosophy, however, defines eternity as what exists outside time - as in describing supernatural beings and forces, whereas sempiternity corresponds to the infinitely temporal, non-metaphoric definitions, as recited in requiem prayers for the dead.[clarification needed] Thomas Hobbes (1588-1679) and many others in the Age of Enlightenment drew on the classical distinction to put forward metaphysical hypotheses such as "eternity is a permanent Now".[2]

Eternity as infinite duration is an important concept in many lives and religions, where the identity of god or gods are said to endure eternally. Religious views of an afterlife may speak of it in terms of eternity.[3] Some thinkers, such as Aristotle, suggest the eternity of the natural cosmos in regard to both past and future eternal duration - Christian theologians may regard  immutability - like the eternal  Platonic forms - as essential.[4] Today cosmologists, philosophers, and others look to analyses of the concept from across cultures and history. They debate, among other things, whether an absolute concept of eternity has real application for fundamental laws of physics - compare the issue of the arrow of time in  entropy.

## Philosophy

Aristotle argued that the cosmos has no beginning. In Aristotle's Metaphysics, eternity is the unmoved mover, understood as the gradient of total synergy ("produces motion by being loved").[5] Boethius defined eternity as "simultaneously full and perfect possession of interminable life".[6]

## Symbolism

Eternity is often symbolized by the endless snake, swallowing its own tail, the ouroboros (or oroboros). The circle, band or ring is also commonly used as a symbol for eternity, as is the mathematical symbol of infinity, ${\displaystyle \infty }$. Symbolically these are reminders that eternity has no beginning/end.

## References

1. ^ "eternity, n." 1. and 2. OED Online. September 2011. Oxford University Press. https://www.oed.com/view/Entry/64704 (accessed October 26, 2019).
2. ^ Mr. Hobbes Considered in his Loyalty, Religion, Reputation, and Manners. By way of Letter to Dr.cornwallis (English autobiography) F. Hobbes, 1662 at p.50.
3. ^ For examples: Bassali, Maurice (2008). Where Will You Spend Eternity?. Xulon Press. p. 138. ISBN 9781606473276. Retrieved April 30, 2021. In the next life, there will be two places only - heaven and hell. [...] In heaven, you will spend an eternity of bliss, light, and glory with God. In hell, you will spend an eternity of woe, darkness and torment apart from God. Which of these two places whould you prefer to spend your eternity?
4. ^ "Stanford Encyclopedia of Philosophy, Eternity in Christian Thought". Plato.stanford.edu. Retrieved June 13, 2016. Augustine connects God's timeless eternity to God's being the cause of all times and God's immutability.
5. ^ Yu, Jiyuan The Structure of Being in Aristotle’s Metaphysics Springer, 2003, p. 188
6. ^ Boedder, Bernard. "Natural Theology". University of Notre Dame. Archived from the original on March 4, 2016. Retrieved March 15, 2015. Aeternitas est interminablis vitae tota simul et perfecta possessio
Basis of this page is in Wikipedia. Text is available under the CC BY-SA 3.0 Unported License. Non-text media are available under their specified licenses. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc. WIKI 2 is an independent company and has no affiliation with Wikimedia Foundation.

format: plain


text:
## Rare event simulation for large-scale structures with local nonlinearities

When modeling large-scale structures, knowledge of the systems and their environment is often incomplete, i.e., wind or wave loads, and possible defects in the structural components, often referred to as uncertainty parameters. Conventional simulations are deterministic and do not take such uncertainty into consideration, making structural reliability analysis, i.e., rare event simulation, feasible. In this work, we use parametrized models to account for the uncertainty. As a result, a rare event simulation becomes a quantication of the impact of all uncertainty parameters on a quantity of interest of the structure, and an essential part of risk assessment. However, traditional parametrized simulations, i.e., through the finite element method (FEM), for large-scale infrastructures, possibly with a moderate to high dimensional parameter domain, is computationally intractable due to multi-query sampling necessitated during the simulation. We adopt non-intrusive reduced order modeling and machine learning techniques as an enabling technique for high-fidelity rare event simulations. We consider dierent approaches for risk assessment for large-scale structures with local nonlinearities with moderate to high dimensional parameter spaces, and provide a comparative study through several numerical examples to demonstrate the feasibility and effectivity of the presented approach.

Year:
2019
Keywords:
Laboratories:


text:
# Determine the asymptotic distribution of $\bar X_n$, properly centered and $\sqrt n$ scaled

Let $X_1, X_2,...X_n$ be i.i.d. with $P(X_i =1)=1-P(X_i =0)=p,p \in (0,1)$. (a) Show that $\bar X_n$ is the MLE of p. (b) Find the mean $\mu_n$ and variance $\sigma^{2}_n$ of $\bar X_n$ and invoke the CLT to determine the asymptotic distribution of $\bar X_n$, properly centered and $\sqrt n$ scaled.

Thoughts: I know how to solve part (a) and also know the mean and variance of part (b). The question that bothers me is the second part of part (b). I don't know to apply CLT here with $\sqrt n$ scaled. Any explicit explanation of this part would be much appreciated.

$S_n = \sum_{i=1}^n X_i \sim Binom(n, p).$ Also, $E(X_i) = p\;$ and $V(X_i) = p(1-p).$ Thus, $E(S_n) = np\;$ and $SD(S_n) = \sqrt{np(1-p)}.$
If we define $Z_n = \frac{S_n - np}{\sqrt{np(1-p)}},$ then $Z_n$ is approximately standard normal. According the the CLT its distribution gets closer to standard normal as $n$ increases. I assume this is what is meant by 'centered and $\sqrt{n}$-scaled'.
Given that $\bar X = S_n/n,$ you ought to be able to re-express the fraction for $Z_n$ in the required format.
• thanks!!! BTW, what is V? Is that the variance? If so, I think it should be $p(1-p)$. What does SD mean here? – hil316 Jan 3 '16 at 3:41


text:
# Ethernet Connectivity Selection Tutorial

Chia sẻ: Dang Thach Quan Koliadang | Ngày: | Loại File: PDF | Số trang:4

0
51
lượt xem
4

## Ethernet Connectivity Selection Tutorial

Mô tả tài liệu

Category 5, 5e or 6? 110 punchdown, or RJ to RJ? T568A or T568B? Shielded or unshielded? Will I choose the right Ethernet patch panel for my application? Will this choice work with future applications? Am I getting the best overall value? With all the choices you face as you design your network and select equipment, including available Ethernet patch panels, it’s easy to become confused and frustrated. Ultimately your choice of Ethernet panels should fit the applications you plan to run. ADC wrote this short tutorial to guide you through these decisions, to make them as painless as possible...

Chủ đề:

Bình luận(0)

Lưu

## Nội dung Text: Ethernet Connectivity Selection Tutorial

1. Ethernet Connectivity Selection Tutorial Category 5, 5e or 6? 110 punchdown, or RJ to RJ? T568A or T568B? Shielded or unshielded? white paper Will I choose the right Ethernet patch panel for my application? Will this choice work with future applications? Am I getting the best overall value? With all the choices you face as you design your network and select equipment, including avail- able Ethernet patch panels, it’s easy to become confused and frustrated. Ultimately your choice of Ethernet panels should fit the applications you plan to run. ADC wrote this short tutorial to guide you through these decisions, to make them as painless as possible and offer you the best solution for your network. First, let’s ask a few key questions. Your answers will help guide you in the decision process. Next, we will briefly discuss each of the most popular options available so you can draw conclusions based on your network needs. Discovery Questions • What applications are you or do you plan to run on this network? 10/100Base-T? 1000Base-T? • What type of network are you designing? Data center? Data backbone? LAN? • Is the project a new network installation or addition to existing network? • Is the installation being built to expand existing capacity with current data capabilities or is it for new, faster data applications? Answers to these questions will guide you to a particular cable type, a particular data patch panel, and the means to terminate the cable into the patch panel — whether the terminations into the patch panel involve “punchdown” cable terminations, pre-made telco-type multi-pair cable ends, or standard RJ45 cable ends. The general guidelines for network transmission capabilities segment the data network; data cen- ter and data network backbone system applications require the highest level of transmission capa- bilities, while feeds to work areas generally require a bit less. However, all network connectivity should be designed with only the highest network engineering standards available. Category 5, 5e, and 6 Cabling The Telecommunications Industry Association (TIA) standards forming group consists of a variety of industry experts including connectivity and cable manufacturers, distributors, installers, and end customers. The TIA determines certain transmission characteristics that must be met to qualify a cable for certain network applications. Category 5 cabling is currently the most prevalent wiring in existing buildings. Electrical charac- teristics defined by the TIA specify near end cross-talk (NEXT), attenuation, and return loss to 100 MHz. The TIA Technical Services Bulletin (TSB) 95 recommends additional criteria for far end cross- talk (FEXT).
2. Category 5e is currently the minimum TIA recommended category of wiring for new installations. Electrical characteristics for NEXT, FEXT, attenuation, and return loss are specified to 100 MHz. NEXT performance is slightly better than category 5. Category 6 is gaining popularity for new installations. Electrical characteristics for NEXT, FEXT, atten- uation, and return loss are specified to 250 MHz. Improvements in all electrical parameters are part of the higher TIA Category 6 standard. Category 7 cabling is a developing standard as of this writing. The International Standards Organization (ISO) is leading the standardization efforts for this new individually-shielded, overall- shielded, 4-pair cable with transmission specifications referenced to 600MHz. The cable end interface will probably be something other than the familiar RJ45 connector, mainly to differentiate the Category 7 installation from existing lower-bandwidth infrastructure. So, which should you use? There is quite a bit of misleading information in the industry on this sub- ject, the biggest myth being that Category 6 is required to run Gigabit Ethernet over copper (1000Base-T). Actually 1000Base-T was designed by the IEEE to run on Category 5. As long as the Category 5 is installed according to TIA-568-B standards and meets the testing criteria in TIA TSB 95, 1000Base-T will perform satisfactorily on Category 5. However, as of this writing, the TIA recommends Category 5e over Category 5 as the minimum cabling for new network infrastructure installations. When do I use Category 6? Does the application standard (i.e., Gigabit Ethernet, 10G, etc.) specify Category 6 as a minimal requirement? As of this writing, the TIA is making recommendations to the IEEE 802.3ae and the 10 Gigabit Ethernet Alliance, who are currently working on 10 Gigabit cabling systems, that any 10 Gigabit Ethernet designed to run on copper cabling use Category 6 because of its improvement in signal to noise. The good news is that Category 6 is backward compatible and will have no trouble running existing applications such as 10/100Base-T and 1000Base-T. Cable Type Summary The chart below summarizes the industry standard UTP cable types used in current networking instal- lations. In addition to the UTP cabling described above, you should understand the issues of cable shielding, and stranded versus solid cable. Category Test Frequency 10/100BaseT 1000BaseT Future Applications Relative Cost Cat 5 100 MHz Yes Yes No $Cat 5e 100 MHz Yes Yes Maybe$ Cat 6 250 MHz Yes Yes Yes $$Cat 7 600 MHz Yes Yes Yes$$ Shielded vs. Unshielded Twisted Pair Unshielded twisted pair (UTP) cabling provides immunity to electromagnetic interference (EMI) with the properties of the two conductors that make up a transmission pair being twisted together. When UTP cabling encounters electrical interference, the noise crossing the twisted pairs is cancelled by the twists in the cable (called “Common Mode Rejection”, a subject outside the scope of this paper). Standard Category 5, 5e and 6 cables contain four unshielded twisted pairs of conductors. For 10BASE-T and 100BASE-TX applications, only two pairs are used, one for the transmit circuit and one for receive circuit. For 1000BASE-T (Gigabit Ethernet) all four pairs are required. The term “shielded twisted pair” cabling can be misleading. There are actually two methods of shield- ing a twisted pair cable. Screened twisted pair cable (ScTP) provides an overall screen or metal foil around the four pairs of conductors, but each individual twisted pair is unshielded. Shielded Twisted 2
3. Pair cable (STP) has each individual pair shielded, plus an overall screen around the four individually shielded pairs. This makes a very expensive and hard to install cable - the legacy token ring IBM Type 1 cable and Category 7 are examples of STP cable. STP cable requires metal end connectors and metal jacks that bond the cable shield to earth ground to carry the interfering signals safely away from the signal conducting pairs – failure to connect the cable shield to earth ground results in the shield cou- pling the interfering noise to the conductors, providing very poor transmission performance. Most of the world uses UTP cabling, with some exceptions located in a few countries in Europe. Stranded vs. Solid Conductor Cable Stranded cable is flexible and often used for patch panel jumpers and work area connections. Stranded cabling is used for shorter patching applications for its flexible cable construction, but also exhibits higher attenuation due to the smaller diameter conductors, and as such should not be used for long, permanent installations. Solid conductor cable is used for the “horizontal” cable runs from the telecommunications room to the work area wall outlet. The typical gauge for Category 5e cable is 24 AWG. Category 6 is 23 AWG - the larger conductor diameter improves attenuation characteristics and signal-to-noise ratio versus the smaller conductor diameter of Category 5e. Wiring Schemes, T568A vs. T568B Wiring schemes also raise a variety of questions: Q: What’s the difference between T568A and T568B? A. The only difference is the positioning of the Green and Orange pairs of wires (see figure 1) Pair 2 Pair 3 Pair 3 Pair 1 Pair 4 Pair 2 Pair 1 Pair 4 T568A T568B Figure 1 Typical RJ45 cable ends, T568A vs. T568B Q: Is there a performance difference between T568A and T568B? A: No. Both wiring schemes have to meet the same performance criteria. Q: Why two schemes? A: The reason is outside of the scope of this paper but it is related to old telephone legacy issues. All you really need to know is that there are two schemes, and how to deal with them. 3


text:
## Algebra: A Combined Approach (4th Edition)

Published by Pearson

# Chapter 2 - Section 2.7 - Linear Inequalities and Problem Solving - Practice: 7

#### Answer

{${x|x\geq8}$}

#### Work Step by Step

$-3x+11\leq-13$ $-3x\leq-13-11$ $-3x\leq-24$ $x\geq8$ {${x|x\geq8}$}

After you claim an answer you’ll have 24 hours to send in a draft. An editor will review the submission and either publish your submission or provide feedback.


text:
Home / Basic Electrical (page 2)

# Basic Electrical

## Phasor Diagram and Phasor Algebra used in AC Circuits

Figure 1 shows a simple AC series circuit containing resistance and inductance. The sine-wave voltage source causes a sine wave of current to flow in the circuit. Since all the components are connected in series, the current in the inductance and the current in the resistance must have the same …

## Instantaneous Current in an Ideal Inductor

In the circuit of Figure 1, we assume that the inductor has negligible resistance. To satisfy Kirchhoff’s voltage law, at every instant the inductive voltage across the coil in Figure 1 must exactly equal the applied voltage. Hence, ${{v}_{L}}=e={{E}_{m}}\sin \omega t$ Figure 1 Inductance in an ac circuit If …

## Instantaneous Current in a Capacitor

If we connect a capacitor across a sine-wave voltage source, as in Figure 1, Kirchhoff’s voltage law requires the voltage across the capacitor to be exactly the same as the applied voltage at every instant. The voltage across a capacitor can change only if the capacitor charges or discharges. Consequently, …

## Periodic Wave

Although the sine wave is by far the most important AC waveform, there are many other types of periodic waves. In electric circuits, a periodic wave is any time-varying quantity, such as voltage, current, or power that continually repeats exactly the same sequence of values with each cycle taking exactly …

## RMS Value of a Sine Wave

All electric circuits convert electric energy into some other form of energy, such as heat, light, or mechanical energy. For many of these energy conversions, it does not matter whether the energy source for the circuit produces direct current or alternating current. Therefore, we find equivalent steady-state values for alternating …

## Energy Stored in an Inductor

If we connect an ideal inductor to a voltage source having no internal resistance, the voltage across the inductance must remain equal to the applied voltage. Therefore, the current rises at a constant rate, as shown in Figure 1(b). The source supplies electrical energy to the ideal inductor at the …

## Resistance Measurement Methods

Low Resistance Measurement We can determine an unknown resistance in Figure 1 by applying Ohm’s law to the readings obtained from the voltmeter and ammeter. This method requires that the unknown resistance is connected into a special circuit with two separate meters. This method is useful for measuring very low …

## What is Frequency Response | Basics

The reaction of a circuit has to change in frequency is referred to as its Frequency Response. For example, consider the parallel RLC circuit shown in Figure 1. If the operating frequency of the circuit increases, Here’s what happens: • The reactance of the inductor increases because of XL=2πfL. The …

## AC Waveform & AC Circuit Theory

Generally, the term Alternating Current (AC) is used to describe any current that periodically changes direction. For example, take a look at the circuit current time relationship as shown in Figure 1. The horizontal axis of the graph is used to represent time (t). The vertical axis of the graph …

## Effect of Temperature on Resistance | Temperature Coefficient of Resistance

Checking the voltage/current (V/I) ratio of conductors at various temperatures shows that the resistance of most conducting materials increases linearly with temperature except at very hot or very cold temperatures. Temperature has little effect on the resistance of some alloys, such as constantan. For a few materials, including carbon and …

## Resonance in Series and Parallel RLC Circuit

In any AC circuit consisting of resistors, capacitors, and inductors, either in series or in parallel, a condition can happen in which the reactive power of the capacitors and of the inductors become equal. This condition is called resonance. Simultaneous with the capacitive reactive power and the inductive reactive power being …

## Phase Relationships in AC Circuits | Phase Difference | Phase Shift

Phase Difference When we have two sine waves with the same frequency, the duration of one cycle is the same for both. Nonetheless, irrespective of their peak values, there are two possibilities: 1. The two waveforms reach their maximum values (and accordingly their minimum values) at the same instant. In this …

## Relationship between Voltage Current and Resistance

The fundamental relationship between resistance, voltage, and current can be expressed using Ohm’s law. Mathematically, it is expressed as: $V=IR$ Where, V is measured in Volts I is measured in Amps R is measured in Ohms Electric Current The electric current is a measure of the rate of flow (i.e., …


text:
# [texhax] pagestyle{empty}

Martin Schröder martin at oneiros.de
Thu Mar 30 00:16:20 CEST 2006

On 2006-03-29 23:57:42 +0200, Reinhard Kotucha wrote:
> For AMS-LaTeX there is a macro package which re-defines deprecated
> commands so that they print quite useful warning messages on screen or
> even errors if requested.
>
> From:
>
>   http://ctan.org/tex-archive/macros/latex/contrib/onlyamsmath/onlyamsmath.dtx
>
> % This package inhibits the usage of plain \TeX\ and on demand of
> % standard \LaTeX\ math environments.
> % This is useful for class writers who want to force their clients to
> % use the environments provided by the amsmath package.
>
> IMO it would not be bad to have something like that for LaTeX.

A start would be the l3names package (in latex2e/exptl/project/expl3):
-------------------------------
l3names
=======

Documents the general naming scheme, and gives new names to all
the TeX primitives.

If this package is used with the option [removeoldnames] then the
original TeX primitive names (\hbox, \def, ...) are made
*undefined* and so free to be defined for other purposes if
needed. Of course this breaks almost all existing LaTeX2 code,
but it may be used for testing purposes, see test2.tex.
-------------------------------

Best
Martin
--
http://www.tm.oneiros.de


text:
# American Institute of Mathematical Sciences

September  2020, 25(9): 3715-3724. doi: 10.3934/dcdsb.2020087

## Local and global well-posedness in the energy space for the dissipative Zakharov-Kuznetsov equation in 3D

Received  March 2019 Revised  October 2019 Published  September 2020 Early access  April 2020

In this paper, we consider the Zakharov-Kuznetsov equation in 3D, with a dissipative term of order $0 < \alpha \leq 2$ in the $x$ direction. We prove that the problem is locally well-posed in $H^{s}( { I\!\!R}^3)$, for $s > 1-\frac{\alpha}{2}$, and by an a priori energy estimate, we prove that the problem is globally well-posed in $H^{1}( { I\!\!R}^3)$.

Citation: Mohamad Darwich. Local and global well-posedness in the energy space for the dissipative Zakharov-Kuznetsov equation in 3D. Discrete & Continuous Dynamical Systems - B, 2020, 25 (9) : 3715-3724. doi: 10.3934/dcdsb.2020087
##### References:

show all references

##### References:
 [1] Zhaohi Huo, Yueling Jia, Qiaoxin Li. Global well-posedness for the 3D Zakharov-Kuznetsov equation in energy space $H^1$. Discrete & Continuous Dynamical Systems - S, 2016, 9 (6) : 1797-1851. doi: 10.3934/dcdss.2016075 [2] Stefan Meyer, Mathias Wilke. Global well-posedness and exponential stability for Kuznetsov's equation in $L_p$-spaces. Evolution Equations & Control Theory, 2013, 2 (2) : 365-378. doi: 10.3934/eect.2013.2.365 [3] Felipe Linares, Mahendra Panthee, Tristan Robert, Nikolay Tzvetkov. On the periodic Zakharov-Kuznetsov equation. Discrete & Continuous Dynamical Systems, 2019, 39 (6) : 3521-3533. doi: 10.3934/dcds.2019145 [4] Felipe Linares, Jean-Claude Saut. The Cauchy problem for the 3D Zakharov-Kuznetsov equation. Discrete & Continuous Dynamical Systems, 2009, 24 (2) : 547-565. doi: 10.3934/dcds.2009.24.547 [5] Francis Ribaud, Stéphane Vento. Local and global well-posedness results for the Benjamin-Ono-Zakharov-Kuznetsov equation. Discrete & Continuous Dynamical Systems, 2017, 37 (1) : 449-483. doi: 10.3934/dcds.2017019 [6] Mo Chen, Lionel Rosier. Exact controllability of the linear Zakharov-Kuznetsov equation. Discrete & Continuous Dynamical Systems - B, 2020, 25 (10) : 3889-3916. doi: 10.3934/dcdsb.2020080 [7] Ivonne Rivas, Muhammad Usman, Bing-Yu Zhang. Global well-posedness and asymptotic behavior of a class of initial-boundary-value problem of the Korteweg-De Vries equation on a finite domain. Mathematical Control & Related Fields, 2011, 1 (1) : 61-81. doi: 10.3934/mcrf.2011.1.61 [8] Barbara Kaltenbacher, Irena Lasiecka. Well-posedness of the Westervelt and the Kuznetsov equation with nonhomogeneous Neumann boundary conditions. Conference Publications, 2011, 2011 (Special) : 763-773. doi: 10.3934/proc.2011.2011.763 [9] Nathan Glatt-Holtz, Roger Temam, Chuntian Wang. Martingale and pathwise solutions to the stochastic Zakharov-Kuznetsov equation with multiplicative noise. Discrete & Continuous Dynamical Systems - B, 2014, 19 (4) : 1047-1085. doi: 10.3934/dcdsb.2014.19.1047 [10] Raphaël Côte, Frédéric Valet. Polynomial growth of high sobolev norms of solutions to the Zakharov-Kuznetsov equation. Communications on Pure & Applied Analysis, 2021, 20 (3) : 1039-1058. doi: 10.3934/cpaa.2021005 [11] Felipe Linares, Gustavo Ponce. On special regularity properties of solutions of the Zakharov-Kuznetsov equation. Communications on Pure & Applied Analysis, 2018, 17 (4) : 1561-1572. doi: 10.3934/cpaa.2018074 [12] Axel Grünrock, Sebastian Herr. The Fourier restriction norm method for the Zakharov-Kuznetsov equation. Discrete & Continuous Dynamical Systems, 2014, 34 (5) : 2061-2068. doi: 10.3934/dcds.2014.34.2061 [13] Vanessa Barros, Felipe Linares. A remark on the well-posedness of a degenerated Zakharov system. Communications on Pure & Applied Analysis, 2015, 14 (4) : 1259-1274. doi: 10.3934/cpaa.2015.14.1259 [14] Christopher Henderson, Stanley Snelson, Andrei Tarfulea. Local well-posedness of the Boltzmann equation with polynomially decaying initial data. Kinetic & Related Models, 2020, 13 (4) : 837-867. doi: 10.3934/krm.2020029 [15] Wei Yan, Yimin Zhang, Yongsheng Li, Jinqiao Duan. Sharp well-posedness of the Cauchy problem for the rotation-modified Kadomtsev-Petviashvili equation in anisotropic Sobolev spaces. Discrete & Continuous Dynamical Systems, 2021  doi: 10.3934/dcds.2021097 [16] Robert Schippa. On the Cauchy problem for higher dimensional Benjamin-Ono and Zakharov-Kuznetsov equations. Discrete & Continuous Dynamical Systems, 2020, 40 (9) : 5189-5215. doi: 10.3934/dcds.2020225 [17] Shinya Kinoshita. Well-posedness for the Cauchy problem of the Klein-Gordon-Zakharov system in 2D. Discrete & Continuous Dynamical Systems, 2018, 38 (3) : 1479-1504. doi: 10.3934/dcds.2018061 [18] Isao Kato. Well-posedness for the Cauchy problem of the Klein-Gordon-Zakharov system in four and more spatial dimensions. Communications on Pure & Applied Analysis, 2016, 15 (6) : 2247-2280. doi: 10.3934/cpaa.2016036 [19] Tadahiro Oh, Yuzhao Wang. On global well-posedness of the modified KdV equation in modulation spaces. Discrete & Continuous Dynamical Systems, 2021, 41 (6) : 2971-2992. doi: 10.3934/dcds.2020393 [20] Elena Rossi. Well-posedness of general 1D initial boundary value problems for scalar balance laws. Discrete & Continuous Dynamical Systems, 2019, 39 (6) : 3577-3608. doi: 10.3934/dcds.2019147

2020 Impact Factor: 1.327


text:
## Organic and Inorganic Chemistry Lesson of the Day – Stereogenic Centre

A stereogenic centre (often called a stereocentre) is an atom that satisfies 2 conditions:

1. it is bonded to at least 3 substituents.
2. interchanging any 2 of the substituents would result in a stereoisomer.

If a molecule has only 1 stereogenic centre, then it definitely has a non-superimposable mirror image (i.e. this molecule is chiral and is an enantiomer).  However, depending on its stereochemistry, it is possible for a molecule with 2 or more stereogenic centres to be achiral; such molecules are called meso isomers (or meso compounds), and I will discuss them in a later lesson.

In organic chemistry, the stereogenic centre is usually a carbon atom that is attached to 4 substituents in a tetrahedral geometry.  In inorganic chemistry, the stereogenic centre is usually the metal centre of a coordination complex.

In organic chemistry, stereogenic centres with substituents in a tetrahedral geometry are common.  Inorganic coordination complexes can also have a tetrahedral geometry.  A stereoisomer with $n$ tetrahedral stereogenic centres can have at most $2^n$ stereoisomers.  The “at most” caveat is important; as mentioned above, it is possible for a molecule with 2 or more stereogenic centres to have a spatial arrangement that results in having a superimposable mirror image; such isomers are meso isomers.   I will discuss meso isomers in more detail in a later lesson.

## Organic and Inorganic Chemistry Lesson of the Day – Chirality and Enantiomers

In chemistry, chirality is a property of a molecule such that the molecule has a non-superimposable mirror image.  In other words, a molecule is chiral if, upon reflection by any plane, it cannot be superimposed onto itself.

Chirality is a property of the 3-dimensional orientation of a molecule, and molecules exhibiting chirality are stereoisomers.  Specifically, two molecules are enantiomers of each other if they are non-superimposable mirror images of each other.  In organic chemistry, chirality commonly arises out of an asymmetric carbon atom, which is a carbon that is attached to 4 different substituents.  Chirality in inorganic chemistry is more complicated, and I will discuss this in a later lesson.

It is important to note that enantiomers are defined as pairs.  This will be later emphasized in the lesson on diastereomers.