Ich habe versucht, die Grammatik von R und Java zu übersetzen [Von Zeit zu Zeit aktualisiert]

Vorwort

Was ist das?

Dies ist ein Vergleich der Grammatik von ** R **, einer auf die Verarbeitung und Analyse statistischer Daten spezialisierten Sprache, mit dem Format von ** Java **, einer Allzwecksprache. Bitte beziehen Sie sich darauf, damit Leute, die Java verstehen, es verwenden können, wenn sie R schreiben möchten.

Erforderliche Vorkenntnisse (Java-Seite)

・ Verstehen Sie die Variablentypen (int, double, boolean, String, around Object). ・ Mehrdimensionales Array verstehen ・ Liste und Karte können verwendet werden (es wird ein Beispielcode verwendet) ・ Extended for-Anweisung [Java 8] kann verwendet werden (wie oben)

Wenn Sie sagen, was Sie mit R tun möchten, werden Sie verstehen, wenn dieser Bereich gedrückt gehalten wird.

Erforderliche Vorkenntnisse (R-Seite)

・ Installierte R. ・ Ich weiß, dass am Ende des Satzes kein Semikolon erforderlich ist. ・ Yaruki

R-Java Opposite Dictionary

Allzweckgrammatik

Gemeinsam für Java und R.

・ ** Andere arithmetische Operatoren als abteilungsbezogene ** (+, -, *) -Vergleichsoperator (<,>, <=,> =,! =) ・ Bedingter Logikoperator(&&, ||), Logischer Operator(&, |),Verweigerung(!)

Verschiedene Dinge

Hinweis

• 1: Selbst wenn Sie in R zwischen ganzzahligen Typen teilen, wird dieser als Gleitkommatyp (doppelt) zurückgegeben. Wenn Sie also einfach 10/4 eingeben, wird beispielsweise 2,5 zurückgegeben.
• 2: Seien Sie vorsichtig, wenn Sie sich auf die automatische Vervollständigung verlassen, da es eine ähnliche, aber völlig andere Funktion namens "readLines ()" gibt. Wenn die Konsole nicht interaktiv ist, wird diese Beschreibung ignoriert und die nachfolgende Verarbeitung wird unter der Annahme fortgesetzt, dass eine leere Zeichenfolge eingegeben wurde. Sie können überprüfen, ob es mit print (interaktiv ()) interaktiv ist.
• 3: Beim Kommentieren über mehrere Zeilen muss # in alle Zeilen eingefügt werden.

if, for, switch-Anweisung

if_for_switch.java

if(statement){
  System.out.println(statement is true);
}

for(int i=0;i<n;i++){
  System.out.println("for loop " + i);
}

switch(num){
  case 0:
    System.out.println("switch num=0");
    break;
  case 1:
    System.out.println("switch num=1");
    break;
  default:
    System.out.println("switch default");
}

if_for_switch.R

if(statement){
  print("statement is TRUE")
}

for(i in 1:n){
  print(paste("for loop ", i-1))
}

switch(num,
  "0" = {print("switch num=0")},
  "1" = {print("switch num=1")},
  {print("switch default")}
)

Hinweis Wie bei der Standardausgabe in der R for-Anweisung ist es nicht möglich, eine Zeichenfolge und einen durch + verbundenen numerischen Wert auszugeben (genau genommen wird dies auch in Java nicht empfohlen). Verwenden Sie die Methode paste (). {} In jeder Anweisung des R kann die switch-Anweisung weggelassen werden, wenn der Inhalt nur eine Anweisung ist.

So rufen Sie jedes Element eines zweidimensionalen Arrays auf (R: Matrix)

matrix.java

int[][] a = new int[4][4];

matrix.R

a <- matrix(ncol=4, nrow=4)

Beide sehen fast gleich aus (es gibt Unterschiede wie "0", wenn der Anfangswert Java ist, und "NA", wenn es R ist. Im Fall von R ist der Wert, den der Inhalt des Matrixtyps annimmt, ein numerischer Wert. Nicht ausschließlich) Wie auf jedes Element dieser Matrix Bezug genommen wird, ist wie folgt.

