VecFor Documentation

Appearance

vecfor_R16P ​

VecFor, Vector algebra class for Fortran poor people, R16P kind.

Source: src/lib/vecfor_R16P.F90

Dependencies

Contents ​

Variables ​

NameTypeAttributesDescription
ex_R16Ptype(vector_R16P)parameterX direction versor.
ey_R16Ptype(vector_R16P)parameterY direction versor.
ez_R16Ptype(vector_R16P)parameterZ direction versor.

Derived Types ​

vector_R16P ​

Vector class.

Components ​

NameTypeAttributesDescription
xreal(kind=R16P)Cartesian component in x direction.
yreal(kind=R16P)Cartesian component in y direction.
zreal(kind=R16P)Cartesian component in z direction.

Type-Bound Procedures ​

NameAttributesDescription
I1P_eq_vectorpass(rhs)Operator integer(I1P) ==.
I1P_great_eq_vectorpass(rhs)Operator integer(I1P) >=.
I1P_great_vectorpass(rhs)Operator integer(I1P) >.
I1P_low_eq_vectorpass(rhs)Operator integer(I1P) <=.
I1P_low_vectorpass(rhs)Operator integer(I1P) <.
I1P_mul_vectorpass(rhs)Operator integer(I1P) *.
I1P_not_eq_vectorpass(rhs)Operator integer(I1P) /=.
I1P_sub_vectorpass(rhs)Operator integer(I1P) -.
I1P_sum_vectorpass(rhs)Operator integer(I1P) +.
I2P_eq_vectorpass(rhs)Operator integer(I2P) ==.
I2P_great_eq_vectorpass(rhs)Operator integer(I2P) >=.
I2P_great_vectorpass(rhs)Operator integer(I2P) >.
I2P_low_eq_vectorpass(rhs)Operator integer(I2P) <=.
I2P_low_vectorpass(rhs)Operator integer(I2P) <.
I2P_mul_vectorpass(rhs)Operator integer(I2P) *.
I2P_not_eq_vectorpass(rhs)Operator integer(I2P) /=.
I2P_sub_vectorpass(rhs)Operator integer(I2P) -.
I2P_sum_vectorpass(rhs)Operator integer(I2P) +.
I4P_eq_vectorpass(rhs)Operator integer(I4P) ==.
I4P_great_eq_vectorpass(rhs)Operator integer(I4P) >=.
I4P_great_vectorpass(rhs)Operator integer(I4P) >.
I4P_low_eq_vectorpass(rhs)Operator integer(I4P) <=.
I4P_low_vectorpass(rhs)Operator integer(I4P) <.
I4P_mul_vectorpass(rhs)Operator integer(I4P) *.
I4P_not_eq_vectorpass(rhs)Operator integer(I4P) /=.
I4P_sub_vectorpass(rhs)Operator integer(I4P) -.
I4P_sum_vectorpass(rhs)Operator integer(I4P) +.
I8P_eq_vectorpass(rhs)Operator integer(I8P) ==.
I8P_great_eq_vectorpass(rhs)Operator integer(I8P) >=.
I8P_great_vectorpass(rhs)Operator integer(I8P) >.
I8P_low_eq_vectorpass(rhs)Operator integer(I8P) <=.
I8P_low_vectorpass(rhs)Operator integer(I8P) <.
I8P_mul_vectorpass(rhs)Operator integer(I8P) *.
I8P_not_eq_vectorpass(rhs)Operator integer(I8P) /=.
I8P_sub_vectorpass(rhs)Operator integer(I8P) -.
I8P_sum_vectorpass(rhs)Operator integer(I8P) +.
R16P_eq_vectorpass(rhs)Operator real(R16P) ==.
R16P_great_eq_vectorpass(rhs)Operator real(R16P) >=.
R16P_great_vectorpass(rhs)Operator real(R16P) >.
R16P_low_eq_vectorpass(rhs)Operator real(R16P) <=.
R16P_low_vectorpass(rhs)Operator real(R16P) <.
R16P_mul_vectorpass(rhs)Operator real(R16P) *.
R16P_not_eq_vectorpass(rhs)Operator real(R16P) /=.
R16P_sub_vectorpass(rhs)Operator real(R16P) -.
R16P_sum_vectorpass(rhs)Operator real(R16P) +.
R4P_eq_vectorpass(rhs)Operator real(R4P) ==.
R4P_great_eq_vectorpass(rhs)Operator real(R4P) >=.
R4P_great_vectorpass(rhs)Operator real(R4P) >.
R4P_low_eq_vectorpass(rhs)Operator real(R4P) <=.
R4P_low_vectorpass(rhs)Operator real(R4P) <.
R4P_mul_vectorpass(rhs)Operator real(R4P) *.
R4P_not_eq_vectorpass(rhs)Operator real(R4P) /=.
R4P_sub_vectorpass(rhs)Operator real(R4P) -.
R4P_sum_vectorpass(rhs)Operator real(R4P) +.
R8P_eq_vectorpass(rhs)Operator real(R8P) ==.
R8P_great_eq_vectorpass(rhs)Operator real(R8P) >=.
R8P_great_vectorpass(rhs)Operator real(R8P) >.
R8P_low_eq_vectorpass(rhs)Operator real(R8P) <=.
R8P_low_vectorpass(rhs)Operator real(R8P) <.
R8P_mul_vectorpass(rhs)Operator real(R8P) *.
R8P_not_eq_vectorpass(rhs)Operator real(R8P) /=.
R8P_sub_vectorpass(rhs)Operator real(R8P) -.
R8P_sum_vectorpass(rhs)Operator real(R8P) +.
anglepass(self)Return the angle (rad) between two
assign_I1Ppass(lhs)Operator = integer(I1P).
assign_I2Ppass(lhs)Operator = integer(I2P).
assign_I4Ppass(lhs)Operator = integer(I4P).
assign_I8Ppass(lhs)Operator = integer(I8P).
assign_R16Ppass(lhs)Operator = real(R16P).
assign_R4Ppass(lhs)Operator = real(R4P).
assign_R8Ppass(lhs)Operator = real(R8P).
assign_vectorpass(lhs)Operator =.
assignment(=)Overloading =.
crossproductpass(lhs)Compute the cross product.
distance_to_linepass(self)Return the distance (scalar) to
distance_to_planepass(self)Return the distance (signed, scalar)
distance_vectorial_to_planepass(self)Return the distance (vectorial) to
dotproductpass(lhs)Compute the scalar (dot) product.
face_normal3nopassReturn the normal of the face.
face_normal4nopassReturn the normal of the face.
iolenpass(self)Compute IO length.
is_collinearpass(self)Return true if the point is col-
is_concyclicpass(self)Return true if the point is concy-
load_from_filepass(self)Load vector from file.
matrixproductpass(rhs)Compute the matrix product.
mirrorMirror vector.
mirror_by_matrixpass(self)Mirror vector given matrix.
mirror_by_normalpass(self)Mirror vector given normal of mirroring plane.
negativepass(rhs)Operator -, unary.
normL2pass(self)Return the norm L2 of vector.
normalizepass(self)Normalize a vector.
normalizedpass(self)Return a normalized copy of vector.
operator(*)Overloading *.
operator(+)Overloading +.
operator(-)Overloading -.
operator(.cross.)Cross product operator.
operator(.dot.)Scalar (dot) product operator.
operator(.matrix.)Matrix product operator.
operator(.ortho.)Component of lhs orthogonal to rhs operator.
operator(.paral.)Component of lhs parallel to rhs operator.
operator(/)Overloading /.
operator(/=)Overloading /=.
operator(<)Overloading <.
operator(<=)Overloading <=.
operator(==)Overloading ==.
operator(>)Overloading >.
operator(>=)Overloading >=.
orthogonalpass(lhs)Compute the component of lhs orthogonal to rhs.
parallelpass(lhs)Compute the component of lhs parallel to rhs.
positivepass(rhs)Operator +, unary.
printfpass(self)Print vector components with a
projection_onto_planepass(self)Calculate the projection of point
rotateRotate vector.
rotate_by_axis_anglepass(self)Rotate vector given axis and angle.
rotate_by_matrixpass(self)Rotate vector given matrix.
save_into_filepass(self)Save vector into file.
sq_normpass(self)Return the square of the norm.
vector_div_I1Ppass(lhs)Operator / integer(I1P).
vector_div_I2Ppass(lhs)Operator / integer(I2P).
vector_div_I4Ppass(lhs)Operator / integer(I4P).
vector_div_I8Ppass(lhs)Operator / integer(I8P).
vector_div_R16Ppass(lhs)Operator / real(R16P).
vector_div_R4Ppass(lhs)Operator / real(R4P).
vector_div_R8Ppass(lhs)Operator / real(R8P).
vector_div_vectorpass(lhs)Operator /.
vector_eq_I1Ppass(lhs)Operator == integer(I1P).
vector_eq_I2Ppass(lhs)Operator == integer(I2P).
vector_eq_I4Ppass(lhs)Operator == integer(I4P).
vector_eq_I8Ppass(lhs)Operator == integer(I8P).
vector_eq_R16Ppass(lhs)Operator == real(R16P).
vector_eq_R4Ppass(lhs)Operator == real(R4P).
vector_eq_R8Ppass(lhs)Operator == real(R8P).
vector_eq_vectorpass(lhs)Operator ==.
vector_great_I1Ppass(lhs)Operator > integer(I1P).
vector_great_I2Ppass(lhs)Operator > integer(I2P).
vector_great_I4Ppass(lhs)Operator > integer(I4P).
vector_great_I8Ppass(lhs)Operator > integer(I8P).
vector_great_R16Ppass(lhs)Operator > real(R16P).
vector_great_R4Ppass(lhs)Operator > real(R4P).
vector_great_R8Ppass(lhs)Operator > real(R8P).
vector_great_eq_I1Ppass(lhs)Operator >= integer(I1P).
vector_great_eq_I2Ppass(lhs)Operator >= integer(I2P).
vector_great_eq_I4Ppass(lhs)Operator >= integer(I4P).
vector_great_eq_I8Ppass(lhs)Operator >= integer(I8P).
vector_great_eq_R16Ppass(lhs)Operator >= real(R16P).
vector_great_eq_R4Ppass(lhs)Operator >= real(R4P).
vector_great_eq_R8Ppass(lhs)Operator >= real(R8P).
vector_great_eq_vectorpass(lhs)Operator >=.
vector_great_vectorpass(lhs)Operator >.
vector_low_I1Ppass(lhs)Operator < integer(I1P).
vector_low_I2Ppass(lhs)Operator < integer(I2P).
vector_low_I4Ppass(lhs)Operator < integer(I4P).
vector_low_I8Ppass(lhs)Operator < integer(I8P).
vector_low_R16Ppass(lhs)Operator < real(R16P).
vector_low_R4Ppass(lhs)Operator < real(R4P).
vector_low_R8Ppass(lhs)Operator < real(R8P).
vector_low_eq_I1Ppass(lhs)Operator <= integer(I1P).
vector_low_eq_I2Ppass(lhs)Operator <= integer(I2P).
vector_low_eq_I4Ppass(lhs)Operator <= integer(I4P).
vector_low_eq_I8Ppass(lhs)Operator <= integer(I8P).
vector_low_eq_R16Ppass(lhs)Operator <= real(R16P).
vector_low_eq_R4Ppass(lhs)Operator <= real(R4P).
vector_low_eq_R8Ppass(lhs)Operator <= real(R8P).
vector_low_eq_vectorpass(lhs)Operator <=.
vector_low_vectorpass(lhs)Operator <.
vector_mul_I1Ppass(lhs)Operator * integer(I1P).
vector_mul_I2Ppass(lhs)Operator * integer(I2P).
vector_mul_I4Ppass(lhs)Operator * integer(I4P).
vector_mul_I8Ppass(lhs)Operator * integer(I8P).
vector_mul_R16Ppass(lhs)Operator * real(R16P).
vector_mul_R4Ppass(lhs)Operator * real(R4P).
vector_mul_R8Ppass(lhs)Operator * real(R8P).
vector_mul_vectorpass(lhs)Operator *.
vector_not_eq_I1Ppass(lhs)Operator /= integer(I1P).
vector_not_eq_I2Ppass(lhs)Operator /= integer(I2P).
vector_not_eq_I4Ppass(lhs)Operator /= integer(I4P).
vector_not_eq_I8Ppass(lhs)Operator /= integer(I8P).
vector_not_eq_R16Ppass(lhs)Operator /= real(R16P).
vector_not_eq_R4Ppass(lhs)Operator /= real(R4P).
vector_not_eq_R8Ppass(lhs)Operator /= real(R8P).
vector_not_eq_vectorpass(lhs)Operator /=.
vector_sub_I1Ppass(lhs)Operator - integer(I1P).
vector_sub_I2Ppass(lhs)Operator - integer(I2P).
vector_sub_I4Ppass(lhs)Operator - integer(I4P).
vector_sub_I8Ppass(lhs)Operator - integer(I8P).
vector_sub_R16Ppass(lhs)Operator - real(R16P).
vector_sub_R4Ppass(lhs)Operator - real(R4P).
vector_sub_R8Ppass(lhs)Operator - real(R8P).
vector_sub_vectorpass(lhs)Operator -.
vector_sum_I1Ppass(lhs)Operator + integer(I1P).
vector_sum_I2Ppass(lhs)Operator + integer(I2P).
vector_sum_I4Ppass(lhs)Operator + integer(I4P).
vector_sum_I8Ppass(lhs)Operator + integer(I8P).
vector_sum_R16Ppass(lhs)Operator + real(R16P).
vector_sum_R4Ppass(lhs)Operator + real(R4P).
vector_sum_R8Ppass(lhs)Operator + real(R8P).
vector_sum_vectorpass(lhs)Operator +.

