标签: bidirectional

我需要一种可以在两个方向上访问的地图,因此使用键 - 键结构而不是键值.这是否存在于Java中？如果没有,创建它的最佳方法是什么？

例如:

mySpecialHashMap.put("key1", "key2");

mySpecialMap.getL2R("key1") returns "key2";
mySpecialMap.getR2L("key2") returns "key1";

我想在Windows中的Python和C#应用程序之间传递数据(我希望通道是双向的)实际上我想传递一个结构,其中包含我用C#(SharpPcap)捕获的网络数据包的数据到Python应用程序然后将修改后的数据包发送回C#程序.你有什么建议 ？(我宁愿这是一个快速的方法)到目前为止我的搜索显示我可以使用这些技术,但我不知道哪个:

1. JSON-RPC
2. 使用WCF(使用Ironclad在IronPython下运行项目)
3. WCF(使用Python for .NET)

我只是试图绑定一个Integer和一个String属性.经过一些谷歌搜索后,应该可以使用以下两种方法之一:

1. public static void bindBidirectional(Property stringProperty,
   Property otherProperty ,StringConverter converter)

2. public static void bindBidirectional(Property stringProperty,
   Property otherProperty ,java.text.Format format)

不幸的是,这似乎对我不起作用.我究竟做错了什么？

import java.text.Format;

import javafx.beans.binding.Bindings;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.util.converter.IntegerStringConverter;

public class BiderectionalBinding {

    public static void main(String[] args) {
        SimpleIntegerProperty intProp = new SimpleIntegerProperty();
        SimpleStringProperty textProp = new SimpleStringProperty();

        Bindings.bindBidirectional(textProp, intProp, new IntegerStringConverter());

        intProp.set(2);
        System.out.println(textProp);

        textProp.set("8");
        System.out.println(intProp);    
    }
}

双向意味着数据传入和传出数据流经同一个通道(套接字),在经典套接字中就是这种情况.例如,您想要连接到服务器:您创建一个套接字,通过同一个通道发送和接收数据.这不是双向的吗？

websockets(双向)有什么不同,只是它们可以在浏览器上运行？这有区别吗？

另一个问题是bind()在服务器端期间会发生什么; 这是用于说OS的TCP堆栈实现,消息必须在该端口上传递到哪个套接字？

我想编写一个在串口上模拟设备的程序.我正在尝试使用伪终端来实现这一目标.我想要一个独特的过程来控制主人.此过程充当串行设备模拟器.我希望另一个进程(例如kermit)能够使用从终端与主站通信.由于不同的工艺要求,我没有使用任何叉子.几乎互联网上的每个伪终端示例都显示了fork()用于主/从.

我让它在一个方向上工作.也就是说,我可以让从属进程将数据写入从属伪终端,并且主机将从主假终端读取它就好了.

问题出在另一个方向.我无法让master写入数据和slave来读取数据.

我将展示非工作双向代码和工作单向代码.

非工作双向主控:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char* argv[])
{
  // get the master fd
  int masterfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
  if(masterfd < 0)
  {
    perror("getpt");
    exit(1);
  }

  // grant access to the slave
  if(grantpt(masterfd) < 0)
  {
    perror("grantpt");
    exit(1);
  }

  // unlock the slave
  if(unlockpt(masterfd) < 0)
  {
    perror("unlockpt");
    exit(1);
  }

  // get the path to the slave
  char slavepath[64];
  if(ptsname_r(masterfd, slavepath, sizeof(slavepath)) < 0)
  {
    perror("ptsname_r");
    exit(1);
  } …

我正在使用数据绑定,我创建了一个非常简单的类

public class ViewUser extends BaseObservable {
    private String name;

    @Bindable
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        notifyPropertyChanged(BR.name);
    }
}

布局简单

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools">
    <data>
        <variable
            name="user"
            type="com.example.ViewUser" />
    </data>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

                <EditText
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:gravity="top"
                    android:lines="3"
                    android:text="@{user.name}" />
    </LinearLayout>
</layout>

当我更新对象时,UI更新没有任何问题,但是如果我从UI更改EditText的值然后让用户使用DataBindingUtil .getUser(),则它没有更新的值.是否可以自动更新属性,或者是否必须使用TextWatcher的onTextChanged等事件更新对象？

我正在使用sublime text v3并发现sublime文本中的波斯字符有问题,我通过使用双向文本包找到解决方案

这是我的问题的图像:

但每次输入波斯语时我都必须使用ctrl + b.反正有没有让双向文本自动运行代码而不是每次都使用ctrl + b？

谢谢.

我正在构建一个客户端Ruby库,它连接到服务器并等待数据,但也允许用户通过调用方法来发送数据.

我使用的机制是有一个初始化套接字对的类,如下所示:

def initialize
  @pipe_r, @pipe_w = Socket.pair(:UNIX, :STREAM, 0)
end

我允许开发人员调用以向服务器发送数据的方法如下所示:

def send(data)
  @pipe_w.write(data)
  @pipe_w.flush
end

然后我在一个单独的线程中有一个循环,我从socket连接到服务器和从@pipe_r:

def socket_loop
  Thread.new do
    socket = TCPSocket.new(host, port)

    loop do
      ready = IO.select([socket, @pipe_r])

      if ready[0].include?(@pipe_r)
        data_to_send = @pipe_r.read_nonblock(1024)
        socket.write(data_to_send)
      end

      if ready[0].include?(socket)
        data_received = socket.read_nonblock(1024)
        h2 << data_received
        break if socket.nil? || socket.closed? || socket.eof?
      end
    end
  end
end

这样可以很好地工作,但只能TCPSocket按照例子的正常情况进行.我需要使用一个OpenSSL::SSL::SSLSocket,但是根据IO.select文档:

使用IO.select的最佳方法是在非阻塞方法(如read_nonblock,write_nonblock等)之后调用它.

[...]

特别是,非阻塞方法和IO.select的组合对于像OpenSSL :: SSL :: SSLSocket这样的IO对象是首选的.

根据这个,我需要IO.select …

我是tensorflow的新手,我正在尝试将一些双向LSTM的代码从旧版本的tensorflow更新到最新版本(1.0),但是我得到了这个错误:

形状必须是等级2,但对于'MatMul_3'(op:'MatMul')具有输入形状的等级3:[100,？,400],[400,2].

该错误发生在pred_mod上.

    _weights = {
    # Hidden layer weights => 2*n_hidden because of foward + backward cells
        'w_emb' : tf.Variable(0.2 * tf.random_uniform([max_features,FLAGS.embedding_dim], minval=-1.0, maxval=1.0, dtype=tf.float32),name='w_emb',trainable=False),
        'c_emb' : tf.Variable(0.2 * tf.random_uniform([3,FLAGS.embedding_dim],minval=-1.0, maxval=1.0, dtype=tf.float32),name='c_emb',trainable=True),
        't_emb' : tf.Variable(0.2 * tf.random_uniform([tag_voc_size,FLAGS.embedding_dim], minval=-1.0, maxval=1.0, dtype=tf.float32),name='t_emb',trainable=False),
        'hidden_w': tf.Variable(tf.random_normal([FLAGS.embedding_dim, 2*FLAGS.num_hidden])),
        'hidden_c': tf.Variable(tf.random_normal([FLAGS.embedding_dim, 2*FLAGS.num_hidden])),
        'hidden_t': tf.Variable(tf.random_normal([FLAGS.embedding_dim, 2*FLAGS.num_hidden])),
        'out_w': tf.Variable(tf.random_normal([2*FLAGS.num_hidden, FLAGS.num_classes]))}

    _biases = {
         'hidden_b': tf.Variable(tf.random_normal([2*FLAGS.num_hidden])),
         'out_b': tf.Variable(tf.random_normal([FLAGS.num_classes]))}


    #~ input PlaceHolders
    seq_len = tf.placeholder(tf.int64,name="input_lr")
    _W = tf.placeholder(tf.int32,name="input_w")
    _C = tf.placeholder(tf.int32,name="input_c")
    _T = tf.placeholder(tf.int32,name="input_t")
    mask = tf.placeholder("float",name="input_mask")

    # Tensorflow …

我想训练张量流中的双向LSTM来执行序列分类问题(情绪分类).

因为序列具有可变长度,所以批次通常用零向量填充.通常,我在单向RNN中使用sequence_length参数来避免对填充向量进行训练.

如何通过双向LSTM进行管理."sequence_length"参数是否自动从向后方向的序列中的高级位置开始？

谢谢