vendor/windows-sys/src/Windows/Win32/AI/MachineLearning/DirectML/mod.rs

   1 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
   2 #[link(name = "windows")]
   3 extern "system" {
   4     #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Graphics_Direct3D12\"`*"]
   5     #[cfg(feature = "Win32_Graphics_Direct3D12")]
   6     pub fn DMLCreateDevice(d3d12device: super::super::super::Graphics::Direct3D12::ID3D12Device, flags: DML_CREATE_DEVICE_FLAGS, riid: *const ::windows_sys::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_sys::core::HRESULT;
   7     #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Graphics_Direct3D12\"`*"]
   8     #[cfg(feature = "Win32_Graphics_Direct3D12")]
   9     pub fn DMLCreateDevice1(d3d12device: super::super::super::Graphics::Direct3D12::ID3D12Device, flags: DML_CREATE_DEVICE_FLAGS, minimumfeaturelevel: DML_FEATURE_LEVEL, riid: *const ::windows_sys::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_sys::core::HRESULT;
  10 }
  11 #[repr(C)]
  12 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
  13 pub struct DML_ACTIVATION_CELU_OPERATOR_DESC {
  14     pub InputTensor: *const DML_TENSOR_DESC,
  15     pub OutputTensor: *const DML_TENSOR_DESC,
  16     pub Alpha: f32,
  17 }
  18 impl ::core::marker::Copy for DML_ACTIVATION_CELU_OPERATOR_DESC {}
  19 impl ::core::clone::Clone for DML_ACTIVATION_CELU_OPERATOR_DESC {
  20     fn clone(&self) -> Self {
  21         *self
  22     }
  23 }
  24 #[repr(C)]
  25 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
  26 pub struct DML_ACTIVATION_ELU_OPERATOR_DESC {
  27     pub InputTensor: *const DML_TENSOR_DESC,
  28     pub OutputTensor: *const DML_TENSOR_DESC,
  29     pub Alpha: f32,
  30 }
  31 impl ::core::marker::Copy for DML_ACTIVATION_ELU_OPERATOR_DESC {}
  32 impl ::core::clone::Clone for DML_ACTIVATION_ELU_OPERATOR_DESC {
  33     fn clone(&self) -> Self {
  34         *self
  35     }
  36 }
  37 #[repr(C)]
  38 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
  39 pub struct DML_ACTIVATION_HARDMAX_OPERATOR_DESC {
  40     pub InputTensor: *const DML_TENSOR_DESC,
  41     pub OutputTensor: *const DML_TENSOR_DESC,
  42 }
  43 impl ::core::marker::Copy for DML_ACTIVATION_HARDMAX_OPERATOR_DESC {}
  44 impl ::core::clone::Clone for DML_ACTIVATION_HARDMAX_OPERATOR_DESC {
  45     fn clone(&self) -> Self {
  46         *self
  47     }
  48 }
  49 #[repr(C)]
  50 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
  51 pub struct DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {
  52     pub InputTensor: *const DML_TENSOR_DESC,
  53     pub OutputTensor: *const DML_TENSOR_DESC,
  54     pub Alpha: f32,
  55     pub Beta: f32,
  56 }
  57 impl ::core::marker::Copy for DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {}
  58 impl ::core::clone::Clone for DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {
  59     fn clone(&self) -> Self {
  60         *self
  61     }
  62 }
  63 #[repr(C)]
  64 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
  65 pub struct DML_ACTIVATION_IDENTITY_OPERATOR_DESC {
  66     pub InputTensor: *const DML_TENSOR_DESC,
  67     pub OutputTensor: *const DML_TENSOR_DESC,
  68 }
  69 impl ::core::marker::Copy for DML_ACTIVATION_IDENTITY_OPERATOR_DESC {}
  70 impl ::core::clone::Clone for DML_ACTIVATION_IDENTITY_OPERATOR_DESC {
  71     fn clone(&self) -> Self {
  72         *self
  73     }
  74 }
  75 #[repr(C)]
  76 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
  77 pub struct DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {
  78     pub InputTensor: *const DML_TENSOR_DESC,
  79     pub OutputTensor: *const DML_TENSOR_DESC,
  80     pub Alpha: f32,
  81 }
  82 impl ::core::marker::Copy for DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {}
  83 impl ::core::clone::Clone for DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {
  84     fn clone(&self) -> Self {
  85         *self
  86     }
  87 }
  88 #[repr(C)]
  89 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
  90 pub struct DML_ACTIVATION_LINEAR_OPERATOR_DESC {
  91     pub InputTensor: *const DML_TENSOR_DESC,
  92     pub OutputTensor: *const DML_TENSOR_DESC,
  93     pub Alpha: f32,
  94     pub Beta: f32,
  95 }
  96 impl ::core::marker::Copy for DML_ACTIVATION_LINEAR_OPERATOR_DESC {}
  97 impl ::core::clone::Clone for DML_ACTIVATION_LINEAR_OPERATOR_DESC {
  98     fn clone(&self) -> Self {
  99         *self
 100     }
 101 }
 102 #[repr(C)]
 103 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 104 pub struct DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {
 105     pub InputTensor: *const DML_TENSOR_DESC,
 106     pub OutputTensor: *const DML_TENSOR_DESC,
 107 }
 108 impl ::core::marker::Copy for DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {}
 109 impl ::core::clone::Clone for DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {
 110     fn clone(&self) -> Self {
 111         *self
 112     }
 113 }
 114 #[repr(C)]
 115 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 116 pub struct DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {
 117     pub InputTensor: *const DML_TENSOR_DESC,
 118     pub SlopeTensor: *const DML_TENSOR_DESC,
 119     pub OutputTensor: *const DML_TENSOR_DESC,
 120 }
 121 impl ::core::marker::Copy for DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {}
 122 impl ::core::clone::Clone for DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {
 123     fn clone(&self) -> Self {
 124         *self
 125     }
 126 }
 127 #[repr(C)]
 128 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 129 pub struct DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {
 130     pub InputTensor: *const DML_TENSOR_DESC,
 131     pub OutputTensor: *const DML_TENSOR_DESC,
 132     pub Alpha: f32,
 133     pub Beta: f32,
 134 }
 135 impl ::core::marker::Copy for DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {}
 136 impl ::core::clone::Clone for DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {
 137     fn clone(&self) -> Self {
 138         *self
 139     }
 140 }
 141 #[repr(C)]
 142 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 143 pub struct DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {
 144     pub InputTensor: *const DML_TENSOR_DESC,
 145     pub InputGradientTensor: *const DML_TENSOR_DESC,
 146     pub OutputGradientTensor: *const DML_TENSOR_DESC,
 147 }
 148 impl ::core::marker::Copy for DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {}
 149 impl ::core::clone::Clone for DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {
 150     fn clone(&self) -> Self {
 151         *self
 152     }
 153 }
 154 #[repr(C)]
 155 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 156 pub struct DML_ACTIVATION_RELU_OPERATOR_DESC {
 157     pub InputTensor: *const DML_TENSOR_DESC,
 158     pub OutputTensor: *const DML_TENSOR_DESC,
 159 }
 160 impl ::core::marker::Copy for DML_ACTIVATION_RELU_OPERATOR_DESC {}
 161 impl ::core::clone::Clone for DML_ACTIVATION_RELU_OPERATOR_DESC {
 162     fn clone(&self) -> Self {
 163         *self
 164     }
 165 }
 166 #[repr(C)]
 167 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 168 pub struct DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {
 169     pub InputTensor: *const DML_TENSOR_DESC,
 170     pub OutputTensor: *const DML_TENSOR_DESC,
 171     pub Alpha: f32,
 172     pub Gamma: f32,
 173 }
 174 impl ::core::marker::Copy for DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {}
 175 impl ::core::clone::Clone for DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {
 176     fn clone(&self) -> Self {
 177         *self
 178     }
 179 }
 180 #[repr(C)]
 181 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 182 pub struct DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {
 183     pub InputTensor: *const DML_TENSOR_DESC,
 184     pub OutputTensor: *const DML_TENSOR_DESC,
 185     pub Alpha: f32,
 186     pub Beta: f32,
 187 }
 188 impl ::core::marker::Copy for DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {}
 189 impl ::core::clone::Clone for DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {
 190     fn clone(&self) -> Self {
 191         *self
 192     }
 193 }
 194 #[repr(C)]
 195 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 196 pub struct DML_ACTIVATION_SHRINK_OPERATOR_DESC {
 197     pub InputTensor: *const DML_TENSOR_DESC,
 198     pub OutputTensor: *const DML_TENSOR_DESC,
 199     pub Bias: f32,
 200     pub Threshold: f32,
 201 }
 202 impl ::core::marker::Copy for DML_ACTIVATION_SHRINK_OPERATOR_DESC {}
 203 impl ::core::clone::Clone for DML_ACTIVATION_SHRINK_OPERATOR_DESC {
 204     fn clone(&self) -> Self {
 205         *self
 206     }
 207 }
 208 #[repr(C)]
 209 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 210 pub struct DML_ACTIVATION_SIGMOID_OPERATOR_DESC {
 211     pub InputTensor: *const DML_TENSOR_DESC,
 212     pub OutputTensor: *const DML_TENSOR_DESC,
 213 }
 214 impl ::core::marker::Copy for DML_ACTIVATION_SIGMOID_OPERATOR_DESC {}
 215 impl ::core::clone::Clone for DML_ACTIVATION_SIGMOID_OPERATOR_DESC {
 216     fn clone(&self) -> Self {
 217         *self
 218     }
 219 }
 220 #[repr(C)]
 221 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 222 pub struct DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {
 223     pub InputTensor: *const DML_TENSOR_DESC,
 224     pub OutputTensor: *const DML_TENSOR_DESC,
 225 }
 226 impl ::core::marker::Copy for DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {}
 227 impl ::core::clone::Clone for DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {
 228     fn clone(&self) -> Self {
 229         *self
 230     }
 231 }
 232 #[repr(C)]
 233 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 234 pub struct DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {
 235     pub InputTensor: *const DML_TENSOR_DESC,
 236     pub OutputTensor: *const DML_TENSOR_DESC,
 237     pub Steepness: f32,
 238 }
 239 impl ::core::marker::Copy for DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {}
 240 impl ::core::clone::Clone for DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {
 241     fn clone(&self) -> Self {
 242         *self
 243     }
 244 }
 245 #[repr(C)]
 246 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 247 pub struct DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {
 248     pub InputTensor: *const DML_TENSOR_DESC,
 249     pub OutputTensor: *const DML_TENSOR_DESC,
 250 }
 251 impl ::core::marker::Copy for DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {}
 252 impl ::core::clone::Clone for DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {
 253     fn clone(&self) -> Self {
 254         *self
 255     }
 256 }
 257 #[repr(C)]
 258 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 259 pub struct DML_ACTIVATION_TANH_OPERATOR_DESC {
 260     pub InputTensor: *const DML_TENSOR_DESC,
 261     pub OutputTensor: *const DML_TENSOR_DESC,
 262 }
 263 impl ::core::marker::Copy for DML_ACTIVATION_TANH_OPERATOR_DESC {}
 264 impl ::core::clone::Clone for DML_ACTIVATION_TANH_OPERATOR_DESC {
 265     fn clone(&self) -> Self {
 266         *self
 267     }
 268 }
 269 #[repr(C)]
 270 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 271 pub struct DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {
 272     pub InputTensor: *const DML_TENSOR_DESC,
 273     pub OutputTensor: *const DML_TENSOR_DESC,
 274     pub Alpha: f32,
 275 }
 276 impl ::core::marker::Copy for DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {}
 277 impl ::core::clone::Clone for DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {
 278     fn clone(&self) -> Self {
 279         *self
 280     }
 281 }
 282 #[repr(C)]
 283 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 284 pub struct DML_ADAM_OPTIMIZER_OPERATOR_DESC {
 285     pub InputParametersTensor: *const DML_TENSOR_DESC,
 286     pub InputFirstMomentTensor: *const DML_TENSOR_DESC,
 287     pub InputSecondMomentTensor: *const DML_TENSOR_DESC,
 288     pub GradientTensor: *const DML_TENSOR_DESC,
 289     pub TrainingStepTensor: *const DML_TENSOR_DESC,
 290     pub OutputParametersTensor: *const DML_TENSOR_DESC,
 291     pub OutputFirstMomentTensor: *const DML_TENSOR_DESC,
 292     pub OutputSecondMomentTensor: *const DML_TENSOR_DESC,
 293     pub LearningRate: f32,
 294     pub Beta1: f32,
 295     pub Beta2: f32,
 296     pub Epsilon: f32,
 297 }
 298 impl ::core::marker::Copy for DML_ADAM_OPTIMIZER_OPERATOR_DESC {}
 299 impl ::core::clone::Clone for DML_ADAM_OPTIMIZER_OPERATOR_DESC {
 300     fn clone(&self) -> Self {
 301         *self
 302     }
 303 }
 304 #[repr(C)]
 305 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 306 pub struct DML_ARGMAX_OPERATOR_DESC {
 307     pub InputTensor: *const DML_TENSOR_DESC,
 308     pub OutputTensor: *const DML_TENSOR_DESC,
 309     pub AxisCount: u32,
 310     pub Axes: *const u32,
 311     pub AxisDirection: DML_AXIS_DIRECTION,
 312 }
 313 impl ::core::marker::Copy for DML_ARGMAX_OPERATOR_DESC {}
 314 impl ::core::clone::Clone for DML_ARGMAX_OPERATOR_DESC {
 315     fn clone(&self) -> Self {
 316         *self
 317     }
 318 }
 319 #[repr(C)]
 320 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 321 pub struct DML_ARGMIN_OPERATOR_DESC {
 322     pub InputTensor: *const DML_TENSOR_DESC,
 323     pub OutputTensor: *const DML_TENSOR_DESC,
 324     pub AxisCount: u32,
 325     pub Axes: *const u32,
 326     pub AxisDirection: DML_AXIS_DIRECTION,
 327 }
 328 impl ::core::marker::Copy for DML_ARGMIN_OPERATOR_DESC {}
 329 impl ::core::clone::Clone for DML_ARGMIN_OPERATOR_DESC {
 330     fn clone(&self) -> Self {
 331         *self
 332     }
 333 }
 334 #[repr(C)]
 335 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
 336 #[cfg(feature = "Win32_Foundation")]
 337 pub struct DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {
 338     pub InputGradientTensor: *const DML_TENSOR_DESC,
 339     pub OutputGradientTensor: *const DML_TENSOR_DESC,
 340     pub DimensionCount: u32,
 341     pub Strides: *const u32,
 342     pub WindowSize: *const u32,
 343     pub StartPadding: *const u32,
 344     pub EndPadding: *const u32,
 345     pub IncludePadding: super::super::super::Foundation::BOOL,
 346 }
 347 #[cfg(feature = "Win32_Foundation")]
 348 impl ::core::marker::Copy for DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {}
 349 #[cfg(feature = "Win32_Foundation")]
 350 impl ::core::clone::Clone for DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {
 351     fn clone(&self) -> Self {
 352         *self
 353     }
 354 }
 355 #[repr(C)]
 356 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
 357 #[cfg(feature = "Win32_Foundation")]
 358 pub struct DML_AVERAGE_POOLING_OPERATOR_DESC {
 359     pub InputTensor: *const DML_TENSOR_DESC,
 360     pub OutputTensor: *const DML_TENSOR_DESC,
 361     pub DimensionCount: u32,
 362     pub Strides: *const u32,
 363     pub WindowSize: *const u32,
 364     pub StartPadding: *const u32,
 365     pub EndPadding: *const u32,
 366     pub IncludePadding: super::super::super::Foundation::BOOL,
 367 }
 368 #[cfg(feature = "Win32_Foundation")]
 369 impl ::core::marker::Copy for DML_AVERAGE_POOLING_OPERATOR_DESC {}
 370 #[cfg(feature = "Win32_Foundation")]
 371 impl ::core::clone::Clone for DML_AVERAGE_POOLING_OPERATOR_DESC {
 372     fn clone(&self) -> Self {
 373         *self
 374     }
 375 }
 376 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 377 pub type DML_AXIS_DIRECTION = i32;
 378 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 379 pub const DML_AXIS_DIRECTION_INCREASING: DML_AXIS_DIRECTION = 0i32;
 380 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 381 pub const DML_AXIS_DIRECTION_DECREASING: DML_AXIS_DIRECTION = 1i32;
 382 #[repr(C)]
 383 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 384 pub struct DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {
 385     pub InputTensor: *const DML_TENSOR_DESC,
 386     pub InputGradientTensor: *const DML_TENSOR_DESC,
 387     pub MeanTensor: *const DML_TENSOR_DESC,
 388     pub VarianceTensor: *const DML_TENSOR_DESC,
 389     pub ScaleTensor: *const DML_TENSOR_DESC,
 390     pub OutputGradientTensor: *const DML_TENSOR_DESC,
 391     pub OutputScaleGradientTensor: *const DML_TENSOR_DESC,
 392     pub OutputBiasGradientTensor: *const DML_TENSOR_DESC,
 393     pub Epsilon: f32,
 394 }
 395 impl ::core::marker::Copy for DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {}
 396 impl ::core::clone::Clone for DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {
 397     fn clone(&self) -> Self {
 398         *self
 399     }
 400 }
 401 #[repr(C)]
 402 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
 403 #[cfg(feature = "Win32_Foundation")]
 404 pub struct DML_BATCH_NORMALIZATION_OPERATOR_DESC {
 405     pub InputTensor: *const DML_TENSOR_DESC,
 406     pub MeanTensor: *const DML_TENSOR_DESC,
 407     pub VarianceTensor: *const DML_TENSOR_DESC,
 408     pub ScaleTensor: *const DML_TENSOR_DESC,
 409     pub BiasTensor: *const DML_TENSOR_DESC,
 410     pub OutputTensor: *const DML_TENSOR_DESC,
 411     pub Spatial: super::super::super::Foundation::BOOL,
 412     pub Epsilon: f32,
 413     pub FusedActivation: *const DML_OPERATOR_DESC,
 414 }
 415 #[cfg(feature = "Win32_Foundation")]
 416 impl ::core::marker::Copy for DML_BATCH_NORMALIZATION_OPERATOR_DESC {}
 417 #[cfg(feature = "Win32_Foundation")]
 418 impl ::core::clone::Clone for DML_BATCH_NORMALIZATION_OPERATOR_DESC {
 419     fn clone(&self) -> Self {
 420         *self
 421     }
 422 }
 423 #[repr(C)]
 424 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 425 pub struct DML_BINDING_DESC {
 426     pub Type: DML_BINDING_TYPE,
 427     pub Desc: *const ::core::ffi::c_void,
 428 }
 429 impl ::core::marker::Copy for DML_BINDING_DESC {}
 430 impl ::core::clone::Clone for DML_BINDING_DESC {
 431     fn clone(&self) -> Self {
 432         *self
 433     }
 434 }
 435 #[repr(C)]
 436 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 437 pub struct DML_BINDING_PROPERTIES {
 438     pub RequiredDescriptorCount: u32,
 439     pub TemporaryResourceSize: u64,
 440     pub PersistentResourceSize: u64,
 441 }
 442 impl ::core::marker::Copy for DML_BINDING_PROPERTIES {}
 443 impl ::core::clone::Clone for DML_BINDING_PROPERTIES {
 444     fn clone(&self) -> Self {
 445         *self
 446     }
 447 }
 448 #[repr(C)]
 449 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Graphics_Direct3D12\"`*"]
 450 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 451 pub struct DML_BINDING_TABLE_DESC {
 452     pub Dispatchable: IDMLDispatchable,
 453     pub CPUDescriptorHandle: super::super::super::Graphics::Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE,
 454     pub GPUDescriptorHandle: super::super::super::Graphics::Direct3D12::D3D12_GPU_DESCRIPTOR_HANDLE,
 455     pub SizeInDescriptors: u32,
 456 }
 457 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 458 impl ::core::marker::Copy for DML_BINDING_TABLE_DESC {}
 459 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 460 impl ::core::clone::Clone for DML_BINDING_TABLE_DESC {
 461     fn clone(&self) -> Self {
 462         *self
 463     }
 464 }
 465 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 466 pub type DML_BINDING_TYPE = i32;
 467 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 468 pub const DML_BINDING_TYPE_NONE: DML_BINDING_TYPE = 0i32;
 469 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 470 pub const DML_BINDING_TYPE_BUFFER: DML_BINDING_TYPE = 1i32;
 471 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 472 pub const DML_BINDING_TYPE_BUFFER_ARRAY: DML_BINDING_TYPE = 2i32;
 473 #[repr(C)]
 474 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Graphics_Direct3D12\"`*"]
 475 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 476 pub struct DML_BUFFER_ARRAY_BINDING {
 477     pub BindingCount: u32,
 478     pub Bindings: *const DML_BUFFER_BINDING,
 479 }
 480 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 481 impl ::core::marker::Copy for DML_BUFFER_ARRAY_BINDING {}
 482 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 483 impl ::core::clone::Clone for DML_BUFFER_ARRAY_BINDING {
 484     fn clone(&self) -> Self {
 485         *self
 486     }
 487 }
 488 #[repr(C)]
 489 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Graphics_Direct3D12\"`*"]
 490 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 491 pub struct DML_BUFFER_BINDING {
 492     pub Buffer: super::super::super::Graphics::Direct3D12::ID3D12Resource,
 493     pub Offset: u64,
 494     pub SizeInBytes: u64,
 495 }
 496 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 497 impl ::core::marker::Copy for DML_BUFFER_BINDING {}
 498 #[cfg(feature = "Win32_Graphics_Direct3D12")]
 499 impl ::core::clone::Clone for DML_BUFFER_BINDING {
 500     fn clone(&self) -> Self {
 501         *self
 502     }
 503 }
 504 #[repr(C)]
 505 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 506 pub struct DML_BUFFER_TENSOR_DESC {
 507     pub DataType: DML_TENSOR_DATA_TYPE,
 508     pub Flags: DML_TENSOR_FLAGS,
 509     pub DimensionCount: u32,
 510     pub Sizes: *const u32,
 511     pub Strides: *const u32,
 512     pub TotalTensorSizeInBytes: u64,
 513     pub GuaranteedBaseOffsetAlignment: u32,
 514 }
 515 impl ::core::marker::Copy for DML_BUFFER_TENSOR_DESC {}
 516 impl ::core::clone::Clone for DML_BUFFER_TENSOR_DESC {
 517     fn clone(&self) -> Self {
 518         *self
 519     }
 520 }
 521 #[repr(C)]
 522 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 523 pub struct DML_CAST_OPERATOR_DESC {
 524     pub InputTensor: *const DML_TENSOR_DESC,
 525     pub OutputTensor: *const DML_TENSOR_DESC,
 526 }
 527 impl ::core::marker::Copy for DML_CAST_OPERATOR_DESC {}
 528 impl ::core::clone::Clone for DML_CAST_OPERATOR_DESC {
 529     fn clone(&self) -> Self {
 530         *self
 531     }
 532 }
 533 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 534 pub type DML_CONVOLUTION_DIRECTION = i32;
 535 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 536 pub const DML_CONVOLUTION_DIRECTION_FORWARD: DML_CONVOLUTION_DIRECTION = 0i32;
 537 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 538 pub const DML_CONVOLUTION_DIRECTION_BACKWARD: DML_CONVOLUTION_DIRECTION = 1i32;
 539 #[repr(C)]
 540 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 541 pub struct DML_CONVOLUTION_INTEGER_OPERATOR_DESC {
 542     pub InputTensor: *const DML_TENSOR_DESC,
 543     pub InputZeroPointTensor: *const DML_TENSOR_DESC,
 544     pub FilterTensor: *const DML_TENSOR_DESC,
 545     pub FilterZeroPointTensor: *const DML_TENSOR_DESC,
 546     pub OutputTensor: *const DML_TENSOR_DESC,
 547     pub DimensionCount: u32,
 548     pub Strides: *const u32,
 549     pub Dilations: *const u32,
 550     pub StartPadding: *const u32,
 551     pub EndPadding: *const u32,
 552     pub GroupCount: u32,
 553 }
 554 impl ::core::marker::Copy for DML_CONVOLUTION_INTEGER_OPERATOR_DESC {}
 555 impl ::core::clone::Clone for DML_CONVOLUTION_INTEGER_OPERATOR_DESC {
 556     fn clone(&self) -> Self {
 557         *self
 558     }
 559 }
 560 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 561 pub type DML_CONVOLUTION_MODE = i32;
 562 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 563 pub const DML_CONVOLUTION_MODE_CONVOLUTION: DML_CONVOLUTION_MODE = 0i32;
 564 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 565 pub const DML_CONVOLUTION_MODE_CROSS_CORRELATION: DML_CONVOLUTION_MODE = 1i32;
 566 #[repr(C)]
 567 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 568 pub struct DML_CONVOLUTION_OPERATOR_DESC {
 569     pub InputTensor: *const DML_TENSOR_DESC,
 570     pub FilterTensor: *const DML_TENSOR_DESC,
 571     pub BiasTensor: *const DML_TENSOR_DESC,
 572     pub OutputTensor: *const DML_TENSOR_DESC,
 573     pub Mode: DML_CONVOLUTION_MODE,
 574     pub Direction: DML_CONVOLUTION_DIRECTION,
 575     pub DimensionCount: u32,
 576     pub Strides: *const u32,
 577     pub Dilations: *const u32,
 578     pub StartPadding: *const u32,
 579     pub EndPadding: *const u32,
 580     pub OutputPadding: *const u32,
 581     pub GroupCount: u32,
 582     pub FusedActivation: *const DML_OPERATOR_DESC,
 583 }
 584 impl ::core::marker::Copy for DML_CONVOLUTION_OPERATOR_DESC {}
 585 impl ::core::clone::Clone for DML_CONVOLUTION_OPERATOR_DESC {
 586     fn clone(&self) -> Self {
 587         *self
 588     }
 589 }
 590 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 591 pub type DML_CREATE_DEVICE_FLAGS = u32;
 592 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 593 pub const DML_CREATE_DEVICE_FLAG_NONE: DML_CREATE_DEVICE_FLAGS = 0u32;
 594 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 595 pub const DML_CREATE_DEVICE_FLAG_DEBUG: DML_CREATE_DEVICE_FLAGS = 1u32;
 596 #[repr(C)]
 597 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
 598 #[cfg(feature = "Win32_Foundation")]
 599 pub struct DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {
 600     pub InputTensor: *const DML_TENSOR_DESC,
 601     pub OutputTensor: *const DML_TENSOR_DESC,
 602     pub Axis: u32,
 603     pub AxisDirection: DML_AXIS_DIRECTION,
 604     pub HasExclusiveProduct: super::super::super::Foundation::BOOL,
 605 }
 606 #[cfg(feature = "Win32_Foundation")]
 607 impl ::core::marker::Copy for DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {}
 608 #[cfg(feature = "Win32_Foundation")]
 609 impl ::core::clone::Clone for DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {
 610     fn clone(&self) -> Self {
 611         *self
 612     }
 613 }
 614 #[repr(C)]
 615 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
 616 #[cfg(feature = "Win32_Foundation")]
 617 pub struct DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {
 618     pub InputTensor: *const DML_TENSOR_DESC,
 619     pub OutputTensor: *const DML_TENSOR_DESC,
 620     pub Axis: u32,
 621     pub AxisDirection: DML_AXIS_DIRECTION,
 622     pub HasExclusiveSum: super::super::super::Foundation::BOOL,
 623 }
 624 #[cfg(feature = "Win32_Foundation")]
 625 impl ::core::marker::Copy for DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {}
 626 #[cfg(feature = "Win32_Foundation")]
 627 impl ::core::clone::Clone for DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {
 628     fn clone(&self) -> Self {
 629         *self
 630     }
 631 }
 632 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 633 pub type DML_DEPTH_SPACE_ORDER = i32;
 634 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 635 pub const DML_DEPTH_SPACE_ORDER_DEPTH_COLUMN_ROW: DML_DEPTH_SPACE_ORDER = 0i32;
 636 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 637 pub const DML_DEPTH_SPACE_ORDER_COLUMN_ROW_DEPTH: DML_DEPTH_SPACE_ORDER = 1i32;
 638 #[repr(C)]
 639 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 640 pub struct DML_DEPTH_TO_SPACE1_OPERATOR_DESC {
 641     pub InputTensor: *const DML_TENSOR_DESC,
 642     pub OutputTensor: *const DML_TENSOR_DESC,
 643     pub BlockSize: u32,
 644     pub Order: DML_DEPTH_SPACE_ORDER,
 645 }
 646 impl ::core::marker::Copy for DML_DEPTH_TO_SPACE1_OPERATOR_DESC {}
 647 impl ::core::clone::Clone for DML_DEPTH_TO_SPACE1_OPERATOR_DESC {
 648     fn clone(&self) -> Self {
 649         *self
 650     }
 651 }
 652 #[repr(C)]
 653 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 654 pub struct DML_DEPTH_TO_SPACE_OPERATOR_DESC {
 655     pub InputTensor: *const DML_TENSOR_DESC,
 656     pub OutputTensor: *const DML_TENSOR_DESC,
 657     pub BlockSize: u32,
 658 }
 659 impl ::core::marker::Copy for DML_DEPTH_TO_SPACE_OPERATOR_DESC {}
 660 impl ::core::clone::Clone for DML_DEPTH_TO_SPACE_OPERATOR_DESC {
 661     fn clone(&self) -> Self {
 662         *self
 663     }
 664 }
 665 #[repr(C)]
 666 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 667 pub struct DML_DIAGONAL_MATRIX_OPERATOR_DESC {
 668     pub OutputTensor: *const DML_TENSOR_DESC,
 669     pub Offset: i32,
 670     pub Value: f32,
 671 }
 672 impl ::core::marker::Copy for DML_DIAGONAL_MATRIX_OPERATOR_DESC {}
 673 impl ::core::clone::Clone for DML_DIAGONAL_MATRIX_OPERATOR_DESC {
 674     fn clone(&self) -> Self {
 675         *self
 676     }
 677 }
 678 #[repr(C)]
 679 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 680 pub struct DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {
 681     pub InputTensor: *const DML_TENSOR_DESC,
 682     pub OutputTensor: *const DML_TENSOR_DESC,
 683     pub OutputScaleTensor: *const DML_TENSOR_DESC,
 684     pub OutputZeroPointTensor: *const DML_TENSOR_DESC,
 685 }
 686 impl ::core::marker::Copy for DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {}
 687 impl ::core::clone::Clone for DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {
 688     fn clone(&self) -> Self {
 689         *self
 690     }
 691 }
 692 #[repr(C)]
 693 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 694 pub struct DML_ELEMENT_WISE_ABS_OPERATOR_DESC {
 695     pub InputTensor: *const DML_TENSOR_DESC,
 696     pub OutputTensor: *const DML_TENSOR_DESC,
 697     pub ScaleBias: *const DML_SCALE_BIAS,
 698 }
 699 impl ::core::marker::Copy for DML_ELEMENT_WISE_ABS_OPERATOR_DESC {}
 700 impl ::core::clone::Clone for DML_ELEMENT_WISE_ABS_OPERATOR_DESC {
 701     fn clone(&self) -> Self {
 702         *self
 703     }
 704 }
 705 #[repr(C)]
 706 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 707 pub struct DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {
 708     pub InputTensor: *const DML_TENSOR_DESC,
 709     pub OutputTensor: *const DML_TENSOR_DESC,
 710     pub ScaleBias: *const DML_SCALE_BIAS,
 711 }
 712 impl ::core::marker::Copy for DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {}
 713 impl ::core::clone::Clone for DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {
 714     fn clone(&self) -> Self {
 715         *self
 716     }
 717 }
 718 #[repr(C)]
 719 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 720 pub struct DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {
 721     pub InputTensor: *const DML_TENSOR_DESC,
 722     pub OutputTensor: *const DML_TENSOR_DESC,
 723     pub ScaleBias: *const DML_SCALE_BIAS,
 724 }
 725 impl ::core::marker::Copy for DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {}
 726 impl ::core::clone::Clone for DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {
 727     fn clone(&self) -> Self {
 728         *self
 729     }
 730 }
 731 #[repr(C)]
 732 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 733 pub struct DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {
 734     pub ATensor: *const DML_TENSOR_DESC,
 735     pub BTensor: *const DML_TENSOR_DESC,
 736     pub OutputTensor: *const DML_TENSOR_DESC,
 737     pub FusedActivation: *const DML_OPERATOR_DESC,
 738 }
 739 impl ::core::marker::Copy for DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {}
 740 impl ::core::clone::Clone for DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {
 741     fn clone(&self) -> Self {
 742         *self
 743     }
 744 }
 745 #[repr(C)]
 746 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 747 pub struct DML_ELEMENT_WISE_ADD_OPERATOR_DESC {
 748     pub ATensor: *const DML_TENSOR_DESC,
 749     pub BTensor: *const DML_TENSOR_DESC,
 750     pub OutputTensor: *const DML_TENSOR_DESC,
 751 }
 752 impl ::core::marker::Copy for DML_ELEMENT_WISE_ADD_OPERATOR_DESC {}
 753 impl ::core::clone::Clone for DML_ELEMENT_WISE_ADD_OPERATOR_DESC {
 754     fn clone(&self) -> Self {
 755         *self
 756     }
 757 }
 758 #[repr(C)]
 759 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 760 pub struct DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {
 761     pub InputTensor: *const DML_TENSOR_DESC,
 762     pub OutputTensor: *const DML_TENSOR_DESC,
 763     pub ScaleBias: *const DML_SCALE_BIAS,
 764 }
 765 impl ::core::marker::Copy for DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {}
 766 impl ::core::clone::Clone for DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {
 767     fn clone(&self) -> Self {
 768         *self
 769     }
 770 }
 771 #[repr(C)]
 772 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 773 pub struct DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {
 774     pub InputTensor: *const DML_TENSOR_DESC,
 775     pub OutputTensor: *const DML_TENSOR_DESC,
 776     pub ScaleBias: *const DML_SCALE_BIAS,
 777 }
 778 impl ::core::marker::Copy for DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {}
 779 impl ::core::clone::Clone for DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {
 780     fn clone(&self) -> Self {
 781         *self
 782     }
 783 }
 784 #[repr(C)]
 785 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 786 pub struct DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {
 787     pub InputTensor: *const DML_TENSOR_DESC,
 788     pub OutputTensor: *const DML_TENSOR_DESC,
 789     pub ScaleBias: *const DML_SCALE_BIAS,
 790 }
 791 impl ::core::marker::Copy for DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {}
 792 impl ::core::clone::Clone for DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {
 793     fn clone(&self) -> Self {
 794         *self
 795     }
 796 }
 797 #[repr(C)]
 798 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 799 pub struct DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {
 800     pub InputTensor: *const DML_TENSOR_DESC,
 801     pub OutputTensor: *const DML_TENSOR_DESC,
 802     pub ScaleBias: *const DML_SCALE_BIAS,
 803 }
 804 impl ::core::marker::Copy for DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {}
 805 impl ::core::clone::Clone for DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {
 806     fn clone(&self) -> Self {
 807         *self
 808     }
 809 }
 810 #[repr(C)]
 811 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 812 pub struct DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {
 813     pub ATensor: *const DML_TENSOR_DESC,
 814     pub BTensor: *const DML_TENSOR_DESC,
 815     pub OutputTensor: *const DML_TENSOR_DESC,
 816 }
 817 impl ::core::marker::Copy for DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {}
 818 impl ::core::clone::Clone for DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {
 819     fn clone(&self) -> Self {
 820         *self
 821     }
 822 }
 823 #[repr(C)]
 824 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 825 pub struct DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {
 826     pub ATensor: *const DML_TENSOR_DESC,
 827     pub BTensor: *const DML_TENSOR_DESC,
 828     pub OutputTensor: *const DML_TENSOR_DESC,
 829 }
 830 impl ::core::marker::Copy for DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {}
 831 impl ::core::clone::Clone for DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {
 832     fn clone(&self) -> Self {
 833         *self
 834     }
 835 }
 836 #[repr(C)]
 837 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 838 pub struct DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {
 839     pub InputTensor: *const DML_TENSOR_DESC,
 840     pub OutputTensor: *const DML_TENSOR_DESC,
 841 }
 842 impl ::core::marker::Copy for DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {}
 843 impl ::core::clone::Clone for DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {
 844     fn clone(&self) -> Self {
 845         *self
 846     }
 847 }
 848 #[repr(C)]
 849 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 850 pub struct DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {
 851     pub InputTensor: *const DML_TENSOR_DESC,
 852     pub OutputTensor: *const DML_TENSOR_DESC,
 853 }
 854 impl ::core::marker::Copy for DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {}
 855 impl ::core::clone::Clone for DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {
 856     fn clone(&self) -> Self {
 857         *self
 858     }
 859 }
 860 #[repr(C)]
 861 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 862 pub struct DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {
 863     pub ATensor: *const DML_TENSOR_DESC,
 864     pub BTensor: *const DML_TENSOR_DESC,
 865     pub OutputTensor: *const DML_TENSOR_DESC,
 866 }
 867 impl ::core::marker::Copy for DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {}
 868 impl ::core::clone::Clone for DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {
 869     fn clone(&self) -> Self {
 870         *self
 871     }
 872 }
 873 #[repr(C)]
 874 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 875 pub struct DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {
 876     pub ATensor: *const DML_TENSOR_DESC,
 877     pub BTensor: *const DML_TENSOR_DESC,
 878     pub OutputTensor: *const DML_TENSOR_DESC,
 879 }
 880 impl ::core::marker::Copy for DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {}
 881 impl ::core::clone::Clone for DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {
 882     fn clone(&self) -> Self {
 883         *self
 884     }
 885 }
 886 #[repr(C)]
 887 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 888 pub struct DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {
 889     pub ATensor: *const DML_TENSOR_DESC,
 890     pub BTensor: *const DML_TENSOR_DESC,
 891     pub OutputTensor: *const DML_TENSOR_DESC,
 892 }
 893 impl ::core::marker::Copy for DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {}
 894 impl ::core::clone::Clone for DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {
 895     fn clone(&self) -> Self {
 896         *self
 897     }
 898 }
 899 #[repr(C)]
 900 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 901 pub struct DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {
 902     pub ATensor: *const DML_TENSOR_DESC,
 903     pub BTensor: *const DML_TENSOR_DESC,
 904     pub OutputTensor: *const DML_TENSOR_DESC,
 905 }
 906 impl ::core::marker::Copy for DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {}
 907 impl ::core::clone::Clone for DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {
 908     fn clone(&self) -> Self {
 909         *self
 910     }
 911 }
 912 #[repr(C)]
 913 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 914 pub struct DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {
 915     pub InputTensor: *const DML_TENSOR_DESC,
 916     pub OutputTensor: *const DML_TENSOR_DESC,
 917     pub ScaleBias: *const DML_SCALE_BIAS,
 918 }
 919 impl ::core::marker::Copy for DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {}
 920 impl ::core::clone::Clone for DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {
 921     fn clone(&self) -> Self {
 922         *self
 923     }
 924 }
 925 #[repr(C)]
 926 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 927 pub struct DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {
 928     pub InputTensor: *const DML_TENSOR_DESC,
 929     pub InputGradientTensor: *const DML_TENSOR_DESC,
 930     pub OutputGradientTensor: *const DML_TENSOR_DESC,
 931     pub Min: f32,
 932     pub Max: f32,
 933 }
 934 impl ::core::marker::Copy for DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {}
 935 impl ::core::clone::Clone for DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {
 936     fn clone(&self) -> Self {
 937         *self
 938     }
 939 }
 940 #[repr(C)]
 941 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 942 pub struct DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {
 943     pub InputTensor: *const DML_TENSOR_DESC,
 944     pub OutputTensor: *const DML_TENSOR_DESC,
 945     pub ScaleBias: *const DML_SCALE_BIAS,
 946     pub Min: f32,
 947     pub Max: f32,
 948 }
 949 impl ::core::marker::Copy for DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {}
 950 impl ::core::clone::Clone for DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {
 951     fn clone(&self) -> Self {
 952         *self
 953     }
 954 }
 955 #[repr(C)]
 956 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 957 pub struct DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {
 958     pub InputTensor: *const DML_TENSOR_DESC,
 959     pub OutputTensor: *const DML_TENSOR_DESC,
 960     pub ScaleBias: *const DML_SCALE_BIAS,
 961     pub Exponent: f32,
 962 }
 963 impl ::core::marker::Copy for DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {}
 964 impl ::core::clone::Clone for DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {
 965     fn clone(&self) -> Self {
 966         *self
 967     }
 968 }
 969 #[repr(C)]
 970 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 971 pub struct DML_ELEMENT_WISE_COSH_OPERATOR_DESC {
 972     pub InputTensor: *const DML_TENSOR_DESC,
 973     pub OutputTensor: *const DML_TENSOR_DESC,
 974     pub ScaleBias: *const DML_SCALE_BIAS,
 975 }
 976 impl ::core::marker::Copy for DML_ELEMENT_WISE_COSH_OPERATOR_DESC {}
 977 impl ::core::clone::Clone for DML_ELEMENT_WISE_COSH_OPERATOR_DESC {
 978     fn clone(&self) -> Self {
 979         *self
 980     }
 981 }
 982 #[repr(C)]
 983 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 984 pub struct DML_ELEMENT_WISE_COS_OPERATOR_DESC {
 985     pub InputTensor: *const DML_TENSOR_DESC,
 986     pub OutputTensor: *const DML_TENSOR_DESC,
 987     pub ScaleBias: *const DML_SCALE_BIAS,
 988 }
 989 impl ::core::marker::Copy for DML_ELEMENT_WISE_COS_OPERATOR_DESC {}
 990 impl ::core::clone::Clone for DML_ELEMENT_WISE_COS_OPERATOR_DESC {
 991     fn clone(&self) -> Self {
 992         *self
 993     }
 994 }
 995 #[repr(C)]
 996 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
 997 pub struct DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {
 998     pub InputTensor: *const DML_TENSOR_DESC,
 999     pub ScaleTensor: *const DML_TENSOR_DESC,
1000     pub ZeroPointTensor: *const DML_TENSOR_DESC,
1001     pub OutputTensor: *const DML_TENSOR_DESC,
1002 }
1003 impl ::core::marker::Copy for DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {}
1004 impl ::core::clone::Clone for DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {
1005     fn clone(&self) -> Self {
1006         *self
1007     }
1008 }
1009 #[repr(C)]
1010 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1011 pub struct DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {
1012     pub ATensor: *const DML_TENSOR_DESC,
1013     pub BTensor: *const DML_TENSOR_DESC,
1014     pub OutputTensor: *const DML_TENSOR_DESC,
1015 }
1016 impl ::core::marker::Copy for DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {}
1017 impl ::core::clone::Clone for DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {
1018     fn clone(&self) -> Self {
1019         *self
1020     }
1021 }
1022 #[repr(C)]
1023 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1024 pub struct DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {
1025     pub ATensor: *const DML_TENSOR_DESC,
1026     pub BTensor: *const DML_TENSOR_DESC,
1027     pub OutputTensor: *const DML_TENSOR_DESC,
1028 }
1029 impl ::core::marker::Copy for DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {}
1030 impl ::core::clone::Clone for DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {
1031     fn clone(&self) -> Self {
1032         *self
1033     }
1034 }
1035 #[repr(C)]
1036 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1037 pub struct DML_ELEMENT_WISE_ERF_OPERATOR_DESC {
1038     pub InputTensor: *const DML_TENSOR_DESC,
1039     pub OutputTensor: *const DML_TENSOR_DESC,
1040     pub ScaleBias: *const DML_SCALE_BIAS,
1041 }
1042 impl ::core::marker::Copy for DML_ELEMENT_WISE_ERF_OPERATOR_DESC {}
1043 impl ::core::clone::Clone for DML_ELEMENT_WISE_ERF_OPERATOR_DESC {
1044     fn clone(&self) -> Self {
1045         *self
1046     }
1047 }
1048 #[repr(C)]
1049 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1050 pub struct DML_ELEMENT_WISE_EXP_OPERATOR_DESC {
1051     pub InputTensor: *const DML_TENSOR_DESC,
1052     pub OutputTensor: *const DML_TENSOR_DESC,
1053     pub ScaleBias: *const DML_SCALE_BIAS,
1054 }
1055 impl ::core::marker::Copy for DML_ELEMENT_WISE_EXP_OPERATOR_DESC {}
1056 impl ::core::clone::Clone for DML_ELEMENT_WISE_EXP_OPERATOR_DESC {
1057     fn clone(&self) -> Self {
1058         *self
1059     }
1060 }
1061 #[repr(C)]
1062 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1063 pub struct DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {
1064     pub InputTensor: *const DML_TENSOR_DESC,
1065     pub OutputTensor: *const DML_TENSOR_DESC,
1066     pub ScaleBias: *const DML_SCALE_BIAS,
1067 }
1068 impl ::core::marker::Copy for DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {}
1069 impl ::core::clone::Clone for DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {
1070     fn clone(&self) -> Self {
1071         *self
1072     }
1073 }
1074 #[repr(C)]
1075 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1076 pub struct DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {
1077     pub InputTensor: *const DML_TENSOR_DESC,
1078     pub OutputTensor: *const DML_TENSOR_DESC,
1079     pub ScaleBias: *const DML_SCALE_BIAS,
1080 }
1081 impl ::core::marker::Copy for DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {}
1082 impl ::core::clone::Clone for DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {
1083     fn clone(&self) -> Self {
1084         *self
1085     }
1086 }
1087 #[repr(C)]
1088 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1089 pub struct DML_ELEMENT_WISE_IF_OPERATOR_DESC {
1090     pub ConditionTensor: *const DML_TENSOR_DESC,
1091     pub ATensor: *const DML_TENSOR_DESC,
1092     pub BTensor: *const DML_TENSOR_DESC,
1093     pub OutputTensor: *const DML_TENSOR_DESC,
1094 }
1095 impl ::core::marker::Copy for DML_ELEMENT_WISE_IF_OPERATOR_DESC {}
1096 impl ::core::clone::Clone for DML_ELEMENT_WISE_IF_OPERATOR_DESC {
1097     fn clone(&self) -> Self {
1098         *self
1099     }
1100 }
1101 #[repr(C)]
1102 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1103 pub struct DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {
1104     pub InputTensor: *const DML_TENSOR_DESC,
1105     pub OutputTensor: *const DML_TENSOR_DESC,
1106     pub InfinityMode: DML_IS_INFINITY_MODE,
1107 }
1108 impl ::core::marker::Copy for DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {}
1109 impl ::core::clone::Clone for DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {
1110     fn clone(&self) -> Self {
1111         *self
1112     }
1113 }
1114 #[repr(C)]
1115 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1116 pub struct DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {
1117     pub InputTensor: *const DML_TENSOR_DESC,
1118     pub OutputTensor: *const DML_TENSOR_DESC,
1119 }
1120 impl ::core::marker::Copy for DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {}
1121 impl ::core::clone::Clone for DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {
1122     fn clone(&self) -> Self {
1123         *self
1124     }
1125 }
1126 #[repr(C)]
1127 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1128 pub struct DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {
1129     pub ATensor: *const DML_TENSOR_DESC,
1130     pub BTensor: *const DML_TENSOR_DESC,
1131     pub OutputTensor: *const DML_TENSOR_DESC,
1132 }
1133 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {}
1134 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {
1135     fn clone(&self) -> Self {
1136         *self
1137     }
1138 }
1139 #[repr(C)]
1140 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1141 pub struct DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {
1142     pub ATensor: *const DML_TENSOR_DESC,
1143     pub BTensor: *const DML_TENSOR_DESC,
1144     pub OutputTensor: *const DML_TENSOR_DESC,
1145 }
1146 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {}
1147 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {
1148     fn clone(&self) -> Self {
1149         *self
1150     }
1151 }
1152 #[repr(C)]
1153 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1154 pub struct DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {
1155     pub ATensor: *const DML_TENSOR_DESC,
1156     pub BTensor: *const DML_TENSOR_DESC,
1157     pub OutputTensor: *const DML_TENSOR_DESC,
1158 }
1159 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {}
1160 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {
1161     fn clone(&self) -> Self {
1162         *self
1163     }
1164 }
1165 #[repr(C)]
1166 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1167 pub struct DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {
1168     pub ATensor: *const DML_TENSOR_DESC,
1169     pub BTensor: *const DML_TENSOR_DESC,
1170     pub OutputTensor: *const DML_TENSOR_DESC,
1171 }
1172 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {}
1173 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {
1174     fn clone(&self) -> Self {
1175         *self
1176     }
1177 }
1178 #[repr(C)]
1179 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1180 pub struct DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {
1181     pub ATensor: *const DML_TENSOR_DESC,
1182     pub BTensor: *const DML_TENSOR_DESC,
1183     pub OutputTensor: *const DML_TENSOR_DESC,
1184 }
1185 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {}
1186 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {
1187     fn clone(&self) -> Self {
1188         *self
1189     }
1190 }
1191 #[repr(C)]
1192 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1193 pub struct DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {
1194     pub ATensor: *const DML_TENSOR_DESC,
1195     pub BTensor: *const DML_TENSOR_DESC,
1196     pub OutputTensor: *const DML_TENSOR_DESC,
1197 }
1198 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {}
1199 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {
1200     fn clone(&self) -> Self {
1201         *self
1202     }
1203 }
1204 #[repr(C)]
1205 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1206 pub struct DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {
1207     pub InputTensor: *const DML_TENSOR_DESC,
1208     pub OutputTensor: *const DML_TENSOR_DESC,
1209 }
1210 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {}
1211 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {
1212     fn clone(&self) -> Self {
1213         *self
1214     }
1215 }
1216 #[repr(C)]
1217 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1218 pub struct DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {
1219     pub ATensor: *const DML_TENSOR_DESC,
1220     pub BTensor: *const DML_TENSOR_DESC,
1221     pub OutputTensor: *const DML_TENSOR_DESC,
1222 }
1223 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {}
1224 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {
1225     fn clone(&self) -> Self {
1226         *self
1227     }
1228 }
1229 #[repr(C)]
1230 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1231 pub struct DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {
1232     pub ATensor: *const DML_TENSOR_DESC,
1233     pub BTensor: *const DML_TENSOR_DESC,
1234     pub OutputTensor: *const DML_TENSOR_DESC,
1235 }
1236 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {}
1237 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {
1238     fn clone(&self) -> Self {
1239         *self
1240     }
1241 }
1242 #[repr(C)]
1243 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1244 pub struct DML_ELEMENT_WISE_LOG_OPERATOR_DESC {
1245     pub InputTensor: *const DML_TENSOR_DESC,
1246     pub OutputTensor: *const DML_TENSOR_DESC,
1247     pub ScaleBias: *const DML_SCALE_BIAS,
1248 }
1249 impl ::core::marker::Copy for DML_ELEMENT_WISE_LOG_OPERATOR_DESC {}
1250 impl ::core::clone::Clone for DML_ELEMENT_WISE_LOG_OPERATOR_DESC {
1251     fn clone(&self) -> Self {
1252         *self
1253     }
1254 }
1255 #[repr(C)]
1256 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1257 pub struct DML_ELEMENT_WISE_MAX_OPERATOR_DESC {
1258     pub ATensor: *const DML_TENSOR_DESC,
1259     pub BTensor: *const DML_TENSOR_DESC,
1260     pub OutputTensor: *const DML_TENSOR_DESC,
1261 }
1262 impl ::core::marker::Copy for DML_ELEMENT_WISE_MAX_OPERATOR_DESC {}
1263 impl ::core::clone::Clone for DML_ELEMENT_WISE_MAX_OPERATOR_DESC {
1264     fn clone(&self) -> Self {
1265         *self
1266     }
1267 }
1268 #[repr(C)]
1269 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1270 pub struct DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {
1271     pub ATensor: *const DML_TENSOR_DESC,
1272     pub BTensor: *const DML_TENSOR_DESC,
1273     pub OutputTensor: *const DML_TENSOR_DESC,
1274 }
1275 impl ::core::marker::Copy for DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {}
1276 impl ::core::clone::Clone for DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {
1277     fn clone(&self) -> Self {
1278         *self
1279     }
1280 }
1281 #[repr(C)]
1282 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1283 pub struct DML_ELEMENT_WISE_MIN_OPERATOR_DESC {
1284     pub ATensor: *const DML_TENSOR_DESC,
1285     pub BTensor: *const DML_TENSOR_DESC,
1286     pub OutputTensor: *const DML_TENSOR_DESC,
1287 }
1288 impl ::core::marker::Copy for DML_ELEMENT_WISE_MIN_OPERATOR_DESC {}
1289 impl ::core::clone::Clone for DML_ELEMENT_WISE_MIN_OPERATOR_DESC {
1290     fn clone(&self) -> Self {
1291         *self
1292     }
1293 }
1294 #[repr(C)]
1295 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1296 pub struct DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {
1297     pub ATensor: *const DML_TENSOR_DESC,
1298     pub BTensor: *const DML_TENSOR_DESC,
1299     pub OutputTensor: *const DML_TENSOR_DESC,
1300 }
1301 impl ::core::marker::Copy for DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {}
1302 impl ::core::clone::Clone for DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {
1303     fn clone(&self) -> Self {
1304         *self
1305     }
1306 }
1307 #[repr(C)]
1308 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1309 pub struct DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {
1310     pub ATensor: *const DML_TENSOR_DESC,
1311     pub BTensor: *const DML_TENSOR_DESC,
1312     pub OutputTensor: *const DML_TENSOR_DESC,
1313 }
1314 impl ::core::marker::Copy for DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {}
1315 impl ::core::clone::Clone for DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {
1316     fn clone(&self) -> Self {
1317         *self
1318     }
1319 }
1320 #[repr(C)]
1321 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1322 pub struct DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {
1323     pub ATensor: *const DML_TENSOR_DESC,
1324     pub BTensor: *const DML_TENSOR_DESC,
1325     pub OutputTensor: *const DML_TENSOR_DESC,
1326 }
1327 impl ::core::marker::Copy for DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {}
1328 impl ::core::clone::Clone for DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {
1329     fn clone(&self) -> Self {
1330         *self
1331     }
1332 }
1333 #[repr(C)]
1334 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1335 pub struct DML_ELEMENT_WISE_POW_OPERATOR_DESC {
1336     pub InputTensor: *const DML_TENSOR_DESC,
1337     pub ExponentTensor: *const DML_TENSOR_DESC,
1338     pub OutputTensor: *const DML_TENSOR_DESC,
1339     pub ScaleBias: *const DML_SCALE_BIAS,
1340 }
1341 impl ::core::marker::Copy for DML_ELEMENT_WISE_POW_OPERATOR_DESC {}
1342 impl ::core::clone::Clone for DML_ELEMENT_WISE_POW_OPERATOR_DESC {
1343     fn clone(&self) -> Self {
1344         *self
1345     }
1346 }
1347 #[repr(C)]
1348 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1349 pub struct DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {
1350     pub ATensor: *const DML_TENSOR_DESC,
1351     pub AScaleTensor: *const DML_TENSOR_DESC,
1352     pub AZeroPointTensor: *const DML_TENSOR_DESC,
1353     pub BTensor: *const DML_TENSOR_DESC,
1354     pub BScaleTensor: *const DML_TENSOR_DESC,
1355     pub BZeroPointTensor: *const DML_TENSOR_DESC,
1356     pub OutputScaleTensor: *const DML_TENSOR_DESC,
1357     pub OutputZeroPointTensor: *const DML_TENSOR_DESC,
1358     pub OutputTensor: *const DML_TENSOR_DESC,
1359 }
1360 impl ::core::marker::Copy for DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {}
1361 impl ::core::clone::Clone for DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {
1362     fn clone(&self) -> Self {
1363         *self
1364     }
1365 }
1366 #[repr(C)]
1367 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1368 pub struct DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {
1369     pub InputTensor: *const DML_TENSOR_DESC,
1370     pub ScaleTensor: *const DML_TENSOR_DESC,
1371     pub ZeroPointTensor: *const DML_TENSOR_DESC,
1372     pub OutputTensor: *const DML_TENSOR_DESC,
1373 }
1374 impl ::core::marker::Copy for DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {}
1375 impl ::core::clone::Clone for DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {
1376     fn clone(&self) -> Self {
1377         *self
1378     }
1379 }
1380 #[repr(C)]
1381 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1382 pub struct DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {
1383     pub InputTensor: *const DML_TENSOR_DESC,
1384     pub OutputTensor: *const DML_TENSOR_DESC,
1385     pub ScaleBias: *const DML_SCALE_BIAS,
1386 }
1387 impl ::core::marker::Copy for DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {}
1388 impl ::core::clone::Clone for DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {
1389     fn clone(&self) -> Self {
1390         *self
1391     }
1392 }
1393 #[repr(C)]
1394 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1395 pub struct DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {
1396     pub InputTensor: *const DML_TENSOR_DESC,
1397     pub OutputTensor: *const DML_TENSOR_DESC,
1398     pub RoundingMode: DML_ROUNDING_MODE,
1399 }
1400 impl ::core::marker::Copy for DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {}
1401 impl ::core::clone::Clone for DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {
1402     fn clone(&self) -> Self {
1403         *self
1404     }
1405 }
1406 #[repr(C)]
1407 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1408 pub struct DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {
1409     pub InputTensor: *const DML_TENSOR_DESC,
1410     pub OutputTensor: *const DML_TENSOR_DESC,
1411 }
1412 impl ::core::marker::Copy for DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {}
1413 impl ::core::clone::Clone for DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {
1414     fn clone(&self) -> Self {
1415         *self
1416     }
1417 }
1418 #[repr(C)]
1419 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1420 pub struct DML_ELEMENT_WISE_SINH_OPERATOR_DESC {
1421     pub InputTensor: *const DML_TENSOR_DESC,
1422     pub OutputTensor: *const DML_TENSOR_DESC,
1423     pub ScaleBias: *const DML_SCALE_BIAS,
1424 }
1425 impl ::core::marker::Copy for DML_ELEMENT_WISE_SINH_OPERATOR_DESC {}
1426 impl ::core::clone::Clone for DML_ELEMENT_WISE_SINH_OPERATOR_DESC {
1427     fn clone(&self) -> Self {
1428         *self
1429     }
1430 }
1431 #[repr(C)]
1432 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1433 pub struct DML_ELEMENT_WISE_SIN_OPERATOR_DESC {
1434     pub InputTensor: *const DML_TENSOR_DESC,
1435     pub OutputTensor: *const DML_TENSOR_DESC,
1436     pub ScaleBias: *const DML_SCALE_BIAS,
1437 }
1438 impl ::core::marker::Copy for DML_ELEMENT_WISE_SIN_OPERATOR_DESC {}
1439 impl ::core::clone::Clone for DML_ELEMENT_WISE_SIN_OPERATOR_DESC {
1440     fn clone(&self) -> Self {
1441         *self
1442     }
1443 }
1444 #[repr(C)]
1445 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1446 pub struct DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {
1447     pub InputTensor: *const DML_TENSOR_DESC,
1448     pub OutputTensor: *const DML_TENSOR_DESC,
1449     pub ScaleBias: *const DML_SCALE_BIAS,
1450 }
1451 impl ::core::marker::Copy for DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {}
1452 impl ::core::clone::Clone for DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {
1453     fn clone(&self) -> Self {
1454         *self
1455     }
1456 }
1457 #[repr(C)]
1458 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1459 pub struct DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {
1460     pub ATensor: *const DML_TENSOR_DESC,
1461     pub BTensor: *const DML_TENSOR_DESC,
1462     pub OutputTensor: *const DML_TENSOR_DESC,
1463 }
1464 impl ::core::marker::Copy for DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {}
1465 impl ::core::clone::Clone for DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {
1466     fn clone(&self) -> Self {
1467         *self
1468     }
1469 }
1470 #[repr(C)]
1471 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1472 pub struct DML_ELEMENT_WISE_TANH_OPERATOR_DESC {
1473     pub InputTensor: *const DML_TENSOR_DESC,
1474     pub OutputTensor: *const DML_TENSOR_DESC,
1475     pub ScaleBias: *const DML_SCALE_BIAS,
1476 }
1477 impl ::core::marker::Copy for DML_ELEMENT_WISE_TANH_OPERATOR_DESC {}
1478 impl ::core::clone::Clone for DML_ELEMENT_WISE_TANH_OPERATOR_DESC {
1479     fn clone(&self) -> Self {
1480         *self
1481     }
1482 }
1483 #[repr(C)]
1484 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1485 pub struct DML_ELEMENT_WISE_TAN_OPERATOR_DESC {
1486     pub InputTensor: *const DML_TENSOR_DESC,
1487     pub OutputTensor: *const DML_TENSOR_DESC,
1488     pub ScaleBias: *const DML_SCALE_BIAS,
1489 }
1490 impl ::core::marker::Copy for DML_ELEMENT_WISE_TAN_OPERATOR_DESC {}
1491 impl ::core::clone::Clone for DML_ELEMENT_WISE_TAN_OPERATOR_DESC {
1492     fn clone(&self) -> Self {
1493         *self
1494     }
1495 }
1496 #[repr(C)]
1497 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1498 pub struct DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {
1499     pub InputTensor: *const DML_TENSOR_DESC,
1500     pub OutputTensor: *const DML_TENSOR_DESC,
1501     pub ScaleBias: *const DML_SCALE_BIAS,
1502     pub Min: f32,
1503 }
1504 impl ::core::marker::Copy for DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {}
1505 impl ::core::clone::Clone for DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {
1506     fn clone(&self) -> Self {
1507         *self
1508     }
1509 }
1510 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1511 pub type DML_EXECUTION_FLAGS = u32;
1512 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1513 pub const DML_EXECUTION_FLAG_NONE: DML_EXECUTION_FLAGS = 0u32;
1514 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1515 pub const DML_EXECUTION_FLAG_ALLOW_HALF_PRECISION_COMPUTATION: DML_EXECUTION_FLAGS = 1u32;
1516 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1517 pub const DML_EXECUTION_FLAG_DISABLE_META_COMMANDS: DML_EXECUTION_FLAGS = 2u32;
1518 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1519 pub const DML_EXECUTION_FLAG_DESCRIPTORS_VOLATILE: DML_EXECUTION_FLAGS = 4u32;
1520 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1521 pub type DML_FEATURE = i32;
1522 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1523 pub const DML_FEATURE_TENSOR_DATA_TYPE_SUPPORT: DML_FEATURE = 0i32;
1524 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1525 pub const DML_FEATURE_FEATURE_LEVELS: DML_FEATURE = 1i32;
1526 #[repr(C)]
1527 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1528 pub struct DML_FEATURE_DATA_FEATURE_LEVELS {
1529     pub MaxSupportedFeatureLevel: DML_FEATURE_LEVEL,
1530 }
1531 impl ::core::marker::Copy for DML_FEATURE_DATA_FEATURE_LEVELS {}
1532 impl ::core::clone::Clone for DML_FEATURE_DATA_FEATURE_LEVELS {
1533     fn clone(&self) -> Self {
1534         *self
1535     }
1536 }
1537 #[repr(C)]
1538 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
1539 #[cfg(feature = "Win32_Foundation")]
1540 pub struct DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {
1541     pub IsSupported: super::super::super::Foundation::BOOL,
1542 }
1543 #[cfg(feature = "Win32_Foundation")]
1544 impl ::core::marker::Copy for DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {}
1545 #[cfg(feature = "Win32_Foundation")]
1546 impl ::core::clone::Clone for DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {
1547     fn clone(&self) -> Self {
1548         *self
1549     }
1550 }
1551 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1552 pub type DML_FEATURE_LEVEL = i32;
1553 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1554 pub const DML_FEATURE_LEVEL_1_0: DML_FEATURE_LEVEL = 4096i32;
1555 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1556 pub const DML_FEATURE_LEVEL_2_0: DML_FEATURE_LEVEL = 8192i32;
1557 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1558 pub const DML_FEATURE_LEVEL_2_1: DML_FEATURE_LEVEL = 8448i32;
1559 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1560 pub const DML_FEATURE_LEVEL_3_0: DML_FEATURE_LEVEL = 12288i32;
1561 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1562 pub const DML_FEATURE_LEVEL_3_1: DML_FEATURE_LEVEL = 12544i32;
1563 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1564 pub const DML_FEATURE_LEVEL_4_0: DML_FEATURE_LEVEL = 16384i32;
1565 #[repr(C)]
1566 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1567 pub struct DML_FEATURE_QUERY_FEATURE_LEVELS {
1568     pub RequestedFeatureLevelCount: u32,
1569     pub RequestedFeatureLevels: *const DML_FEATURE_LEVEL,
1570 }
1571 impl ::core::marker::Copy for DML_FEATURE_QUERY_FEATURE_LEVELS {}
1572 impl ::core::clone::Clone for DML_FEATURE_QUERY_FEATURE_LEVELS {
1573     fn clone(&self) -> Self {
1574         *self
1575     }
1576 }
1577 #[repr(C)]
1578 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1579 pub struct DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {
1580     pub DataType: DML_TENSOR_DATA_TYPE,
1581 }
1582 impl ::core::marker::Copy for DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {}
1583 impl ::core::clone::Clone for DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {
1584     fn clone(&self) -> Self {
1585         *self
1586     }
1587 }
1588 #[repr(C)]
1589 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1590 pub struct DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {
1591     pub OutputTensor: *const DML_TENSOR_DESC,
1592     pub ValueDataType: DML_TENSOR_DATA_TYPE,
1593     pub Value: DML_SCALAR_UNION,
1594 }
1595 impl ::core::marker::Copy for DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {}
1596 impl ::core::clone::Clone for DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {
1597     fn clone(&self) -> Self {
1598         *self
1599     }
1600 }
1601 #[repr(C)]
1602 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1603 pub struct DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {
1604     pub OutputTensor: *const DML_TENSOR_DESC,
1605     pub ValueDataType: DML_TENSOR_DATA_TYPE,
1606     pub ValueStart: DML_SCALAR_UNION,
1607     pub ValueDelta: DML_SCALAR_UNION,
1608 }
1609 impl ::core::marker::Copy for DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {}
1610 impl ::core::clone::Clone for DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {
1611     fn clone(&self) -> Self {
1612         *self
1613     }
1614 }
1615 #[repr(C)]
1616 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1617 pub struct DML_GATHER_ELEMENTS_OPERATOR_DESC {
1618     pub InputTensor: *const DML_TENSOR_DESC,
1619     pub IndicesTensor: *const DML_TENSOR_DESC,
1620     pub OutputTensor: *const DML_TENSOR_DESC,
1621     pub Axis: u32,
1622 }
1623 impl ::core::marker::Copy for DML_GATHER_ELEMENTS_OPERATOR_DESC {}
1624 impl ::core::clone::Clone for DML_GATHER_ELEMENTS_OPERATOR_DESC {
1625     fn clone(&self) -> Self {
1626         *self
1627     }
1628 }
1629 #[repr(C)]
1630 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1631 pub struct DML_GATHER_ND1_OPERATOR_DESC {
1632     pub InputTensor: *const DML_TENSOR_DESC,
1633     pub IndicesTensor: *const DML_TENSOR_DESC,
1634     pub OutputTensor: *const DML_TENSOR_DESC,
1635     pub InputDimensionCount: u32,
1636     pub IndicesDimensionCount: u32,
1637     pub BatchDimensionCount: u32,
1638 }
1639 impl ::core::marker::Copy for DML_GATHER_ND1_OPERATOR_DESC {}
1640 impl ::core::clone::Clone for DML_GATHER_ND1_OPERATOR_DESC {
1641     fn clone(&self) -> Self {
1642         *self
1643     }
1644 }
1645 #[repr(C)]
1646 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1647 pub struct DML_GATHER_ND_OPERATOR_DESC {
1648     pub InputTensor: *const DML_TENSOR_DESC,
1649     pub IndicesTensor: *const DML_TENSOR_DESC,
1650     pub OutputTensor: *const DML_TENSOR_DESC,
1651     pub InputDimensionCount: u32,
1652     pub IndicesDimensionCount: u32,
1653 }
1654 impl ::core::marker::Copy for DML_GATHER_ND_OPERATOR_DESC {}
1655 impl ::core::clone::Clone for DML_GATHER_ND_OPERATOR_DESC {
1656     fn clone(&self) -> Self {
1657         *self
1658     }
1659 }
1660 #[repr(C)]
1661 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1662 pub struct DML_GATHER_OPERATOR_DESC {
1663     pub InputTensor: *const DML_TENSOR_DESC,
1664     pub IndicesTensor: *const DML_TENSOR_DESC,
1665     pub OutputTensor: *const DML_TENSOR_DESC,
1666     pub Axis: u32,
1667     pub IndexDimensions: u32,
1668 }
1669 impl ::core::marker::Copy for DML_GATHER_OPERATOR_DESC {}
1670 impl ::core::clone::Clone for DML_GATHER_OPERATOR_DESC {
1671     fn clone(&self) -> Self {
1672         *self
1673     }
1674 }
1675 #[repr(C)]
1676 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1677 pub struct DML_GEMM_OPERATOR_DESC {
1678     pub ATensor: *const DML_TENSOR_DESC,
1679     pub BTensor: *const DML_TENSOR_DESC,
1680     pub CTensor: *const DML_TENSOR_DESC,
1681     pub OutputTensor: *const DML_TENSOR_DESC,
1682     pub TransA: DML_MATRIX_TRANSFORM,
1683     pub TransB: DML_MATRIX_TRANSFORM,
1684     pub Alpha: f32,
1685     pub Beta: f32,
1686     pub FusedActivation: *const DML_OPERATOR_DESC,
1687 }
1688 impl ::core::marker::Copy for DML_GEMM_OPERATOR_DESC {}
1689 impl ::core::clone::Clone for DML_GEMM_OPERATOR_DESC {
1690     fn clone(&self) -> Self {
1691         *self
1692     }
1693 }
1694 #[repr(C)]
1695 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1696 pub struct DML_GRAPH_DESC {
1697     pub InputCount: u32,
1698     pub OutputCount: u32,
1699     pub NodeCount: u32,
1700     pub Nodes: *const DML_GRAPH_NODE_DESC,
1701     pub InputEdgeCount: u32,
1702     pub InputEdges: *const DML_GRAPH_EDGE_DESC,
1703     pub OutputEdgeCount: u32,
1704     pub OutputEdges: *const DML_GRAPH_EDGE_DESC,
1705     pub IntermediateEdgeCount: u32,
1706     pub IntermediateEdges: *const DML_GRAPH_EDGE_DESC,
1707 }
1708 impl ::core::marker::Copy for DML_GRAPH_DESC {}
1709 impl ::core::clone::Clone for DML_GRAPH_DESC {
1710     fn clone(&self) -> Self {
1711         *self
1712     }
1713 }
1714 #[repr(C)]
1715 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1716 pub struct DML_GRAPH_EDGE_DESC {
1717     pub Type: DML_GRAPH_EDGE_TYPE,
1718     pub Desc: *const ::core::ffi::c_void,
1719 }
1720 impl ::core::marker::Copy for DML_GRAPH_EDGE_DESC {}
1721 impl ::core::clone::Clone for DML_GRAPH_EDGE_DESC {
1722     fn clone(&self) -> Self {
1723         *self
1724     }
1725 }
1726 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1727 pub type DML_GRAPH_EDGE_TYPE = i32;
1728 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1729 pub const DML_GRAPH_EDGE_TYPE_INVALID: DML_GRAPH_EDGE_TYPE = 0i32;
1730 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1731 pub const DML_GRAPH_EDGE_TYPE_INPUT: DML_GRAPH_EDGE_TYPE = 1i32;
1732 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1733 pub const DML_GRAPH_EDGE_TYPE_OUTPUT: DML_GRAPH_EDGE_TYPE = 2i32;
1734 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1735 pub const DML_GRAPH_EDGE_TYPE_INTERMEDIATE: DML_GRAPH_EDGE_TYPE = 3i32;
1736 #[repr(C)]
1737 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1738 pub struct DML_GRAPH_NODE_DESC {
1739     pub Type: DML_GRAPH_NODE_TYPE,
1740     pub Desc: *const ::core::ffi::c_void,
1741 }
1742 impl ::core::marker::Copy for DML_GRAPH_NODE_DESC {}
1743 impl ::core::clone::Clone for DML_GRAPH_NODE_DESC {
1744     fn clone(&self) -> Self {
1745         *self
1746     }
1747 }
1748 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1749 pub type DML_GRAPH_NODE_TYPE = i32;
1750 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1751 pub const DML_GRAPH_NODE_TYPE_INVALID: DML_GRAPH_NODE_TYPE = 0i32;
1752 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1753 pub const DML_GRAPH_NODE_TYPE_OPERATOR: DML_GRAPH_NODE_TYPE = 1i32;
1754 #[repr(C)]
1755 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
1756 #[cfg(feature = "Win32_Foundation")]
1757 pub struct DML_GRU_OPERATOR_DESC {
1758     pub InputTensor: *const DML_TENSOR_DESC,
1759     pub WeightTensor: *const DML_TENSOR_DESC,
1760     pub RecurrenceTensor: *const DML_TENSOR_DESC,
1761     pub BiasTensor: *const DML_TENSOR_DESC,
1762     pub HiddenInitTensor: *const DML_TENSOR_DESC,
1763     pub SequenceLengthsTensor: *const DML_TENSOR_DESC,
1764     pub OutputSequenceTensor: *const DML_TENSOR_DESC,
1765     pub OutputSingleTensor: *const DML_TENSOR_DESC,
1766     pub ActivationDescCount: u32,
1767     pub ActivationDescs: *const DML_OPERATOR_DESC,
1768     pub Direction: DML_RECURRENT_NETWORK_DIRECTION,
1769     pub LinearBeforeReset: super::super::super::Foundation::BOOL,
1770 }
1771 #[cfg(feature = "Win32_Foundation")]
1772 impl ::core::marker::Copy for DML_GRU_OPERATOR_DESC {}
1773 #[cfg(feature = "Win32_Foundation")]
1774 impl ::core::clone::Clone for DML_GRU_OPERATOR_DESC {
1775     fn clone(&self) -> Self {
1776         *self
1777     }
1778 }
1779 #[repr(C)]
1780 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1781 pub struct DML_INPUT_GRAPH_EDGE_DESC {
1782     pub GraphInputIndex: u32,
1783     pub ToNodeIndex: u32,
1784     pub ToNodeInputIndex: u32,
1785     pub Name: ::windows_sys::core::PCSTR,
1786 }
1787 impl ::core::marker::Copy for DML_INPUT_GRAPH_EDGE_DESC {}
1788 impl ::core::clone::Clone for DML_INPUT_GRAPH_EDGE_DESC {
1789     fn clone(&self) -> Self {
1790         *self
1791     }
1792 }
1793 #[repr(C)]
1794 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1795 pub struct DML_INTERMEDIATE_GRAPH_EDGE_DESC {
1796     pub FromNodeIndex: u32,
1797     pub FromNodeOutputIndex: u32,
1798     pub ToNodeIndex: u32,
1799     pub ToNodeInputIndex: u32,
1800     pub Name: ::windows_sys::core::PCSTR,
1801 }
1802 impl ::core::marker::Copy for DML_INTERMEDIATE_GRAPH_EDGE_DESC {}
1803 impl ::core::clone::Clone for DML_INTERMEDIATE_GRAPH_EDGE_DESC {
1804     fn clone(&self) -> Self {
1805         *self
1806     }
1807 }
1808 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1809 pub type DML_INTERPOLATION_MODE = i32;
1810 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1811 pub const DML_INTERPOLATION_MODE_NEAREST_NEIGHBOR: DML_INTERPOLATION_MODE = 0i32;
1812 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1813 pub const DML_INTERPOLATION_MODE_LINEAR: DML_INTERPOLATION_MODE = 1i32;
1814 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1815 pub type DML_IS_INFINITY_MODE = i32;
1816 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1817 pub const DML_IS_INFINITY_MODE_EITHER: DML_IS_INFINITY_MODE = 0i32;
1818 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1819 pub const DML_IS_INFINITY_MODE_POSITIVE: DML_IS_INFINITY_MODE = 1i32;
1820 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1821 pub const DML_IS_INFINITY_MODE_NEGATIVE: DML_IS_INFINITY_MODE = 2i32;
1822 #[repr(C)]
1823 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1824 pub struct DML_JOIN_OPERATOR_DESC {
1825     pub InputCount: u32,
1826     pub InputTensors: *const DML_TENSOR_DESC,
1827     pub OutputTensor: *const DML_TENSOR_DESC,
1828     pub Axis: u32,
1829 }
1830 impl ::core::marker::Copy for DML_JOIN_OPERATOR_DESC {}
1831 impl ::core::clone::Clone for DML_JOIN_OPERATOR_DESC {
1832     fn clone(&self) -> Self {
1833         *self
1834     }
1835 }
1836 #[repr(C)]
1837 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
1838 #[cfg(feature = "Win32_Foundation")]
1839 pub struct DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {
1840     pub InputTensor: *const DML_TENSOR_DESC,
1841     pub InputGradientTensor: *const DML_TENSOR_DESC,
1842     pub OutputGradientTensor: *const DML_TENSOR_DESC,
1843     pub CrossChannel: super::super::super::Foundation::BOOL,
1844     pub LocalSize: u32,
1845     pub Alpha: f32,
1846     pub Beta: f32,
1847     pub Bias: f32,
1848 }
1849 #[cfg(feature = "Win32_Foundation")]
1850 impl ::core::marker::Copy for DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {}
1851 #[cfg(feature = "Win32_Foundation")]
1852 impl ::core::clone::Clone for DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {
1853     fn clone(&self) -> Self {
1854         *self
1855     }
1856 }
1857 #[repr(C)]
1858 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
1859 #[cfg(feature = "Win32_Foundation")]
1860 pub struct DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {
1861     pub InputTensor: *const DML_TENSOR_DESC,
1862     pub OutputTensor: *const DML_TENSOR_DESC,
1863     pub CrossChannel: super::super::super::Foundation::BOOL,
1864     pub LocalSize: u32,
1865     pub Alpha: f32,
1866     pub Beta: f32,
1867     pub Bias: f32,
1868 }
1869 #[cfg(feature = "Win32_Foundation")]
1870 impl ::core::marker::Copy for DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {}
1871 #[cfg(feature = "Win32_Foundation")]
1872 impl ::core::clone::Clone for DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {
1873     fn clone(&self) -> Self {
1874         *self
1875     }
1876 }
1877 #[repr(C)]
1878 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1879 pub struct DML_LP_NORMALIZATION_OPERATOR_DESC {
1880     pub InputTensor: *const DML_TENSOR_DESC,
1881     pub OutputTensor: *const DML_TENSOR_DESC,
1882     pub Axis: u32,
1883     pub Epsilon: f32,
1884     pub P: u32,
1885 }
1886 impl ::core::marker::Copy for DML_LP_NORMALIZATION_OPERATOR_DESC {}
1887 impl ::core::clone::Clone for DML_LP_NORMALIZATION_OPERATOR_DESC {
1888     fn clone(&self) -> Self {
1889         *self
1890     }
1891 }
1892 #[repr(C)]
1893 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1894 pub struct DML_LP_POOLING_OPERATOR_DESC {
1895     pub InputTensor: *const DML_TENSOR_DESC,
1896     pub OutputTensor: *const DML_TENSOR_DESC,
1897     pub DimensionCount: u32,
1898     pub Strides: *const u32,
1899     pub WindowSize: *const u32,
1900     pub StartPadding: *const u32,
1901     pub EndPadding: *const u32,
1902     pub P: u32,
1903 }
1904 impl ::core::marker::Copy for DML_LP_POOLING_OPERATOR_DESC {}
1905 impl ::core::clone::Clone for DML_LP_POOLING_OPERATOR_DESC {
1906     fn clone(&self) -> Self {
1907         *self
1908     }
1909 }
1910 #[repr(C)]
1911 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
1912 #[cfg(feature = "Win32_Foundation")]
1913 pub struct DML_LSTM_OPERATOR_DESC {
1914     pub InputTensor: *const DML_TENSOR_DESC,
1915     pub WeightTensor: *const DML_TENSOR_DESC,
1916     pub RecurrenceTensor: *const DML_TENSOR_DESC,
1917     pub BiasTensor: *const DML_TENSOR_DESC,
1918     pub HiddenInitTensor: *const DML_TENSOR_DESC,
1919     pub CellMemInitTensor: *const DML_TENSOR_DESC,
1920     pub SequenceLengthsTensor: *const DML_TENSOR_DESC,
1921     pub PeepholeTensor: *const DML_TENSOR_DESC,
1922     pub OutputSequenceTensor: *const DML_TENSOR_DESC,
1923     pub OutputSingleTensor: *const DML_TENSOR_DESC,
1924     pub OutputCellSingleTensor: *const DML_TENSOR_DESC,
1925     pub ActivationDescCount: u32,
1926     pub ActivationDescs: *const DML_OPERATOR_DESC,
1927     pub Direction: DML_RECURRENT_NETWORK_DIRECTION,
1928     pub ClipThreshold: f32,
1929     pub UseClipThreshold: super::super::super::Foundation::BOOL,
1930     pub CoupleInputForget: super::super::super::Foundation::BOOL,
1931 }
1932 #[cfg(feature = "Win32_Foundation")]
1933 impl ::core::marker::Copy for DML_LSTM_OPERATOR_DESC {}
1934 #[cfg(feature = "Win32_Foundation")]
1935 impl ::core::clone::Clone for DML_LSTM_OPERATOR_DESC {
1936     fn clone(&self) -> Self {
1937         *self
1938     }
1939 }
1940 #[repr(C)]
1941 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1942 pub struct DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {
1943     pub ATensor: *const DML_TENSOR_DESC,
1944     pub AZeroPointTensor: *const DML_TENSOR_DESC,
1945     pub BTensor: *const DML_TENSOR_DESC,
1946     pub BZeroPointTensor: *const DML_TENSOR_DESC,
1947     pub OutputTensor: *const DML_TENSOR_DESC,
1948 }
1949 impl ::core::marker::Copy for DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {}
1950 impl ::core::clone::Clone for DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {
1951     fn clone(&self) -> Self {
1952         *self
1953     }
1954 }
1955 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1956 pub type DML_MATRIX_TRANSFORM = i32;
1957 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1958 pub const DML_MATRIX_TRANSFORM_NONE: DML_MATRIX_TRANSFORM = 0i32;
1959 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1960 pub const DML_MATRIX_TRANSFORM_TRANSPOSE: DML_MATRIX_TRANSFORM = 1i32;
1961 #[repr(C)]
1962 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1963 pub struct DML_MAX_POOLING1_OPERATOR_DESC {
1964     pub InputTensor: *const DML_TENSOR_DESC,
1965     pub OutputTensor: *const DML_TENSOR_DESC,
1966     pub OutputIndicesTensor: *const DML_TENSOR_DESC,
1967     pub DimensionCount: u32,
1968     pub Strides: *const u32,
1969     pub WindowSize: *const u32,
1970     pub StartPadding: *const u32,
1971     pub EndPadding: *const u32,
1972 }
1973 impl ::core::marker::Copy for DML_MAX_POOLING1_OPERATOR_DESC {}
1974 impl ::core::clone::Clone for DML_MAX_POOLING1_OPERATOR_DESC {
1975     fn clone(&self) -> Self {
1976         *self
1977     }
1978 }
1979 #[repr(C)]
1980 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
1981 pub struct DML_MAX_POOLING2_OPERATOR_DESC {
1982     pub InputTensor: *const DML_TENSOR_DESC,
1983     pub OutputTensor: *const DML_TENSOR_DESC,
1984     pub OutputIndicesTensor: *const DML_TENSOR_DESC,
1985     pub DimensionCount: u32,
1986     pub Strides: *const u32,
1987     pub WindowSize: *const u32,
1988     pub StartPadding: *const u32,
1989     pub EndPadding: *const u32,
1990     pub Dilations: *const u32,
1991 }
1992 impl ::core::marker::Copy for DML_MAX_POOLING2_OPERATOR_DESC {}
1993 impl ::core::clone::Clone for DML_MAX_POOLING2_OPERATOR_DESC {
1994     fn clone(&self) -> Self {
1995         *self
1996     }
1997 }
1998 #[repr(C)]
1999 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2000 pub struct DML_MAX_POOLING_GRAD_OPERATOR_DESC {
2001     pub InputTensor: *const DML_TENSOR_DESC,
2002     pub InputGradientTensor: *const DML_TENSOR_DESC,
2003     pub OutputGradientTensor: *const DML_TENSOR_DESC,
2004     pub DimensionCount: u32,
2005     pub Strides: *const u32,
2006     pub WindowSize: *const u32,
2007     pub StartPadding: *const u32,
2008     pub EndPadding: *const u32,
2009     pub Dilations: *const u32,
2010 }
2011 impl ::core::marker::Copy for DML_MAX_POOLING_GRAD_OPERATOR_DESC {}
2012 impl ::core::clone::Clone for DML_MAX_POOLING_GRAD_OPERATOR_DESC {
2013     fn clone(&self) -> Self {
2014         *self
2015     }
2016 }
2017 #[repr(C)]
2018 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2019 pub struct DML_MAX_POOLING_OPERATOR_DESC {
2020     pub InputTensor: *const DML_TENSOR_DESC,
2021     pub OutputTensor: *const DML_TENSOR_DESC,
2022     pub DimensionCount: u32,
2023     pub Strides: *const u32,
2024     pub WindowSize: *const u32,
2025     pub StartPadding: *const u32,
2026     pub EndPadding: *const u32,
2027 }
2028 impl ::core::marker::Copy for DML_MAX_POOLING_OPERATOR_DESC {}
2029 impl ::core::clone::Clone for DML_MAX_POOLING_OPERATOR_DESC {
2030     fn clone(&self) -> Self {
2031         *self
2032     }
2033 }
2034 #[repr(C)]
2035 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2036 pub struct DML_MAX_UNPOOLING_OPERATOR_DESC {
2037     pub InputTensor: *const DML_TENSOR_DESC,
2038     pub IndicesTensor: *const DML_TENSOR_DESC,
2039     pub OutputTensor: *const DML_TENSOR_DESC,
2040 }
2041 impl ::core::marker::Copy for DML_MAX_UNPOOLING_OPERATOR_DESC {}
2042 impl ::core::clone::Clone for DML_MAX_UNPOOLING_OPERATOR_DESC {
2043     fn clone(&self) -> Self {
2044         *self
2045     }
2046 }
2047 #[repr(C)]
2048 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
2049 #[cfg(feature = "Win32_Foundation")]
2050 pub struct DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {
2051     pub InputTensor: *const DML_TENSOR_DESC,
2052     pub ScaleTensor: *const DML_TENSOR_DESC,
2053     pub BiasTensor: *const DML_TENSOR_DESC,
2054     pub OutputTensor: *const DML_TENSOR_DESC,
2055     pub AxisCount: u32,
2056     pub Axes: *const u32,
2057     pub NormalizeVariance: super::super::super::Foundation::BOOL,
2058     pub Epsilon: f32,
2059     pub FusedActivation: *const DML_OPERATOR_DESC,
2060 }
2061 #[cfg(feature = "Win32_Foundation")]
2062 impl ::core::marker::Copy for DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {}
2063 #[cfg(feature = "Win32_Foundation")]
2064 impl ::core::clone::Clone for DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {
2065     fn clone(&self) -> Self {
2066         *self
2067     }
2068 }
2069 #[repr(C)]
2070 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
2071 #[cfg(feature = "Win32_Foundation")]
2072 pub struct DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {
2073     pub InputTensor: *const DML_TENSOR_DESC,
2074     pub ScaleTensor: *const DML_TENSOR_DESC,
2075     pub BiasTensor: *const DML_TENSOR_DESC,
2076     pub OutputTensor: *const DML_TENSOR_DESC,
2077     pub CrossChannel: super::super::super::Foundation::BOOL,
2078     pub NormalizeVariance: super::super::super::Foundation::BOOL,
2079     pub Epsilon: f32,
2080     pub FusedActivation: *const DML_OPERATOR_DESC,
2081 }
2082 #[cfg(feature = "Win32_Foundation")]
2083 impl ::core::marker::Copy for DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {}
2084 #[cfg(feature = "Win32_Foundation")]
2085 impl ::core::clone::Clone for DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {
2086     fn clone(&self) -> Self {
2087         *self
2088     }
2089 }
2090 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2091 pub const DML_MINIMUM_BUFFER_TENSOR_ALIGNMENT: u32 = 16u32;
2092 #[repr(C)]
2093 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2094 pub struct DML_NONZERO_COORDINATES_OPERATOR_DESC {
2095     pub InputTensor: *const DML_TENSOR_DESC,
2096     pub OutputCountTensor: *const DML_TENSOR_DESC,
2097     pub OutputCoordinatesTensor: *const DML_TENSOR_DESC,
2098 }
2099 impl ::core::marker::Copy for DML_NONZERO_COORDINATES_OPERATOR_DESC {}
2100 impl ::core::clone::Clone for DML_NONZERO_COORDINATES_OPERATOR_DESC {
2101     fn clone(&self) -> Self {
2102         *self
2103     }
2104 }
2105 #[repr(C)]
2106 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2107 pub struct DML_ONE_HOT_OPERATOR_DESC {
2108     pub IndicesTensor: *const DML_TENSOR_DESC,
2109     pub ValuesTensor: *const DML_TENSOR_DESC,
2110     pub OutputTensor: *const DML_TENSOR_DESC,
2111     pub Axis: u32,
2112 }
2113 impl ::core::marker::Copy for DML_ONE_HOT_OPERATOR_DESC {}
2114 impl ::core::clone::Clone for DML_ONE_HOT_OPERATOR_DESC {
2115     fn clone(&self) -> Self {
2116         *self
2117     }
2118 }
2119 #[repr(C)]
2120 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2121 pub struct DML_OPERATOR_DESC {
2122     pub Type: DML_OPERATOR_TYPE,
2123     pub Desc: *const ::core::ffi::c_void,
2124 }
2125 impl ::core::marker::Copy for DML_OPERATOR_DESC {}
2126 impl ::core::clone::Clone for DML_OPERATOR_DESC {
2127     fn clone(&self) -> Self {
2128         *self
2129     }
2130 }
2131 #[repr(C)]
2132 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2133 pub struct DML_OPERATOR_GRAPH_NODE_DESC {
2134     pub Operator: IDMLOperator,
2135     pub Name: ::windows_sys::core::PCSTR,
2136 }
2137 impl ::core::marker::Copy for DML_OPERATOR_GRAPH_NODE_DESC {}
2138 impl ::core::clone::Clone for DML_OPERATOR_GRAPH_NODE_DESC {
2139     fn clone(&self) -> Self {
2140         *self
2141     }
2142 }
2143 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2144 pub type DML_OPERATOR_TYPE = i32;
2145 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2146 pub const DML_OPERATOR_INVALID: DML_OPERATOR_TYPE = 0i32;
2147 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2148 pub const DML_OPERATOR_ELEMENT_WISE_IDENTITY: DML_OPERATOR_TYPE = 1i32;
2149 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2150 pub const DML_OPERATOR_ELEMENT_WISE_ABS: DML_OPERATOR_TYPE = 2i32;
2151 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2152 pub const DML_OPERATOR_ELEMENT_WISE_ACOS: DML_OPERATOR_TYPE = 3i32;
2153 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2154 pub const DML_OPERATOR_ELEMENT_WISE_ADD: DML_OPERATOR_TYPE = 4i32;
2155 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2156 pub const DML_OPERATOR_ELEMENT_WISE_ASIN: DML_OPERATOR_TYPE = 5i32;
2157 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2158 pub const DML_OPERATOR_ELEMENT_WISE_ATAN: DML_OPERATOR_TYPE = 6i32;
2159 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2160 pub const DML_OPERATOR_ELEMENT_WISE_CEIL: DML_OPERATOR_TYPE = 7i32;
2161 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2162 pub const DML_OPERATOR_ELEMENT_WISE_CLIP: DML_OPERATOR_TYPE = 8i32;
2163 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2164 pub const DML_OPERATOR_ELEMENT_WISE_COS: DML_OPERATOR_TYPE = 9i32;
2165 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2166 pub const DML_OPERATOR_ELEMENT_WISE_DIVIDE: DML_OPERATOR_TYPE = 10i32;
2167 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2168 pub const DML_OPERATOR_ELEMENT_WISE_EXP: DML_OPERATOR_TYPE = 11i32;
2169 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2170 pub const DML_OPERATOR_ELEMENT_WISE_FLOOR: DML_OPERATOR_TYPE = 12i32;
2171 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2172 pub const DML_OPERATOR_ELEMENT_WISE_LOG: DML_OPERATOR_TYPE = 13i32;
2173 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2174 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_AND: DML_OPERATOR_TYPE = 14i32;
2175 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2176 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_EQUALS: DML_OPERATOR_TYPE = 15i32;
2177 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2178 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_GREATER_THAN: DML_OPERATOR_TYPE = 16i32;
2179 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2180 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_LESS_THAN: DML_OPERATOR_TYPE = 17i32;
2181 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2182 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_NOT: DML_OPERATOR_TYPE = 18i32;
2183 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2184 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_OR: DML_OPERATOR_TYPE = 19i32;
2185 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2186 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_XOR: DML_OPERATOR_TYPE = 20i32;
2187 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2188 pub const DML_OPERATOR_ELEMENT_WISE_MAX: DML_OPERATOR_TYPE = 21i32;
2189 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2190 pub const DML_OPERATOR_ELEMENT_WISE_MEAN: DML_OPERATOR_TYPE = 22i32;
2191 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2192 pub const DML_OPERATOR_ELEMENT_WISE_MIN: DML_OPERATOR_TYPE = 23i32;
2193 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2194 pub const DML_OPERATOR_ELEMENT_WISE_MULTIPLY: DML_OPERATOR_TYPE = 24i32;
2195 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2196 pub const DML_OPERATOR_ELEMENT_WISE_POW: DML_OPERATOR_TYPE = 25i32;
2197 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2198 pub const DML_OPERATOR_ELEMENT_WISE_CONSTANT_POW: DML_OPERATOR_TYPE = 26i32;
2199 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2200 pub const DML_OPERATOR_ELEMENT_WISE_RECIP: DML_OPERATOR_TYPE = 27i32;
2201 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2202 pub const DML_OPERATOR_ELEMENT_WISE_SIN: DML_OPERATOR_TYPE = 28i32;
2203 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2204 pub const DML_OPERATOR_ELEMENT_WISE_SQRT: DML_OPERATOR_TYPE = 29i32;
2205 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2206 pub const DML_OPERATOR_ELEMENT_WISE_SUBTRACT: DML_OPERATOR_TYPE = 30i32;
2207 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2208 pub const DML_OPERATOR_ELEMENT_WISE_TAN: DML_OPERATOR_TYPE = 31i32;
2209 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2210 pub const DML_OPERATOR_ELEMENT_WISE_THRESHOLD: DML_OPERATOR_TYPE = 32i32;
2211 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2212 pub const DML_OPERATOR_ELEMENT_WISE_QUANTIZE_LINEAR: DML_OPERATOR_TYPE = 33i32;
2213 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2214 pub const DML_OPERATOR_ELEMENT_WISE_DEQUANTIZE_LINEAR: DML_OPERATOR_TYPE = 34i32;
2215 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2216 pub const DML_OPERATOR_ACTIVATION_ELU: DML_OPERATOR_TYPE = 35i32;
2217 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2218 pub const DML_OPERATOR_ACTIVATION_HARDMAX: DML_OPERATOR_TYPE = 36i32;
2219 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2220 pub const DML_OPERATOR_ACTIVATION_HARD_SIGMOID: DML_OPERATOR_TYPE = 37i32;
2221 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2222 pub const DML_OPERATOR_ACTIVATION_IDENTITY: DML_OPERATOR_TYPE = 38i32;
2223 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2224 pub const DML_OPERATOR_ACTIVATION_LEAKY_RELU: DML_OPERATOR_TYPE = 39i32;
2225 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2226 pub const DML_OPERATOR_ACTIVATION_LINEAR: DML_OPERATOR_TYPE = 40i32;
2227 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2228 pub const DML_OPERATOR_ACTIVATION_LOG_SOFTMAX: DML_OPERATOR_TYPE = 41i32;
2229 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2230 pub const DML_OPERATOR_ACTIVATION_PARAMETERIZED_RELU: DML_OPERATOR_TYPE = 42i32;
2231 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2232 pub const DML_OPERATOR_ACTIVATION_PARAMETRIC_SOFTPLUS: DML_OPERATOR_TYPE = 43i32;
2233 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2234 pub const DML_OPERATOR_ACTIVATION_RELU: DML_OPERATOR_TYPE = 44i32;
2235 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2236 pub const DML_OPERATOR_ACTIVATION_SCALED_ELU: DML_OPERATOR_TYPE = 45i32;
2237 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2238 pub const DML_OPERATOR_ACTIVATION_SCALED_TANH: DML_OPERATOR_TYPE = 46i32;
2239 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2240 pub const DML_OPERATOR_ACTIVATION_SIGMOID: DML_OPERATOR_TYPE = 47i32;
2241 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2242 pub const DML_OPERATOR_ACTIVATION_SOFTMAX: DML_OPERATOR_TYPE = 48i32;
2243 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2244 pub const DML_OPERATOR_ACTIVATION_SOFTPLUS: DML_OPERATOR_TYPE = 49i32;
2245 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2246 pub const DML_OPERATOR_ACTIVATION_SOFTSIGN: DML_OPERATOR_TYPE = 50i32;
2247 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2248 pub const DML_OPERATOR_ACTIVATION_TANH: DML_OPERATOR_TYPE = 51i32;
2249 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2250 pub const DML_OPERATOR_ACTIVATION_THRESHOLDED_RELU: DML_OPERATOR_TYPE = 52i32;
2251 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2252 pub const DML_OPERATOR_CONVOLUTION: DML_OPERATOR_TYPE = 53i32;
2253 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2254 pub const DML_OPERATOR_GEMM: DML_OPERATOR_TYPE = 54i32;
2255 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2256 pub const DML_OPERATOR_REDUCE: DML_OPERATOR_TYPE = 55i32;
2257 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2258 pub const DML_OPERATOR_AVERAGE_POOLING: DML_OPERATOR_TYPE = 56i32;
2259 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2260 pub const DML_OPERATOR_LP_POOLING: DML_OPERATOR_TYPE = 57i32;
2261 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2262 pub const DML_OPERATOR_MAX_POOLING: DML_OPERATOR_TYPE = 58i32;
2263 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2264 pub const DML_OPERATOR_ROI_POOLING: DML_OPERATOR_TYPE = 59i32;
2265 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2266 pub const DML_OPERATOR_SLICE: DML_OPERATOR_TYPE = 60i32;
2267 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2268 pub const DML_OPERATOR_CAST: DML_OPERATOR_TYPE = 61i32;
2269 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2270 pub const DML_OPERATOR_SPLIT: DML_OPERATOR_TYPE = 62i32;
2271 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2272 pub const DML_OPERATOR_JOIN: DML_OPERATOR_TYPE = 63i32;
2273 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2274 pub const DML_OPERATOR_PADDING: DML_OPERATOR_TYPE = 64i32;
2275 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2276 pub const DML_OPERATOR_VALUE_SCALE_2D: DML_OPERATOR_TYPE = 65i32;
2277 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2278 pub const DML_OPERATOR_UPSAMPLE_2D: DML_OPERATOR_TYPE = 66i32;
2279 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2280 pub const DML_OPERATOR_GATHER: DML_OPERATOR_TYPE = 67i32;
2281 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2282 pub const DML_OPERATOR_SPACE_TO_DEPTH: DML_OPERATOR_TYPE = 68i32;
2283 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2284 pub const DML_OPERATOR_DEPTH_TO_SPACE: DML_OPERATOR_TYPE = 69i32;
2285 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2286 pub const DML_OPERATOR_TILE: DML_OPERATOR_TYPE = 70i32;
2287 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2288 pub const DML_OPERATOR_TOP_K: DML_OPERATOR_TYPE = 71i32;
2289 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2290 pub const DML_OPERATOR_BATCH_NORMALIZATION: DML_OPERATOR_TYPE = 72i32;
2291 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2292 pub const DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION: DML_OPERATOR_TYPE = 73i32;
2293 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2294 pub const DML_OPERATOR_LOCAL_RESPONSE_NORMALIZATION: DML_OPERATOR_TYPE = 74i32;
2295 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2296 pub const DML_OPERATOR_LP_NORMALIZATION: DML_OPERATOR_TYPE = 75i32;
2297 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2298 pub const DML_OPERATOR_RNN: DML_OPERATOR_TYPE = 76i32;
2299 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2300 pub const DML_OPERATOR_LSTM: DML_OPERATOR_TYPE = 77i32;
2301 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2302 pub const DML_OPERATOR_GRU: DML_OPERATOR_TYPE = 78i32;
2303 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2304 pub const DML_OPERATOR_ELEMENT_WISE_SIGN: DML_OPERATOR_TYPE = 79i32;
2305 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2306 pub const DML_OPERATOR_ELEMENT_WISE_IS_NAN: DML_OPERATOR_TYPE = 80i32;
2307 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2308 pub const DML_OPERATOR_ELEMENT_WISE_ERF: DML_OPERATOR_TYPE = 81i32;
2309 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2310 pub const DML_OPERATOR_ELEMENT_WISE_SINH: DML_OPERATOR_TYPE = 82i32;
2311 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2312 pub const DML_OPERATOR_ELEMENT_WISE_COSH: DML_OPERATOR_TYPE = 83i32;
2313 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2314 pub const DML_OPERATOR_ELEMENT_WISE_TANH: DML_OPERATOR_TYPE = 84i32;
2315 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2316 pub const DML_OPERATOR_ELEMENT_WISE_ASINH: DML_OPERATOR_TYPE = 85i32;
2317 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2318 pub const DML_OPERATOR_ELEMENT_WISE_ACOSH: DML_OPERATOR_TYPE = 86i32;
2319 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2320 pub const DML_OPERATOR_ELEMENT_WISE_ATANH: DML_OPERATOR_TYPE = 87i32;
2321 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2322 pub const DML_OPERATOR_ELEMENT_WISE_IF: DML_OPERATOR_TYPE = 88i32;
2323 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2324 pub const DML_OPERATOR_ELEMENT_WISE_ADD1: DML_OPERATOR_TYPE = 89i32;
2325 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2326 pub const DML_OPERATOR_ACTIVATION_SHRINK: DML_OPERATOR_TYPE = 90i32;
2327 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2328 pub const DML_OPERATOR_MAX_POOLING1: DML_OPERATOR_TYPE = 91i32;
2329 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2330 pub const DML_OPERATOR_MAX_UNPOOLING: DML_OPERATOR_TYPE = 92i32;
2331 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2332 pub const DML_OPERATOR_DIAGONAL_MATRIX: DML_OPERATOR_TYPE = 93i32;
2333 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2334 pub const DML_OPERATOR_SCATTER_ELEMENTS: DML_OPERATOR_TYPE = 94i32;
2335 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2336 pub const DML_OPERATOR_SCATTER: DML_OPERATOR_TYPE = 94i32;
2337 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2338 pub const DML_OPERATOR_ONE_HOT: DML_OPERATOR_TYPE = 95i32;
2339 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2340 pub const DML_OPERATOR_RESAMPLE: DML_OPERATOR_TYPE = 96i32;
2341 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2342 pub const DML_OPERATOR_ELEMENT_WISE_BIT_SHIFT_LEFT: DML_OPERATOR_TYPE = 97i32;
2343 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2344 pub const DML_OPERATOR_ELEMENT_WISE_BIT_SHIFT_RIGHT: DML_OPERATOR_TYPE = 98i32;
2345 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2346 pub const DML_OPERATOR_ELEMENT_WISE_ROUND: DML_OPERATOR_TYPE = 99i32;
2347 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2348 pub const DML_OPERATOR_ELEMENT_WISE_IS_INFINITY: DML_OPERATOR_TYPE = 100i32;
2349 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2350 pub const DML_OPERATOR_ELEMENT_WISE_MODULUS_TRUNCATE: DML_OPERATOR_TYPE = 101i32;
2351 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2352 pub const DML_OPERATOR_ELEMENT_WISE_MODULUS_FLOOR: DML_OPERATOR_TYPE = 102i32;
2353 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2354 pub const DML_OPERATOR_FILL_VALUE_CONSTANT: DML_OPERATOR_TYPE = 103i32;
2355 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2356 pub const DML_OPERATOR_FILL_VALUE_SEQUENCE: DML_OPERATOR_TYPE = 104i32;
2357 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2358 pub const DML_OPERATOR_CUMULATIVE_SUMMATION: DML_OPERATOR_TYPE = 105i32;
2359 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2360 pub const DML_OPERATOR_REVERSE_SUBSEQUENCES: DML_OPERATOR_TYPE = 106i32;
2361 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2362 pub const DML_OPERATOR_GATHER_ELEMENTS: DML_OPERATOR_TYPE = 107i32;
2363 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2364 pub const DML_OPERATOR_GATHER_ND: DML_OPERATOR_TYPE = 108i32;
2365 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2366 pub const DML_OPERATOR_SCATTER_ND: DML_OPERATOR_TYPE = 109i32;
2367 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2368 pub const DML_OPERATOR_MAX_POOLING2: DML_OPERATOR_TYPE = 110i32;
2369 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2370 pub const DML_OPERATOR_SLICE1: DML_OPERATOR_TYPE = 111i32;
2371 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2372 pub const DML_OPERATOR_TOP_K1: DML_OPERATOR_TYPE = 112i32;
2373 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2374 pub const DML_OPERATOR_DEPTH_TO_SPACE1: DML_OPERATOR_TYPE = 113i32;
2375 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2376 pub const DML_OPERATOR_SPACE_TO_DEPTH1: DML_OPERATOR_TYPE = 114i32;
2377 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2378 pub const DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION1: DML_OPERATOR_TYPE = 115i32;
2379 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2380 pub const DML_OPERATOR_RESAMPLE1: DML_OPERATOR_TYPE = 116i32;
2381 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2382 pub const DML_OPERATOR_MATRIX_MULTIPLY_INTEGER: DML_OPERATOR_TYPE = 117i32;
2383 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2384 pub const DML_OPERATOR_QUANTIZED_LINEAR_MATRIX_MULTIPLY: DML_OPERATOR_TYPE = 118i32;
2385 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2386 pub const DML_OPERATOR_CONVOLUTION_INTEGER: DML_OPERATOR_TYPE = 119i32;
2387 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2388 pub const DML_OPERATOR_QUANTIZED_LINEAR_CONVOLUTION: DML_OPERATOR_TYPE = 120i32;
2389 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2390 pub const DML_OPERATOR_ELEMENT_WISE_BIT_AND: DML_OPERATOR_TYPE = 121i32;
2391 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2392 pub const DML_OPERATOR_ELEMENT_WISE_BIT_OR: DML_OPERATOR_TYPE = 122i32;
2393 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2394 pub const DML_OPERATOR_ELEMENT_WISE_BIT_XOR: DML_OPERATOR_TYPE = 123i32;
2395 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2396 pub const DML_OPERATOR_ELEMENT_WISE_BIT_NOT: DML_OPERATOR_TYPE = 124i32;
2397 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2398 pub const DML_OPERATOR_ELEMENT_WISE_BIT_COUNT: DML_OPERATOR_TYPE = 125i32;
2399 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2400 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL: DML_OPERATOR_TYPE = 126i32;
2401 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2402 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL: DML_OPERATOR_TYPE = 127i32;
2403 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2404 pub const DML_OPERATOR_ACTIVATION_CELU: DML_OPERATOR_TYPE = 128i32;
2405 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2406 pub const DML_OPERATOR_ACTIVATION_RELU_GRAD: DML_OPERATOR_TYPE = 129i32;
2407 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2408 pub const DML_OPERATOR_AVERAGE_POOLING_GRAD: DML_OPERATOR_TYPE = 130i32;
2409 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2410 pub const DML_OPERATOR_MAX_POOLING_GRAD: DML_OPERATOR_TYPE = 131i32;
2411 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2412 pub const DML_OPERATOR_RANDOM_GENERATOR: DML_OPERATOR_TYPE = 132i32;
2413 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2414 pub const DML_OPERATOR_NONZERO_COORDINATES: DML_OPERATOR_TYPE = 133i32;
2415 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2416 pub const DML_OPERATOR_RESAMPLE_GRAD: DML_OPERATOR_TYPE = 134i32;
2417 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2418 pub const DML_OPERATOR_SLICE_GRAD: DML_OPERATOR_TYPE = 135i32;
2419 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2420 pub const DML_OPERATOR_ADAM_OPTIMIZER: DML_OPERATOR_TYPE = 136i32;
2421 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2422 pub const DML_OPERATOR_ARGMIN: DML_OPERATOR_TYPE = 137i32;
2423 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2424 pub const DML_OPERATOR_ARGMAX: DML_OPERATOR_TYPE = 138i32;
2425 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2426 pub const DML_OPERATOR_ROI_ALIGN: DML_OPERATOR_TYPE = 139i32;
2427 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2428 pub const DML_OPERATOR_GATHER_ND1: DML_OPERATOR_TYPE = 140i32;
2429 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2430 pub const DML_OPERATOR_ELEMENT_WISE_ATAN_YX: DML_OPERATOR_TYPE = 141i32;
2431 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2432 pub const DML_OPERATOR_ELEMENT_WISE_CLIP_GRAD: DML_OPERATOR_TYPE = 142i32;
2433 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2434 pub const DML_OPERATOR_ELEMENT_WISE_DIFFERENCE_SQUARE: DML_OPERATOR_TYPE = 143i32;
2435 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2436 pub const DML_OPERATOR_LOCAL_RESPONSE_NORMALIZATION_GRAD: DML_OPERATOR_TYPE = 144i32;
2437 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2438 pub const DML_OPERATOR_CUMULATIVE_PRODUCT: DML_OPERATOR_TYPE = 145i32;
2439 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2440 pub const DML_OPERATOR_BATCH_NORMALIZATION_GRAD: DML_OPERATOR_TYPE = 146i32;
2441 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2442 pub const DML_OPERATOR_ELEMENT_WISE_QUANTIZED_LINEAR_ADD: DML_OPERATOR_TYPE = 147i32;
2443 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2444 pub const DML_OPERATOR_DYNAMIC_QUANTIZE_LINEAR: DML_OPERATOR_TYPE = 148i32;
2445 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2446 pub const DML_OPERATOR_ROI_ALIGN1: DML_OPERATOR_TYPE = 149i32;
2447 #[repr(C)]
2448 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2449 pub struct DML_OUTPUT_GRAPH_EDGE_DESC {
2450     pub FromNodeIndex: u32,
2451     pub FromNodeOutputIndex: u32,
2452     pub GraphOutputIndex: u32,
2453     pub Name: ::windows_sys::core::PCSTR,
2454 }
2455 impl ::core::marker::Copy for DML_OUTPUT_GRAPH_EDGE_DESC {}
2456 impl ::core::clone::Clone for DML_OUTPUT_GRAPH_EDGE_DESC {
2457     fn clone(&self) -> Self {
2458         *self
2459     }
2460 }
2461 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2462 pub type DML_PADDING_MODE = i32;
2463 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2464 pub const DML_PADDING_MODE_CONSTANT: DML_PADDING_MODE = 0i32;
2465 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2466 pub const DML_PADDING_MODE_EDGE: DML_PADDING_MODE = 1i32;
2467 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2468 pub const DML_PADDING_MODE_REFLECTION: DML_PADDING_MODE = 2i32;
2469 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2470 pub const DML_PADDING_MODE_SYMMETRIC: DML_PADDING_MODE = 3i32;
2471 #[repr(C)]
2472 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2473 pub struct DML_PADDING_OPERATOR_DESC {
2474     pub InputTensor: *const DML_TENSOR_DESC,
2475     pub OutputTensor: *const DML_TENSOR_DESC,
2476     pub PaddingMode: DML_PADDING_MODE,
2477     pub PaddingValue: f32,
2478     pub DimensionCount: u32,
2479     pub StartPadding: *const u32,
2480     pub EndPadding: *const u32,
2481 }
2482 impl ::core::marker::Copy for DML_PADDING_OPERATOR_DESC {}
2483 impl ::core::clone::Clone for DML_PADDING_OPERATOR_DESC {
2484     fn clone(&self) -> Self {
2485         *self
2486     }
2487 }
2488 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2489 pub const DML_PERSISTENT_BUFFER_ALIGNMENT: u32 = 256u32;
2490 #[repr(C)]
2491 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2492 pub struct DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {
2493     pub InputTensor: *const DML_TENSOR_DESC,
2494     pub InputScaleTensor: *const DML_TENSOR_DESC,
2495     pub InputZeroPointTensor: *const DML_TENSOR_DESC,
2496     pub FilterTensor: *const DML_TENSOR_DESC,
2497     pub FilterScaleTensor: *const DML_TENSOR_DESC,
2498     pub FilterZeroPointTensor: *const DML_TENSOR_DESC,
2499     pub BiasTensor: *const DML_TENSOR_DESC,
2500     pub OutputScaleTensor: *const DML_TENSOR_DESC,
2501     pub OutputZeroPointTensor: *const DML_TENSOR_DESC,
2502     pub OutputTensor: *const DML_TENSOR_DESC,
2503     pub DimensionCount: u32,
2504     pub Strides: *const u32,
2505     pub Dilations: *const u32,
2506     pub StartPadding: *const u32,
2507     pub EndPadding: *const u32,
2508     pub GroupCount: u32,
2509 }
2510 impl ::core::marker::Copy for DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {}
2511 impl ::core::clone::Clone for DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {
2512     fn clone(&self) -> Self {
2513         *self
2514     }
2515 }
2516 #[repr(C)]
2517 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2518 pub struct DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {
2519     pub ATensor: *const DML_TENSOR_DESC,
2520     pub AScaleTensor: *const DML_TENSOR_DESC,
2521     pub AZeroPointTensor: *const DML_TENSOR_DESC,
2522     pub BTensor: *const DML_TENSOR_DESC,
2523     pub BScaleTensor: *const DML_TENSOR_DESC,
2524     pub BZeroPointTensor: *const DML_TENSOR_DESC,
2525     pub OutputScaleTensor: *const DML_TENSOR_DESC,
2526     pub OutputZeroPointTensor: *const DML_TENSOR_DESC,
2527     pub OutputTensor: *const DML_TENSOR_DESC,
2528 }
2529 impl ::core::marker::Copy for DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {}
2530 impl ::core::clone::Clone for DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {
2531     fn clone(&self) -> Self {
2532         *self
2533     }
2534 }
2535 #[repr(C)]
2536 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2537 pub struct DML_RANDOM_GENERATOR_OPERATOR_DESC {
2538     pub InputStateTensor: *const DML_TENSOR_DESC,
2539     pub OutputTensor: *const DML_TENSOR_DESC,
2540     pub OutputStateTensor: *const DML_TENSOR_DESC,
2541     pub Type: DML_RANDOM_GENERATOR_TYPE,
2542 }
2543 impl ::core::marker::Copy for DML_RANDOM_GENERATOR_OPERATOR_DESC {}
2544 impl ::core::clone::Clone for DML_RANDOM_GENERATOR_OPERATOR_DESC {
2545     fn clone(&self) -> Self {
2546         *self
2547     }
2548 }
2549 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2550 pub type DML_RANDOM_GENERATOR_TYPE = i32;
2551 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2552 pub const DML_RANDOM_GENERATOR_TYPE_PHILOX_4X32_10: DML_RANDOM_GENERATOR_TYPE = 0i32;
2553 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2554 pub type DML_RECURRENT_NETWORK_DIRECTION = i32;
2555 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2556 pub const DML_RECURRENT_NETWORK_DIRECTION_FORWARD: DML_RECURRENT_NETWORK_DIRECTION = 0i32;
2557 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2558 pub const DML_RECURRENT_NETWORK_DIRECTION_BACKWARD: DML_RECURRENT_NETWORK_DIRECTION = 1i32;
2559 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2560 pub const DML_RECURRENT_NETWORK_DIRECTION_BIDIRECTIONAL: DML_RECURRENT_NETWORK_DIRECTION = 2i32;
2561 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2562 pub type DML_REDUCE_FUNCTION = i32;
2563 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2564 pub const DML_REDUCE_FUNCTION_ARGMAX: DML_REDUCE_FUNCTION = 0i32;
2565 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2566 pub const DML_REDUCE_FUNCTION_ARGMIN: DML_REDUCE_FUNCTION = 1i32;
2567 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2568 pub const DML_REDUCE_FUNCTION_AVERAGE: DML_REDUCE_FUNCTION = 2i32;
2569 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2570 pub const DML_REDUCE_FUNCTION_L1: DML_REDUCE_FUNCTION = 3i32;
2571 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2572 pub const DML_REDUCE_FUNCTION_L2: DML_REDUCE_FUNCTION = 4i32;
2573 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2574 pub const DML_REDUCE_FUNCTION_LOG_SUM: DML_REDUCE_FUNCTION = 5i32;
2575 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2576 pub const DML_REDUCE_FUNCTION_LOG_SUM_EXP: DML_REDUCE_FUNCTION = 6i32;
2577 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2578 pub const DML_REDUCE_FUNCTION_MAX: DML_REDUCE_FUNCTION = 7i32;
2579 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2580 pub const DML_REDUCE_FUNCTION_MIN: DML_REDUCE_FUNCTION = 8i32;
2581 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2582 pub const DML_REDUCE_FUNCTION_MULTIPLY: DML_REDUCE_FUNCTION = 9i32;
2583 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2584 pub const DML_REDUCE_FUNCTION_SUM: DML_REDUCE_FUNCTION = 10i32;
2585 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2586 pub const DML_REDUCE_FUNCTION_SUM_SQUARE: DML_REDUCE_FUNCTION = 11i32;
2587 #[repr(C)]
2588 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2589 pub struct DML_REDUCE_OPERATOR_DESC {
2590     pub Function: DML_REDUCE_FUNCTION,
2591     pub InputTensor: *const DML_TENSOR_DESC,
2592     pub OutputTensor: *const DML_TENSOR_DESC,
2593     pub AxisCount: u32,
2594     pub Axes: *const u32,
2595 }
2596 impl ::core::marker::Copy for DML_REDUCE_OPERATOR_DESC {}
2597 impl ::core::clone::Clone for DML_REDUCE_OPERATOR_DESC {
2598     fn clone(&self) -> Self {
2599         *self
2600     }
2601 }
2602 #[repr(C)]
2603 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2604 pub struct DML_RESAMPLE1_OPERATOR_DESC {
2605     pub InputTensor: *const DML_TENSOR_DESC,
2606     pub OutputTensor: *const DML_TENSOR_DESC,
2607     pub InterpolationMode: DML_INTERPOLATION_MODE,
2608     pub DimensionCount: u32,
2609     pub Scales: *const f32,
2610     pub InputPixelOffsets: *const f32,
2611     pub OutputPixelOffsets: *const f32,
2612 }
2613 impl ::core::marker::Copy for DML_RESAMPLE1_OPERATOR_DESC {}
2614 impl ::core::clone::Clone for DML_RESAMPLE1_OPERATOR_DESC {
2615     fn clone(&self) -> Self {
2616         *self
2617     }
2618 }
2619 #[repr(C)]
2620 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2621 pub struct DML_RESAMPLE_GRAD_OPERATOR_DESC {
2622     pub InputGradientTensor: *const DML_TENSOR_DESC,
2623     pub OutputGradientTensor: *const DML_TENSOR_DESC,
2624     pub InterpolationMode: DML_INTERPOLATION_MODE,
2625     pub DimensionCount: u32,
2626     pub Scales: *const f32,
2627     pub InputPixelOffsets: *const f32,
2628     pub OutputPixelOffsets: *const f32,
2629 }
2630 impl ::core::marker::Copy for DML_RESAMPLE_GRAD_OPERATOR_DESC {}
2631 impl ::core::clone::Clone for DML_RESAMPLE_GRAD_OPERATOR_DESC {
2632     fn clone(&self) -> Self {
2633         *self
2634     }
2635 }
2636 #[repr(C)]
2637 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2638 pub struct DML_RESAMPLE_OPERATOR_DESC {
2639     pub InputTensor: *const DML_TENSOR_DESC,
2640     pub OutputTensor: *const DML_TENSOR_DESC,
2641     pub InterpolationMode: DML_INTERPOLATION_MODE,
2642     pub ScaleCount: u32,
2643     pub Scales: *const f32,
2644 }
2645 impl ::core::marker::Copy for DML_RESAMPLE_OPERATOR_DESC {}
2646 impl ::core::clone::Clone for DML_RESAMPLE_OPERATOR_DESC {
2647     fn clone(&self) -> Self {
2648         *self
2649     }
2650 }
2651 #[repr(C)]
2652 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2653 pub struct DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {
2654     pub InputTensor: *const DML_TENSOR_DESC,
2655     pub SequenceLengthsTensor: *const DML_TENSOR_DESC,
2656     pub OutputTensor: *const DML_TENSOR_DESC,
2657     pub Axis: u32,
2658 }
2659 impl ::core::marker::Copy for DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {}
2660 impl ::core::clone::Clone for DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {
2661     fn clone(&self) -> Self {
2662         *self
2663     }
2664 }
2665 #[repr(C)]
2666 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2667 pub struct DML_RNN_OPERATOR_DESC {
2668     pub InputTensor: *const DML_TENSOR_DESC,
2669     pub WeightTensor: *const DML_TENSOR_DESC,
2670     pub RecurrenceTensor: *const DML_TENSOR_DESC,
2671     pub BiasTensor: *const DML_TENSOR_DESC,
2672     pub HiddenInitTensor: *const DML_TENSOR_DESC,
2673     pub SequenceLengthsTensor: *const DML_TENSOR_DESC,
2674     pub OutputSequenceTensor: *const DML_TENSOR_DESC,
2675     pub OutputSingleTensor: *const DML_TENSOR_DESC,
2676     pub ActivationDescCount: u32,
2677     pub ActivationDescs: *const DML_OPERATOR_DESC,
2678     pub Direction: DML_RECURRENT_NETWORK_DIRECTION,
2679 }
2680 impl ::core::marker::Copy for DML_RNN_OPERATOR_DESC {}
2681 impl ::core::clone::Clone for DML_RNN_OPERATOR_DESC {
2682     fn clone(&self) -> Self {
2683         *self
2684     }
2685 }
2686 #[repr(C)]
2687 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`, `\"Win32_Foundation\"`*"]
2688 #[cfg(feature = "Win32_Foundation")]
2689 pub struct DML_ROI_ALIGN1_OPERATOR_DESC {
2690     pub InputTensor: *const DML_TENSOR_DESC,
2691     pub ROITensor: *const DML_TENSOR_DESC,
2692     pub BatchIndicesTensor: *const DML_TENSOR_DESC,
2693     pub OutputTensor: *const DML_TENSOR_DESC,
2694     pub ReductionFunction: DML_REDUCE_FUNCTION,
2695     pub InterpolationMode: DML_INTERPOLATION_MODE,
2696     pub SpatialScaleX: f32,
2697     pub SpatialScaleY: f32,
2698     pub InputPixelOffset: f32,
2699     pub OutputPixelOffset: f32,
2700     pub OutOfBoundsInputValue: f32,
2701     pub MinimumSamplesPerOutput: u32,
2702     pub MaximumSamplesPerOutput: u32,
2703     pub AlignRegionsToCorners: super::super::super::Foundation::BOOL,
2704 }
2705 #[cfg(feature = "Win32_Foundation")]
2706 impl ::core::marker::Copy for DML_ROI_ALIGN1_OPERATOR_DESC {}
2707 #[cfg(feature = "Win32_Foundation")]
2708 impl ::core::clone::Clone for DML_ROI_ALIGN1_OPERATOR_DESC {
2709     fn clone(&self) -> Self {
2710         *self
2711     }
2712 }
2713 #[repr(C)]
2714 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2715 pub struct DML_ROI_ALIGN_OPERATOR_DESC {
2716     pub InputTensor: *const DML_TENSOR_DESC,
2717     pub ROITensor: *const DML_TENSOR_DESC,
2718     pub BatchIndicesTensor: *const DML_TENSOR_DESC,
2719     pub OutputTensor: *const DML_TENSOR_DESC,
2720     pub ReductionFunction: DML_REDUCE_FUNCTION,
2721     pub InterpolationMode: DML_INTERPOLATION_MODE,
2722     pub SpatialScaleX: f32,
2723     pub SpatialScaleY: f32,
2724     pub OutOfBoundsInputValue: f32,
2725     pub MinimumSamplesPerOutput: u32,
2726     pub MaximumSamplesPerOutput: u32,
2727 }
2728 impl ::core::marker::Copy for DML_ROI_ALIGN_OPERATOR_DESC {}
2729 impl ::core::clone::Clone for DML_ROI_ALIGN_OPERATOR_DESC {
2730     fn clone(&self) -> Self {
2731         *self
2732     }
2733 }
2734 #[repr(C)]
2735 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2736 pub struct DML_ROI_POOLING_OPERATOR_DESC {
2737     pub InputTensor: *const DML_TENSOR_DESC,
2738     pub ROITensor: *const DML_TENSOR_DESC,
2739     pub OutputTensor: *const DML_TENSOR_DESC,
2740     pub SpatialScale: f32,
2741     pub PooledSize: DML_SIZE_2D,
2742 }
2743 impl ::core::marker::Copy for DML_ROI_POOLING_OPERATOR_DESC {}
2744 impl ::core::clone::Clone for DML_ROI_POOLING_OPERATOR_DESC {
2745     fn clone(&self) -> Self {
2746         *self
2747     }
2748 }
2749 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2750 pub type DML_ROUNDING_MODE = i32;
2751 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2752 pub const DML_ROUNDING_MODE_HALVES_TO_NEAREST_EVEN: DML_ROUNDING_MODE = 0i32;
2753 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2754 pub const DML_ROUNDING_MODE_TOWARD_ZERO: DML_ROUNDING_MODE = 1i32;
2755 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2756 pub const DML_ROUNDING_MODE_TOWARD_INFINITY: DML_ROUNDING_MODE = 2i32;
2757 #[repr(C)]
2758 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2759 pub union DML_SCALAR_UNION {
2760     pub Bytes: [u8; 8],
2761     pub Int8: i8,
2762     pub UInt8: u8,
2763     pub Int16: i16,
2764     pub UInt16: u16,
2765     pub Int32: i32,
2766     pub UInt32: u32,
2767     pub Int64: i64,
2768     pub UInt64: u64,
2769     pub Float32: f32,
2770     pub Float64: f64,
2771 }
2772 impl ::core::marker::Copy for DML_SCALAR_UNION {}
2773 impl ::core::clone::Clone for DML_SCALAR_UNION {
2774     fn clone(&self) -> Self {
2775         *self
2776     }
2777 }
2778 #[repr(C)]
2779 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2780 pub struct DML_SCALE_BIAS {
2781     pub Scale: f32,
2782     pub Bias: f32,
2783 }
2784 impl ::core::marker::Copy for DML_SCALE_BIAS {}
2785 impl ::core::clone::Clone for DML_SCALE_BIAS {
2786     fn clone(&self) -> Self {
2787         *self
2788     }
2789 }
2790 #[repr(C)]
2791 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2792 pub struct DML_SCATTER_ND_OPERATOR_DESC {
2793     pub InputTensor: *const DML_TENSOR_DESC,
2794     pub IndicesTensor: *const DML_TENSOR_DESC,
2795     pub UpdatesTensor: *const DML_TENSOR_DESC,
2796     pub OutputTensor: *const DML_TENSOR_DESC,
2797     pub InputDimensionCount: u32,
2798     pub IndicesDimensionCount: u32,
2799 }
2800 impl ::core::marker::Copy for DML_SCATTER_ND_OPERATOR_DESC {}
2801 impl ::core::clone::Clone for DML_SCATTER_ND_OPERATOR_DESC {
2802     fn clone(&self) -> Self {
2803         *self
2804     }
2805 }
2806 #[repr(C)]
2807 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2808 pub struct DML_SCATTER_OPERATOR_DESC {
2809     pub InputTensor: *const DML_TENSOR_DESC,
2810     pub IndicesTensor: *const DML_TENSOR_DESC,
2811     pub UpdatesTensor: *const DML_TENSOR_DESC,
2812     pub OutputTensor: *const DML_TENSOR_DESC,
2813     pub Axis: u32,
2814 }
2815 impl ::core::marker::Copy for DML_SCATTER_OPERATOR_DESC {}
2816 impl ::core::clone::Clone for DML_SCATTER_OPERATOR_DESC {
2817     fn clone(&self) -> Self {
2818         *self
2819     }
2820 }
2821 #[repr(C)]
2822 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2823 pub struct DML_SIZE_2D {
2824     pub Width: u32,
2825     pub Height: u32,
2826 }
2827 impl ::core::marker::Copy for DML_SIZE_2D {}
2828 impl ::core::clone::Clone for DML_SIZE_2D {
2829     fn clone(&self) -> Self {
2830         *self
2831     }
2832 }
2833 #[repr(C)]
2834 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2835 pub struct DML_SLICE1_OPERATOR_DESC {
2836     pub InputTensor: *const DML_TENSOR_DESC,
2837     pub OutputTensor: *const DML_TENSOR_DESC,
2838     pub DimensionCount: u32,
2839     pub InputWindowOffsets: *const u32,
2840     pub InputWindowSizes: *const u32,
2841     pub InputWindowStrides: *const i32,
2842 }
2843 impl ::core::marker::Copy for DML_SLICE1_OPERATOR_DESC {}
2844 impl ::core::clone::Clone for DML_SLICE1_OPERATOR_DESC {
2845     fn clone(&self) -> Self {
2846         *self
2847     }
2848 }
2849 #[repr(C)]
2850 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2851 pub struct DML_SLICE_GRAD_OPERATOR_DESC {
2852     pub InputGradientTensor: *const DML_TENSOR_DESC,
2853     pub OutputGradientTensor: *const DML_TENSOR_DESC,
2854     pub DimensionCount: u32,
2855     pub InputWindowOffsets: *const u32,
2856     pub InputWindowSizes: *const u32,
2857     pub InputWindowStrides: *const i32,
2858 }
2859 impl ::core::marker::Copy for DML_SLICE_GRAD_OPERATOR_DESC {}
2860 impl ::core::clone::Clone for DML_SLICE_GRAD_OPERATOR_DESC {
2861     fn clone(&self) -> Self {
2862         *self
2863     }
2864 }
2865 #[repr(C)]
2866 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2867 pub struct DML_SLICE_OPERATOR_DESC {
2868     pub InputTensor: *const DML_TENSOR_DESC,
2869     pub OutputTensor: *const DML_TENSOR_DESC,
2870     pub DimensionCount: u32,
2871     pub Offsets: *const u32,
2872     pub Sizes: *const u32,
2873     pub Strides: *const u32,
2874 }
2875 impl ::core::marker::Copy for DML_SLICE_OPERATOR_DESC {}
2876 impl ::core::clone::Clone for DML_SLICE_OPERATOR_DESC {
2877     fn clone(&self) -> Self {
2878         *self
2879     }
2880 }
2881 #[repr(C)]
2882 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2883 pub struct DML_SPACE_TO_DEPTH1_OPERATOR_DESC {
2884     pub InputTensor: *const DML_TENSOR_DESC,
2885     pub OutputTensor: *const DML_TENSOR_DESC,
2886     pub BlockSize: u32,
2887     pub Order: DML_DEPTH_SPACE_ORDER,
2888 }
2889 impl ::core::marker::Copy for DML_SPACE_TO_DEPTH1_OPERATOR_DESC {}
2890 impl ::core::clone::Clone for DML_SPACE_TO_DEPTH1_OPERATOR_DESC {
2891     fn clone(&self) -> Self {
2892         *self
2893     }
2894 }
2895 #[repr(C)]
2896 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2897 pub struct DML_SPACE_TO_DEPTH_OPERATOR_DESC {
2898     pub InputTensor: *const DML_TENSOR_DESC,
2899     pub OutputTensor: *const DML_TENSOR_DESC,
2900     pub BlockSize: u32,
2901 }
2902 impl ::core::marker::Copy for DML_SPACE_TO_DEPTH_OPERATOR_DESC {}
2903 impl ::core::clone::Clone for DML_SPACE_TO_DEPTH_OPERATOR_DESC {
2904     fn clone(&self) -> Self {
2905         *self
2906     }
2907 }
2908 #[repr(C)]
2909 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2910 pub struct DML_SPLIT_OPERATOR_DESC {
2911     pub InputTensor: *const DML_TENSOR_DESC,
2912     pub OutputCount: u32,
2913     pub OutputTensors: *const DML_TENSOR_DESC,
2914     pub Axis: u32,
2915 }
2916 impl ::core::marker::Copy for DML_SPLIT_OPERATOR_DESC {}
2917 impl ::core::clone::Clone for DML_SPLIT_OPERATOR_DESC {
2918     fn clone(&self) -> Self {
2919         *self
2920     }
2921 }
2922 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2923 pub const DML_TARGET_VERSION: u32 = 16384u32;
2924 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2925 pub const DML_TEMPORARY_BUFFER_ALIGNMENT: u32 = 256u32;
2926 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2927 pub type DML_TENSOR_DATA_TYPE = i32;
2928 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2929 pub const DML_TENSOR_DATA_TYPE_UNKNOWN: DML_TENSOR_DATA_TYPE = 0i32;
2930 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2931 pub const DML_TENSOR_DATA_TYPE_FLOAT32: DML_TENSOR_DATA_TYPE = 1i32;
2932 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2933 pub const DML_TENSOR_DATA_TYPE_FLOAT16: DML_TENSOR_DATA_TYPE = 2i32;
2934 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2935 pub const DML_TENSOR_DATA_TYPE_UINT32: DML_TENSOR_DATA_TYPE = 3i32;
2936 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2937 pub const DML_TENSOR_DATA_TYPE_UINT16: DML_TENSOR_DATA_TYPE = 4i32;
2938 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2939 pub const DML_TENSOR_DATA_TYPE_UINT8: DML_TENSOR_DATA_TYPE = 5i32;
2940 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2941 pub const DML_TENSOR_DATA_TYPE_INT32: DML_TENSOR_DATA_TYPE = 6i32;
2942 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2943 pub const DML_TENSOR_DATA_TYPE_INT16: DML_TENSOR_DATA_TYPE = 7i32;
2944 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2945 pub const DML_TENSOR_DATA_TYPE_INT8: DML_TENSOR_DATA_TYPE = 8i32;
2946 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2947 pub const DML_TENSOR_DATA_TYPE_FLOAT64: DML_TENSOR_DATA_TYPE = 9i32;
2948 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2949 pub const DML_TENSOR_DATA_TYPE_UINT64: DML_TENSOR_DATA_TYPE = 10i32;
2950 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2951 pub const DML_TENSOR_DATA_TYPE_INT64: DML_TENSOR_DATA_TYPE = 11i32;
2952 #[repr(C)]
2953 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2954 pub struct DML_TENSOR_DESC {
2955     pub Type: DML_TENSOR_TYPE,
2956     pub Desc: *const ::core::ffi::c_void,
2957 }
2958 impl ::core::marker::Copy for DML_TENSOR_DESC {}
2959 impl ::core::clone::Clone for DML_TENSOR_DESC {
2960     fn clone(&self) -> Self {
2961         *self
2962     }
2963 }
2964 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2965 pub const DML_TENSOR_DIMENSION_COUNT_MAX: u32 = 5u32;
2966 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2967 pub const DML_TENSOR_DIMENSION_COUNT_MAX1: u32 = 8u32;
2968 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2969 pub type DML_TENSOR_FLAGS = u32;
2970 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2971 pub const DML_TENSOR_FLAG_NONE: DML_TENSOR_FLAGS = 0u32;
2972 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2973 pub const DML_TENSOR_FLAG_OWNED_BY_DML: DML_TENSOR_FLAGS = 1u32;
2974 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2975 pub type DML_TENSOR_TYPE = i32;
2976 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2977 pub const DML_TENSOR_TYPE_INVALID: DML_TENSOR_TYPE = 0i32;
2978 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2979 pub const DML_TENSOR_TYPE_BUFFER: DML_TENSOR_TYPE = 1i32;
2980 #[repr(C)]
2981 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2982 pub struct DML_TILE_OPERATOR_DESC {
2983     pub InputTensor: *const DML_TENSOR_DESC,
2984     pub OutputTensor: *const DML_TENSOR_DESC,
2985     pub RepeatsCount: u32,
2986     pub Repeats: *const u32,
2987 }
2988 impl ::core::marker::Copy for DML_TILE_OPERATOR_DESC {}
2989 impl ::core::clone::Clone for DML_TILE_OPERATOR_DESC {
2990     fn clone(&self) -> Self {
2991         *self
2992     }
2993 }
2994 #[repr(C)]
2995 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
2996 pub struct DML_TOP_K1_OPERATOR_DESC {
2997     pub InputTensor: *const DML_TENSOR_DESC,
2998     pub OutputValueTensor: *const DML_TENSOR_DESC,
2999     pub OutputIndexTensor: *const DML_TENSOR_DESC,
3000     pub Axis: u32,
3001     pub K: u32,
3002     pub AxisDirection: DML_AXIS_DIRECTION,
3003 }
3004 impl ::core::marker::Copy for DML_TOP_K1_OPERATOR_DESC {}
3005 impl ::core::clone::Clone for DML_TOP_K1_OPERATOR_DESC {
3006     fn clone(&self) -> Self {
3007         *self
3008     }
3009 }
3010 #[repr(C)]
3011 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
3012 pub struct DML_TOP_K_OPERATOR_DESC {
3013     pub InputTensor: *const DML_TENSOR_DESC,
3014     pub OutputValueTensor: *const DML_TENSOR_DESC,
3015     pub OutputIndexTensor: *const DML_TENSOR_DESC,
3016     pub Axis: u32,
3017     pub K: u32,
3018 }
3019 impl ::core::marker::Copy for DML_TOP_K_OPERATOR_DESC {}
3020 impl ::core::clone::Clone for DML_TOP_K_OPERATOR_DESC {
3021     fn clone(&self) -> Self {
3022         *self
3023     }
3024 }
3025 #[repr(C)]
3026 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
3027 pub struct DML_UPSAMPLE_2D_OPERATOR_DESC {
3028     pub InputTensor: *const DML_TENSOR_DESC,
3029     pub OutputTensor: *const DML_TENSOR_DESC,
3030     pub ScaleSize: DML_SIZE_2D,
3031     pub InterpolationMode: DML_INTERPOLATION_MODE,
3032 }
3033 impl ::core::marker::Copy for DML_UPSAMPLE_2D_OPERATOR_DESC {}
3034 impl ::core::clone::Clone for DML_UPSAMPLE_2D_OPERATOR_DESC {
3035     fn clone(&self) -> Self {
3036         *self
3037     }
3038 }
3039 #[repr(C)]
3040 #[doc = "*Required features: `\"Win32_AI_MachineLearning_DirectML\"`*"]
3041 pub struct DML_VALUE_SCALE_2D_OPERATOR_DESC {
3042     pub InputTensor: *const DML_TENSOR_DESC,
3043     pub OutputTensor: *const DML_TENSOR_DESC,
3044     pub Scale: f32,
3045     pub ChannelCount: u32,
3046     pub Bias: *const f32,
3047 }
3048 impl ::core::marker::Copy for DML_VALUE_SCALE_2D_OPERATOR_DESC {}
3049 impl ::core::clone::Clone for DML_VALUE_SCALE_2D_OPERATOR_DESC {
3050     fn clone(&self) -> Self {
3051         *self
3052     }
3053 }
3054 pub type IDMLBindingTable = *mut ::core::ffi::c_void;
3055 pub type IDMLCommandRecorder = *mut ::core::ffi::c_void;
3056 pub type IDMLCompiledOperator = *mut ::core::ffi::c_void;
3057 pub type IDMLDebugDevice = *mut ::core::ffi::c_void;
3058 pub type IDMLDevice = *mut ::core::ffi::c_void;
3059 pub type IDMLDevice1 = *mut ::core::ffi::c_void;
3060 pub type IDMLDeviceChild = *mut ::core::ffi::c_void;
3061 pub type IDMLDispatchable = *mut ::core::ffi::c_void;
3062 pub type IDMLObject = *mut ::core::ffi::c_void;
3063 pub type IDMLOperator = *mut ::core::ffi::c_void;
3064 pub type IDMLOperatorInitializer = *mut ::core::ffi::c_void;
3065 pub type IDMLPageable = *mut ::core::ffi::c_void;