Subroutines ​

assign_I1P ​

Operator = integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = 1_I1P
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

fortran
subroutine assign_I1P(lhs, rhs)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inoutLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

assign_I2P ​

Operator = integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = 1_I2P
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

fortran
subroutine assign_I2P(lhs, rhs)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inoutLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

assign_I4P ​

Operator = integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = 1_I4P
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

fortran
subroutine assign_I4P(lhs, rhs)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inoutLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

assign_I8P ​

Operator = integer(I8P).

fortran
 type(vector_R16P) :: pt
 pt = 1_I8P
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

fortran
subroutine assign_I8P(lhs, rhs)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inoutLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

assign_R16P ​

Operator = real(R16P).

fortran
 type(vector_R16P) :: pt
 pt = 1._R16P
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

fortran
subroutine assign_R16P(lhs, rhs)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inoutLeft hand side.
rhsreal(kind=R16P)inRight hand side.

assign_R4P ​

Operator = real(R4P).

fortran
 type(vector_R16P) :: pt
 pt = 1._R4P
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

fortran
subroutine assign_R4P(lhs, rhs)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inoutLeft hand side.
rhsreal(kind=R4P)inRight hand side.

assign_R8P ​

Operator = real(R8P).

fortran
 type(vector_R16P) :: pt
 pt = 1._R8P
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

