vecfor_RPP

VecFor, Vector algebra class for Fortran poor people, default kind. If not defined otherwise, the default kind is R8P.

Source: src/third_party/VecFor/src/lib/vecfor_RPP.F90

Dependencies

Contents

• vector
• load_from_file
• normalize
• printf
• save_into_file
• mirror_by_normal
• mirror_by_matrix
• rotate_by_axis_angle
• rotate_by_matrix
• assign_vector
• assign_R16P
• assign_R8P
• assign_R4P
• assign_I8P
• assign_I4P
• assign_I2P
• assign_I1P
• rotation_matrix
• mirror_matrix
• crossproduct_RPP
• dotproduct
• matrixproduct
• orthogonal
• parallel
• angle
• distance_to_line
• distance_to_plane
• distance_vectorial_to_plane
• face_normal3
• face_normal4
• iolen
• is_collinear
• is_concyclic
• normalized
• normL2
• projection_onto_plane
• sq_norm
• vector_mul_vector
• R16P_mul_vector
• vector_mul_R16P
• R8P_mul_vector
• vector_mul_R8P
• R4P_mul_vector
• vector_mul_R4P
• I8P_mul_vector
• vector_mul_I8P
• I4P_mul_vector
• vector_mul_I4P
• I2P_mul_vector
• vector_mul_I2P
• I1P_mul_vector
• vector_mul_I1P
• vector_div_vector
• vector_div_R16P
• vector_div_R8P
• vector_div_R4P
• vector_div_I8P
• vector_div_I4P
• vector_div_I2P
• vector_div_I1P
• positive
• vector_sum_vector
• R16P_sum_vector
• vector_sum_R16P
• R8P_sum_vector
• vector_sum_R8P
• R4P_sum_vector
• vector_sum_R4P
• I8P_sum_vector
• vector_sum_I8P
• I4P_sum_vector
• vector_sum_I4P
• I2P_sum_vector
• vector_sum_I2P
• I1P_sum_vector
• vector_sum_I1P
• negative
• vector_sub_vector
• R16P_sub_vector
• vector_sub_R16P
• R8P_sub_vector
• vector_sub_R8P
• R4P_sub_vector
• vector_sub_R4P
• I8P_sub_vector
• vector_sub_I8P
• I4P_sub_vector
• vector_sub_I4P
• I2P_sub_vector
• vector_sub_I2P
• I1P_sub_vector
• vector_sub_I1P
• vector_not_eq_vector
• R16P_not_eq_vector
• vector_not_eq_R16P
• R8P_not_eq_vector
• vector_not_eq_R8P
• R4P_not_eq_vector
• vector_not_eq_R4P
• I8P_not_eq_vector
• vector_not_eq_I8P
• I4P_not_eq_vector
• vector_not_eq_I4P
• I2P_not_eq_vector
• vector_not_eq_I2P
• I1P_not_eq_vector
• vector_not_eq_I1P
• vector_low_vector
• R16P_low_vector
• vector_low_R16P
• R8P_low_vector
• vector_low_R8P
• R4P_low_vector
• vector_low_R4P
• I8P_low_vector
• vector_low_I8P
• I4P_low_vector
• vector_low_I4P
• I2P_low_vector
• vector_low_I2P
• I1P_low_vector
• vector_low_I1P
• vector_low_eq_vector
• R16P_low_eq_vector
• vector_low_eq_R16P
• R8P_low_eq_vector
• vector_low_eq_R8P
• R4P_low_eq_vector
• vector_low_eq_R4P
• I8P_low_eq_vector
• vector_low_eq_I8P
• I4P_low_eq_vector
• vector_low_eq_I4P
• I2P_low_eq_vector
• vector_low_eq_I2P
• I1P_low_eq_vector
• vector_low_eq_I1P
• vector_eq_vector
• R16P_eq_vector
• vector_eq_R16P
• R8P_eq_vector
• vector_eq_R8P
• R4P_eq_vector
• vector_eq_R4P
• I8P_eq_vector
• vector_eq_I8P
• I4P_eq_vector
• vector_eq_I4P
• I2P_eq_vector
• vector_eq_I2P
• I1P_eq_vector
• vector_eq_I1P
• vector_great_eq_vector
• R16P_great_eq_vector
• vector_great_eq_R16P
• R8P_great_eq_vector
• vector_great_eq_R8P
• R4P_great_eq_vector
• vector_great_eq_R4P
• I8P_great_eq_vector
• vector_great_eq_I8P
• I4P_great_eq_vector
• vector_great_eq_I4P
• I2P_great_eq_vector
• vector_great_eq_I2P
• I1P_great_eq_vector
• vector_great_eq_I1P
• vector_great_vector
• R16P_great_vector
• vector_great_R16P
• R8P_great_vector
• vector_great_R8P
• R4P_great_vector
• vector_great_R4P
• I8P_great_vector
• vector_great_I8P
• I4P_great_vector
• vector_great_I4P
• I2P_great_vector
• vector_great_I2P
• I1P_great_vector
• vector_great_I1P

Variables

Name	Type	Attributes	Description
ex	type(vector)	parameter	X direction versor.
ey	type(vector)	parameter	Y direction versor.
ez	type(vector)	parameter	Z direction versor.

Derived Types

vector

Vector class.

Components

Name	Type	Attributes	Description
x	real(kind=R8P)		Cartesian component in x direction.
y	real(kind=R8P)		Cartesian component in y direction.
z	real(kind=R8P)		Cartesian component in z direction.

Type-Bound Procedures

Name	Attributes	Description
operator(.cross.)		Cross product operator.
operator(.dot.)		Scalar (dot) product operator.
operator(.matrix.)		Matrix product operator.
operator(.paral.)		Component of lhs parallel to rhs operator.
operator(.ortho.)		Component of lhs orthogonal to rhs operator.
crossproduct	pass(lhs)	Compute the cross product.
dotproduct	pass(lhs)	Compute the scalar (dot) product.
matrixproduct	pass(rhs)	Compute the matrix product.
orthogonal	pass(lhs)	Compute the component of lhs orthogonal to rhs.
parallel	pass(lhs)	Compute the component of lhs parallel to rhs.
angle	pass(self)	Return the angle (rad) between two
distance_to_line	pass(self)	Return the distance (scalar) to
distance_to_plane	pass(self)	Return the distance (signed, scalar)
distance_vectorial_to_plane	pass(self)	Return the distance (vectorial) to
face_normal3	nopass	Return the normal of the face.
face_normal4	nopass	Return the normal of the face.
iolen	pass(self)	Compute IO length.
is_collinear	pass(self)	Return true if the point is col-
is_concyclic	pass(self)	Return true if the point is concy-
load_from_file	pass(self)	Load vector from file.
mirror		Mirror vector.
normalize	pass(self)	Normalize a vector.
normalized	pass(self)	Return a normalized copy of vector.
normL2	pass(self)	Return the norm L2 of vector.
printf	pass(self)	Print vector components with a
projection_onto_plane	pass(self)	Calculate the projection of point
rotate		Rotate vector.
save_into_file	pass(self)	Save vector into file.
sq_norm	pass(self)	Return the square of the norm.
assignment(=)		Overloading =.
operator(*)		Overloading *.
operator(/)		Overloading /.
operator(+)		Overloading +.
operator(-)		Overloading -.
operator(/=)		Overloading /=.
operator(<)		Overloading <.
operator(<=)		Overloading <=.
operator(==)		Overloading ==.
operator(>=)		Overloading >=.
operator(>)		Overloading >.
mirror_by_normal	pass(self)	Mirror vector given normal of mirroring plane.
mirror_by_matrix	pass(self)	Mirror vector given matrix.
rotate_by_axis_angle	pass(self)	Rotate vector given axis and angle.
rotate_by_matrix	pass(self)	Rotate vector given matrix.
assign_vector	pass(lhs)	Operator =.
assign_R16P	pass(lhs)	Operator = real(R16P).
assign_R8P	pass(lhs)	Operator = real(R8P).
assign_R4P	pass(lhs)	Operator = real(R4P).
assign_I8P	pass(lhs)	Operator = integer(I8P).
assign_I4P	pass(lhs)	Operator = integer(I4P).
assign_I2P	pass(lhs)	Operator = integer(I2P).
assign_I1P	pass(lhs)	Operator = integer(I1P).
vector_mul_vector	pass(lhs)	Operator *.
R16P_mul_vector	pass(rhs)	Operator real(R16P) *.
vector_mul_R16P	pass(lhs)	Operator * real(R16P).
R8P_mul_vector	pass(rhs)	Operator real(R8P) *.
vector_mul_R8P	pass(lhs)	Operator * real(R8P).
R4P_mul_vector	pass(rhs)	Operator real(R4P) *.
vector_mul_R4P	pass(lhs)	Operator * real(R4P).
I8P_mul_vector	pass(rhs)	Operator integer(I8P) *.
vector_mul_I8P	pass(lhs)	Operator * integer(I8P).
I4P_mul_vector	pass(rhs)	Operator integer(I4P) *.
vector_mul_I4P	pass(lhs)	Operator * integer(I4P).
I2P_mul_vector	pass(rhs)	Operator integer(I2P) *.
vector_mul_I2P	pass(lhs)	Operator * integer(I2P).
I1P_mul_vector	pass(rhs)	Operator integer(I1P) *.
vector_mul_I1P	pass(lhs)	Operator * integer(I1P).
vector_div_vector	pass(lhs)	Operator /.
vector_div_R16P	pass(lhs)	Operator / real(R16P).
vector_div_R8P	pass(lhs)	Operator / real(R8P).
vector_div_R4P	pass(lhs)	Operator / real(R4P).
vector_div_I8P	pass(lhs)	Operator / integer(I8P).
vector_div_I4P	pass(lhs)	Operator / integer(I4P).
vector_div_I2P	pass(lhs)	Operator / integer(I2P).
vector_div_I1P	pass(lhs)	Operator / integer(I1P).
positive	pass(rhs)	Operator +, unary.
vector_sum_vector	pass(lhs)	Operator +.
R16P_sum_vector	pass(rhs)	Operator real(R16P) +.
vector_sum_R16P	pass(lhs)	Operator + real(R16P).
R8P_sum_vector	pass(rhs)	Operator real(R8P) +.
vector_sum_R8P	pass(lhs)	Operator + real(R8P).
R4P_sum_vector	pass(rhs)	Operator real(R4P) +.
vector_sum_R4P	pass(lhs)	Operator + real(R4P).
I8P_sum_vector	pass(rhs)	Operator integer(I8P) +.
vector_sum_I8P	pass(lhs)	Operator + integer(I8P).
I4P_sum_vector	pass(rhs)	Operator integer(I4P) +.
vector_sum_I4P	pass(lhs)	Operator + integer(I4P).
I2P_sum_vector	pass(rhs)	Operator integer(I2P) +.
vector_sum_I2P	pass(lhs)	Operator + integer(I2P).
I1P_sum_vector	pass(rhs)	Operator integer(I1P) +.
vector_sum_I1P	pass(lhs)	Operator + integer(I1P).
negative	pass(rhs)	Operator -, unary.
vector_sub_vector	pass(lhs)	Operator -.
R16P_sub_vector	pass(rhs)	Operator real(R16P) -.
vector_sub_R16P	pass(lhs)	Operator - real(R16P).
R8P_sub_vector	pass(rhs)	Operator real(R8P) -.
vector_sub_R8P	pass(lhs)	Operator - real(R8P).
R4P_sub_vector	pass(rhs)	Operator real(R4P) -.
vector_sub_R4P	pass(lhs)	Operator - real(R4P).
I8P_sub_vector	pass(rhs)	Operator integer(I8P) -.
vector_sub_I8P	pass(lhs)	Operator - integer(I8P).
I4P_sub_vector	pass(rhs)	Operator integer(I4P) -.
vector_sub_I4P	pass(lhs)	Operator - integer(I4P).
I2P_sub_vector	pass(rhs)	Operator integer(I2P) -.
vector_sub_I2P	pass(lhs)	Operator - integer(I2P).
I1P_sub_vector	pass(rhs)	Operator integer(I1P) -.
vector_sub_I1P	pass(lhs)	Operator - integer(I1P).
vector_not_eq_vector	pass(lhs)	Operator /=.
R16P_not_eq_vector	pass(rhs)	Operator real(R16P) /=.
vector_not_eq_R16P	pass(lhs)	Operator /= real(R16P).
R8P_not_eq_vector	pass(rhs)	Operator real(R8P) /=.
vector_not_eq_R8P	pass(lhs)	Operator /= real(R8P).
R4P_not_eq_vector	pass(rhs)	Operator real(R4P) /=.
vector_not_eq_R4P	pass(lhs)	Operator /= real(R4P).
I8P_not_eq_vector	pass(rhs)	Operator integer(I8P) /=.
vector_not_eq_I8P	pass(lhs)	Operator /= integer(I8P).
I4P_not_eq_vector	pass(rhs)	Operator integer(I4P) /=.
vector_not_eq_I4P	pass(lhs)	Operator /= integer(I4P).
I2P_not_eq_vector	pass(rhs)	Operator integer(I2P) /=.
vector_not_eq_I2P	pass(lhs)	Operator /= integer(I2P).
I1P_not_eq_vector	pass(rhs)	Operator integer(I1P) /=.
vector_not_eq_I1P	pass(lhs)	Operator /= integer(I1P).
vector_low_vector	pass(lhs)	Operator <.
R16P_low_vector	pass(rhs)	Operator real(R16P) <.
vector_low_R16P	pass(lhs)	Operator < real(R16P).
R8P_low_vector	pass(rhs)	Operator real(R8P) <.
vector_low_R8P	pass(lhs)	Operator < real(R8P).
R4P_low_vector	pass(rhs)	Operator real(R4P) <.
vector_low_R4P	pass(lhs)	Operator < real(R4P).
I8P_low_vector	pass(rhs)	Operator integer(I8P) <.
vector_low_I8P	pass(lhs)	Operator < integer(I8P).
I4P_low_vector	pass(rhs)	Operator integer(I4P) <.
vector_low_I4P	pass(lhs)	Operator < integer(I4P).
I2P_low_vector	pass(rhs)	Operator integer(I2P) <.
vector_low_I2P	pass(lhs)	Operator < integer(I2P).
I1P_low_vector	pass(rhs)	Operator integer(I1P) <.
vector_low_I1P	pass(lhs)	Operator < integer(I1P).
vector_low_eq_vector	pass(lhs)	Operator <=.
R16P_low_eq_vector	pass(rhs)	Operator real(R16P) <=.
vector_low_eq_R16P	pass(lhs)	Operator <= real(R16P).
R8P_low_eq_vector	pass(rhs)	Operator real(R8P) <=.
vector_low_eq_R8P	pass(lhs)	Operator <= real(R8P).
R4P_low_eq_vector	pass(rhs)	Operator real(R4P) <=.
vector_low_eq_R4P	pass(lhs)	Operator <= real(R4P).
I8P_low_eq_vector	pass(rhs)	Operator integer(I8P) <=.
vector_low_eq_I8P	pass(lhs)	Operator <= integer(I8P).
I4P_low_eq_vector	pass(rhs)	Operator integer(I4P) <=.
vector_low_eq_I4P	pass(lhs)	Operator <= integer(I4P).
I2P_low_eq_vector	pass(rhs)	Operator integer(I2P) <=.
vector_low_eq_I2P	pass(lhs)	Operator <= integer(I2P).
I1P_low_eq_vector	pass(rhs)	Operator integer(I1P) <=.
vector_low_eq_I1P	pass(lhs)	Operator <= integer(I1P).
vector_eq_vector	pass(lhs)	Operator ==.
R16P_eq_vector	pass(rhs)	Operator real(R16P) ==.
vector_eq_R16P	pass(lhs)	Operator == real(R16P).
R8P_eq_vector	pass(rhs)	Operator real(R8P) ==.
vector_eq_R8P	pass(lhs)	Operator == real(R8P).
R4P_eq_vector	pass(rhs)	Operator real(R4P) ==.
vector_eq_R4P	pass(lhs)	Operator == real(R4P).
I8P_eq_vector	pass(rhs)	Operator integer(I8P) ==.
vector_eq_I8P	pass(lhs)	Operator == integer(I8P).
I4P_eq_vector	pass(rhs)	Operator integer(I4P) ==.
vector_eq_I4P	pass(lhs)	Operator == integer(I4P).
I2P_eq_vector	pass(rhs)	Operator integer(I2P) ==.
vector_eq_I2P	pass(lhs)	Operator == integer(I2P).
I1P_eq_vector	pass(rhs)	Operator integer(I1P) ==.
vector_eq_I1P	pass(lhs)	Operator == integer(I1P).
vector_great_eq_vector	pass(lhs)	Operator >=.
R16P_great_eq_vector	pass(rhs)	Operator real(R16P) >=.
vector_great_eq_R16P	pass(lhs)	Operator >= real(R16P).
R8P_great_eq_vector	pass(rhs)	Operator real(R8P) >=.
vector_great_eq_R8P	pass(lhs)	Operator >= real(R8P).
R4P_great_eq_vector	pass(rhs)	Operator real(R4P) >=.
vector_great_eq_R4P	pass(lhs)	Operator >= real(R4P).
I8P_great_eq_vector	pass(rhs)	Operator integer(I8P) >=.
vector_great_eq_I8P	pass(lhs)	Operator >= integer(I8P).
I4P_great_eq_vector	pass(rhs)	Operator integer(I4P) >=.
vector_great_eq_I4P	pass(lhs)	Operator >= integer(I4P).
I2P_great_eq_vector	pass(rhs)	Operator integer(I2P) >=.
vector_great_eq_I2P	pass(lhs)	Operator >= integer(I2P).
I1P_great_eq_vector	pass(rhs)	Operator integer(I1P) >=.
vector_great_eq_I1P	pass(lhs)	Operator >= integer(I1P).
vector_great_vector	pass(lhs)	Operator >.
R16P_great_vector	pass(rhs)	Operator real(R16P) >.
vector_great_R16P	pass(lhs)	Operator > real(R16P).
R8P_great_vector	pass(rhs)	Operator real(R8P) >.
vector_great_R8P	pass(lhs)	Operator > real(R8P).
R4P_great_vector	pass(rhs)	Operator real(R4P) >.
vector_great_R4P	pass(lhs)	Operator > real(R4P).
I8P_great_vector	pass(rhs)	Operator integer(I8P) >.
vector_great_I8P	pass(lhs)	Operator > integer(I8P).
I4P_great_vector	pass(rhs)	Operator integer(I4P) >.
vector_great_I4P	pass(lhs)	Operator > integer(I4P).
I2P_great_vector	pass(rhs)	Operator integer(I2P) >.
vector_great_I2P	pass(lhs)	Operator > integer(I2P).
I1P_great_vector	pass(rhs)	Operator integer(I1P) >.
vector_great_I1P	pass(lhs)	Operator > integer(I1P).

