在Tensor7中找到最小的正实数？

一种可能性：

t = { 0,  -1,  -3,
      6,   5,   0,
      0.3, 0.6, 0.9 }

temp = {}
for _,n in ipairs(t) do
  if n > 0 then               --仅保留正数
    temp[#temp+1] = n
  end
end
table.sort(temp)              --排序后将最小值排在第一位

print('Answer',temp[1])       --输出最小值

UPDATE: 要找到最小值发生的位置，请将以上代码更改为：

t = { 0,  -1,  -3,
      6,   5,   0,
      0.3, 0.6, 0.9 }

temp = {}
for i,n in ipairs(t) do
  if n > 0 then               --仅保留正数
    temp[#temp+1] = { n = n, p = i}
  end
end
table.sort(temp,function(a,b) return a.n < b.n end)      --排序后将最小值排在第一位

print('Answer '.. temp[1].n ..' at position '.. temp[1].p)  --输出最小值及其位置

另一种可能性：

t = { 0,  -1,  -3,
      6,   5,   0,
      0.3, 0.6, 0.9 }

for _,n in ipairs(t) do
  if n > 0 then               --仅针对正数
    if ans == nil then
      ans = n                 --第一个正数被认为是最低的
    else
      if n < ans then ans = n end  --如果找到更低的值，则替换先前的值
    end
  end
end

print('Answer',ans)

更新：为了找到最低值出现的位置，将上述代码修改为：

t = { 0,  -1,  -3,
      6,   5,   0,
      0.3, 0.6, 0.9 }

for i,n in ipairs(t) do
  if n > 0 then               --仅针对正数
    if ans == nil then
      ans = n                 --第一个正数被认为是最低的
      pos = i
    else
      if n < ans then         --如果找到更低的值，则替换先前的值
        ans = n
        pos = i               --保留位置
      end
    end
  end
end

print('Answer '.. ans ..' at position '.. pos)

t = torch.Tensor({{0, -1, -3}, {6, 5, 0}, {0.3, 0.6, 0.9}})
minpos = torch.min(t[t:gt(0)])

0.3

如何获取所需元素的索引：

1）创建掩码

mask = t:eq(minpos)

 0  0  0
 0  0  0
 1  0  0
[torch.ByteTensor of size 3x3]

2）以某种方式获取掩码的非零元素的索引。例如，使用此函数：

function indexesOf(mask)
    local lin_indices = torch.linspace(1, mask:nElement(), mask:nElement())[mask]
    if lin_indices:nElement() == 0 then return nil end

    local sp_indices = torch.LongTensor(mask:nDimension(), lin_indices:nElement())
    sp_indices[1] = lin_indices - 1
    local divisor = mask:nElement()
    for d = 1, mask:nDimension() - 1 do
        divisor = divisor / mask:size(d)
        local fdiv = torch.div(sp_indices[d], divisor)
        sp_indices[d + 1] = sp_indices[d] - fdiv * divisor
        sp_indices[d] = fdiv
    end
    return sp_indices:t() + 1
end

indexes = indexesOf(mask)

 3  1
[torch.LongTensor of size 1x2]