fortran
subroutine assign_R8P(lhs, rhs)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inoutLeft hand side.
rhsreal(kind=R8P)inRight hand side.

assign_vector ​

Operator =

fortran
 type(vector_R16P) :: pt
 pt = 1 * ex_R16P + 2 * ey_R16P + 3 * ez_R16P
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: pure

fortran
subroutine assign_vector(lhs, rhs)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inoutLeft hand side.
rhstype(vector_R16P)inRight hand side.

load_from_file ​

Load vector from file.

fortran
 type(vector_R16P) :: pt
 pt = 1 * ex_R16P + 2 * ey_R16P + 3 * ez_R16P
 open(unit=10, form='unformatted', status='scratch')
 call pt%save_into_file(unit=10)
 rewind(unit=10)
 call pt%load_from_file(unit=10)
 close(unit=10)
 print "(3(F3.1,1X))", pt%x, pt%y, pt%z
fortran
subroutine load_from_file(self, unit, fmt, pos, iostat, iomsg)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inoutVector.
unitinteger(kind=I4P)inLogic unit.
fmtcharacter(len=*)inoptionalIO format.
posinteger(kind=I8P)inoptionalPosition specifier.
iostatinteger(kind=I4P)outoptionalIO error.
iomsgcharacter(len=*)outoptionalIO error message.

mirror_by_matrix ​

Mirror vector given matrix (of mirroring).

Attributes: pure

fortran
subroutine mirror_by_matrix(self, matrix)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inoutVector.
matrixreal(kind=R16P)inMirroring matrix.

Call graph

mirror_by_normal ​

Mirror vector given normal of mirroring plane.

Attributes: pure

fortran
subroutine mirror_by_normal(self, normal)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inoutVector.
normaltype(vector_R16P)inNormal of mirroring plane.

Call graph

normalize ​

Normalize vector.

The normalization is made by means of norm L2. If the norm L2 of the vector is less than the parameter smallRPP the normalization value is set to normL2 + smallRPP.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P
 call pt%normalize
 print "(3(F4.2,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

fortran
subroutine normalize(self)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inoutVector.

Call graph

printf ​

Print in a pretty ascii format the components of type Vector.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P
 call pt%printf(prefix='[x, y, z] = ', sep=', ')
fortran
subroutine printf(self, unit, prefix, sep, suffix, iostat, iomsg)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inVector.
unitinteger(kind=I4P)inoptionalLogic unit.
prefixcharacter(len=*)inoptionalPrefix string.
sepcharacter(len=*)inoptionalComponents separator.
suffixcharacter(len=*)inoptionalSuffix string.
iostatinteger(kind=I4P)outoptionalIO error.
iomsgcharacter(len=*)outoptionalIO error message.

Call graph

rotate_by_axis_angle ​

Rotate vector given axis and angle.

Angle must be in radiants.

Attributes: pure

fortran
subroutine rotate_by_axis_angle(self, axis, angle)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inoutVector.
axistype(vector_R16P)inAxis of rotation.
anglereal(kind=R16P)inAngle of rotation.

Call graph

rotate_by_matrix ​

Rotate vector given matrix (of ratation).

Attributes: pure

fortran
subroutine rotate_by_matrix(self, matrix)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inoutVector.
matrixreal(kind=R16P)inRotation matrix.

Call graph

save_into_file ​

Save vector into file.

fortran
 type(vector_R16P) :: pt
 pt = 1 * ex_R16P + 2 * ey_R16P + 3 * ez_R16P
 open(unit=10, form='unformatted', status='scratch')
 call pt%save_into_file(unit=10)
 rewind(unit=10)
 call pt%load_from_file(unit=10)
 close(unit=10)
 print "(3(F3.1,1X))", pt%x, pt%y, pt%z
fortran
subroutine save_into_file(self, unit, fmt, pos, iostat, iomsg)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inVector data.
unitinteger(kind=I4P)inLogic unit.
fmtcharacter(len=*)inoptionalIO format.
posinteger(kind=I8P)inoptionalPosition specifier.
iostatinteger(kind=I4P)outoptionalIO error.
iomsgcharacter(len=*)outoptionalIO error message.

Functions ​

I1P_eq_vector ​

Operator integer(I1P) ==.

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", 5_I1P == pt

Attributes: elemental

Returns: logical

fortran
function I1P_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I1P_great_eq_vector ​

Operator integer(I1P) >=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4_I1P >= pt

Attributes: elemental

Returns: logical

fortran
function I1P_great_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I1P_great_vector ​

Operator integer(I1P) >.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4_I1P > pt

Attributes: elemental

Returns: logical

fortran
function I1P_great_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I1P_low_eq_vector ​

Operator integer(I1P) <=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I1P <= pt

Attributes: elemental

Returns: logical

fortran
function I1P_low_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I1P_low_vector ​

Operator integer(I1P) <.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I1P < pt

Attributes: elemental

Returns: logical

fortran
function I1P_low_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I1P_mul_vector ​

Operator integer(I1P) *.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I1P * pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I1P_mul_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I1P_not_eq_vector ​

Operator integer(I1P) /=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I1P /= pt

Attributes: elemental

Returns: logical

fortran
function I1P_not_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I1P_sub_vector ​

Operator integer(I1P) -.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I1P - pt(1)
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I1P_sub_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I1P_sum_vector ​

Operator integer(I1P) +.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I1P + pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I1P_sum_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I1P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I2P_eq_vector ​

Operator integer(I2P) ==.

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", 5_I2P == pt

Attributes: elemental

Returns: logical

fortran
function I2P_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I2P_great_eq_vector ​

Operator integer(I2P) >=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4_I2P >= pt

Attributes: elemental

Returns: logical

fortran
function I2P_great_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I2P_great_vector ​

Operator integer(I2P) >.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4_I2P > pt

Attributes: elemental

Returns: logical

fortran
function I2P_great_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I2P_low_eq_vector ​

Operator integer(I2P) <=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I2P <= pt

Attributes: elemental

Returns: logical

fortran
function I2P_low_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I2P_low_vector ​

Operator integer(I2P) <.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I2P < pt

Attributes: elemental

Returns: logical

fortran
function I2P_low_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I2P_mul_vector ​

Operator integer(I2P) *.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I2P * pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I2P_mul_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I2P_not_eq_vector ​

Operator integer(I2P) /=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I2P /= pt

Attributes: elemental

Returns: logical

fortran
function I2P_not_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I2P_sub_vector ​

Operator integer(I2P) -.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I2P - pt(1)
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I2P_sub_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I2P_sum_vector ​

Operator integer(I2P) +.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I2P + pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I2P_sum_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I2P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I4P_eq_vector ​

Operator integer(I4P) ==.

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", 5_I4P == pt

Attributes: elemental

Returns: logical

fortran
function I4P_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I4P_great_eq_vector ​

Operator integer(I4P) >=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4_I4P >= pt

Attributes: elemental

Returns: logical

fortran
function I4P_great_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I4P_great_vector ​

Operator integer(I4P) >.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4_I4P > pt

Attributes: elemental

Returns: logical

fortran
function I4P_great_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I4P_low_eq_vector ​

Operator integer(I4P) <=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I4P <= pt

Attributes: elemental

Returns: logical

fortran
function I4P_low_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I4P_low_vector ​

Operator integer(I4P) <.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I4P < pt

Attributes: elemental

Returns: logical

fortran
function I4P_low_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I4P_mul_vector ​

Operator integer(I4P) *.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I4P * pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I4P_mul_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I4P_not_eq_vector ​

Operator integer(I4P) /=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I4P /= pt

Attributes: elemental

Returns: logical

fortran
function I4P_not_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I4P_sub_vector ​

Operator integer(I4P) -.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I4P - pt(1)
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I4P_sub_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I4P_sum_vector ​

Operator integer(I4P) +.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I4P + pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I4P_sum_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I8P_eq_vector ​

Operator integer(I8P) ==.

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", 5_I8P == pt

Attributes: elemental

Returns: logical

fortran
function I8P_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I8P_great_eq_vector ​

Operator integer(I8P) >=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4_I8P >= pt

Attributes: elemental

Returns: logical

fortran
function I8P_great_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I8P_great_vector ​

Operator integer(I8P) >.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4_I8P > pt

Attributes: elemental

Returns: logical

fortran
function I8P_great_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I8P_low_eq_vector ​

Operator integer(I8P) <=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I8P <= pt

Attributes: elemental

Returns: logical

fortran
function I8P_low_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I8P_low_vector ​

Operator integer(I8P) <.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I8P < pt

Attributes: elemental

Returns: logical

fortran
function I8P_low_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I8P_mul_vector ​

Operator integer(I8P) *.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I8P * pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I8P_mul_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I8P_not_eq_vector ​

Operator integer(I8P) /=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1_I8P /= pt

Attributes: elemental

Returns: logical

fortran
function I8P_not_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

I8P_sub_vector ​

Operator integer(I8P) -.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I8P - pt(1)
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I8P_sub_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

I8P_sum_vector ​

Operator integer(I8P) +.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2_I8P + pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function I8P_sum_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsinteger(kind=I8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R16P_eq_vector ​

Operator real(R16P) ==.

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", 5._R16P == pt

Attributes: elemental

Returns: logical

fortran
function R16P_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R16P_great_eq_vector ​

Operator real(R16P) >=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4._R16P >= pt

Attributes: elemental

Returns: logical

fortran
function R16P_great_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R16P_great_vector ​

Operator real(R16P) >.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4._R16P > pt

Attributes: elemental

Returns: logical

fortran
function R16P_great_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R16P_low_eq_vector ​

Operator real(R16P) <=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R16P <= pt

Attributes: elemental

Returns: logical

fortran
function R16P_low_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R16P_low_vector ​

Operator real(R16P) <.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R16P < pt

Attributes: elemental

Returns: logical

fortran
function R16P_low_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R16P_mul_vector ​

Operator real(R16P) *.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R16P * pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R16P_mul_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R16P_not_eq_vector ​

Operator real(R16P) /=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R16P /= pt

Attributes: elemental

Returns: logical

fortran
function R16P_not_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R16P_sub_vector ​

Operator real(R16P) -.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R16P - pt(1)
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R16P_sub_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R16P_sum_vector ​

Operator real(R16P) +.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R16P + pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R16P_sum_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R4P_eq_vector ​

Operator real(R4P) ==.

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", 5._R4P == pt

Attributes: elemental

Returns: logical

fortran
function R4P_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R4P_great_eq_vector ​

Operator real(R4P) >=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4._R4P >= pt

Attributes: elemental

Returns: logical

fortran
function R4P_great_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R4P_great_vector ​

Operator real(R4P) >.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4._R4P > pt

Attributes: elemental

Returns: logical

fortran
function R4P_great_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R4P_low_eq_vector ​

Operator real(R4P) <=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R4P <= pt

Attributes: elemental

Returns: logical

fortran
function R4P_low_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R4P_low_vector ​

Operator real(R4P) <.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R4P < pt

Attributes: elemental

Returns: logical

fortran
function R4P_low_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R4P_mul_vector ​

Operator real(R4P) *.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R4P * pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R4P_mul_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R4P_not_eq_vector ​

Operator real(R4P) /=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R4P /= pt

Attributes: elemental

Returns: logical

fortran
function R4P_not_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R4P_sub_vector ​

Operator real(R4P) -.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R4P - pt(1)
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R4P_sub_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R4P_sum_vector ​

Operator real(R4P) +.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R4P + pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R4P_sum_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R4P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R8P_eq_vector ​

Operator real(R8P) ==.

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", 5._R8P == pt

Attributes: elemental

Returns: logical

fortran
function R8P_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R8P_great_eq_vector ​

Operator real(R8P) >=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4._R8P >= pt

Attributes: elemental

Returns: logical

fortran
function R8P_great_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R8P_great_vector ​

Operator real(R8P) >.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 4._R8P > pt

Attributes: elemental

Returns: logical

fortran
function R8P_great_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R8P_low_eq_vector ​

Operator real(R8P) <=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R8P <= pt

Attributes: elemental

Returns: logical

fortran
function R8P_low_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R8P_low_vector ​

Operator real(R8P) <.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R8P < pt

Attributes: elemental

Returns: logical

fortran
function R8P_low_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R8P_mul_vector ​

Operator real(R8P) *.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R8P * pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R8P_mul_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R8P_not_eq_vector ​

Operator real(R8P) /=.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", 1._R8P /= pt

Attributes: elemental

Returns: logical

fortran
function R8P_not_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

R8P_sub_vector ​

Operator real(R8P) -.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R8P - pt(1)
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R8P_sub_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

R8P_sum_vector ​

Operator real(R8P) +.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = 2._R8P + pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function R8P_sum_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R8P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

angle_R16P ​

Calculate the angle (rad) between two vectors.

fortran
 type(vector_R16P) :: pt(1:2)
 real(R16P)        :: a

 pt(1) = ex_R16P
 pt(2) = 2 * ex_R16P
 a = pt(1)%angle(pt(2))
 print "(F3.1)", a
fortran
 type(vector_R16P) :: pt(1:2)
 real(R16P)        :: a

 pt(1) = ex_R16P
 pt(2) = ey_R16P
 a = angle_R16P(pt(1), pt(2))
 print "(F4.2)", a

Attributes: elemental

Returns: real(kind=R16P)

fortran
function angle_R16P(self, other) result(angle_)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inThe first vector.
othertype(vector_R16P)inOther vector.

Call graph

crossproduct_RPP ​

Compute the cross product. */ Left hand side. */ Right hand side. */ Cross product vector. */

Compute the scalar (dot) product. */ Left hand side. */ Right hand side. */ Dot product. */

Compute the cross product.

V→=(y1z2−z1y2)i→+(z1x2−x1z2)j→+(x1y2−y1x2)k→

where ( x_i ), ( y_i ) and ( z_i ) ( i=1,2 ) are the components of the vectors.

fortran
 type(vector_R16P) :: pt(0:2)
 pt(1) = 2 * ex_R16P
 pt(2) = ex_R16P
 pt(0) = pt(1).cross.pt(2)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function crossproduct_RPP(lhs, rhs) result(cross)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

Call graph

distance_to_line_R16P ​

Calculate the distance (scalar) to line defined by the 2 points.

The convention for the points numeration is the following:

         . self
         ^
         |
         |
 1.-------------.2
fortran
 type(vector_R16P) :: pt(0:2)
 real(R16P)        :: d

 pt(0) = 5.3 * ez_R16P
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 d = pt(0)%distance_to_line(pt1=pt(1), pt2=pt(2))
 print "(F3.1)", d
fortran
 type(vector_R16P) :: pt(0:2)
 real(R16P)        :: d

 pt(0) = 5.3 * ez_R16P
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 d = distance_to_line_R16P(pt(0), pt1=pt(1), pt2=pt(2))
 print "(F3.1)", d

Attributes: elemental

Returns: real(kind=R16P)

fortran
function distance_to_line_R16P(self, pt1, pt2) result(distance)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inThe point from which computing the distance.
pt1type(vector_R16P)inFirst line point.
pt2type(vector_R16P)inSecond line point.

Call graph

distance_to_plane_R16P ​

Calculate the distance (signed, scalar) to plane defined by the 3 points.

The convention for the points numeration is the following:

 3.----.2
   \   |
    \ *---------> . self
     \ |
      \|
       .1
fortran
 type(vector_R16P) :: pt(0:3)
 real(R16P)        :: d

 pt(0) = 5.3 * ez_R16P
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 d = pt(0)%distance_to_plane(pt1=pt(1), pt2=pt(2), pt3=pt(3))
 print "(F3.1)", d
fortran
 type(vector_R16P) :: pt(0:3)
 real(R16P)        :: d

 pt(0) = 5.3 * ez_R16P
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 d = distance_to_plane_R16P(pt(0), pt1=pt(1), pt2=pt(2), pt3=pt(3))
 print "(F3.1)", d

Attributes: elemental

Returns: real(kind=R16P)

fortran
function distance_to_plane_R16P(self, pt1, pt2, pt3) result(distance)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inThe point from which computing the distance.
pt1type(vector_R16P)inFirst plane point.
pt2type(vector_R16P)inSecond plane point.
pt3type(vector_R16P)inThird plane point.

Call graph

distance_vectorial_to_plane_R16P ​

Calculate the distance (vectorial) to plane defined by the 3 points.

The convention for the points numeration is the following:

 3.----.2
   \   |
    \ *---------> . self
     \ |
      \|
       .1
fortran
 type(vector_R16P) :: pt(0:3)

 pt(0) = 5.3 * ez_R16P
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 pt(0) = pt(0)%distance_vectorial_to_plane(pt1=pt(1), pt2=pt(2), pt3=pt(3))
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z
fortran
 type(vector_R16P) :: pt(0:3)

 pt(0) = 5.3 * ez_R16P
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 pt(0) = distance_vectorial_to_plane_R16P(pt(0), pt1=pt(1), pt2=pt(2), pt3=pt(3))
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function distance_vectorial_to_plane_R16P(self, pt1, pt2, pt3) result(distance)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inThe point from which computing the distance.
pt1type(vector_R16P)inFirst plane point.
pt2type(vector_R16P)inSecond plane point.
pt3type(vector_R16P)inThird plane point.

Call graph

dotproduct ​

Compute the scalar (dot) product.

D=x1⋅x2+y1⋅y2+z1⋅z2

where ( x_i ), ( y_i ) and ( z_i ) ( i=1,2 ) are the components of the vectors.

fortran
 type(vector_R16P) :: pt(1:2)
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 print "(F3.1)", pt(1).dot.pt(2)

Attributes: elemental

Returns: real(kind=R16P)

fortran
function dotproduct(lhs, rhs) result(dot)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

Call graph

face_normal3_R16P ​

Calculate the normal of the face defined by the 3 points.

The convention for the points numeration is the following:

 3.----.2
   \   |
    \  |
     \ |
      \|
       .1

The normal is calculated by the cross product of the side s12 for the side s13: s12 x s13. The normal is normalized if the variable norm is passed (with any value).

fortran
 type(vector_R16P) :: pt(0:3)

 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 pt(0) = pt(1)%face_normal3(pt1=pt(1), pt2=pt(2), pt3=pt(3), norm='y')
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)
fortran
 type(vector_R16P) :: pt(0:3)

 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 pt(0) = face_normal3_R16P(pt1=pt(1), pt2=pt(2), pt3=pt(3), norm='y')
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function face_normal3_R16P(pt1, pt2, pt3, norm) result(normal)