Beseitigen Sie die Verwendung von for-Anweisungen (Familie anwenden)

Wenn Sie die for-Anweisung nicht verwenden, ist sie für eine Person wie R, aber schwer zu erklären. Lassen Sie uns also sehen, was die Apply-Familie im Gegensatz zu Java tut.

Wenden Sie die Funktion auf jedes Element eines mehrdimensionalen Arrays an

apply.java

//Sequenzgenerierung und Initialisierung von hier aus
int[][] mtrx = new int[4][4];
for(int i=0;i<4;i++){
  for(int j=0;j<4;i++){
    mtrx[i][j] = i * 4 + j;
  }
}
//Bisher
//Vorbereitung von Funktionen, die von hier aus wiederholt angewendet werden sollen
int add(int i){
  return i+1;
}
//Bisher
//Scannen Sie von hier aus das Array und wenden Sie die Funktion an
for(int i=0;i<4;i++){
  for(int j=0;j<4;i++){
    mtrx[i][j] = add(mtrx[i][j]);
  }
}
//Bisher

Ein zweidimensionales Array mit den Zahlen 0 bis 15 wird erzeugt und jedem Element wird 1 hinzugefügt (dies ist natürlich eine haarsträubende Erklärung) ~ ~ Es ist redundant geschrieben. ).

apply.R

#Matrixgenerierung und Initialisierung von hier aus
a <- matrix(c(1:16), ncol=4, nrow=4, byrow=TRUE)
#Bisher
#Vorbereitung von Funktionen, die von hier aus wiederholt angewendet werden sollen
add <- function(i){
  return(i+1)
}
#Bisher
#Scannen Sie von hier aus die Matrix und wenden Sie die Funktion an
apply(a, c(1,2), add)
#Bisher

Es kann sehr einfach so geschrieben werden. Ich habe eine Funktion erstellt, die hier wiederholt ausgeführt wird, aber Sie können jede der verfügbaren Funktionen verwenden (z. B. gibt Ihnen sqrt eine Matrix mit den Quadratwurzeln aller Elemente).

