DML_LSTM_OPERATOR_DESC

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DML_LSTM_OPERATOR_DESC
{
    public IntPtr InputTensor;
    public IntPtr WeightTensor;
    public IntPtr RecurrenceTensor;
    public IntPtr BiasTensor;
    public IntPtr HiddenInitTensor;
    public IntPtr CellMemInitTensor;
    public IntPtr SequenceLengthsTensor;
    public IntPtr PeepholeTensor;
    public IntPtr OutputSequenceTensor;
    public IntPtr OutputSingleTensor;
    public IntPtr OutputCellSingleTensor;
    public uint ActivationDescCount;
    public IntPtr ActivationDescs;
    public int Direction;
    public float ClipThreshold;
    [MarshalAs(UnmanagedType.Bool)] public bool UseClipThreshold;
    [MarshalAs(UnmanagedType.Bool)] public bool CoupleInputForget;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DML_LSTM_OPERATOR_DESC
    Public InputTensor As IntPtr
    Public WeightTensor As IntPtr
    Public RecurrenceTensor As IntPtr
    Public BiasTensor As IntPtr
    Public HiddenInitTensor As IntPtr
    Public CellMemInitTensor As IntPtr
    Public SequenceLengthsTensor As IntPtr
    Public PeepholeTensor As IntPtr
    Public OutputSequenceTensor As IntPtr
    Public OutputSingleTensor As IntPtr
    Public OutputCellSingleTensor As IntPtr
    Public ActivationDescCount As UInteger
    Public ActivationDescs As IntPtr
    Public Direction As Integer
    Public ClipThreshold As Single
    <MarshalAs(UnmanagedType.Bool)> Public UseClipThreshold As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public CoupleInputForget As Boolean
End Structure

import ctypes
from ctypes import wintypes

class DML_LSTM_OPERATOR_DESC(ctypes.Structure):
    _fields_ = [
        ("InputTensor", ctypes.c_void_p),
        ("WeightTensor", ctypes.c_void_p),
        ("RecurrenceTensor", ctypes.c_void_p),
        ("BiasTensor", ctypes.c_void_p),
        ("HiddenInitTensor", ctypes.c_void_p),
        ("CellMemInitTensor", ctypes.c_void_p),
        ("SequenceLengthsTensor", ctypes.c_void_p),
        ("PeepholeTensor", ctypes.c_void_p),
        ("OutputSequenceTensor", ctypes.c_void_p),
        ("OutputSingleTensor", ctypes.c_void_p),
        ("OutputCellSingleTensor", ctypes.c_void_p),
        ("ActivationDescCount", wintypes.DWORD),
        ("ActivationDescs", ctypes.c_void_p),
        ("Direction", ctypes.c_int),
        ("ClipThreshold", ctypes.c_float),
        ("UseClipThreshold", wintypes.BOOL),
        ("CoupleInputForget", wintypes.BOOL),
    ]

#[repr(C)]
pub struct DML_LSTM_OPERATOR_DESC {
    pub InputTensor: *mut core::ffi::c_void,
    pub WeightTensor: *mut core::ffi::c_void,
    pub RecurrenceTensor: *mut core::ffi::c_void,
    pub BiasTensor: *mut core::ffi::c_void,
    pub HiddenInitTensor: *mut core::ffi::c_void,
    pub CellMemInitTensor: *mut core::ffi::c_void,
    pub SequenceLengthsTensor: *mut core::ffi::c_void,
    pub PeepholeTensor: *mut core::ffi::c_void,
    pub OutputSequenceTensor: *mut core::ffi::c_void,
    pub OutputSingleTensor: *mut core::ffi::c_void,
    pub OutputCellSingleTensor: *mut core::ffi::c_void,
    pub ActivationDescCount: u32,
    pub ActivationDescs: *mut core::ffi::c_void,
    pub Direction: i32,
    pub ClipThreshold: f32,
    pub UseClipThreshold: i32,
    pub CoupleInputForget: i32,
}

import "golang.org/x/sys/windows"

type DML_LSTM_OPERATOR_DESC struct {
	InputTensor uintptr
	WeightTensor uintptr
	RecurrenceTensor uintptr
	BiasTensor uintptr
	HiddenInitTensor uintptr
	CellMemInitTensor uintptr
	SequenceLengthsTensor uintptr
	PeepholeTensor uintptr
	OutputSequenceTensor uintptr
	OutputSingleTensor uintptr
	OutputCellSingleTensor uintptr
	ActivationDescCount uint32
	ActivationDescs uintptr
	Direction int32
	ClipThreshold float32
	UseClipThreshold int32
	CoupleInputForget int32
}

type
  DML_LSTM_OPERATOR_DESC = record
    InputTensor: Pointer;
    WeightTensor: Pointer;
    RecurrenceTensor: Pointer;
    BiasTensor: Pointer;
    HiddenInitTensor: Pointer;
    CellMemInitTensor: Pointer;
    SequenceLengthsTensor: Pointer;
    PeepholeTensor: Pointer;
    OutputSequenceTensor: Pointer;
    OutputSingleTensor: Pointer;
    OutputCellSingleTensor: Pointer;
    ActivationDescCount: DWORD;
    ActivationDescs: Pointer;
    Direction: Integer;
    ClipThreshold: Single;
    UseClipThreshold: BOOL;
    CoupleInputForget: BOOL;
  end;

const DML_LSTM_OPERATOR_DESC = extern struct {
    InputTensor: ?*anyopaque,
    WeightTensor: ?*anyopaque,
    RecurrenceTensor: ?*anyopaque,
    BiasTensor: ?*anyopaque,
    HiddenInitTensor: ?*anyopaque,
    CellMemInitTensor: ?*anyopaque,
    SequenceLengthsTensor: ?*anyopaque,
    PeepholeTensor: ?*anyopaque,
    OutputSequenceTensor: ?*anyopaque,
    OutputSingleTensor: ?*anyopaque,
    OutputCellSingleTensor: ?*anyopaque,
    ActivationDescCount: u32,
    ActivationDescs: ?*anyopaque,
    Direction: i32,
    ClipThreshold: f32,
    UseClipThreshold: i32,
    CoupleInputForget: i32,
};

type
  DML_LSTM_OPERATOR_DESC {.bycopy.} = object
    InputTensor: pointer
    WeightTensor: pointer
    RecurrenceTensor: pointer
    BiasTensor: pointer
    HiddenInitTensor: pointer
    CellMemInitTensor: pointer
    SequenceLengthsTensor: pointer
    PeepholeTensor: pointer
    OutputSequenceTensor: pointer
    OutputSingleTensor: pointer
    OutputCellSingleTensor: pointer
    ActivationDescCount: uint32
    ActivationDescs: pointer
    Direction: int32
    ClipThreshold: float32
    UseClipThreshold: int32
    CoupleInputForget: int32

struct DML_LSTM_OPERATOR_DESC
{
    void* InputTensor;
    void* WeightTensor;
    void* RecurrenceTensor;
    void* BiasTensor;
    void* HiddenInitTensor;
    void* CellMemInitTensor;
    void* SequenceLengthsTensor;
    void* PeepholeTensor;
    void* OutputSequenceTensor;
    void* OutputSingleTensor;
    void* OutputCellSingleTensor;
    uint ActivationDescCount;
    void* ActivationDescs;
    int Direction;
    float ClipThreshold;
    int UseClipThreshold;
    int CoupleInputForget;
}