Arguments

NameTypeIntentAttributesDescription
pt1type(vector_R16P)inFirst face point.
pt2type(vector_R16P)inSecond face point.
pt3type(vector_R16P)inThird face point.
normcharacter(len=1)inoptionalIf 'norm' is passed as argument the normal is normalized.

Call graph

face_normal4_R16P ​

Calculate the normal of the face defined by 4 points.

The convention for the points numeration is the following:

 3.----------.2
  |          |
  |          |
  |          |
  |          |
 4.----------.1

The normal is calculated by the cross product of the diagonal d13 for the diagonal d24: d13 x d24. The normal is normalized if the variable norm is passed (with any value).

fortran
 type(vector_R16P) :: pt(0:4)

 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 pt(4) = ex_R16P + ey_R16P
 pt(0) = pt(1)%face_normal4(pt1=pt(1), pt2=pt(2), pt3=pt(3), pt4=pt(4), norm='y')
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)
fortran
 type(vector_R16P) :: pt(0:4)

 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 pt(4) = ex_R16P + ey_R16P
 pt(0) = face_normal4_R16P(pt1=pt(1), pt2=pt(2), pt3=pt(3), pt4=pt(4), norm='y')
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function face_normal4_R16P(pt1, pt2, pt3, pt4, norm) result(normal)

Arguments

NameTypeIntentAttributesDescription
pt1type(vector_R16P)inFirst face point.
pt2type(vector_R16P)inSecond face point.
pt3type(vector_R16P)inThird face point.
pt4type(vector_R16P)inFourth face point.
normcharacter(len=1)inoptionalIf 'norm' is passed as argument the normal is normalized.

Call graph

iolen_R16P ​

Compute IO length.

fortran
 use penf, only : byte_size
 type(vector_R16P) :: pt
 print*, pt%iolen()/byte_size(pt%x)
fortran
 use penf, only : byte_size
 type(vector_R16P) :: pt
 print*, iolen_R16P(pt)/byte_size(pt%x)

Returns: integer(kind=I4P)

fortran
function iolen_R16P(self) result(iolen_)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inVector.

is_collinear_R16P ​

Return true if the point is collinear with other two given points.

fortran
 type(vector_R16P) :: pt(0:2)

 pt(0) = 3 * ex_R16P
 pt(1) = 1 * ex_R16P
 pt(2) = 2 * ex_R16P
 print "(L1)", pt(0)%is_collinear(pt1=pt(1), pt2=pt(2))
fortran
 type(vector_R16P) :: pt(0:2)

 pt(0) = 3 * ex_R16P
 pt(1) = 1 * ex_R16P
 pt(2) = 2 * ex_R16P
 print "(L1)", is_collinear_R16P(pt(0), pt1=pt(1), pt2=pt(2))