Hinweis -Die Option "byrow" der Funktion "matrix ()" ist eine Option, um den Quellvektor (in diesem Beispiel "c (1:16)" als Matrix in Zeileneinheiten anzuordnen. Der Standardwert ist FALSE, daher wird die durch Ausführen dieses Codes erhaltene Matrix transponiert. -Die zweite Option (c (1: 2)) der Funktion apply () gibt den Bereich an. Machen Sie dasselbe mit 1 für "alle Zeilen" und 2 für "alle Spalten". ** Wenn Sie nur eine for-Schleife in einem zweidimensionalen Array drehen möchten, müssen Sie sich darüber keine Gedanken machen, also spielen Sie nicht achtlos damit herum **. Insbesondere machen die folgenden zwei Codes ungefähr dasselbe. R ist wirklich nur das, nicht überschreiben.

apply2.java

int sum(int[] arr){  //Eine Funktion, die die Summe der Arrays angibt. R ist Standard
  int sum = 0;
  for(int i : arr){
    sum += i;
  }
  return sum;
}

int[] sum_arr = new int[4];
for(int i=0;i<4;i++){
  sum_arr[i] = sum(mtrx[i]);  //Summe für alle Zeilen()Funktion anwenden
}

apply2.R

apply(a, 1, sum)

Funktion auf jedes Element von HashMap anwenden (lapply)

Zunächst muss verstanden werden, dass Listentypvariablen in R ** nicht denselben Wertetyp enthalten müssen **. Mit anderen Worten, es ist so, als würde man deklarieren, dass Java Map Objekttypen verarbeitet, es sei denn, Sie deklarieren etwas Besonderes.

lapply.java

Map<String, Object> a = new HashMap<>();
a.put("i", 123);
a.put("d", 4.56d);
a.put("b", false);

lapply.R

a <- list(i = 123, d = 4.56, b = FALSE)

Auf diese Weise ist es möglich, gleichzeitig einen Ganzzahltyp, einen Gleitkommatyp mit doppelter Genauigkeit und einen logischen Typ zu haben. lapply führt die Verarbeitung von Listen und Matrizen durch und ** gibt die Ergebnisse als Liste zurück **.

lapply2.java

Map<String, Object> a = new HashMap<>();
a.put("i", 123);
a.put("d", 4.56d);
a.put("b", false);

for(Object o : a.values()){
  add(o);
}    //Kompilierungsfehler!

lapply2.R

a <- list(i = 123, d = 4.56, b = FALSE)

lapply(a, add) #add()Funktion ist anwendbar.Umgeleitet von R.

Da das in apply.java definierte Argument der Funktion add () vom Typ int ist, kann der obige Code nicht in Java ausgeführt werden. In R ist jedoch keine Typdeklaration erforderlich, und die Variable wird automatisch mit dem größten Typ abgeglichen, sodass dieser Code ausgeführt werden kann (behandelt als FALSE = 0, TRUE = 1) und die Ausgabe wie folgt lautet. Zu

> lapply(a, add)
$i
[1] 124

$d
[1] 5.56

$b
[1] 1

Sie können lapply für 2D-Arrays verwenden, dies ist jedoch umständlich, es sei denn, Sie müssen als Listentyp ausgeben. Sie können davon ausgehen, dass es sich um eine solche Funktion handelt. Für die von apply.java (apply.R) generierte 4x4-Matrix geben die folgenden zwei lapply () fast dasselbe aus.

lapply3.java

Map<String, Integer> lapply(int[][] arr){
  Map<String, Integer> a = new HashMap<>();
  for(int i=0;i<arr[0].length;i++){
    for(int j=0;j<arr.length;j++){
      a.put(String.valueOf(i * 4 + j + 1), add(arr[j][i]));
      //arr[i][j]Nicht arr[j][i]Beachten Sie, dass
      //In R wird spaltenweise nach zweidimensionalen Arrays gesucht
    }
  }
  return a;
}

lapply3.R

lapply(a, add)  
#apply.Addiere für alle Elemente von a wie in R.()Bewerben, aber
#Das Erscheinungsbild des Ausgabeergebnisses wird angewendet.Es ist völlig anders als R. Bitte laufen und überprüfen

Hinweis -In lapply3.java wird Map <String, Integer> als Rückgabetyp verwendet, aber in Wirklichkeit wird die Zahl von 1 bis 16 (in String-Typ umgewandelt) in Key eingegeben, sodass sie redundant aussieht. Da die Zeilennummer und die Spaltennummer der R-Matrix Namen haben können, wird eine solche Beschreibung verwendet, da der im Schlüssel eingegebene Wert möglicherweise kein numerischer Wert ist, wenn versucht wird, genau zu entsprechen.

String-Verarbeitung

Insgesamt ist R nicht gut in der Zeichenfolgenverarbeitung. Wenn für die Datenvorverarbeitung ein großer Teil der Zeichenfolgenverarbeitung erforderlich ist, sollten Sie zunächst eine andere Sprache oder eine Tabellenberechnungssoftware verwenden.

Verknüpfen

str_concat.java

//Beispiel 1
String str = "Hello" + " " + "world!";  //Nicht zu empfehlen, da es viel Speicher verbraucht

//Beispiel 2
StringBuilder builder = new StringBuilder();
builder.append("Hello");
builder.append(" ");
builder.append("world!");
String str = builder.toString();

str_concat.R

str <- paste("Hello", " ", "world!")

Ergänzende Bestimmungen

Ausführungsumgebung des Codes auf dieser Seite

Java -Java version: 1.8.0_231 -IDE: Intellij IDEA Community Edition 2019.2

R -R version: R x64 3.6.0 -IDE: R Studio 1.2.1335

Bitte beziehen Sie sich darauf, wenn Sie es nicht gut ausführen können.