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

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