Attributes: elemental

Returns: logical

fortran
function is_collinear_R16P(self, pt1, pt2, tolerance) result(is_collinear_)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inVector.
pt1type(vector_R16P)inFirst line point.
pt2type(vector_R16P)inSecond line point.
tolerancereal(kind=R16P)inoptionalTolerance for collinearity check.

Call graph

is_concyclic_R16P ​

Return true if the point is concyclic with other three given points.

Based on Ptolemy's Theorem.

fortran
 type(vector_R16P) :: pt(0:3)

 pt(0) = -1 * ey_R16P
 pt(1) =  1 * ex_R16P
 pt(2) =  1 * ey_R16P
 pt(3) = -1 * ex_R16P
 print "(L1)", pt(0)%is_concyclic(pt1=pt(1), pt2=pt(2), pt3=pt(3))
fortran
 type(vector_R16P) :: pt(0:3)

 pt(0) = -1 * ey_R16P
 pt(1) =  1 * ex_R16P
 pt(2) =  1 * ey_R16P
 pt(3) = -1 * ex_R16P
 print "(L1)", is_concyclic_R16P(pt(0), pt1=pt(1), pt2=pt(2), pt3=pt(3))

Attributes: elemental

Returns: logical

fortran
function is_concyclic_R16P(self, pt1, pt2, pt3, tolerance) result(is_concyclic_)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inVector.
pt1type(vector_R16P)inFirst arc point.
pt2type(vector_R16P)inSecond arc point.
pt3type(vector_R16P)inThird arc point.
tolerancereal(kind=R16P)inoptionalTolerance for concyclicity check.

Call graph

matrixproduct ​

Compute the matrix product.

fortran
 type(vector_R16P) :: pt(2)
 real(R16P)        :: I(3,3)
 pt(1) = 2 * ex_R16P
 I = 0._RPP
 I(1,1) = 1._RPP
 I(2,2) = 1._RPP
 I(3,3) = 1._RPP
 pt(2) = I.matrix.pt(1)
 print "(3(F3.1,1X))", abs(pt(2)%x), abs(pt(2)%y), abs(pt(2)%z)

Attributes: pure

Returns: type(vector_R16P)

fortran
function matrixproduct(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsreal(kind=R16P)inLeft hand side.
rhsclass(vector_R16P)inRight hand side.

Call graph

mirror_matrix_R16P ​

Return the mirror matrix (Householder's matrix) given normal of the mirroring plane.

Attributes: pure

Returns: real(kind=R16P)

fortran
function mirror_matrix_R16P(normal) result(matrix)

Arguments

NameTypeIntentAttributesDescription
normaltype(vector_R16P)inNormal of mirroring plane.

Call graph

negative ​

Operator - unary.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = - pt(1)
 print "(3(F4.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function negative(rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
rhsclass(vector_R16P)inRight hand side.

normL2_R16P ​

Return the norm L2 of vector.

The norm L2 if defined as ( N = \sqrt {x^2 + y^2 + z^2 } ).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P
 print "(F4.2)", pt%normL2()
fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P
 print "(F4.2)", normL2_R16P(pt)

Attributes: elemental

Returns: real(kind=R16P)

fortran
function normL2_R16P(self) result(norm)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inVector.

Call graph

normalized_R16P ​

Return a normalized copy of vector.

The normalization is made by means of norm L2. If the norm L2 of the vector is less than the parameter smallRPP the normalization value is set to normL2(vec)+smallRPP.

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P
 pt = pt%normalized()
 print "(3(F4.2,1X))", abs(pt%x), abs(pt%y), abs(pt%z)
fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P
 pt = normalized_R16P(pt)
 print "(3(F4.2,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function normalized_R16P(self) result(norm)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inVector.

Call graph

orthogonal ​

Compute the component of lhs orthogonal to rhs.

fortran
 type(vector_R16P) :: pt(0:2)
 pt(1) = 2 * ex_R16P + 3 * ey_R16P
 pt(2) = ex_R16P
 pt(0) = pt(1).ortho.pt(2)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function orthogonal(lhs, rhs) result(ortho)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

parallel ​

Attributes: elemental

Returns: type(vector_R16P)

fortran
function parallel(lhs, rhs) result(paral)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inCompute the component of lhs parallel to rhs.
rhstype(vector_R16P)inRight hand side.

Call graph

positive ​

Operator + unary.

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = + pt(1)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function positive(rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
rhsclass(vector_R16P)inRight hand side.

projection_onto_plane_R16P ​

Calculate the projection of point onto plane defined by 3 points.

The convention for the points numeration is the following:

 1.----.2
   \   |
    \ *---------> . self
     \ |
      \|
       .3
fortran
 type(vector_R16P) :: pt(0:3)

 pt(0) = 1 * ex_R16P + 2 * ey_R16P + 5.3 * ez_R16P
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 pt(0) = pt(0)%projection_onto_plane(pt1=pt(1), pt2=pt(2), pt3=pt(3))
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z
fortran
 type(vector_R16P) :: pt(0:3)

 pt(0) = 1 * ex_R16P + 2 * ey_R16P + 5.3 * ez_R16P
 pt(1) = ex_R16P
 pt(2) = ey_R16P
 pt(3) = ex_R16P - ey_R16P
 pt(0) = projection_onto_plane_R16P(pt(0), pt1=pt(1), pt2=pt(2), pt3=pt(3))
 print "(3(F3.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function projection_onto_plane_R16P(self, pt1, pt2, pt3) result(projection)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inThe point from which computing the distance.
pt1type(vector_R16P)inFirst plane point.
pt2type(vector_R16P)inSecond plane point.
pt3type(vector_R16P)inThird plane point.

Call graph

rotation_matrix_R16P ​

Return the rotation matrix given axis and angle of ratation.

Angle must be in radiants.

Attributes: pure

Returns: real(kind=R16P)

fortran
function rotation_matrix_R16P(axis, angle) result(matrix)

Arguments

NameTypeIntentAttributesDescription
axistype(vector_R16P)inAxis of ratation.
anglereal(kind=R16P)inAngle of ratation.

Call graph

sq_norm_R16P ​

Return the square of the norm of vector.

The square norm if defined as ( N = x^2 + y^2 + z^2 ).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P
 print "(F3.1)", pt%sq_norm()
fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P
 print "(F3.1)", sq_norm_R16P(pt)

Attributes: elemental

Returns: real(kind=R16P)

fortran
function sq_norm_R16P(self) result(sq)

Arguments

NameTypeIntentAttributesDescription
selfclass(vector_R16P)inVector.

Call graph

vector_div_I1P ​

Operator / integer(I1P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) / 2_I1P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_div_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

vector_div_I2P ​

Operator / integer(I2P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) / 2_I2P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_div_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

vector_div_I4P ​

Operator / integer(I4P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) / 2_I4P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_div_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

vector_div_I8P ​

Operator / integer(I8P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) / 2_I8P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_div_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

vector_div_R16P ​

Operator / real(R16P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) / 2._R16P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_div_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

vector_div_R4P ​

Operator / real(R4P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) / 2._R4P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_div_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

vector_div_R8P ​

Operator / real(R8P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) / 2._R8P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_div_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

vector_div_vector ​

Operator /.

fortran
 type(vector_R16P) :: pt(0:2)
 pt(1) = 1 * ex_R16P + 1 * ey_R16P + 1 * ez_R16P
 pt(2) = pt(1) + 1
 pt(0) = pt(1) / pt(2)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_div_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

vector_eq_I1P ​

Operator == integer(I1P).

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", pt == 5_I1P

Attributes: elemental

Returns: logical

fortran
function vector_eq_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

Call graph

vector_eq_I2P ​

Operator == integer(I2P).

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", pt == 5_I2P

Attributes: elemental

Returns: logical

fortran
function vector_eq_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

Call graph

vector_eq_I4P ​

Operator == integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", pt == 5_I4P

Attributes: elemental

Returns: logical

fortran
function vector_eq_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

Call graph

vector_eq_I8P ​

Operator == integer(I8P).

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", pt == 5_I8P

Attributes: elemental

Returns: logical

fortran
function vector_eq_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

Call graph

vector_eq_R16P ​

Operator == real(R16P).

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", pt == 5._R16P

Attributes: elemental

Returns: logical

fortran
function vector_eq_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

Call graph

vector_eq_R4P ​

Operator == real(R4P).

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", pt == 5._R4P

Attributes: elemental

Returns: logical

fortran
function vector_eq_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

Call graph

vector_eq_R8P ​

Operator == real(R8P).

fortran
 type(vector_R16P) :: pt
 pt = 4 * ex_R16P + 3 * ey_R16P
 print "(L1)", pt == 5._R8P

Attributes: elemental

Returns: logical

fortran
function vector_eq_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

Call graph

vector_eq_vector ​

Operator ==.

The comparison is done with respect normL2 and, secondary, with respect the directions.

fortran
 type(vector_R16P) :: pt(1:2)
 pt(1) = ex_R16P + ey_R16P + ez_R16P
 pt(2) = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt(1) == pt(2)

Attributes: elemental

Returns: logical

fortran
function vector_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

Call graph

vector_great_I1P ​

Operator > integer(I1P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt > 1_I1P

Attributes: elemental

Returns: logical

fortran
function vector_great_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

Call graph

vector_great_I2P ​

Operator > integer(I2P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt > 1_I2P

Attributes: elemental

Returns: logical

fortran
function vector_great_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

Call graph

vector_great_I4P ​

Operator > integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt > 1_I4P

Attributes: elemental

Returns: logical

fortran
function vector_great_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

Call graph

vector_great_I8P ​

Operator > integer(I8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt > 1_I8P

Attributes: elemental

Returns: logical

fortran
function vector_great_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

Call graph

vector_great_R16P ​

Operator > real(R16P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt > 1._R16P

Attributes: elemental

Returns: logical

fortran
function vector_great_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

Call graph

vector_great_R4P ​

Operator > real(R4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt > 1._R4P

Attributes: elemental

Returns: logical

fortran
function vector_great_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

Call graph

vector_great_R8P ​

Operator > real(R8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt > 1._R8P

Attributes: elemental

Returns: logical

fortran
function vector_great_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

Call graph

vector_great_eq_I1P ​

Operator >= integer(I1P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt >= 1_I1P

Attributes: elemental

Returns: logical

fortran
function vector_great_eq_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

Call graph

vector_great_eq_I2P ​

Operator >= integer(I2P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt >= 1_I2P

Attributes: elemental

Returns: logical

fortran
function vector_great_eq_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

Call graph

vector_great_eq_I4P ​

Operator >= integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt >= 1_I4P

Attributes: elemental

Returns: logical

fortran
function vector_great_eq_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

Call graph

vector_great_eq_I8P ​

Operator >= integer(I8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt >= 1_I8P

Attributes: elemental

Returns: logical

fortran
function vector_great_eq_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

Call graph

vector_great_eq_R16P ​

Operator >= real(R16P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt >= 1._R16P

Attributes: elemental

Returns: logical

fortran
function vector_great_eq_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

Call graph

vector_great_eq_R4P ​

Operator >= real(R4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt >= 1._R4P

Attributes: elemental

Returns: logical

fortran
function vector_great_eq_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

Call graph

vector_great_eq_R8P ​

Operator >= real(R8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt >= 1._R8P

Attributes: elemental

Returns: logical

fortran
function vector_great_eq_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

Call graph

vector_great_eq_vector ​

Operator >=.

fortran
 type(vector_R16P) :: pt(1:2)
 pt(1) = ex_R16P + ey_R16P + ez_R16P
 pt(2) = pt(1) + 1
 print "(L1)", pt(2) >= pt(1)

Attributes: elemental

Returns: logical

fortran
function vector_great_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

Call graph

vector_great_vector ​

Operator >.

fortran
 type(vector_R16P) :: pt(1:2)
 pt(1) = ex_R16P + ey_R16P + ez_R16P
 pt(2) = pt(1) + 1
 print "(L1)", pt(2) > pt(1)

Attributes: elemental

Returns: logical

fortran
function vector_great_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

Call graph

vector_low_I1P ​

Operator < integer(I1P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt < 4_I1P

Attributes: elemental

Returns: logical

fortran
function vector_low_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

Call graph

vector_low_I2P ​

Operator < integer(I2P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt < 4_I2P

Attributes: elemental

Returns: logical

fortran
function vector_low_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

Call graph

vector_low_I4P ​

Operator < integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt < 4_I4P

Attributes: elemental

Returns: logical

fortran
function vector_low_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

Call graph

vector_low_I8P ​

Operator < integer(I8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt < 4_I8P

Attributes: elemental

Returns: logical

fortran
function vector_low_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

Call graph

vector_low_R16P ​

Operator < real(R16P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt < 4._R16P

Attributes: elemental

Returns: logical

fortran
function vector_low_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

Call graph

vector_low_R4P ​

Operator < real(R4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt < 4._R4P

Attributes: elemental

Returns: logical

fortran
function vector_low_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

Call graph

vector_low_R8P ​

Operator < real(R8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt < 4._R8P

Attributes: elemental

Returns: logical

fortran
function vector_low_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

Call graph

vector_low_eq_I1P ​

Operator <= integer(I1P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt <= 4_I1P

Attributes: elemental

Returns: logical

fortran
function vector_low_eq_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

Call graph

vector_low_eq_I2P ​

Operator <= integer(I2P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt <= 4_I2P

Attributes: elemental

Returns: logical

fortran
function vector_low_eq_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

Call graph

vector_low_eq_I4P ​

Operator <= integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt <= 4_I4P

Attributes: elemental

Returns: logical

fortran
function vector_low_eq_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

Call graph

vector_low_eq_I8P ​

Operator <= integer(I8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt <= 4_I8P

Attributes: elemental

Returns: logical

fortran
function vector_low_eq_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

Call graph

vector_low_eq_R16P ​

Operator <= real(R16P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt <= 4._R16P

Attributes: elemental

Returns: logical

fortran
function vector_low_eq_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

Call graph

vector_low_eq_R4P ​

Operator <= real(R4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt <= 4._R4P

Attributes: elemental

Returns: logical

fortran
function vector_low_eq_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

Call graph

vector_low_eq_R8P ​

Operator <= real(R8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt <= 4._R8P

Attributes: elemental

Returns: logical

fortran
function vector_low_eq_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

Call graph

vector_low_eq_vector ​

Operator <=.

fortran
 type(vector_R16P) :: pt(1:2)
 pt(1) = ex_R16P + ey_R16P + ez_R16P
 pt(2) = pt(1) + 1
 print "(L1)", pt(1) <= pt(2)

Attributes: elemental

Returns: logical

fortran
function vector_low_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

Call graph

vector_low_vector ​

Operator <.

fortran
 type(vector_R16P) :: pt(1:2)
 pt(1) = ex_R16P + ey_R16P + ez_R16P
 pt(2) = pt(1) + 1
 print "(L1)", pt(1) < pt(2)

Attributes: elemental

Returns: logical

fortran
function vector_low_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

Call graph

vector_mul_I1P ​

Operator * integer(I1P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) * 2_I1P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_mul_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

vector_mul_I2P ​

Operator * integer(I2P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) * 2_I2P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_mul_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

vector_mul_I4P ​

Operator * integer(I4P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) * 2_I4P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_mul_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

vector_mul_I8P ​

Operator * integer(I8P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) * 2_I8P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_mul_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

vector_mul_R16P ​

Operator * real(R16P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) * 2._R16P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_mul_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

vector_mul_R4P ​

Operator * real(R4P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) * 2._R4P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_mul_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

vector_mul_R8P ​

Operator * real(R8P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) * 2._R8P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_mul_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

vector_mul_vector ​

Operator *.

fortran
 type(vector_R16P) :: pt(0:2)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(2) = pt(1) + 1
 pt(0) = pt(1) * pt(2)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_mul_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

vector_not_eq_I1P ​

Operator /= integer(I1P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt /= 1_I1P

Attributes: elemental

Returns: logical

fortran
function vector_not_eq_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

Call graph

vector_not_eq_I2P ​

Operator /= integer(I2P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt /= 1_I2P

Attributes: elemental

Returns: logical

fortran
function vector_not_eq_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

Call graph

vector_not_eq_I4P ​

Operator /= integer(I4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt /= 1_I4P

Attributes: elemental

Returns: logical

fortran
function vector_not_eq_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

Call graph

vector_not_eq_I8P ​

Operator /= integer(I8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt /= 1_I8P

Attributes: elemental

Returns: logical

fortran
function vector_not_eq_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

Call graph

vector_not_eq_R16P ​

Operator /= real(R16P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt /= 1._R16P

Attributes: elemental

Returns: logical

fortran
function vector_not_eq_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

Call graph

vector_not_eq_R4P ​

Operator /= real(R4P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt /= 1._R4P

Attributes: elemental

Returns: logical

fortran
function vector_not_eq_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

Call graph

vector_not_eq_R8P ​

Operator /= real(R8P).

fortran
 type(vector_R16P) :: pt
 pt = ex_R16P + ey_R16P + ez_R16P
 print "(L1)", pt /= 1._R8P

Attributes: elemental

Returns: logical

fortran
function vector_not_eq_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

Call graph

vector_not_eq_vector ​

Operator /=.

The comparison is done with respect normL2 and, secondary, with respect the directions.

fortran
 type(vector_R16P) :: pt(1:2)
 pt(1) = ex_R16P + ey_R16P + ez_R16P
 pt(2) = pt(1) + 1
 print "(L1)", pt(1) /= pt(2)
fortran
 type(vector_R16P) :: pt(1:2)
 pt(1) = ex_R16P + ey_R16P + ez_R16P
 pt(2) = ex_R16P + ey_R16P - ez_R16P
 print "(L1)", pt(1) /= pt(2)

Attributes: elemental

Returns: logical

fortran
function vector_not_eq_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

Call graph

vector_sub_I1P ​

Operator - integer(I1P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) - 3_I1P
 print "(3(F4.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sub_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

vector_sub_I2P ​

Operator - integer(I2P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) - 3_I2P
 print "(3(F4.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sub_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

vector_sub_I4P ​

Operator - integer(I4P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) - 3_I4P
 print "(3(F4.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sub_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

vector_sub_I8P ​

Operator - integer(I8P).

fortran
 type(vector_R16P) :: pt(0:1)
 character(4) :: res(3)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) - 2_I8P
 res(1) = trim(adjustl(str('(F4.1)',pt(0)%x)))
 res(2) = trim(adjustl(str('(F4.1)',pt(0)%y)))
 res(3) = trim(adjustl(str('(F4.1)',pt(0)%z)))
 print "(A4,1X,A3,1X,A4)", res(1), res(2), res(3)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sub_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

vector_sub_R16P ​

Operator - real(R16P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) - 3._R16P
 print "(3(F4.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sub_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

vector_sub_R4P ​

Operator - real(R4P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) - 3._R4P
 print "(3(F4.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sub_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

vector_sub_R8P ​

Operator - real(R8P).

fortran
 type(vector_R16P) :: pt(0:1)
 character(4) :: res(3)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) - 2._R8P
 res(1) = trim(adjustl(str('(F4.1)',pt(0)%x)))
 res(2) = trim(adjustl(str('(F4.1)',pt(0)%y)))
 res(3) = trim(adjustl(str('(F4.1)',pt(0)%z)))
 print "(A4,1X,A3,1X,A4)", res(1), res(2), res(3)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sub_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

vector_sub_vector ​

Operator -.

fortran
 type(vector_R16P) :: pt(0:2)
 pt(1) = 1 * ex_R16P + 1 * ey_R16P + 1 * ez_R16P
 pt(2) = pt(1) + 1
 pt(0) = pt(1) - pt(2)
 print "(3(F4.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sub_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.

vector_sum_I1P ​

Operator + integer(I1P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) + 2_I1P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sum_I1P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I1P)inRight hand side.

vector_sum_I2P ​

Operator + integer(I2P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) + 2_I2P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sum_I2P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I2P)inRight hand side.

vector_sum_I4P ​

Operator + integer(I4P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) + 2_I4P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sum_I4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I4P)inRight hand side.

vector_sum_I8P ​

Operator + integer(I8P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) + 2_I8P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sum_I8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsinteger(kind=I8P)inRight hand side.

vector_sum_R16P ​

Operator + real(R16P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) + 2._R16P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sum_R16P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R16P)inRight hand side.

vector_sum_R4P ​

Operator + real(R4P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) + 2._R4P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sum_R4P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R4P)inRight hand side.

vector_sum_R8P ​

Operator + real(R8P).

fortran
 type(vector_R16P) :: pt(0:1)
 pt(1) = 1 * ex_R16P + 2 * ey_R16P + 1 * ez_R16P
 pt(0) = pt(1) + 2._R8P
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sum_R8P(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhsreal(kind=R8P)inRight hand side.

vector_sum_vector ​

Operator +.

fortran
 type(vector_R16P) :: pt(0:2)
 pt(1) = 1 * ex_R16P + 1 * ey_R16P + 1 * ez_R16P
 pt(2) = pt(1) + 1
 pt(0) = pt(1) + pt(2)
 print "(3(F3.1,1X))", abs(pt(0)%x), abs(pt(0)%y), abs(pt(0)%z)

Attributes: elemental

Returns: type(vector_R16P)

fortran
function vector_sum_vector(lhs, rhs) result(opr)

Arguments

NameTypeIntentAttributesDescription
lhsclass(vector_R16P)inLeft hand side.
rhstype(vector_R16P)inRight hand side.