Subroutines

load_from_file

Load vector from file.

 type(vector) :: pt
 pt = 1 * ex + 2 * ey + 3 * ez
 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

subroutine load_from_file(self, unit, fmt, pos, iostat, iomsg)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	inout		Vector.
unit	integer(kind=I4P)	in		Logic unit.
fmt	character(len=*)	in	optional	IO format.
pos	integer(kind=I8P)	in	optional	Position specifier.
iostat	integer(kind=I4P)	out	optional	IO error.
iomsg	character(len=*)	out	optional	IO error message.

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.

 type(vector) :: pt
 pt = ex + ey
 call pt%normalize
 print "(3(F4.2,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

subroutine normalize(self)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	inout		Vector.

Call graph

printf

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

 type(vector) :: pt
 pt = ex + ey
 call pt%printf(prefix='[x, y, z] = ', sep=', ')

subroutine printf(self, unit, prefix, sep, suffix, iostat, iomsg)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		Vector.
unit	integer(kind=I4P)	in	optional	Logic unit.
prefix	character(len=*)	in	optional	Prefix string.
sep	character(len=*)	in	optional	Components separator.
suffix	character(len=*)	in	optional	Suffix string.
iostat	integer(kind=I4P)	out	optional	IO error.
iomsg	character(len=*)	out	optional	IO error message.

Call graph

save_into_file

Save vector into file.

 type(vector) :: pt
 pt = 1 * ex + 2 * ey + 3 * ez
 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

subroutine save_into_file(self, unit, fmt, pos, iostat, iomsg)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		Vector data.
unit	integer(kind=I4P)	in		Logic unit.
fmt	character(len=*)	in	optional	IO format.
pos	integer(kind=I8P)	in	optional	Position specifier.
iostat	integer(kind=I4P)	out	optional	IO error.
iomsg	character(len=*)	out	optional	IO error message.

Call graph

mirror_by_normal

Mirror vector given normal of mirroring plane.

Attributes: pure

subroutine mirror_by_normal(self, normal)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	inout		Vector.
normal	type(vector)	in		Normal of mirroring plane.

Call graph

mirror_by_matrix

Mirror vector given matrix (of mirroring).

Attributes: pure

subroutine mirror_by_matrix(self, matrix)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	inout		Vector.
matrix	real(kind=R8P)	in		Mirroring matrix.

Call graph

rotate_by_axis_angle

Rotate vector given axis and angle.

Angle must be in radiants.

Attributes: pure

subroutine rotate_by_axis_angle(self, axis, angle)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	inout		Vector.
axis	type(vector)	in		Axis of rotation.
angle	real(kind=R8P)	in		Angle of rotation.

Call graph

rotate_by_matrix

Rotate vector given matrix (of ratation).

Attributes: pure

subroutine rotate_by_matrix(self, matrix)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	inout		Vector.
matrix	real(kind=R8P)	in		Rotation matrix.

Call graph

assign_vector

Operator =

 type(vector) :: pt
 pt = 1 * ex + 2 * ey + 3 * ez
 print "(3(F3.1,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: pure

subroutine assign_vector(lhs, rhs)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	inout		Left hand side.
rhs	type(vector)	in		Right hand side.

assign_R16P

Operator = real(R16P).

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

Attributes: elemental

subroutine assign_R16P(lhs, rhs)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	inout		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

assign_R8P

Operator = real(R8P).

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

Attributes: elemental

subroutine assign_R8P(lhs, rhs)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	inout		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

assign_R4P

Operator = real(R4P).

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

Attributes: elemental

subroutine assign_R4P(lhs, rhs)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	inout		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

assign_I8P

Operator = integer(I8P).

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

Attributes: elemental

subroutine assign_I8P(lhs, rhs)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	inout		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

assign_I4P

Operator = integer(I4P).

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

Attributes: elemental

subroutine assign_I4P(lhs, rhs)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	inout		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

assign_I2P

Operator = integer(I4P).

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

Attributes: elemental

subroutine assign_I2P(lhs, rhs)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	inout		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

assign_I1P

Operator = integer(I4P).

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

Attributes: elemental

subroutine assign_I1P(lhs, rhs)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	inout		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

Functions

rotation_matrix

Return the rotation matrix given axis and angle of ratation.

Angle must be in radiants.

Attributes: pure

Returns: real(kind=R8P)

function rotation_matrix(axis, angle) result(matrix)

Arguments

Name	Type	Intent	Attributes	Description
axis	type(vector)	in		Axis of ratation.
angle	real(kind=R8P)	in		Angle of ratation.

Call graph

mirror_matrix

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

Attributes: pure

Returns: real(kind=R8P)

function mirror_matrix(normal) result(matrix)

Arguments

Name	Type	Intent	Attributes	Description
normal	type(vector)	in		Normal of mirroring plane.

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.

$$\overrightarrow{V}=\left(y_1{z}_2-z_1{y}_2\right)\overrightarrow{i}+\left(z_1{x}_2-x_1{z}_2\right)\overrightarrow{j}+\left(x_1{y}_2-y_1{x}_2\right)\overrightarrow{k}$$

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

 type(vector) :: pt(0:2)
 pt(1) = 2 * ex
 pt(2) = ex
 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)

function crossproduct_RPP(lhs, rhs) result(cross)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

Call graph

dotproduct

Compute the scalar (dot) product.

$$\mathrm{D}=x_1\cdot x_2+y_1\cdot y_2+z_1\cdot z_2$$

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

 type(vector) :: pt(1:2)
 pt(1) = ex
 pt(2) = ey
 print "(F3.1)", pt(1).dot.pt(2)

Attributes: elemental

Returns: real(kind=R8P)

function dotproduct(lhs, rhs) result(dot)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

Call graph

matrixproduct

Compute the matrix product.

 type(vector) :: pt(2)
 real(R8P)        :: I(3,3)
 pt(1) = 2 * ex
 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)

function matrixproduct(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

orthogonal

Compute the component of lhs orthogonal to rhs.

 type(vector) :: pt(0:2)
 pt(1) = 2 * ex + 3 * ey
 pt(2) = ex
 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)

function orthogonal(lhs, rhs) result(ortho)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

parallel

Attributes: elemental

Returns: type(vector)

function parallel(lhs, rhs) result(paral)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Compute the component of lhs parallel to rhs.
rhs	type(vector)	in		Right hand side.

Call graph

angle

Calculate the angle (rad) between two vectors.

 type(vector) :: pt(1:2)
 real(R8P)        :: a

 pt(1) = ex
 pt(2) = 2 * ex
 a = pt(1)%angle(pt(2))
 print "(F3.1)", a

 type(vector) :: pt(1:2)
 real(R8P)        :: a

 pt(1) = ex
 pt(2) = ey
 a = angle(pt(1), pt(2))
 print "(F4.2)", a

Attributes: elemental

Returns: real(kind=R8P)

function angle(self, other) result(angle_)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		The first vector.
other	type(vector)	in		Other vector.

Call graph

distance_to_line

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

The convention for the points numeration is the following:

         . self
         ^
         |
         |
 1.-------------.2

 type(vector) :: pt(0:2)
 real(R8P)        :: d

 pt(0) = 5.3 * ez
 pt(1) = ex
 pt(2) = ey
 d = pt(0)%distance_to_line(pt1=pt(1), pt2=pt(2))
 print "(F3.1)", d

 type(vector) :: pt(0:2)
 real(R8P)        :: d

 pt(0) = 5.3 * ez
 pt(1) = ex
 pt(2) = ey
 d = distance_to_line(pt(0), pt1=pt(1), pt2=pt(2))
 print "(F3.1)", d

Attributes: elemental

Returns: real(kind=R8P)

function distance_to_line(self, pt1, pt2) result(distance)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		The point from which computing the distance.
pt1	type(vector)	in		First line point.
pt2	type(vector)	in		Second line point.

Call graph

distance_to_plane

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

 type(vector) :: pt(0:3)
 real(R8P)        :: d

 pt(0) = 5.3 * ez
 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 d = pt(0)%distance_to_plane(pt1=pt(1), pt2=pt(2), pt3=pt(3))
 print "(F3.1)", d

 type(vector) :: pt(0:3)
 real(R8P)        :: d

 pt(0) = 5.3 * ez
 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 d = distance_to_plane(pt(0), pt1=pt(1), pt2=pt(2), pt3=pt(3))
 print "(F3.1)", d

Attributes: elemental

Returns: real(kind=R8P)

function distance_to_plane(self, pt1, pt2, pt3) result(distance)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		The point from which computing the distance.
pt1	type(vector)	in		First plane point.
pt2	type(vector)	in		Second plane point.
pt3	type(vector)	in		Third plane point.

Call graph

distance_vectorial_to_plane

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

The convention for the points numeration is the following:

 3.----.2
   \   |
    \ *---------> . self
     \ |
      \|
       .1

 type(vector) :: pt(0:3)

 pt(0) = 5.3 * ez
 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 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

 type(vector) :: pt(0:3)

 pt(0) = 5.3 * ez
 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 pt(0) = distance_vectorial_to_plane(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)

function distance_vectorial_to_plane(self, pt1, pt2, pt3) result(distance)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		The point from which computing the distance.
pt1	type(vector)	in		First plane point.
pt2	type(vector)	in		Second plane point.
pt3	type(vector)	in		Third plane point.

Call graph

face_normal3

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).

 type(vector) :: pt(0:3)

 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 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)

 type(vector) :: pt(0:3)

 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 pt(0) = 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)

Attributes: elemental

Returns: type(vector)

function face_normal3(pt1, pt2, pt3, norm) result(normal)

Arguments

Name	Type	Intent	Attributes	Description
pt1	type(vector)	in		First face point.
pt2	type(vector)	in		Second face point.
pt3	type(vector)	in		Third face point.
norm	character(len=1)	in	optional	If 'norm' is passed as argument the normal is normalized.

Call graph

face_normal4

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).

 type(vector) :: pt(0:4)

 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 pt(4) = ex + ey
 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)

 type(vector) :: pt(0:4)

 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 pt(4) = ex + ey
 pt(0) = 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)

Attributes: elemental

Returns: type(vector)

function face_normal4(pt1, pt2, pt3, pt4, norm) result(normal)

Arguments

Name	Type	Intent	Attributes	Description
pt1	type(vector)	in		First face point.
pt2	type(vector)	in		Second face point.
pt3	type(vector)	in		Third face point.
pt4	type(vector)	in		Fourth face point.
norm	character(len=1)	in	optional	If 'norm' is passed as argument the normal is normalized.

Call graph

iolen

Compute IO length.

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

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

Returns: integer(kind=I4P)

function iolen(self) result(iolen_)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		Vector.

is_collinear

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

 type(vector) :: pt(0:2)

 pt(0) = 3 * ex
 pt(1) = 1 * ex
 pt(2) = 2 * ex
 print "(L1)", pt(0)%is_collinear(pt1=pt(1), pt2=pt(2))

 type(vector) :: pt(0:2)

 pt(0) = 3 * ex
 pt(1) = 1 * ex
 pt(2) = 2 * ex
 print "(L1)", is_collinear(pt(0), pt1=pt(1), pt2=pt(2))

Attributes: elemental

Returns: logical

function is_collinear(self, pt1, pt2, tolerance) result(is_collinear_)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		Vector.
pt1	type(vector)	in		First line point.
pt2	type(vector)	in		Second line point.
tolerance	real(kind=R8P)	in	optional	Tolerance for collinearity check.

Call graph

is_concyclic

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

Based on Ptolemy's Theorem.

 type(vector) :: pt(0:3)

 pt(0) = -1 * ey
 pt(1) =  1 * ex
 pt(2) =  1 * ey
 pt(3) = -1 * ex
 print "(L1)", pt(0)%is_concyclic(pt1=pt(1), pt2=pt(2), pt3=pt(3))

 type(vector) :: pt(0:3)

 pt(0) = -1 * ey
 pt(1) =  1 * ex
 pt(2) =  1 * ey
 pt(3) = -1 * ex
 print "(L1)", is_concyclic(pt(0), pt1=pt(1), pt2=pt(2), pt3=pt(3))

Attributes: elemental

Returns: logical

function is_concyclic(self, pt1, pt2, pt3, tolerance) result(is_concyclic_)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		Vector.
pt1	type(vector)	in		First arc point.
pt2	type(vector)	in		Second arc point.
pt3	type(vector)	in		Third arc point.
tolerance	real(kind=R8P)	in	optional	Tolerance for concyclicity check.

Call graph

normalized

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.

 type(vector) :: pt
 pt = ex + ey
 pt = pt%normalized()
 print "(3(F4.2,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

 type(vector) :: pt
 pt = ex + ey
 pt = normalized(pt)
 print "(3(F4.2,1X))", abs(pt%x), abs(pt%y), abs(pt%z)

Attributes: elemental

Returns: type(vector)

function normalized(self) result(norm)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		Vector.

Call graph

normL2

Return the norm L2 of vector.

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

 type(vector) :: pt
 pt = ex + ey
 print "(F4.2)", pt%normL2()

 type(vector) :: pt
 pt = ex + ey
 print "(F4.2)", normL2(pt)

Attributes: elemental

Returns: real(kind=R8P)

function normL2(self) result(norm)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		Vector.

Call graph

projection_onto_plane

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

The convention for the points numeration is the following:

 1.----.2
   \   |
    \ *---------> . self
     \ |
      \|
       .3

 type(vector) :: pt(0:3)

 pt(0) = 1 * ex + 2 * ey + 5.3 * ez
 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 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

 type(vector) :: pt(0:3)

 pt(0) = 1 * ex + 2 * ey + 5.3 * ez
 pt(1) = ex
 pt(2) = ey
 pt(3) = ex - ey
 pt(0) = projection_onto_plane(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)

