tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

is_infinite.https.any.js (9436B)

      1 // META: title=test WebNN API Element-wise logical isInfinite operation
      2 // META: global=window
      3 // META: variant=?cpu
      4 // META: variant=?gpu
      5 // META: variant=?npu
      6 // META: script=../resources/utils.js
      7 // META: timeout=long
      8 
      9 'use strict';
     10 
     11 // https://www.w3.org/TR/webnn/#api-mlgraphbuilder-logical
     12 // Check if the values of the input tensor are infinite, element-wise.
     13 //
     14 // MLOperand isInfinite(MLOperand input);
     15 
     16 const isInfiniteTests = [
     17  // isInfinite tests
     18  {
     19    'name': 'isInfinite float32 positive 0D scalar',
     20    'graph': {
     21      'inputs': {
     22        'isInfiniteInput': {
     23          'data': [1.5],
     24          'descriptor': {shape: [], dataType: 'float32'}
     25        }
     26      },
     27      'operators': [{
     28        'name': 'isInfinite',
     29        'arguments': [{'input': 'isInfiniteInput'}],
     30        'outputs': 'isInfiniteOutput'
     31      }],
     32      'expectedOutputs': {
     33        'isInfiniteOutput': {
     34          'data': [0],
     35          'descriptor': {shape: [], dataType: 'uint8'}
     36        }
     37      }
     38    }
     39  },
     40  {
     41    'name': 'isInfinite float32 1D tensor',
     42    'graph': {
     43      'inputs': {
     44        'isInfiniteInput': {
     45          'data': [Infinity, -Infinity],
     46          'descriptor': {shape: [2], dataType: 'float32'}
     47        }
     48      },
     49      'operators': [{
     50        'name': 'isInfinite',
     51        'arguments': [{'input': 'isInfiniteInput'}],
     52        'outputs': 'isInfiniteOutput'
     53      }],
     54      'expectedOutputs': {
     55        'isInfiniteOutput': {
     56          'data': [1, 1],
     57          'descriptor': {shape: [2], dataType: 'uint8'}
     58        }
     59      }
     60    }
     61  },
     62  {
     63    'name': 'isInfinite float32 2D tensor',
     64    'graph': {
     65      'inputs': {
     66        'isInfiniteInput': {
     67          'data': [1.0, Infinity, -2.5, -Infinity],
     68          'descriptor': {shape: [2, 2], dataType: 'float32'}
     69        }
     70      },
     71      'operators': [{
     72        'name': 'isInfinite',
     73        'arguments': [{'input': 'isInfiniteInput'}],
     74        'outputs': 'isInfiniteOutput'
     75      }],
     76      'expectedOutputs': {
     77        'isInfiniteOutput': {
     78          'data': [0, 1, 0, 1],
     79          'descriptor': {shape: [2, 2], dataType: 'uint8'}
     80        }
     81      }
     82    }
     83  },
     84  {
     85    'name': 'isInfinite float32 3D tensor',
     86    'graph': {
     87      'inputs': {
     88        'isInfiniteInput': {
     89          'data': [1.0, Infinity, -2.5, 0.0, NaN, -Infinity, 3.14, Infinity],
     90          'descriptor': {shape: [2, 2, 2], dataType: 'float32'}
     91        }
     92      },
     93      'operators': [{
     94        'name': 'isInfinite',
     95        'arguments': [{'input': 'isInfiniteInput'}],
     96        'outputs': 'isInfiniteOutput'
     97      }],
     98      'expectedOutputs': {
     99        'isInfiniteOutput': {
    100          'data': [0, 1, 0, 0, 0, 1, 0, 1],
    101          'descriptor': {shape: [2, 2, 2], dataType: 'uint8'}
    102        }
    103      }
    104    }
    105  },
    106  {
    107    'name': 'isInfinite float32 4D tensor',
    108    'graph': {
    109      'inputs': {
    110        'isInfiniteInput': {
    111          'data': [1.0, Infinity, -2.5, 0.0, NaN, -Infinity, 3.14, Infinity,
    112                   -0.0, 42.0, -Infinity, -999.99, 1e10, -1e-10, Infinity, 100.5],
    113          'descriptor': {shape: [2, 2, 2, 2], dataType: 'float32'}
    114        }
    115      },
    116      'operators': [{
    117        'name': 'isInfinite',
    118        'arguments': [{'input': 'isInfiniteInput'}],
    119        'outputs': 'isInfiniteOutput'
    120      }],
    121      'expectedOutputs': {
    122        'isInfiniteOutput': {
    123          'data': [0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0],
    124          'descriptor': {shape: [2, 2, 2, 2], dataType: 'uint8'}
    125        }
    126      }
    127    }
    128  },
    129  {
    130    'name': 'isInfinite float32 special values',
    131    'graph': {
    132      'inputs': {
    133        'isInfiniteInput': {
    134          'data': [Infinity, -Infinity, NaN, 0.0,
    135            -0.0, 1.0, -1.0, 3.40282346638528859811704e+38],
    136          'descriptor': {shape: [8], dataType: 'float32'}
    137        }
    138      },
    139      'operators': [{
    140        'name': 'isInfinite',
    141        'arguments': [{'input': 'isInfiniteInput'}],
    142        'outputs': 'isInfiniteOutput'
    143      }],
    144      'expectedOutputs': {
    145        'isInfiniteOutput': {
    146          'data': [1, 1, 0, 0, 0, 0, 0, 0],
    147          'descriptor': {shape: [8], dataType: 'uint8'}
    148        }
    149      }
    150    }
    151  },
    152  {
    153    'name': 'isInfinite float32 all infinite values',
    154    'graph': {
    155      'inputs': {
    156        'isInfiniteInput': {
    157          'data': [Infinity, -Infinity, Infinity, -Infinity],
    158          'descriptor': {shape: [4], dataType: 'float32'}
    159        }
    160      },
    161      'operators': [{
    162        'name': 'isInfinite',
    163        'arguments': [{'input': 'isInfiniteInput'}],
    164        'outputs': 'isInfiniteOutput'
    165      }],
    166      'expectedOutputs': {
    167        'isInfiniteOutput': {
    168          'data': [1, 1, 1, 1],
    169          'descriptor': {shape: [4], dataType: 'uint8'}
    170        }
    171      }
    172    }
    173  },
    174  {
    175    'name': 'isInfinite float32 no infinite values',
    176    'graph': {
    177      'inputs': {
    178        'isInfiniteInput': {
    179          'data': [1.0, 2.5, -3.7, 0.0, -0.0, NaN],
    180          'descriptor': {shape: [6], dataType: 'float32'}
    181        }
    182      },
    183      'operators': [{
    184        'name': 'isInfinite',
    185        'arguments': [{'input': 'isInfiniteInput'}],
    186        'outputs': 'isInfiniteOutput'
    187      }],
    188      'expectedOutputs': {
    189        'isInfiniteOutput': {
    190          'data': [0, 0, 0, 0, 0, 0],
    191          'descriptor': {shape: [6], dataType: 'uint8'}
    192        }
    193      }
    194    }
    195  },
    196  {
    197    'name': 'isInfinite float32 positive infinity only',
    198    'graph': {
    199      'inputs': {
    200        'isInfiniteInput': {
    201          'data': [Infinity, 1.0, 2.5, -3.7],
    202          'descriptor': {shape: [4], dataType: 'float32'}
    203        }
    204      },
    205      'operators': [{
    206        'name': 'isInfinite',
    207        'arguments': [{'input': 'isInfiniteInput'}],
    208        'outputs': 'isInfiniteOutput'
    209      }],
    210      'expectedOutputs': {
    211        'isInfiniteOutput': {
    212          'data': [1, 0, 0, 0],
    213          'descriptor': {shape: [4], dataType: 'uint8'}
    214        }
    215      }
    216    }
    217  },
    218  {
    219    'name': 'isInfinite float32 negative infinity only',
    220    'graph': {
    221      'inputs': {
    222        'isInfiniteInput': {
    223          'data': [1.0, -Infinity, 2.5, -3.7],
    224          'descriptor': {shape: [4], dataType: 'float32'}
    225        }
    226      },
    227      'operators': [{
    228        'name': 'isInfinite',
    229        'arguments': [{'input': 'isInfiniteInput'}],
    230        'outputs': 'isInfiniteOutput'
    231      }],
    232      'expectedOutputs': {
    233        'isInfiniteOutput': {
    234          'data': [0, 1, 0, 0],
    235          'descriptor': {shape: [4], dataType: 'uint8'}
    236        }
    237      }
    238    }
    239  },
    240  {
    241    'name': 'isInfinite float32 large finite values',
    242    'graph': {
    243      'inputs': {
    244        'isInfiniteInput': {
    245          'data': [1e38, -1e38, 3.40282346638528859811704e+38,
    246            -3.40282346638528859811704e+38, 1e39, -1e39],
    247          'descriptor': {shape: [6], dataType: 'float32'}
    248        }
    249      },
    250      'operators': [{
    251        'name': 'isInfinite',
    252        'arguments': [{'input': 'isInfiniteInput'}],
    253        'outputs': 'isInfiniteOutput'
    254      }],
    255      'expectedOutputs': {
    256        'isInfiniteOutput': {
    257          'data': [0, 0, 0, 0, 1, 1],
    258          'descriptor': {shape: [6], dataType: 'uint8'}
    259        }
    260      }
    261    }
    262  },
    263 
    264  // float16 tests
    265  {
    266    'name': 'isInfinite float16 positive 0D scalar',
    267    'graph': {
    268      'inputs': {
    269        'isInfiniteInput': {
    270          'data': [1.5],
    271          'descriptor': {shape: [], dataType: 'float16'}
    272        }
    273      },
    274      'operators': [{
    275        'name': 'isInfinite',
    276        'arguments': [{'input': 'isInfiniteInput'}],
    277        'outputs': 'isInfiniteOutput'
    278      }],
    279      'expectedOutputs': {
    280        'isInfiniteOutput': {
    281          'data': [0],
    282          'descriptor': {shape: [], dataType: 'uint8'}
    283        }
    284      }
    285    }
    286  },
    287  {
    288    'name': 'isInfinite float16 1D tensor',
    289    'graph': {
    290      'inputs': {
    291        'isInfiniteInput': {
    292          'data': [Infinity, -Infinity],
    293          'descriptor': {shape: [2], dataType: 'float16'}
    294        }
    295      },
    296      'operators': [{
    297        'name': 'isInfinite',
    298        'arguments': [{'input': 'isInfiniteInput'}],
    299        'outputs': 'isInfiniteOutput'
    300      }],
    301      'expectedOutputs': {
    302        'isInfiniteOutput': {
    303          'data': [1, 1],
    304          'descriptor': {shape: [2], dataType: 'uint8'}
    305        }
    306      }
    307    }
    308  },
    309  {
    310    'name': 'isInfinite float16 2D tensor',
    311    'graph': {
    312      'inputs': {
    313        'isInfiniteInput': {
    314          'data': [1.0, Infinity, -2.5, -Infinity],
    315          'descriptor': {shape: [2, 2], dataType: 'float16'}
    316        }
    317      },
    318      'operators': [{
    319        'name': 'isInfinite',
    320        'arguments': [{'input': 'isInfiniteInput'}],
    321        'outputs': 'isInfiniteOutput'
    322      }],
    323      'expectedOutputs': {
    324        'isInfiniteOutput': {
    325          'data': [0, 1, 0, 1],
    326          'descriptor': {shape: [2, 2], dataType: 'uint8'}
    327        }
    328      }
    329    }
    330  },
    331  {
    332    'name': 'isInfinite float16 special values',
    333    'graph': {
    334      'inputs': {
    335        'isInfiniteInput': {
    336          'data': [Infinity, -Infinity, NaN, 0.0, -0.0, 1.0, -1.0],
    337          'descriptor': {shape: [7], dataType: 'float16'}
    338        }
    339      },
    340      'operators': [{
    341        'name': 'isInfinite',
    342        'arguments': [{'input': 'isInfiniteInput'}],
    343        'outputs': 'isInfiniteOutput'
    344      }],
    345      'expectedOutputs': {
    346        'isInfiniteOutput': {
    347          'data': [1, 1, 0, 0, 0, 0, 0],
    348          'descriptor': {shape: [7], dataType: 'uint8'}
    349        }
    350      }
    351    }
    352  },
    353 ]
    354 
    355 webnn_conformance_test(
    356    isInfiniteTests, buildAndExecuteGraph, getZeroULPTolerance);