Arrays 基于另一个数组中的元素分配数组元素

第一次在这里发帖，我有一个（可能很简单）问题

我想根据另一个数组（B）中相应的值来分配一个数组（A）中元素的值，例如，如果A（1）=2，则将4分配给B（1）

我想象这将通过使用DO循环和一些if语句来实现。然而，我使用的If语句似乎是指循环索引，而不是此时的特定元素

有人能给我指出正确的方向吗？

您可以使用掩码数组赋值。给定两个形状相同的数组，

A

和

B

（即相同的列数，每个维度的大小相同），如果要将

B

的元素设置为4，其中

A

的对应元素等于

2

，则只需编写

where(A==2) B = 4

where

与其他地方的

一起

，就像

if

和

else if

，在那里也有一个

结尾。有关更多详细信息，请参阅您喜爱的文档

如果您不能用
where
表达您的操作，您可能（如果您有最新的编译器）对
do concurrent
构造感兴趣。而且，如果所有其他方法都失败了，还有一些好的老式
do
和
if
可以依靠。
您可能可以使用掩码数组分配。给定两个形状相同的数组，
A
和
B
（即相同的列数，每个维度的大小相同），如果要将
B
的元素设置为4，其中
A
的对应元素等于
2
，则只需编写

where(A==2) B = 4

where
与其他地方的
一起
，就像
if
和
else if
，在那里也有一个
结尾。有关更多详细信息，请参阅您喜爱的文档

如果您不能用
where
表达您的操作，您可能（如果您有最新的编译器）对
do concurrent
构造感兴趣。而且，如果所有其他方法都失败了，还有一些好的老式
do
和
if
可以依靠。
您可能可以使用掩码数组分配。给定两个形状相同的数组，
A
和
B
（即相同的列数，每个维度的大小相同），如果要将
B
的元素设置为4，其中
A
的对应元素等于
2
，则只需编写

where(A==2) B = 4

where
与其他地方的
一起
，就像
if
和
else if
，在那里也有一个
结尾。有关更多详细信息，请参阅您喜爱的文档

如果您不能用
where
表达您的操作，您可能（如果您有最新的编译器）对
do concurrent
构造感兴趣。而且，如果所有其他方法都失败了，还有一些好的老式
do
和
if
可以依靠。
您可能可以使用掩码数组分配。给定两个形状相同的数组，
A
和
B
（即相同的列数，每个维度的大小相同），如果要将
B
的元素设置为4，其中
A
的对应元素等于
2
，则只需编写

where(A==2) B = 4

where
与其他地方的
一起
，就像
if
和
else if
，在那里也有一个
结尾。有关更多详细信息，请参阅您喜爱的文档

如果您不能用
where
表达您的操作，您可能（如果您有最新的编译器）对
do concurrent
构造感兴趣。而且，如果其他一切都失败了，还有一些好的老式的
do
和
if
可以依靠。
你也可以尝试一个带有<代码>合并
使用掩码从两个现有数组构造一个新数组，以选择正确的值：

program test
  integer,parameter :: LENGTH=5
  integer :: A(LENGTH)
  integer :: B(LENGTH)
  real    :: R(LENGTH)
  integer :: i

  call random_number(R)
  A = int( R*3 )
  B = [ ( i,i=1,LENGTH) ]

  print *,'A:',A

  print *,'B:',B
  B = merge( 4, B, A == 2 )
  print *,'B:',B
end program

输出：

 A:           2           1           2           2           1
 B:           1           2           3           4           5
 B:           4           2           4           4           5

说明：

  B = merge( 4, B, A == 2 )


A==2
构造一个临时逻辑数组，该数组为
.true。
at
i
if
A（i）==2
4
在本例中是一个临时数组，其长度与
B
因此，
merge
从
4
中选择值，如果临时逻辑数组为
.true.
，则从
B
中选择相应的值，否则
结果向量被写回
B
（
=
）
您也可以尝试使用<代码>合并
使用掩码从两个现有数组构造一个新数组，以选择正确的值：

program test
  integer,parameter :: LENGTH=5
  integer :: A(LENGTH)
  integer :: B(LENGTH)
  real    :: R(LENGTH)
  integer :: i

  call random_number(R)
  A = int( R*3 )
  B = [ ( i,i=1,LENGTH) ]

  print *,'A:',A

  print *,'B:',B
  B = merge( 4, B, A == 2 )
  print *,'B:',B
end program

输出：

 A:           2           1           2           2           1
 B:           1           2           3           4           5
 B:           4           2           4           4           5

说明：

  B = merge( 4, B, A == 2 )


A==2
构造一个临时逻辑数组，该数组为
.true。
at
i
if
A（i）==2
4
在本例中是一个临时数组，其长度与
B
因此，
merge
从
4
中选择值，如果临时逻辑数组为
.true.
，则从
B
中选择相应的值，否则
结果向量被写回
B
（
=
）
您也可以尝试使用<代码>合并
使用掩码从两个现有数组构造一个新数组，以选择正确的值：

program test
  integer,parameter :: LENGTH=5
  integer :: A(LENGTH)
  integer :: B(LENGTH)
  real    :: R(LENGTH)
  integer :: i

  call random_number(R)
  A = int( R*3 )
  B = [ ( i,i=1,LENGTH) ]

  print *,'A:',A

  print *,'B:',B
  B = merge( 4, B, A == 2 )
  print *,'B:',B
end program

输出：

 A:           2           1           2           2           1
 B:           1           2           3           4           5
 B:           4           2           4           4           5

说明：

  B = merge( 4, B, A == 2 )


A==2
构造一个临时逻辑数组，该数组为
.true。
at
i
if
A（i）==2
4
在本例中是一个临时数组，其长度与
B
因此，
merge
从
4
中选择值，如果临时逻辑数组为
.true.
，则从
B
中选择相应的值，否则
结果向量被写回
B
（
=
）
您也可以