数値の操作とプロパティ#
abs#
名前#
abs(3) - [数値] 絶対値
概要#
result = abs(a)
elemental TYPE(kind=KIND) function abs(a)
TYPE(kind=KIND),intent(in) :: a
特性#
a は任意の実数、整数、または複素数の値です。
a が複素数の場合、戻り値はaと同じ種類の浮動小数点数になります。
それ以外の場合は、戻り値の型と種類はaと同じです。
説明#
abs(3) は、数値引数aの絶対値を計算します。
数学では、実数xの絶対値またはモジュラスは、|x|と表記され、xの符号を無視した大きさです。
数の絶対値は、ゼロからの距離と考えることができます。したがって、複素数の絶対値は、実数部をx値、虚数部をy値とする点<x,y>のように、大きさsqrt(x%re**2,x%im**2)の実数です。
オプション#
- a
絶対値を計算する値。
結果#
a が整数型または実数型の場合、結果の値は絶対値|a|であり、入力引数と同じ型と種類です。
a が値(x, y)の複素数の場合、結果は、次のように近似された実数です。
sqrt(x**2 + y**2)
過度のオーバーフローやアンダーフローなしに計算されます（つまり、結果の計算で、返される実数の許容される大きさをオーバーフローする可能性があり、非常に小さい値は、たとえば返される値を計算する際に二乗されるとアンダーフローが発生する可能性があります）。
つまり、複素数以外の値をx軸上の複素数とみなし、複素数をx-y点<x%re,x%im>とみなすと、abs(3)の結果は、原点からの値の距離の（正の）大きさになります。
例#
サンプルプログラム
program demo_abs
implicit none
integer,parameter :: dp=kind(0.0d0)
integer :: i = -1
real :: x = -1.0
complex :: z = (-3.0,-4.0)
doubleprecision :: rr = -45.78_dp
character(len=*),parameter :: &
! some formats
frmt = '(1x,a15,1x," In: ",g0, T51," Out: ",g0)', &
frmtc = '(1x,a15,1x," In: (",g0,",",g0,")",T51," Out: ",g0)', &
g = '(*(g0,1x))'
! basic usage
! any integer, real, or complex type
write(*, frmt) 'integer ', i, abs(i)
write(*, frmt) 'real ', x, abs(x)
write(*, frmt) 'doubleprecision ', rr, abs(rr)
write(*, frmtc) 'complex ', z, abs(z)
! You can take the absolute value of any value whose positive value
! is representable with the same type and kind.
write(*, *) 'abs range test : ', abs(huge(0)), abs(-huge(0))
write(*, *) 'abs range test : ', abs(huge(0.0)), abs(-huge(0.0))
write(*, *) 'abs range test : ', abs(tiny(0.0)), abs(-tiny(0.0))
! A dusty corner is that abs(-huge(0)-1) of an integer would be
! a representable negative value on most machines but result in a
! positive value out of range.
! elemental
write(*, g) ' abs is elemental:', abs([20, 0, -1, -3, 100])
! COMPLEX input produces REAL output
write(*, g)' complex input produces real output', &
& abs(cmplx(30.0_dp,40.0_dp,kind=dp))
! dusty corner: "kind=dp" is required or the value returned by
! CMPLX() is a default real instead of double precision
! the returned value for complex input can be thought of as the
! distance from the origin <0,0>
write(*, g) ' distance of (', z, ') from zero is', abs( z )
write(*, g) ' so beware of overflow with complex values'
!write(*, g) abs(cmplx( huge(0.0), huge(0.0) ))
write(*, g) ' because the biggest default real is',huge(0.0)
end program demo_abs
結果
integer In: -1 Out: 1
real In: -1.000000 Out: 1.000000
doubleprecision In: -45.78000000000000 Out: 45.78000000000000
complex In: (-3.000000,-4.000000) Out: 5.000000
abs range test : 2147483647 2147483647
abs range test : 3.4028235E+38 3.4028235E+38
abs range test : 1.1754944E-38 1.1754944E-38
abs is elemental: 20 0 1 3 100
complex input produces real output 50.00000000000000
distance of ( -3.000000 -4.000000 ) from zero is 5.000000
so beware of overflow with complex values
Inf
because the biggest default real is .3402823E+39
標準#
FORTRAN 77
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
aint#
名前#
aint(3) - [数値] ゼロ方向に切り捨てて整数にする
概要#
result = aint(x [,kind])
elemental real(kind=KIND) function iaint(x,KIND)
real(kind=**),intent(in) :: x
integer(kind=**),intent(in),optional :: KIND
特性#
**として指定されたkindは、型のサポートされている任意のkindです。**
kindが指定されない限り、結果はデフォルトの種類の実数です。
kindは、結果のkindパラメータを示す整数初期化式です。
説明#
aint(3) は、引数をゼロ方向に切り捨てて整数にします。
オプション#
- x
切り捨てる実数値。
- kind
結果のkindパラメータを示します。
結果#
符号は、xの大きさが1未満でない限り、xの符号と同じです。その場合、ゼロが返されます。
それ以外の場合、aint(3)は、xの大きさを超えない最大の整数（入力と同じ符号）を返します。
つまり、ゼロに向かって値を切り捨てます。
例#
サンプルプログラム
program demo_aint
use, intrinsic :: iso_fortran_env, only : sp=>real32, dp=>real64
implicit none
real(kind=dp) :: x8
print *,'basics:'
print *,' just chops off the fractional part'
print *, aint(-2.999), aint(-2.1111)
print *,' if |x| < 1 a positive zero is returned'
print *, aint(-0.999), aint( 0.9999)
print *,' input may be of any real kind'
x8 = 4.3210_dp
print *, aint(-x8), aint(x8)
print *,'elemental:'
print *,aint([ &
& -2.7, -2.5, -2.2, -2.0, -1.5, -1.0, -0.5, &
& 0.0, &
& +0.5, +1.0, +1.5, +2.0, +2.2, +2.5, +2.7 ])
end program demo_aint
結果
basics:
just chops off the fractional part
-2.000000 -2.000000
if |x| < 1 a positive zero is returned
0.0000000E+00 0.0000000E+00
input may be of any real kind
-4.00000000000000 4.00000000000000
elemental:
-2.000000 -2.000000 -2.000000 -2.000000 -1.000000
-1.000000 0.0000000E+00 0.0000000E+00 0.0000000E+00 1.000000
1.000000 2.000000 2.000000 2.000000 2.000000
標準#
FORTRAN 77
参照#
anint(3)、int(3)、nint(3)、selected_int_kind(3)、ceiling(3)、floor(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
anint#
名前#
anint(3) - [数値] 最近接の整数
概要#
result = anint(a [,kind])
elemental real(kind=KIND) function anint(x,KIND)
real(kind=**),intent(in) :: x
integer,intent(in),optional :: KIND
特性#
a は任意の種類の実数型です。
KIND はスカラー整数定数式です。
結果は実数型です。結果の種類は、kindで指定されない限り、xと同じです。
説明#
anint(3) は、引数を最近接の整数に丸めます。
整数型を返すnint(3)とは異なり、実数の全範囲を返すことができます（整数型は通常、実数型よりも値の範囲が小さいです）。
オプション#
- a
丸める値
- kind
結果の種類を指定します。デフォルトはaの種類です。
結果#
戻り値は、aに最も近い整数です。
a がゼロより大きい場合、anint(a)(3) は aint(a + 0.5) を返します。
a がゼロ以下の場合、aint(a - 0.5)を返します。ただし、aintでは|a| < 1 の場合、結果はゼロ(0)と指定されています。
-0.5 < a <= -0.0 の場合に anint(a) が負のゼロを返すかどうかはプロセッサ依存です。負のゼロのサポートを有効または無効にするコンパイラスイッチが多くの場合使用できます。
例#
サンプルプログラム
program demo_anint
use, intrinsic :: iso_fortran_env, only : real32, real64, real128
implicit none
real,allocatable :: arr(:)
! basics
print *, 'ANINT (2.783) has the value 3.0 =>', anint(2.783)
print *, 'ANINT (-2.783) has the value -3.0 =>', anint(-2.783)
print *, 'by default the kind of the output is the kind of the input'
print *, anint(1234567890.1234567890e0)
print *, anint(1234567890.1234567890d0)
print *, 'sometimes specifying the result kind is useful when passing'
print *, 'results as an argument, for example.'
print *, 'do you know why the results are different?'
print *, anint(1234567890.1234567890,kind=real64)
print *, anint(1234567890.1234567890d0,kind=real64)
! elemental
print *, 'numbers on a cusp are always the most troublesome'
print *, anint([ -2.7, -2.5, -2.2, -2.0, -1.5, -1.0, -0.5, 0.0 ])
print *, 'negative zero is processor dependent'
arr=[ 0.0, 0.1, 0.5, 1.0, 1.5, 2.0, 2.2, 2.5, 2.7 ]
print *, anint(arr)
arr=[ -0.0, -0.1, -0.5, -1.0, -1.5, -2.0, -2.2, -2.5, -2.7 ]
print *, anint(arr)
end program demo_anint
結果
> ANINT (2.783) has the value 3.0 => 3.000000
> ANINT (-2.783) has the value -3.0 => -3.000000
> by default the kind of the output is the kind of the input
> 1.2345679E+09
> 1234567890.00000
> sometimes specifying the result kind is useful when passing
> results as an argument, for example.
> do you know why the results are different?
> 1234567936.00000
> 1234567890.00000
> numbers on a cusp are always the most troublesome
> -3.000000 -3.000000 -2.000000 -2.000000 -2.000000
> -1.000000 -1.000000 0.0000000E+00
> negative zero is processor dependent
> 0.0000000E+00 0.0000000E+00 1.000000 1.000000 2.000000
> 2.000000 2.000000 3.000000 3.000000
> 0.0000000E+00 0.0000000E+00 -1.000000 -1.000000 -2.000000
> -2.000000 -2.000000 -3.000000 -3.000000
標準#
FORTRAN 77
参照#
aint(3)、int(3)、nint(3)、selected_int_kind(3)、ceiling(3)、floor(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
ceiling#
名前#
ceiling(3) - [数値] 整数天井関数
概要#
result = ceiling(a [,kind])
elemental integer(KIND) function ceiling(a,KIND)
real(kind=**),intent(in) :: a
integer,intent(in),optional :: KIND
特性#
** a は *実数* 型です。
KIND はスカラー整数定数式である必要があります。存在する場合は、結果の種類を指定します。
結果は *整数* 型です。KIND が指定されていない場合は、デフォルトの種類になります。
説明#
ceiling(3) は、a 以上で最小の整数を返します。
数直線 -n <– 0 -> +n では、返される値は常に入力値と同じか、入力値の右側になります。
オプション#
- a
天井を求めるための *実数* 値。
- kind
結果のkindパラメータを示します。
結果#
結果は、入力値が整数でない場合は、a と等しい *整数* 値、またはa より大きく最小の *整数* 値になります。
a が整数の場合は、返される値は int(a) となります。
指定された *整数* 型で表現できない場合は、結果は未定義です。
例#
サンプルプログラム
program demo_ceiling
implicit none
! just a convenient format for a list of integers
character(len=*),parameter :: ints='(*(" > ",5(i0:,",",1x),/))'
real :: x
real :: y
! basic usage
x = 63.29
y = -63.59
print ints, ceiling(x)
print ints, ceiling(y)
! note the result was the next integer larger to the right
! real values equal to whole numbers
x = 63.0
y = -63.0
print ints, ceiling(x)
print ints, ceiling(y)
! elemental (so an array argument is allowed)
print ints , &
& ceiling([ &
& -2.7, -2.5, -2.2, -2.0, -1.5, &
& -1.0, -0.5, 0.0, +0.5, +1.0, &
& +1.5, +2.0, +2.2, +2.5, +2.7 ])
end program demo_ceiling
結果
> 64
> -63
> 63
> -63
> -2, -2, -2, -2, -1,
> -1, 0, 0, 1, 1,
> 2, 2, 3, 3, 3
標準#
Fortran 95
参照#
aint(3)、anint(3)、int(3)、selected_int_kind(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
conjg#
名前#
conjg(3) - [数値] 複素数の共役複素数
概要#
result = conjg(z)
elemental complex(kind=KIND) function conjg(z)
complex(kind=**),intent(in) :: z
特性#
z は任意の有効な種類の *複素数* 値です。
返される値は、入力と同じ *複素数* 型です。
説明#
conjg(3) は、*複素数* 値 z の共役複素数を返します。
つまり、z が *複素数* 値 (x, y) の場合、結果は (x, -y) となります。
数学では、複素数の共役複素数とは、実数部と虚数部の大きさが等しく、y の符号が反対である値です。
複素数の行列の場合、conjg(array) は array の要素ごとの共役を表し、array の共役転置ではありません。
オプション#
- z
共役を作成する値。
結果#
入力値と同じ値を返しますが、虚数成分の符号は入力値とは逆になります。
つまり、z の値が (x,y) の場合、結果は (x, -y) となります。
例#
サンプルプログラム
program demo_conjg
use, intrinsic :: iso_fortran_env, only : real_kinds, &
& real32, real64, real128
implicit none
complex :: z = (2.0, 3.0)
complex(kind=real64) :: dz = ( &
& 1.2345678901234567_real64, -1.2345678901234567_real64)
complex :: arr(3,3)
integer :: i
! basics
! notice the sine of the imaginary component changes
print *, z, conjg(z)
! any complex kind is supported. z is of default kind but
! dz is kind=real64.
print *, dz
dz = conjg(dz)
print *, dz
print *
! the function is elemental so it can take arrays
arr(1,:)=[(-1.0, 2.0),( 3.0, 4.0),( 5.0,-6.0)]
arr(2,:)=[( 7.0,-8.0),( 8.0, 9.0),( 9.0, 9.0)]
arr(3,:)=[( 1.0, 9.0),( 2.0, 0.0),(-3.0,-7.0)]
write(*,*)'original'
write(*,'(3("(",g8.2,",",g8.2,")",1x))')(arr(i,:),i=1,3)
arr = conjg(arr)
write(*,*)'conjugate'
write(*,'(3("(",g8.2,",",g8.2,")",1x))')(arr(i,:),i=1,3)
end program demo_conjg
結果
> (2.000000,3.000000) (2.000000,-3.000000)
>
> (1.23456789012346,-1.23456789012346)
> (1.23456789012346,1.23456789012346)
>
> original
> (-1.0 , 2.0 ) ( 3.0 , 4.0 ) ( 5.0 ,-6.0 )
> ( 7.0 ,-8.0 ) ( 8.0 , 9.0 ) ( 9.0 , 9.0 )
> ( 1.0 , 9.0 ) ( 2.0 , 0.0 ) (-3.0 ,-7.0 )
>
> conjugate
> (-1.0 ,-2.0 ) ( 3.0 ,-4.0 ) ( 5.0 , 6.0 )
> ( 7.0 , 8.0 ) ( 8.0 ,-9.0 ) ( 9.0 ,-9.0 )
> ( 1.0 ,-9.0 ) ( 2.0 , 0.0 ) (-3.0 , 7.0 )
標準#
FORTRAN 77
参照#
Fortran は *複素数* 値を強力にサポートしており、代数式や論理式に加えて、*複素数* 値を受け取ったり生成したりする多くの組込み関数が含まれています。
abs(3)、acosh(3)、acos(3)、asinh(3)、asin(3)、atan2(3)、atanh(3)、atan(3)、cosh(3)、cos(3)、co_sum(3)、dble(3)、dot_product(3)、exp(3)、int(3)、is_contiguous(3)、kind(3)、log(3)、matmul(3)、precision(3)、product(3)、range(3)、rank(3)、sinh(3)、sin(3)、sqrt(3)、storage_size(3)、sum(3)、tanh(3)、tan(3)、unpack(3)、
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
dim#
名前#
dim(3) - [数値] X - Y の正の差
概要#
result = dim(x, y)
elemental TYPE(kind=KIND) function dim(x, y )
TYPE(kind=KIND),intent(in) :: x, y
特性#
x と y は *実数* または *整数* のいずれでもかまいませんが、型と種類は同じです。
結果は、引数と同じ型と種類です。
説明#
dim(3) は、x - y と 0 の最大値を返します。つまり、結果が正の場合は差 x - y を返し、そうでない場合は 0 を返します。これは次のものと同等です。
max(0,x-y)
オプション#
- x
減数、つまり、から減算される数。
- y
被減数、つまり、減算される数。
結果#
差 x - y または 0 のうち、大きい方を返します。
例#
サンプルプログラム
program demo_dim
use, intrinsic :: iso_fortran_env, only : real64
implicit none
integer :: i
real(kind=real64) :: x
! basic usage
i = dim(4, 15)
x = dim(4.321_real64, 1.111_real64)
print *, i
print *, x
! elemental
print *, dim([1,2,3],2)
print *, dim([1,2,3],[3,2,1])
print *, dim(-10,[0,-10,-20])
end program demo_dim
結果
> 0
> 3.21000000000000
> 0 0 1
> 0 0 2
> 0 0 10
標準#
FORTRAN 77
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
dprod#
名前#
dprod(3) - [数値] 倍精度実数積
概要#
result = dprod(x,y)
elemental function dprod(x,y)
real,intent(in) :: x
real,intent(in) :: y
doubleprecision :: dprod
特性#
x はデフォルトの実数です。
y はデフォルトの実数です。
結果は *倍精度* 実数です。
デフォルトの *実数* のサイズを指定するコンパイラオプションの設定は、この関数に影響を与える可能性があります。
説明#
dprod(3) は、デフォルトの *実数* 値 x と y の *倍精度* 積を生成します。
つまり、引数を倍精度に変換してから乗算することが期待されますが、単純な式 x*y ではその必要はありません。これは、高精度が必要な特殊な計算で重要になる可能性があります。
結果は、x と y の積に対するプロセッサ依存の近似値になります。標準では、プロセッサが単精度で計算してから倍精度に変換するのではなく、倍精度で積を計算することを推奨していますが、これは単なる推奨事項です。
オプション#
- x
乗数
- y
被乗数
結果#
返される積の値は、dble(x)*dble(y) と同じ値になります。
例#
サンプルプログラム
program demo_dprod
implicit none
integer,parameter :: dp=kind(0.0d0)
real :: x = 5.2
real :: y = 2.3
doubleprecision :: xx
real(kind=dp) :: dd
print *,'algebraically 5.2 x 2.3 is exactly 11.96'
print *,'as floating point values results may differ slightly:'
! basic usage
dd = dprod(x,y)
print *, 'compare dprod(xy)=',dd, &
& 'to x*y=',x*y, &
& 'to dble(x)*dble(y)=',dble(x)*dble(y)
print *,'test if an expected result is produced'
xx=-6.0d0
write(*,*)DPROD(-3.0, 2.0),xx
write(*,*)merge('PASSED','FAILED',DPROD(-3.0, 2.0) == xx)
print *,'elemental'
print *, dprod( [2.3,3.4,4.5], 10.0 )
print *, dprod( [2.3,3.4,4.5], [9.8,7.6,5.4] )
end program demo_dprod
結果：（これはプログラミング環境によって異なる場合があります）
> algebraically 5.2 x 2.3 is exactly 11.96
> as floating point values results may differ slightly:
> compare dprod(xy)= 11.9599993133545 to x*y= 11.96000
> to dble(x)*dble(y)= 11.9599993133545
> test if an expected result is produced
> -6.00000000000000 -6.00000000000000
> PASSED
> elemental
> 22.9999995231628 34.0000009536743 45.0000000000000
> 22.5399999713898 25.8400004005432 24.3000004291534
標準#
FORTRAN 77
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
floor#
名前#
floor(3) - [数値] 引数以下の最大整数を返す関数
概要#
result = floor(a [,kind])
elemental integer(kind=KIND) function floor( a ,kind )
real(kind=**),intent(in) :: a
integer(kind=**),intent(in),optional :: KIND
特性#
**として指定されたkindは、型のサポートされている任意のkindです。**
a は任意の種類の *実数* です。
KIND は、*整数* 型の任意の有効な値です。
結果は、指定された種類またはデフォルトの種類の *整数* です。
説明#
floor(3) は、a 以下の最大の整数を返します。
言い換えれば、数直線上の値の左側にある整数を選びます。
*実数* 値 a の大きさが出力値の範囲を超えないように注意する必要があります。なぜなら、*実数* 値によってサポートされる値の範囲は、通常、*整数* の範囲よりも大きいためです。
オプション#
- a
操作対象の値。有効な値は、返される整数の種類のサイズによって、-huge(int(a,kind=KIND))-1からhuge(int(a),kind=KIND)の範囲に制限されます。
- kind
結果の種類パラメータを示すスカラー整数定数初期化式。
結果#
戻り値は、kindが存在する場合はinteger(kind)型、存在しない場合はデフォルトの種類のinteger型になります。
指定された整数型で表現できない場合は、結果は未定義です。
結果の種類の範囲内にある場合、結果は数直線上での入力値の左端またはその位置にある整数です。
aが正の場合、結果は小数部を除いた値です。
aが負の場合、それは入力値の左端またはその位置にある整数です。
例#
サンプルプログラム
program demo_floor
implicit none
real :: x = 63.29
real :: y = -63.59
print *, x, floor(x)
print *, y, floor(y)
! elemental
print *,floor([ &
& -2.7, -2.5, -2.2, -2.0, -1.5, -1.0, -0.5, &
& 0.0, &
& +0.5, +1.0, +1.5, +2.0, +2.2, +2.5, +2.7 ])
! note even a small deviation from the whole number changes the result
print *, [2.0,2.0-epsilon(0.0),2.0-2*epsilon(0.0)]
print *,floor([2.0,2.0-epsilon(0.0),2.0-2*epsilon(0.0)])
! A=Nan, Infinity or <huge(0_KIND)-1 < A > huge(0_KIND) is undefined
end program demo_floor
結果
> 63.29000 63
> -63.59000 -64
> -3 -3 -3 -2 -2 -1
> -1 0 0 1 1 2
> 2 2 2
> 2.000000 2.000000 2.000000
> 2 1 1
標準#
Fortran 95
参照#
ceiling(3)、nint(3)、aint(3)、anint(3)、int(3)、selected_int_kind(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
max#
名前#
max(3) - [数値] 引数リストの最大値
概要#
result = max(a1, a2, a3, ...)
elemental TYPE(kind=KIND) function max(a1, a2, a3, ... )
TYPE(kind=KIND,intent(in),optional :: a1
TYPE(kind=KIND,intent(in),optional :: a2
TYPE(kind=KIND,intent(in),optional :: a3
:
:
:
特性#
a3、a3、a4…は、a1と同じ型と種類である必要があります。
引数は（すべて）、整数、実数、または文字にすることができます。
引数は2つ以上必要です。
文字結果の長さは、最長の引数の長さです。
結果の型と種類は、引数の型と種類と同じです。
説明#
max(3)は、最も大きい（最も正の）値を持つ引数を返します。
文字型引数の場合は、引数が組み込みの演算子で順次比較された場合と同様に、文字の種類の照合順序が考慮されます。
選択された文字引数が最長の引数より短い場合、結果はすべての値が右側にブランクで最長の引数の長さまで拡張されたものと同じです。
任意の数のオプションを受け取るFortran組み込み関数は珍しいですが、さらにmax(3)は要素関数であるため、同じ形状であれば、任意の数の引数が配列になる可能性があります。「スカラー」関数を配列で要素的に呼び出すことに慣れていない人のために、結果の動作を明確にする拡張説明が例に含まれています。
配列の最大値を取得するだけの場合、maxval(3)を参照してください。
オプション#
- a1
最初の引数は、返される値の型と種類、および残りの引数の型と種類を決定し、最大値（最も正の値）を求める値の集合のメンバーでもあります。
- a2,a3,…
最大値を求める残りの引数。
max(3)には、少なくとも2つの引数が必要です。
結果#
戻り値は、配列引数と同じ形状の配列、またはすべての引数がスカラーの場合はスカラーに対応します。
引数のいずれかが配列の場合、戻り値は同じ形状の配列になり、各要素はその位置で発生する最大値です。すべてのスカラー値は、すべての要素がスカラー値に設定された同じ形状の配列として扱われます。
例#
サンプルプログラム
program demo_max
implicit none
real :: arr1(4)= [10.0,11.0,30.0,-100.0]
real :: arr2(5)= [20.0,21.0,32.0,-200.0,2200.0]
integer :: box(3,4)= reshape([-6,-5,-4,-3,-2,-1,1,2,3,4,5,6],shape(box))
! basic usage
! this is simple enough when all arguments are scalar
! the most positive value is returned, not the one with the
! largest magnitude
write(*,*)'scalars:',max(10.0,11.0,30.0,-100.0)
write(*,*)'scalars:',max(-22222.0,-0.0001)
! strings do not need to be of the same length
write(*,*)'characters:',max('the','words','order')
! leading spaces are significant; everyone is padded on the right
! to the length of the longest argument
write(*,*)'characters:',max('c','bb','a')
write(*,*)'characters:',max(' c','b','a')
! elemental
! there must be at least two arguments, so even if A1 is an array
! max(A1) is not valid. See MAXVAL(3) and/or MAXLOC(3) instead.
! strings in a single array do need to be of the same length
! but the different objects can still be of different lengths.
write(*,"(*('""',a,'""':,1x))")MAX(['A','Z'],['BB','Y '])
! note the result is now an array with the max of every element
! position, as can be illustrated numerically as well:
write(*,'(a,*(i3,1x))')'box= ',box
write(*,'(a,*(i3,1x))')'box**2=',sign(1,box)*box**2
write(*,'(a,*(i3,1x))')'max ',max(box,sign(1,box)*box**2)
! Remember if any argument is an array by the definition of an
! elemental function all the array arguments must be the same shape.
! to find the single largest value of arrays you could use something
! like MAXVAL([arr1, arr2]) or probably better (no large temp array),
! max(maxval(arr1),maxval(arr2)) instead
! so this returns an array of the same shape as any input array
! where each result is the maximum that occurs at that position.
write(*,*)max(arr1,arr2(1:4))
! this returns an array just like arr1 except all values less than
! zero are set to zero:
write(*,*)max(box,0)
! When mixing arrays and scalars you can think of the scalars
! as being a copy of one of the arrays with all values set to
! the scalar value.
end program demo_max
結果
scalars: 30.00000
scalars: -9.9999997E-05
characters:words
characters:c
characters:b
"BB" "Z "
box= -6 -5 -4 -3 -2 -1 1 2 3 4 5 6
box**2=-36 -25 -16 -9 -4 -1 1 4 9 16 25 36
max -6 -5 -4 -3 -2 -1 1 4 9 16 25 36
20.00000 21.00000 32.00000 -100.0000
0 0 0 0 0 0
1 2 3 4 5 6
標準#
FORTRAN 77
参照#
maxloc(3)、minloc(3)、maxval(3)、minval(3)、min(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
min#
名前#
min(3) - [数値] 引数リストの最小値
概要#
result = min(a1, a2, a3, ... )
elemental TYPE(kind=KIND) function min(a1, a2, a3, ... )
TYPE(kind=KIND,intent(in) :: a1
TYPE(kind=KIND,intent(in) :: a2
TYPE(kind=KIND,intent(in) :: a3
:
:
:
特性#
TYPEは、整数、実数、または文字にすることができます。
説明#
min(3)は、最も小さい（最も負の）値を持つ引数を返します。
max(3)と同様にmin(3)の動作の拡張例については、max(3)を参照してください。
オプション#
- a1
最小値を求める値の集合の最初の要素。
- a2, a3, …
a1と同じ型と種類で、最小値を求める値の集合を完成させる式。
結果#
戻り値は、引数のうち最小の値に対応し、最初の引数と同じ型と種類になります。
例#
サンプルプログラム
program demo_min
implicit none
write(*,*)min(10.0,11.0,30.0,-100.0)
end program demo_min
結果
-100.0000000
標準#
FORTRAN 77
参照#
maxloc(3)、minloc(3)、minval(3)、max(3)、
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
mod#
名前#
mod(3) - [数値] 余り関数
概要#
result = mod(a, p)
elemental type(TYPE(kind=KIND)) function mod(a,p)
type(TYPE(kind=KIND),intent(in) :: a
type(TYPE(kind=KIND),intent(in) :: p
特性#
結果と引数はすべて同じ型と種類です。
型は任意の種類の実数または整数にすることができます。
説明#
mod(3)は、aをpで除算した余りを計算します。
数学では、余りは、ある計算を実行した後に「残っている」量です。算術では、余りは、整数の商（整数除算）を生成するために1つの整数を別の整数で除算した後に「残っている」整数です。多項式の代数では、余りは、1つの多項式を別の多項式で除算した後に「残っている」多項式です。剰余演算は、被除数と除数を与えられたときにそのような余りを生成する演算です。
(剰余)。 (2022年10月10日)。Wikipediaで。https://en.wikipedia.org/wiki/Remainder
オプション#
- a
被除数
- p
除数（0以外）。
結果#
戻り値は、a - (int(a/p) * p)の結果です。
式からわかるように、pの符号は打ち消されます。したがって、返される値は常にaの符号を持ちます。
もちろん、結果はpの倍数すべてで減らされているため、結果の大きさはpの大きさよりも小さくなります。
例#
サンプルプログラム
program demo_mod
implicit none
! basics
print *, mod( -17, 3 ), modulo( -17, 3 )
print *, mod( 17, -3 ), modulo( 17, -3 )
print *, mod( 17, 3 ), modulo( 17, 3 )
print *, mod( -17, -3 ), modulo( -17, -3 )
print *, mod(-17.5, 5.2), modulo(-17.5, 5.2)
print *, mod( 17.5,-5.2), modulo( 17.5,-5.2)
print *, mod( 17.5, 5.2), modulo( 17.5, 5.2)
print *, mod(-17.5,-5.2), modulo(-17.5,-5.2)
! with a divisor of 1 the fractional part is returned
print *, mod(-17.5, 1.0), modulo(-17.5, 1.0)
print *, mod( 17.5,-1.0), modulo( 17.5,-1.0)
print *, mod( 17.5, 1.0), modulo( 17.5, 1.0)
print *, mod(-17.5,-1.0), modulo(-17.5,-1.0)
end program demo_mod
結果
-2 1
2 -1
2 2
-2 -2
-1.900001 3.299999
1.900001 -3.299999
1.900001 1.900001
-1.900001 -1.900001
-0.5000000 0.5000000
0.5000000 -0.5000000
0.5000000 0.5000000
-0.5000000 -0.5000000
標準#
FORTRAN 77
参照#
modulo(3) - モジュロ関数
aint(3) - 0に向かって切り捨てて整数実数にする
int(3) - 0に向かって切り捨てて整数整数にする
anint(3) - 最近の整数実数
nint(3) - 最近の整数整数
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
modulo#
名前#
modulo(3) - [数値] モジュロ関数
概要#
result = modulo(a, p)
elemental TYPE(kind=KIND) function modulo(a,p)
TYPE(kind=KIND),intent(in) :: a
TYPE(kind=KIND),intent(in) :: p
特性#
aは任意の種類の実数または整数にすることができます。
pはaと同じ型と種類です。
結果と引数はすべて同じ型と種類です。
説明#
modulo(3)は、aモジュロpを計算します。
オプション#
- a
moduloを取る値
- p
余りがp以下になるまでaを減らす値。0であってはいけません。
結果#
結果の型と種類は、引数の型と種類です。
aとpが整数型の場合：modulo(a,p)の値はa - floor (real(a) / real(p)) * pです。
aとpが実数型の場合：modulo(a,p)の値はa - floor (a / p) * pです。
返される値は、pと同じ符号を持ち、pの大きさよりも小さい大きさになります。
例#
サンプルプログラム
program demo_modulo
implicit none
print *, modulo(17,3) ! yields 2
print *, modulo(17.5,5.5) ! yields 1.0
print *, modulo(-17,3) ! yields 1
print *, modulo(-17.5,5.5) ! yields 4.5
print *, modulo(17,-3) ! yields -1
print *, modulo(17.5,-5.5) ! yields -4.5
end program demo_modulo
結果
> 2
> 1.000000
> 1
> 4.500000
> -1
> -4.500000
標準#
Fortran 95
参照#
fortran-lang組み込み関数の説明
sign#
名前#
sign(3) - [数値] 符号コピー関数
概要#
result = sign(a, b)
elemental type(TYPE(kind=KIND))function sign(a, b)
type(TYPE(kind=KIND)),intent(in) :: a, b
特性#
aは、整数型または実数型にする必要があります。
bは、aと同じ型にする必要があります。
結果の特性は、aと同じです。
説明#
sign(3) は、a の絶対値に b の符号をつけた値を返します。
正のゼロと負のゼロを区別するプロセッサの場合、sign() は実数値 0.0 と -0.0 を区別するために使用できます。負のゼロを区別できる場合、SIGN (1.0, -0.0) は -1.0 を返します。
オプション#
- a
絶対値が返される値。
- b
符号が返される値。
結果#
a の絶対値に b の符号をつけた値。つまり、
b >= 0 の場合、結果は abs(a)
b < 0 の場合、結果は -abs(a)。
b が実数であり、プロセッサが-0.0 と 0.0 を区別する場合、結果は -abs(a)
例#
サンプルプログラム
program demo_sign
implicit none
! basics
print *, sign( -12, 1 )
print *, sign( -12, 0 )
print *, sign( -12, -1 )
print *, sign( 12, 1 )
print *, sign( 12, 0 )
print *, sign( 12, -1 )
if(sign(1.0,-0.0)== -1.0)then
print *, 'this processor distinguishes +0 from -0'
else
print *, 'this processor does not distinguish +0 from -0'
endif
print *, 'elemental', sign( -12.0, [1.0, 0.0, -1.0] )
end program demo_sign
結果
12
12
-12
12
12
-12
this processor does not distinguish +0 from -0
elemental 12.00000 12.00000 -12.00000
標準#
FORTRAN 77
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
cshift#
名前#
cshift(3) - [変換] 配列の要素を巡回シフトする
概要#
result = cshift(array, shift [,dim])
type(TYPE, kind=KIND) function cshift(array, shift, dim )
type(TYPE,kind=KIND),intent(in) :: array(..)
integer(kind=**),intent(in) :: shift
integer(kind=**),intent(in) :: dim
特性#
array は任意の型とランクを持つことができます。
array のランクが 1 の場合、shift は整数スカラーです。そうでない場合、array の形状が [d1, d2, …, dn] である場合、shift はスカラーまたはランク n-1 であり、形状は [d1, d2, …, dDIM-1, dDIM+1, …, dn] となります。
dim は、1 <= dim <= n（n は array のランク）の範囲の整数スカラーです。dim が省略された場合、値 1 が指定されたものとみなされます。
結果は、自動的にarray と同じ型、種類、形状になります。
注記：**と指定された種類は、その型でサポートされている任意の種類です。
説明#
cshift(3) は、array の要素をdim の次元方向に巡回シフトします。dim が省略された場合、1 とみなされます。dim は、1 <= dim <= n（n は array のランク）の範囲の整数型のスカラーです。
array のランクが 1 の場合、array のすべての要素が shift 個分シフトされます。ランクが 1 より大きい場合、指定された次元方向に沿った array のすべての完全なランク 1 セクションがシフトされます。各ランク 1 セクションの一方の端からシフトされた要素は、もう一方の端に戻されます。
オプション#
- array
シフトされる任意の型の配列。
- shift
巡回シフトする位置の数。負の値は右シフト、正の値は左シフトを生成します。
- dim
多ランクの array をシフトする次元。デフォルトは 1 です。
結果#
array 引数と同じ型とランクの配列を返します。
ランク 2 の配列の行は、すべて同じ量だけ、または異なる量だけシフトできます。
cshift#
例#
サンプルプログラム
program demo_cshift
implicit none
integer, dimension(5) :: i1,i2,i3
integer, dimension(3,4) :: a, b
!basics
i1=[10,20,30,40,50]
print *,'start with:'
print '(1x,5i3)', i1
print *,'shift -2'
print '(1x,5i3)', cshift(i1,-2)
print *,'shift +2'
print '(1x,5i3)', cshift(i1,+2)
print *,'start with a matrix'
a = reshape( [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], [ 3, 4 ])
print '(4i3)', a(1,:)
print '(4i3)', a(2,:)
print '(4i3)', a(3,:)
print *,'matrix shifted along rows, each by its own amount [-1,0,1]'
b = cshift(a, SHIFT=[1, 0, -1], DIM=2)
print *
print '(4i3)', b(1,:)
print '(4i3)', b(2,:)
print '(4i3)', b(3,:)
end program demo_cshift
結果
> start with:
> 10 20 30 40 50
> shift -2
> 40 50 10 20 30
> shift +2
> 30 40 50 10 20
> start with a matrix
> 1 4 7 10
> 2 5 8 11
> 3 6 9 12
> matrix shifted along rows, each by its own amount
>
> 4 7 10 1
> 2 5 8 11
> 12 3 6 9
標準#
Fortran 95
参照#
eoshift(3) - 配列の要素を端からシフトする
sum(3) - 配列の要素の合計
product(3) - 配列要素の積
findloc(3) - 次元 DIM に沿って MASK によって識別された ARRAY の最初の要素の位置
maxloc(3) - 配列内の最大値の位置
fortran-lang組み込み関数の説明
dot_product#
名前#
dot_product(3) - [変換] 2 つのベクトルのドット積
概要#
result = dot_product(vector_a, vector_b)
TYPE(kind=KIND) function dot_product(vector_a, vector_b)
TYPE(kind=KIND),intent(in) :: vector_a(:)
TYPE(kind=KIND),intent(in) :: vector_b(:)
特性#
vector_a、vector_b は、同じサイズのランク 1 の任意の数値型または論理型配列です。
2 つのベクトルは同じ種類である必要はありませんが、いずれの呼び出しについても両方とも論理型または数値型でなければなりません。
結果は、もう一方のベクトルがオプションで昇格される場合、そのベクトルよりも高い型のベクトルと同じ型と種類になります。
2 つのベクトルは数値型または論理型のいずれでもよく、ランク 1 でサイズが等しい配列でなければなりません。
説明#
dot_product(3) は、2 つのベクトル vector_a と vector_b のドット積を計算します。
オプション#
- vector_a
値のランク 1 ベクトル
- vector_b
vector_a が数値型の場合は数値型、vector_a が論理型の場合は論理型でなければなりません。vector_b は、vector_a と同じサイズのランク 1 の配列でなければなりません。
結果#
引数が数値型の場合、戻り値は数値型のスカラーです。引数が論理型の場合、戻り値は .true. または .false. です。
ベクトルが整数型または実数型の場合、結果は
sum(vector_a*vector_b)
ベクトルが複素数型の場合、結果は
sum(conjg(vector_a)*vector_b)**
ベクトルが論理型の場合、結果は
any(vector_a .and. vector_b)
例#
サンプルプログラム
program demo_dot_prod
implicit none
integer, dimension(3) :: a, b
a = [ 1, 2, 3 ]
b = [ 4, 5, 6 ]
print '(3i3)', a
print *
print '(3i3)', b
print *
print *, dot_product(a,b)
end program demo_dot_prod
結果
> 1 2 3
>
> 4 5 6
>
> 32
標準#
Fortran 95
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
eoshift#
名前#
eoshift(3) - [変換] 配列の要素を端からシフトする
概要#
result = eoshift( array, shift [,boundary] [,dim] )
type(TYPE(kind=KIND)) function eoshift(array,shift,boundary,dim)
type(TYPE(kind=KIND)),intent(in) :: array(..)
integer(kind=**),intent(in) :: shift(..)
type(TYPE(kind=KIND)),intent(in) :: boundary(..)
integer(kind=**),intent(in) :: dim
特性#
array は任意の型の配列です。
shift は任意の種類の整数です。スカラーにすることができます。array のランクが 1 より大きく、dim が指定されている場合、dim 次元を除去した array と同じ形状になります。
boundary は、array と同じ型と種類のスカラーにすることができます。array のランクが 1 の場合はスカラーでなければなりません。そうでない場合、dim 次元を除去した array と同じ形状の配列にすることができます。以下で説明するように、特定の型については省略できます。
dim は任意の種類の整数です。デフォルトは 1 です。
結果は、array と同じ型、型パラメータ、形状になります。
**として指定されたkindは、型のサポートされている任意のkindです。**
結果は、array 引数と同じ型、種類、ランクの配列です。
説明#
eoshift(3) は、array の要素をdim の次元方向に端からシフトします。
一方の端からシフトされた要素は削除されます。
boundary が存在する場合、boundary から対応する値がもう一方の端に戻されます。それ以外の場合は、デフォルト値が使用されます。
オプション#
- array
シフトされる要素を持つ任意の型の配列。array のランクが 1 の場合、array のすべての要素が shift 個分シフトされます。ランクが 1 より大きい場合、指定された次元方向に沿った array のすべての完全なランク 1 セクションがシフトされます。
- shift
シフトする要素の数。負の値は右シフト、正の値は左シフトを生成します。
- boundary
シフトによって空いた要素を埋めるために使用する値。boundary が存在しない場合、array の型に応じて次の値がコピーされます。
Array Type | Boundary Value
-----------------------------------------------------
Numeric | 0, 0.0, or (0.0, 0.0) of the type and kind of "array"
Logical | .false.
Character(len)| LEN blanks
これらは、boundary を省略できる唯一の型です。これらの型の型は必要に応じて array の型に変換されます。
- dim
dim は次の範囲内です。
1 <= DIM <= n
ここで、“n” は array のランクです。dim が省略された場合、1 とみなされます。
結果#
指定された数の要素が指定された方向に削除され、空いた要素が boundary 値でバックフィルされた、入力と同じ特性を持つ配列を返します。
例#
サンプルプログラム
program demo_eoshift
implicit none
integer, dimension(3,3) :: a
integer :: i
a = reshape( [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ], [ 3, 3 ])
print '(3i3)', (a(i,:),i=1,3)
print *
! shift it
a = eoshift(a, SHIFT=[1, 2, 1], BOUNDARY=-5, DIM=2)
print '(3i3)', (a(i,:),i=1,3)
end program demo_eoshift
結果
> 1 4 7
> 2 5 8
> 3 6 9
>
> 4 7 -5
> 8 -5 -5
> 6 9 -5
標準#
Fortran 95
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
matmul#
名前#
matmul(3) - [変換] 数値型または論理型の行列積
概要#
result = matmul(matrix_a,matrix_b)
function matmul(matrix_a, matrix_b)
type(TYPE1(kind=**) :: matrix_a(..)
type(TYPE2(kind=**) :: matrix_b(..)
type(TYPE(kind=PROMOTED)) :: matmul(..)
特性#
matrix_a は、ランク 1 または 2 の数値型（整数型、実数型、または複素数型）または論理型の配列です。
matrix_b は、ランク 1 または 2 の数値型（整数型、実数型、または複素数型）または論理型の配列です。
少なくとも 1 つの引数のランクが 2 でなければなりません。
matrix_b の最初の次元のサイズは、matrix_a の最後の次元のサイズと等しくなければなりません。
結果の型は、各引数の要素が右辺式として掛け合わされた場合と同じです（つまり、引数が同じ型でない場合、結果は、2 つの型の単純なスカラー乗算で生成されるものと同じ昇格規則に従います）。
1 つの引数が論理型の場合、両方が論理型でなければなりません。論理型の場合、結果の型は、配列の要素に .and. 演算子が使用された場合と同じです。
結果の形状は、以下で説明するように、引数の形状によって異なります。
説明#
matmul(3) は、数値型または論理型の引数に対して行列積を実行します。
オプション#
- matrix_a
階数が1または2の数値または論理配列。
- matrix_b
階数が1または2の数値または論理配列。**matrix_a**の最後の次元と**matrix_b**の最初の次元は等しくなければなりません。
**matrix_a**と**matrix_b**は異なる数値型であってもよいことに注意してください。
結果#
数値引数#
**matrix_a**と**matrix_b**が数値の場合、結果は**matrix_a**と**matrix_b**の通常の行列積を含む配列です。
まず、数値式**C=matmul(A,B)**について
任意のベクトル**A(n)**は行ベクトル**A(1,n)**として扱われます。
任意のベクトル**B(n)**は列ベクトル**B(n,1)**として扱われます。
形状と階数#
結果の形状は、最初の行列の行数と2番目の行列の列数によって決定されます。ただし、いずれかの引数の階数が1（ベクトル）の場合、結果は階数1でもあります。逆に、両方の引数の階数が2の場合、結果は階数2になります。つまり…
**matrix_a**の形状が[n,m]で、**matrix_b**の形状が[m,k]の場合、結果は[n,k]の形状になります。
**matrix_a**の形状が[m]で、**matrix_b**の形状が[m,k]の場合、結果は[k]の形状になります。
**matrix_a**の形状が[n,m]で、**matrix_b**の形状が[m]の場合、結果は[n]の形状になります。
値#
積の要素**C(i,j)**は、**A**のi行目のエントリと**B**のj列目のエントリを要素ごとに掛け合わせ、これらの積を合計することで得られます。言い換えれば、**C(i,j)**は**A**のi行目と**B**のj列目のドット積です。
論理引数#
値#
**matrix_a**と**matrix_b**が論理型の場合、結果の配列要素は代わりに…
Value_of_Element (i,j) = &
ANY( (row_i_of_MATRIX_A) .AND. (column_j_of_MATRIX_B) )
例#
サンプルプログラム
program demo_matmul
implicit none
integer :: a(2,3), b(3,2), c(2), d(3), e(2,2), f(3), g(2), v1(4),v2(4)
a = reshape([1, 2, 3, 4, 5, 6], [2, 3])
b = reshape([10, 20, 30, 40, 50, 60], [3, 2])
c = [1, 2]
d = [1, 2, 3]
e = matmul(a, b)
f = matmul(c,a)
g = matmul(a,d)
call print_matrix_int('A is ',a)
call print_matrix_int('B is ',b)
call print_vector_int('C is ',c)
call print_vector_int('D is ',d)
call print_matrix_int('E is matmul(A,B)',e)
call print_vector_int('F is matmul(C,A)',f)
call print_vector_int('G is matmul(A,D)',g)
! look at argument shapes when one is a vector
write(*,'(" > shape")')
! at least one argument must be of rank two
! so for two vectors at least one must be reshaped
v1=[11,22,33,44]
v2=[10,20,30,40]
! these return a vector C(1:1)
! treat A(1:n) as A(1:1,1:n)
call print_vector_int('Cd is a vector (not a scalar)',&
& matmul(reshape(v1,[1,size(v1)]),v2))
! or treat B(1:m) as B(1:m,1:1)
call print_vector_int('cD is a vector too',&
& matmul(v1,reshape(v2,[size(v2),1])))
! or treat A(1:n) as A(1:1,1:n) and B(1:m) as B(1:m,1:1)
! but note this returns a matrix C(1:1,1:1) not a vector!
call print_matrix_int('CD is a matrix',matmul(&
& reshape(v1,[1,size(v1)]), &
& reshape(v2,[size(v2),1])))
contains
! CONVENIENCE ROUTINES TO PRINT IN ROW-COLUMN ORDER
subroutine print_vector_int(title,arr)
character(len=*),intent(in) :: title
integer,intent(in) :: arr(:)
call print_matrix_int(title,reshape(arr,[1,shape(arr)]))
end subroutine print_vector_int
subroutine print_matrix_int(title,arr)
!@(#) print small 2d integer arrays in row-column format
character(len=*),parameter :: all='(" > ",*(g0,1x))' ! a handy format
character(len=*),intent(in) :: title
integer,intent(in) :: arr(:,:)
integer :: i
character(len=:),allocatable :: biggest
print all
print all, trim(title)
biggest=' ' ! make buffer to write integer into
! find how many characters to use for integers
write(biggest,'(i0)')ceiling(log10(real(maxval(abs(arr)))))+2
! use this format to write a row
biggest='(" > [",*(i'//trim(biggest)//':,","))'
! print one row of array at a time
do i=1,size(arr,dim=1)
write(*,fmt=biggest,advance='no')arr(i,:)
write(*,'(" ]")')
enddo
end subroutine print_matrix_int
end program demo_matmul
結果
>
> A is
> [ 1, 3, 5 ]
> [ 2, 4, 6 ]
>
> B is
> [ 10, 40 ]
> [ 20, 50 ]
> [ 30, 60 ]
>
> C is
> [ 1, 2 ]
>
> D is
> [ 1, 2, 3 ]
>
> E is matmul(A,B)
> [ 220, 490 ]
> [ 280, 640 ]
>
> F is matmul(C,A)
> [ 5, 11, 17 ]
>
> G is matmul(A,D)
> [ 22, 28 ]
> shape
>
> Cd is a vector (not a scalar)
> [ 3300 ]
>
> cD is a vector too
> [ 3300 ]
>
> CD is a matrix
> [ 3300 ]
標準#
Fortran 95
参照#
リソース#
非常に大きな行列の掛け算を最適化するために、Strassenの行列-行列乗算アルゴリズムのWinograd変形に興味があるかもしれません。参照
"GEMMW: A portable level 3 BLAS Winograd variant of Strassen's
matrix-matrix multiply algorithm",
Douglas, C. C., Heroux, M., Slishman, G., and Smith, R. M.,
Journal of Computational Physics,
Vol. 110, No. 1, January 1994, pages 1-10.
The numerical instabilities of Strassen's method for matrix
multiplication requires special processing.
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
parity#
名前#
parity(3) - [ARRAY:REDUCTION] .NEQV.演算による配列の縮約
要約#
result = parity( mask [,dim] )
logical(kind=KIND) function parity(mask, dim)
type(logical(kind=KIND)),intent(in) :: mask(..)
type(integer(kind=**)),intent(in),optional :: dim
特性#
maskは論理配列です。
dimは整数スカラーです。
結果は、maskと同じ種類の型パラメーターを持つ論理型です。**dim**が存在しない場合はスカラーです。それ以外の場合は、**dim**によって指定された次元が削除されたmaskの階数と形状になります。
**として指定されたkindは、型のサポートされている任意のkindです。**
説明#
parity(3)は、dimが存在し、1でない場合、dimに沿ってmaskの偶奇配列（つまり、.neqv.を使用した縮約）を計算します。それ以外の場合は、スカラーとして全体のmask配列の偶奇を返します。
オプション#
- mask
論理型の配列でなければなりません。
- dim
(オプション) 1からnの範囲の値を持つ整数型のスカラーでなければなりません。ここで、nはmaskの階数に等しくなります。
結果#
結果は、maskと同じ型です。
dimが存在しない場合、mask内のすべての要素の偶奇を表すスカラーが返されます。要素が奇数の場合は.true.、それ以外の場合は.false.。
MASKの階数が1の場合、PARITY(MASK, DIM)はPARITY(MASK)と等しくなります。それ以外の場合は、次元dimが削除された偶奇値の配列が結果となります。
例#
サンプルプログラム
program demo_parity
implicit none
logical, parameter :: T=.true., F=.false.
logical :: x(3,4)
! basics
print *, parity([T,F])
print *, parity([T,F,F])
print *, parity([T,F,F,T])
print *, parity([T,F,F,T,T])
x(1,:)=[T,T,T,T]
x(2,:)=[T,T,T,T]
x(3,:)=[T,T,T,T]
print *, parity(x)
print *, parity(x,dim=1)
print *, parity(x,dim=2)
end program demo_parity
結果
> T
> T
> F
> T
> F
> T T T T
> F F F
標準#
Fortran 2008
参照#
all(3) - すべての値がtrueかどうかを判別します。
any(3) - 論理配列内のいずれかの値が.true.かどうかを判別します。
count(3) - 配列内のtrueの値をカウントします。
sum(3) - 配列の要素を合計します。
maxval(3) - 配列または行の最大値を決定します。
minval(3) - 配列の最小値。
product(3) - 配列要素の積
reduce(3) - 一般的な配列の縮約
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
null#
名前#
null(3) - [TRANSFORMATIONAL] 非関連ポインタを返す関数
要約#
ptr => null( [mold] )
function null(mold)
type(TYPE(kind=**)),pointer,optional :: mold
特性#
moldは、任意の関連状態と任意の型のポインタです。
結果は、非関連ポインタまたは未割り当ての割り当て可能エンティティです。
説明#
null(3)は、非関連ポインタを返します。
moldが存在する場合、同じ型の非関連ポインタが返され、それ以外の場合はコンテキストによって型が決定されます。
Fortran 95では、moldはオプションです。Fortran 2003には、必須となる場合があることに注意してください。
オプション#
- mold
任意の関連状態と任意の型のポインタ。
結果#
非関連ポインタまたは未割り当ての割り当て可能エンティティ。
例#
サンプルプログラム
!program demo_null
module showit
implicit none
private
character(len=*),parameter :: g='(*(g0,1x))'
public gen
! a generic interface that only differs in the
! type of the pointer the second argument is
interface gen
module procedure s1
module procedure s2
end interface
contains
subroutine s1 (j, pi)
integer j
integer, pointer :: pi
if(associated(pi))then
write(*,g)'Two integers in S1:,',j,'and',pi
else
write(*,g)'One integer in S1:,',j
endif
end subroutine s1
subroutine s2 (k, pr)
integer k
real, pointer :: pr
if(associated(pr))then
write(*,g)'integer and real in S2:,',k,'and',pr
else
write(*,g)'One integer in S2:,',k
endif
end subroutine s2
end module showit
program demo_null
use showit, only : gen
real,target :: x = 200.0
integer,target :: i = 100
real, pointer :: real_ptr
integer, pointer :: integer_ptr
! so how do we call S1() or S2() with a disassociated pointer?
! the answer is the null() function with a mold value
! since s1() and s2() both have a first integer
! argument the NULL() pointer must be associated
! to a real or integer type via the mold option
! so the following can distinguish whether s1(1)
! or s2() is called, even though the pointers are
! not associated or defined
call gen (1, null (real_ptr) ) ! invokes s2
call gen (2, null (integer_ptr) ) ! invokes s1
real_ptr => x
integer_ptr => i
call gen (3, real_ptr ) ! invokes s2
call gen (4, integer_ptr ) ! invokes s1
end program demo_null
結果
One integer in S2:, 1
One integer in S1:, 2
integer and real in S2:, 3 and 200.000000
Two integers in S1:, 4 and 100
標準#
Fortran 95
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost