我正在R中建立一个维护程序员。对于不同的机器，我有具有特定活动的例程，这些例程应在特定日期执行，该日期由频率和开始日期定义。
我已经有了一个data.table，其频率（以周为单位），大型维护的最后一个已知日期以及每个例程的计划日期（根据其频率和最后日期）。简化版本如下：
require(data.table)
dt <- structure(list(id = c(1, 2, 3, 4, 5, 6, 7, 8, 9), machine = c("t1",
"t1", "t1", "t1", "t1", "t2", "t2", "t2", "t2"), frequencyWeeks = c(4,
12, 24, 48, 96, 4, 24, 48, 96), lastMaintenance = structure(c(17889,
17889, 17889, 17889, 17889, 17871, 17871, 17871, 17871), class = "Date"),
datesRoutines = list(structure(c(17889, 17917, 17945, 17973,
18001, 18029, 18057, 18085, 18113, 18141, 18169, 18197, 18225,
18253, 18281, 18309, 18337, 18365, 18393, 18421, 18449, 18477,
18505, 18533, 18561, 18589, 18617), class = "Date"), structure(c(17889,
17973, 18057, 18141, 18225, 18309, 18393, 18477, 18561), class = "Date"),
structure(c(17889, 18057, 18225, 18393, 18561), class = "Date"),
structure(c(17889, 18225, 18561), class = "Date"), structure(c(17889,
18561), class = "Date"), structure(c(17871, 17899, 17927,
17955, 17983, 18011, 18039, 18067, 18095, 18123, 18151,
18179, 18207, 18235, 18263, 18291, 18319, 18347, 18375,
18403, 18431, 18459, 18487, 18515, 18543, 18571, 18599,
18627), class = "Date"), structure(c(17871, 18039, 18207,
18375, 18543), class = "Date"), structure(c(17871, 18207,
18543), class = "Date"), structure(c(17871, 18543), class = "Date"))), class = c("data.table",
"data.frame"), row.names = c(NA, -9L))
dt
id machine frequencyWeeks lastMaintenance datesRoutines
1: 1 t1 4 2018-12-24 2018-12-24,2019-01-21,2019-02-18,2019-03-18,2019-04-15,2019-05-13,...
2: 2 t1 12 2018-12-24 2018-12-24,2019-03-18,2019-06-10,2019-09-02,2019-11-25,2020-02-17,...
3: 3 t1 24 2018-12-24 2018-12-24,2019-06-10,2019-11-25,2020-05-11,2020-10-26
4: 4 t1 48 2018-12-24 2018-12-24,2019-11-25,2020-10-26
5: 5 t1 96 2018-12-24 2018-12-24,2020-10-26
6: 6 t2 4 2018-12-06 2018-12-06,2019-01-03,2019-01-31,2019-02-28,2019-03-28,2019-04-25,...
7: 7 t2 24 2018-12-06 2018-12-06,2019-05-23,2019-11-07,2020-04-23,2020-10-08
8: 8 t2 48 2018-12-06 2018-12-06,2019-11-07,2020-10-08
9: 9 t2 96 2018-12-06 2018-12-06,2020-10-08
需要：我想为每台机器和干预日期确定id最高的例程（以增加复杂性的顺序记录例程，这意味着它将是最复杂的例程）
我曾经尝试过的事情：我使用嵌套的for循环来实现它：
for (j in dt[, unique(machine)]){
for (i in dt[machine == j, ][1, datesRoutines[[1]]]){
result[count, "machine"] <- j
result[count, "date"] <- as.Date(i, origin = origin)
result[count, "rutina"] <- dt[machine == j, i %in% datesRoutines[[1]], by = id][V1 == TRUE, max(id)]
count <- count + 1
}
}
setDT(result)
预期结果：我希望data.table的计算机，日期和例行ID为：
head(result)
machine date rutina
1 t1 2018-12-24 5
2 t1 2019-01-21 1
3 t1 2019-02-18 1
4 t1 2019-03-18 2
5 t1 2019-04-15 1
6 t1 2019-05-13 1
问题：可以对其向量化吗？这样做的代码是什么？
答案 0 :(得分：1)
这是我能想到的最好的简单解释：
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Build;
import android.os.Handler;
import android.util.Log;
import java.util.ArrayList;
import java.util.UUID;
import com.rsradar.app.MainActivity;
import com.rsradar.app.model.Constants;
public class UartBluetooth {
private final static String TAG = UartBluetooth.class.getSimpleName();
private BluetoothManager mBluetoothManager;
private BluetoothAdapter mBluetoothAdapter;
private String mBluetoothDeviceAddress;
private BluetoothGatt mBluetoothGatt;
private int mConnectionState = STATE_DISCONNECTED;
private BluetoothDevice device;
private MainActivity mainActivity;
private static final int STATE_DISCONNECTED = 0;
private static final int STATE_CONNECTING = 1;
private static final int STATE_CONNECTED = 2;
public final static String ACTION_GATT_CONNECTED =
"com.nordicsemi.nrfUART.ACTION_GATT_CONNECTED";
public final static String ACTION_DATA_AVAILABLE =
"com.nordicsemi.nrfUART.ACTION_DATA_AVAILABLE";
public final static String EXTRA_DATA =
"com.nordicsemi.nrfUART.EXTRA_DATA";
public final static String DEVICE_DOES_NOT_SUPPORT_UART =
"com.nordicsemi.nrfUART.DEVICE_DOES_NOT_SUPPORT_UART";
public static final UUID TX_POWER_UUID = UUID.fromString("00001804-0000-1000-8000-00805f9b34fb");
public static final UUID TX_POWER_LEVEL_UUID = UUID.fromString("00002a07-0000-1000-8000-00805f9b34fb");
public static final UUID CCCD = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
public static final UUID FIRMWARE_REVISON_UUID = UUID.fromString("00002a26-0000-1000-8000-00805f9b34fb");
public static final UUID DIS_UUID = UUID.fromString("0000180a-0000-1000-8000-00805f9b34fb");
public static final UUID RX_SERVICE_UUID = UUID.fromString("6e400001-b5a3-f393-e0a9-e50e24dcca9e");
public static final UUID RX_CHAR_UUID = UUID.fromString("6e400002-b5a3-f393-e0a9-e50e24dcca9e");
public static final UUID TX_CHAR_UUID = UUID.fromString("6e400003-b5a3-f393-e0a9-e50e24dcca9e");
// Debugging
private static final boolean D = true;
// Name for the SDP record when creating server socket
private static final String NAME = "BluetoothMulti";
// Member fields
private final BluetoothAdapter mAdapter;
private final Handler mHandler;
private int mState;
private ArrayList<String> mDeviceAddresses;
private ArrayList<BluetoothSocket> mSockets;
/**
* A bluetooth piconet can support up to 7 connections. This array holds 7 unique UUIDs.
* When attempting to make a connection, the UUID on the client must match one that the server
* is listening for. When accepting incoming connections server listens for all 7 UUIDs.
* When trying to form an outgoing connection, the client tries each UUID one at a time.
*/
private ArrayList<UUID> mUuids;
// Constants that indicate the current connection state
public static final int STATE_NONE = 0; // we're doing nothing
public static final int STATE_LISTEN = 1; // now listening for incoming connections
//public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection
//public static final int STATE_CONNECTED = 3; // now connected to a remote device
public UartBluetooth(Context context, Handler handler) {
mAdapter = BluetoothAdapter.getDefaultAdapter();
mState = STATE_NONE;
mHandler = handler;
mDeviceAddresses = new ArrayList<String>();
mSockets = new ArrayList<BluetoothSocket>();
mUuids = new ArrayList<UUID>();
// 7 randomly-generated UUIDs. These must match on both server and client.
mUuids.add(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
mUuids.add(UUID.fromString("2d64189d-5a2c-4511-a074-77f199fd0834"));
}
/**
* Set the current state of the chat connection
* @param state An integer defining the current connection state
*/
private synchronized void setState(int state) {
if (D) Log.d(TAG, "setState() " + mState + " -> " + state);
mState = state;
// Give the new state to the Handler so the UI Activity can update
mHandler.obtainMessage(Constants.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
}
/**
* Return the current connection state. */
public synchronized int getState() {
return mState;
}
/**
* Start the chat service. Specifically start AcceptThread to begin a
* session in listening (server) mode. Called by the Activity onResume() */
public synchronized void start() {
if (D) Log.d(TAG, "start");
// Cancel any thread currently running a connection
//if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
setState(STATE_LISTEN);
}
/**
* Start the ConnectThread to initiate a connection to a remote device.
* @param device The BluetoothDevice to connect
*/
public synchronized void connect(MainActivity mainActivity, BluetoothAdapter bluetoothAdapter, BluetoothDevice device) {
this.mBluetoothAdapter = bluetoothAdapter;
this.mainActivity = mainActivity;
this.device = device;
Log.w(TAG, "test on try connect");
if (mBluetoothAdapter == null || device.getAddress() == null) {
Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
return;
}
Log.w(TAG, "run is running");
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
mBluetoothGatt = device.connectGatt(mainActivity, true, mGattCallback);
}
mConnectionState = STATE_CONNECTING;
}
/**
* Stop all threads
*/
public synchronized void stop() {
if (D) Log.d(TAG, "stop");
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
if(mBluetoothGatt != null){
mBluetoothGatt.disconnect();
}
}
try {
this.finalize();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
setState(STATE_NONE);
}
/**
* This thread runs while listening for incoming connections. It behaves
* like a server-side client. It runs until a connection is accepted
* (or until cancelled).
*/
private BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
String intentAction;
if (newState == BluetoothProfile.STATE_CONNECTED) {
intentAction = ACTION_GATT_CONNECTED;
mConnectionState = STATE_CONNECTED;
// TODO: handler
Log.i(TAG, "Connected to GATT server.");
// Attempts to discover services after successful connection.
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
Log.i(TAG, "Attempting to start service discovery:" +
mBluetoothGatt.discoverServices());
}
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
intentAction = Constants.ACTION_GATT_LASER_DISCONNECTED;
mConnectionState = STATE_DISCONNECTED;
Log.i(TAG, "Disconnected from GATT server.");
// TODO: handler
mainActivity.btListener.listenerSet(false,device.getName());
}
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.w(TAG, "mBluetoothGatt = " + mBluetoothGatt );
// TODO: handler
mainActivity.btListener.listenerSet(true,device.getName());
enableTXNotification();
} else {
Log.w(TAG, "onServicesDiscovered received: " + status);
}
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic,
int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
// TODO: handler
System.out.println(" read ok");
}
}
@Override
public void onCharacteristicChanged(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic) {
//System.out.println("RUN");
// TODO: handler
byte[] buffer = characteristic.getValue();
int deviceType = 0;
if (device.getName().equals(Constants.DEVICE_LASER)){
deviceType = 1;
} else if (device.getName().equals(Constants.DEVICE_RF)){
deviceType = 2;
}
mHandler.obtainMessage(Constants.MESSAGE_READ, deviceType, -1, buffer).sendToTarget();
//System.out.println(" change ok");
}
};
public void enableTXNotification()
{
/*
if (mBluetoothGatt == null) {
showMessage("mBluetoothGatt null" + mBluetoothGatt);
broadcastUpdate(DEVICE_DOES_NOT_SUPPORT_UART);
return;
}
*/
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
BluetoothGattService RxService = mBluetoothGatt.getService(RX_SERVICE_UUID);
if (RxService == null) {
return;
}
BluetoothGattCharacteristic TxChar = RxService.getCharacteristic(TX_CHAR_UUID);
if (TxChar == null) {
return;
}
mBluetoothGatt.setCharacteristicNotification(TxChar,true);
BluetoothGattDescriptor descriptor = TxChar.getDescriptor(CCCD);
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
mBluetoothGatt.writeDescriptor(descriptor);
}
}
public void readCharacteristic(BluetoothGattCharacteristic characteristic) {
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
Log.w(TAG, "BluetoothAdapter not initialized");
return;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
mBluetoothGatt.readCharacteristic(characteristic);
}
}
}
在这里，您可以进一步前进：
results <- list()
for(m in unique(dt$machine)){
dates <- dt[machine==m]$datesRoutines
dates <- as.Date(unique(unlist(dates)), origin="1970-01-01")
result <- data.table(date=dates)
result[, machine:=m]
for(d in dates){
result[date==d, routine:=dt[as.Date(d, origin="1970-01-01") %in% unlist(datesRoutines),
.(id, ord=as.double(max(which(as.Date(d, origin="1970-01-01") %in% unlist(datesRoutines))))),
by=seq_len(nrow(dt))][,.(ord==max(ord), id)][V1==T][, max(id)]]
}
results[[m]] <- result
}
final_result <- rbindlist(results)
最后，对于results <- list()
for(m in unique(dt$machine)){
dates <- dt[machine==m]$datesRoutines
dates <- as.Date(unique(unlist(dates)), origin="1970-01-01")
result <- data.table(date=dates)
result[, machine:=m]
result$routine <-lapply(result$date, function(d){
dt[as.Date(d, origin="1970-01-01") %in% unlist(datesRoutines),
.(id, ord=as.double(max(which(as.Date(d, origin="1970-01-01") %in% unlist(datesRoutines))))),
by=seq_len(nrow(dt))][,.(ord==max(ord), id)][V1==T][, max(id)]})
results[[m]] <- result
}
final_result <- rbindlist(results)
的讨厌者：
for loop