function projection_onto_plane(self, pt1, pt2, pt3) result(projection)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		The point from which computing the distance.
pt1	type(vector)	in		First plane point.
pt2	type(vector)	in		Second plane point.
pt3	type(vector)	in		Third plane point.

Call graph

sq_norm

Return the square of the norm of vector.

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

 type(vector) :: pt
 pt = ex + ey
 print "(F3.1)", pt%sq_norm()

 type(vector) :: pt
 pt = ex + ey
 print "(F3.1)", sq_norm(pt)

Attributes: elemental

Returns: real(kind=R8P)

function sq_norm(self) result(sq)

Arguments

Name	Type	Intent	Attributes	Description
self	class(vector)	in		Vector.

Call graph

vector_mul_vector

Operator *.

 type(vector) :: pt(0:2)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_mul_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

R16P_mul_vector

Operator real(R16P) *.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R16P_mul_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_mul_R16P

Operator * real(R16P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_mul_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

R8P_mul_vector

Operator real(R8P) *.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R8P_mul_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_mul_R8P

Operator * real(R8P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_mul_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

R4P_mul_vector

Operator real(R4P) *.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R4P_mul_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_mul_R4P

Operator * real(R4P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_mul_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

I8P_mul_vector

Operator integer(I8P) *.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I8P_mul_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_mul_I8P

Operator * integer(I8P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_mul_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

I4P_mul_vector

Operator integer(I4P) *.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I4P_mul_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_mul_I4P

Operator * integer(I4P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_mul_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

I2P_mul_vector

Operator integer(I2P) *.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I2P_mul_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_mul_I2P

Operator * integer(I2P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_mul_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

I1P_mul_vector

Operator integer(I1P) *.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I1P_mul_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_mul_I1P

Operator * integer(I1P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_mul_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

vector_div_vector

Operator /.

 type(vector) :: pt(0:2)
 pt(1) = 1 * ex + 1 * ey + 1 * ez
 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)

function vector_div_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

vector_div_R16P

Operator / real(R16P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_div_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

vector_div_R8P

Operator / real(R8P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_div_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

vector_div_R4P

Operator / real(R4P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_div_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

vector_div_I8P

Operator / integer(I8P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_div_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

vector_div_I4P

Operator / integer(I4P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_div_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

vector_div_I2P

Operator / integer(I2P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_div_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

vector_div_I1P

Operator / integer(I1P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_div_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

positive

Operator + unary.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function positive(rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
rhs	class(vector)	in		Right hand side.

vector_sum_vector

Operator +.

 type(vector) :: pt(0:2)
 pt(1) = 1 * ex + 1 * ey + 1 * ez
 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)

function vector_sum_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

R16P_sum_vector

Operator real(R16P) +.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R16P_sum_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sum_R16P

Operator + real(R16P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sum_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

R8P_sum_vector

Operator real(R8P) +.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R8P_sum_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sum_R8P

Operator + real(R8P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sum_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

R4P_sum_vector

Operator real(R4P) +.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R4P_sum_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sum_R4P

Operator + real(R4P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sum_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

I8P_sum_vector

Operator integer(I8P) +.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I8P_sum_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sum_I8P

Operator + integer(I8P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sum_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

I4P_sum_vector

Operator integer(I4P) +.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I4P_sum_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sum_I4P

Operator + integer(I4P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sum_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

I2P_sum_vector

Operator integer(I2P) +.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I2P_sum_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sum_I2P

Operator + integer(I2P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sum_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

I1P_sum_vector

Operator integer(I1P) +.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I1P_sum_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sum_I1P

Operator + integer(I1P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sum_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

negative

Operator - unary.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 pt(0) = - pt(1)
 print "(3(F4.1,1X))", pt(0)%x, pt(0)%y, pt(0)%z

Attributes: elemental

Returns: type(vector)

function negative(rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
rhs	class(vector)	in		Right hand side.

vector_sub_vector

Operator -.

 type(vector) :: pt(0:2)
 pt(1) = 1 * ex + 1 * ey + 1 * ez
 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)

function vector_sub_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

R16P_sub_vector

Operator real(R16P) -.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R16P_sub_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sub_R16P

Operator - real(R16P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sub_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

R8P_sub_vector

Operator real(R8P) -.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R8P_sub_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sub_R8P

Operator - real(R8P).

 type(vector) :: pt(0:1)
 character(4) :: res(3)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sub_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

R4P_sub_vector

Operator real(R4P) -.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function R4P_sub_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sub_R4P

Operator - real(R4P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sub_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

I8P_sub_vector

Operator integer(I8P) -.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I8P_sub_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sub_I8P

Operator - integer(I8P).

 type(vector) :: pt(0:1)
 character(4) :: res(3)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sub_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

I4P_sub_vector

Operator integer(I4P) -.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I4P_sub_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sub_I4P

Operator - integer(I4P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sub_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

I2P_sub_vector

Operator integer(I2P) -.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I2P_sub_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sub_I2P

Operator - integer(I2P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sub_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

I1P_sub_vector

Operator integer(I1P) -.

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function I1P_sub_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

vector_sub_I1P

Operator - integer(I1P).

 type(vector) :: pt(0:1)
 pt(1) = 1 * ex + 2 * ey + 1 * ez
 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)

function vector_sub_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

vector_not_eq_vector

Operator /=.

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

 type(vector) :: pt(1:2)
 pt(1) = ex + ey + ez
 pt(2) = pt(1) + 1
 print "(L1)", pt(1) /= pt(2)

 type(vector) :: pt(1:2)
 pt(1) = ex + ey + ez
 pt(2) = ex + ey - ez
 print "(L1)", pt(1) /= pt(2)

Attributes: elemental

Returns: logical

function vector_not_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

Call graph

R16P_not_eq_vector

Operator real(R16P) /=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R16P /= pt

Attributes: elemental

Returns: logical

function R16P_not_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_not_eq_R16P

Operator /= real(R16P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt /= 1._R16P

Attributes: elemental

Returns: logical

function vector_not_eq_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

Call graph

R8P_not_eq_vector

Operator real(R8P) /=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R8P /= pt

Attributes: elemental

Returns: logical

function R8P_not_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_not_eq_R8P

Operator /= real(R8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt /= 1._R8P

Attributes: elemental

Returns: logical

function vector_not_eq_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

Call graph

R4P_not_eq_vector

Operator real(R4P) /=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R4P /= pt

Attributes: elemental

Returns: logical

function R4P_not_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_not_eq_R4P

Operator /= real(R4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt /= 1._R4P

Attributes: elemental

Returns: logical

function vector_not_eq_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

Call graph

I8P_not_eq_vector

Operator integer(I8P) /=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I8P /= pt

Attributes: elemental

Returns: logical

function I8P_not_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_not_eq_I8P

Operator /= integer(I8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt /= 1_I8P

Attributes: elemental

Returns: logical

function vector_not_eq_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

Call graph

I4P_not_eq_vector

Operator integer(I4P) /=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I4P /= pt

Attributes: elemental

Returns: logical

function I4P_not_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_not_eq_I4P

Operator /= integer(I4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt /= 1_I4P

Attributes: elemental

Returns: logical

function vector_not_eq_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

Call graph

I2P_not_eq_vector

Operator integer(I2P) /=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I2P /= pt

Attributes: elemental

Returns: logical

function I2P_not_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_not_eq_I2P

Operator /= integer(I2P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt /= 1_I2P

Attributes: elemental

Returns: logical

function vector_not_eq_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

Call graph

I1P_not_eq_vector

Operator integer(I1P) /=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I1P /= pt

Attributes: elemental

Returns: logical

function I1P_not_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_not_eq_I1P

Operator /= integer(I1P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt /= 1_I1P

Attributes: elemental

Returns: logical

function vector_not_eq_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

Call graph

vector_low_vector

Operator <.

 type(vector) :: pt(1:2)
 pt(1) = ex + ey + ez
 pt(2) = pt(1) + 1
 print "(L1)", pt(1) < pt(2)

Attributes: elemental

Returns: logical

function vector_low_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

Call graph

R16P_low_vector

Operator real(R16P) <.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R16P < pt

Attributes: elemental

Returns: logical

function R16P_low_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_R16P

Operator < real(R16P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt < 4._R16P

Attributes: elemental

Returns: logical

function vector_low_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

Call graph

R8P_low_vector

Operator real(R8P) <.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R8P < pt

Attributes: elemental

Returns: logical

function R8P_low_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_R8P

Operator < real(R8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt < 4._R8P

Attributes: elemental

Returns: logical

function vector_low_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

Call graph

R4P_low_vector

Operator real(R4P) <.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R4P < pt

Attributes: elemental

Returns: logical

function R4P_low_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_R4P

Operator < real(R4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt < 4._R4P

Attributes: elemental

Returns: logical

function vector_low_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

Call graph

I8P_low_vector

Operator integer(I8P) <.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I8P < pt

Attributes: elemental

Returns: logical

function I8P_low_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_I8P

Operator < integer(I8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt < 4_I8P

Attributes: elemental

Returns: logical

function vector_low_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

Call graph

I4P_low_vector

Operator integer(I4P) <.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I4P < pt

Attributes: elemental

Returns: logical

function I4P_low_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_I4P

Operator < integer(I4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt < 4_I4P

Attributes: elemental

Returns: logical

function vector_low_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

Call graph

I2P_low_vector

Operator integer(I2P) <.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I2P < pt

Attributes: elemental

Returns: logical

function I2P_low_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_I2P

Operator < integer(I2P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt < 4_I2P

Attributes: elemental

Returns: logical

function vector_low_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

Call graph

I1P_low_vector

Operator integer(I1P) <.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I1P < pt

Attributes: elemental

Returns: logical

function I1P_low_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_I1P

Operator < integer(I1P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt < 4_I1P

Attributes: elemental

Returns: logical

function vector_low_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

Call graph

vector_low_eq_vector

Operator <=.

 type(vector) :: pt(1:2)
 pt(1) = ex + ey + ez
 pt(2) = pt(1) + 1
 print "(L1)", pt(1) <= pt(2)

Attributes: elemental

Returns: logical

function vector_low_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

Call graph

R16P_low_eq_vector

Operator real(R16P) <=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R16P <= pt

Attributes: elemental

Returns: logical

function R16P_low_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_eq_R16P

Operator <= real(R16P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt <= 4._R16P

Attributes: elemental

Returns: logical

function vector_low_eq_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

Call graph

R8P_low_eq_vector

Operator real(R8P) <=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R8P <= pt

Attributes: elemental

Returns: logical

function R8P_low_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_eq_R8P

Operator <= real(R8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt <= 4._R8P

Attributes: elemental

Returns: logical

function vector_low_eq_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

Call graph

R4P_low_eq_vector

Operator real(R4P) <=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1._R4P <= pt

Attributes: elemental

Returns: logical

function R4P_low_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_eq_R4P

Operator <= real(R4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt <= 4._R4P

Attributes: elemental

Returns: logical

function vector_low_eq_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

Call graph

I8P_low_eq_vector

Operator integer(I8P) <=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I8P <= pt

Attributes: elemental

Returns: logical

function I8P_low_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_eq_I8P

Operator <= integer(I8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt <= 4_I8P

Attributes: elemental

Returns: logical

function vector_low_eq_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

Call graph

I4P_low_eq_vector

Operator integer(I4P) <=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I4P <= pt

Attributes: elemental

Returns: logical

function I4P_low_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_eq_I4P

Operator <= integer(I4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt <= 4_I4P

Attributes: elemental

Returns: logical

function vector_low_eq_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

Call graph

I2P_low_eq_vector

Operator integer(I2P) <=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I2P <= pt

Attributes: elemental

Returns: logical

function I2P_low_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_eq_I2P

Operator <= integer(I2P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt <= 4_I2P

Attributes: elemental

Returns: logical

function vector_low_eq_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

Call graph

I1P_low_eq_vector

Operator integer(I1P) <=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 1_I1P <= pt

Attributes: elemental

Returns: logical

function I1P_low_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_low_eq_I1P

Operator <= integer(I1P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt <= 4_I1P

Attributes: elemental

Returns: logical

function vector_low_eq_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

Call graph

vector_eq_vector

Operator ==.

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

 type(vector) :: pt(1:2)
 pt(1) = ex + ey + ez
 pt(2) = ex + ey + ez
 print "(L1)", pt(1) == pt(2)

Attributes: elemental

Returns: logical

function vector_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

Call graph

R16P_eq_vector

Operator real(R16P) ==.

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", 5._R16P == pt

Attributes: elemental

Returns: logical

function R16P_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_eq_R16P

Operator == real(R16P).

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", pt == 5._R16P

Attributes: elemental

Returns: logical

function vector_eq_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

Call graph

R8P_eq_vector

Operator real(R8P) ==.

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", 5._R8P == pt

Attributes: elemental

Returns: logical

function R8P_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_eq_R8P

Operator == real(R8P).

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", pt == 5._R8P

Attributes: elemental

Returns: logical

function vector_eq_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

Call graph

R4P_eq_vector

Operator real(R4P) ==.

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", 5._R4P == pt

Attributes: elemental

Returns: logical

function R4P_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_eq_R4P

Operator == real(R4P).

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", pt == 5._R4P

Attributes: elemental

Returns: logical

function vector_eq_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

Call graph

I8P_eq_vector

Operator integer(I8P) ==.

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", 5_I8P == pt

Attributes: elemental

Returns: logical

function I8P_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_eq_I8P

Operator == integer(I8P).

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", pt == 5_I8P

Attributes: elemental

Returns: logical

function vector_eq_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

Call graph

I4P_eq_vector

Operator integer(I4P) ==.

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", 5_I4P == pt

Attributes: elemental

Returns: logical

function I4P_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_eq_I4P

Operator == integer(I4P).

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", pt == 5_I4P

Attributes: elemental

Returns: logical

function vector_eq_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

Call graph

I2P_eq_vector

Operator integer(I2P) ==.

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", 5_I2P == pt

Attributes: elemental

Returns: logical

function I2P_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_eq_I2P

Operator == integer(I2P).

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", pt == 5_I2P

Attributes: elemental

Returns: logical

function vector_eq_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

Call graph

I1P_eq_vector

Operator integer(I1P) ==.

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", 5_I1P == pt

Attributes: elemental

Returns: logical

function I1P_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_eq_I1P

Operator == integer(I1P).

 type(vector) :: pt
 pt = 4 * ex + 3 * ey
 print "(L1)", pt == 5_I1P

Attributes: elemental

Returns: logical

function vector_eq_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

Call graph

vector_great_eq_vector

Operator >=.

 type(vector) :: pt(1:2)
 pt(1) = ex + ey + ez
 pt(2) = pt(1) + 1
 print "(L1)", pt(2) >= pt(1)

Attributes: elemental

Returns: logical

function vector_great_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

Call graph

R16P_great_eq_vector

Operator real(R16P) >=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4._R16P >= pt

Attributes: elemental

Returns: logical

function R16P_great_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_eq_R16P

Operator >= real(R16P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt >= 1._R16P

Attributes: elemental

Returns: logical

function vector_great_eq_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

Call graph

R8P_great_eq_vector

Operator real(R8P) >=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4._R8P >= pt

Attributes: elemental

Returns: logical

function R8P_great_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_eq_R8P

Operator >= real(R8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt >= 1._R8P

Attributes: elemental

Returns: logical

function vector_great_eq_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

Call graph

R4P_great_eq_vector

Operator real(R4P) >=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4._R4P >= pt

Attributes: elemental

Returns: logical

function R4P_great_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_eq_R4P

Operator >= real(R4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt >= 1._R4P

Attributes: elemental

Returns: logical

function vector_great_eq_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

Call graph

I8P_great_eq_vector

Operator integer(I8P) >=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4_I8P >= pt

Attributes: elemental

Returns: logical

function I8P_great_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_eq_I8P

Operator >= integer(I8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt >= 1_I8P

Attributes: elemental

Returns: logical

function vector_great_eq_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

Call graph

I4P_great_eq_vector

Operator integer(I4P) >=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4_I4P >= pt

Attributes: elemental

Returns: logical

function I4P_great_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_eq_I4P

Operator >= integer(I4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt >= 1_I4P

Attributes: elemental

Returns: logical

function vector_great_eq_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

Call graph

I2P_great_eq_vector

Operator integer(I2P) >=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4_I2P >= pt

Attributes: elemental

Returns: logical

function I2P_great_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_eq_I2P

Operator >= integer(I2P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt >= 1_I2P

Attributes: elemental

Returns: logical

function vector_great_eq_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

Call graph

I1P_great_eq_vector

Operator integer(I1P) >=.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4_I1P >= pt

Attributes: elemental

Returns: logical

function I1P_great_eq_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_eq_I1P

Operator >= integer(I1P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt >= 1_I1P

Attributes: elemental

Returns: logical

function vector_great_eq_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

Call graph

vector_great_vector

Operator >.

 type(vector) :: pt(1:2)
 pt(1) = ex + ey + ez
 pt(2) = pt(1) + 1
 print "(L1)", pt(2) > pt(1)

Attributes: elemental

Returns: logical

function vector_great_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	type(vector)	in		Right hand side.

Call graph

R16P_great_vector

Operator real(R16P) >.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4._R16P > pt

Attributes: elemental

Returns: logical

function R16P_great_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R16P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_R16P

Operator > real(R16P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt > 1._R16P

Attributes: elemental

Returns: logical

function vector_great_R16P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R16P)	in		Right hand side.

Call graph

R8P_great_vector

Operator real(R8P) >.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4._R8P > pt

Attributes: elemental

Returns: logical

function R8P_great_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_R8P

Operator > real(R8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt > 1._R8P

Attributes: elemental

Returns: logical

function vector_great_R8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R8P)	in		Right hand side.

Call graph

R4P_great_vector

Operator real(R4P) >.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4._R4P > pt

Attributes: elemental

Returns: logical

function R4P_great_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	real(kind=R4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_R4P

Operator > real(R4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt > 1._R4P

Attributes: elemental

Returns: logical

function vector_great_R4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	real(kind=R4P)	in		Right hand side.

Call graph

I8P_great_vector

Operator integer(I8P) >.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4_I8P > pt

Attributes: elemental

Returns: logical

function I8P_great_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I8P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_I8P

Operator > integer(I8P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt > 1_I8P

Attributes: elemental

Returns: logical

function vector_great_I8P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I8P)	in		Right hand side.

Call graph

I4P_great_vector

Operator integer(I4P) >.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4_I4P > pt

Attributes: elemental

Returns: logical

function I4P_great_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I4P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_I4P

Operator > integer(I4P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt > 1_I4P

Attributes: elemental

Returns: logical

function vector_great_I4P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I4P)	in		Right hand side.

Call graph

I2P_great_vector

Operator integer(I2P) >.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4_I2P > pt

Attributes: elemental

Returns: logical

function I2P_great_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I2P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_I2P

Operator > integer(I2P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt > 1_I2P

Attributes: elemental

Returns: logical

function vector_great_I2P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I2P)	in		Right hand side.

Call graph

I1P_great_vector

Operator integer(I1P) >.

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", 4_I1P > pt

Attributes: elemental

Returns: logical

function I1P_great_vector(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	integer(kind=I1P)	in		Left hand side.
rhs	class(vector)	in		Right hand side.

Call graph

vector_great_I1P

Operator > integer(I1P).

 type(vector) :: pt
 pt = ex + ey + ez
 print "(L1)", pt > 1_I1P

Attributes: elemental

Returns: logical

function vector_great_I1P(lhs, rhs) result(opr)

Arguments

Name	Type	Intent	Attributes	Description
lhs	class(vector)	in		Left hand side.
rhs	integer(kind=I1P)	in		Right hand side.

Call graph