TADM2E 3.28 - Revision history

Matt: Undo revision 1067 by FuckMatt (talk)

2020-08-01T00:59:54Z

Undo revision 1067 by FuckMatt (talk)

FuckMatt: Blanked the page

2020-07-31T09:38:42Z

Blanked the page

Matt: Undo revision 991 by MattWars (talk)

2020-07-27T23:34:22Z

Undo revision 991 by MattWars (talk)

MattWars at 10:17, 27 July 2020

2020-07-27T10:17:00Z

Matt: Undo revision 773 by FuckYou (talk)

2020-07-23T14:40:16Z

Undo revision 773 by FuckYou (talk)

FuckYou: Replaced content with "We need fast wifi"

2020-07-14T01:41:36Z

Replaced content with "We need fast wifi"

Murrayc2: This media wiki supports , which is nice.

2015-11-08T09:31:56Z

This media wiki supports <source>, which is nice.

Murrayc2: j seems to be the length of x, so rename it to make it clearer.

2015-11-08T09:29:54Z

j seems to be the length of x, so rename it to make it clearer.

Murrayc2: Slight cleanup

2015-11-08T09:22:24Z

Slight cleanup

Murrayc2: Clean up the code and state that it is Java.

2015-11-08T09:21:08Z

Clean up the code and state that it is Java.

← Older revision	Revision as of 00:59, 1 August 2020
Line 1:	Line 1:
	+	We need two passes over X:

	+	1. Calculate cumulative production P and Q:<br>
	+	<math>P_0 = 1, P_k=X_k P_{k-1}=\prod_{i=1}^kx_i</math><br>
	+	<math>Q_n = 1, Q_k=X_k Q_{k+1}=\prod_{i=k}^nx_i</math>
	+
	+	2. Calculate M:<br>
	+	<math>M_k=P_{k-1}Q_{k+1}, k\in[1,n]</math>
	+	-------------------------------------------------------------------------------------
	+	Using Iteration:
	+
	+	Java example:
	+	<source lang="java">
	+	public class Multiplication {
	+	public static int[] product(int[] x) {
	+	int[] M = new int[x.length];
	+
	+	for (int i = 0; i < x.length; i++) {
	+	M[i] = product(x, M, i + 1, x.length);
	+	}
	+
	+	return M;
	+	}
	+
	+	private static int product(int[] x, int[] y, int i, int length) {
	+	if (i == length)
	+	return productLeft(x, i - 2, length);
	+
	+	return x[i] * productLeft(x, i - 2, length) * productRight(x, i + 1, length);
	+	}
	+
	+	private static int productLeft(int[] x, int i, int length) {
	+	if (i < 0)
	+	return 1;
	+
	+	return x[i] * productLeft(x, i - 1, length);
	+	}
	+
	+	private static int productRight(int[] x, int i, int length) {
	+	if (i >= length)
	+	return 1;
	+
	+	return x[i] * productRight(x, i + 1, length);
	+	}
	+	}
	+	</source>
	+
	+	--[[User:Tnoumessi\|Tnoumessi]] ([[User talk:Tnoumessi\|talk]]) 00:21, 8 April 2015 (EDT)

← Older revision		Revision as of 09:38, 31 July 2020
Line 1:		Line 1:
−	~~We need two passes over X:~~

−	~~1. Calculate cumulative production P and Q:<br>~~
−	~~<math>P_0 = 1, P_k=X_k P_{k-1}=\prod_{i=1}^kx_i</math><br>~~
−	~~<math>Q_n = 1, Q_k=X_k Q_{k+1}=\prod_{i=k}^nx_i</math>~~
−
−	~~2. Calculate M:<br>~~
−	~~<math>M_k=P_{k-1}Q_{k+1}, k\in[1,n]</math>~~
−	~~-------------------------------------------------------------------------------------~~
−	~~Using Iteration:~~
−
−	~~Java example:~~
−	~~<source lang="java">~~
−	~~public class Multiplication {~~
−	~~public static int[] product(int[] x) {~~
−	~~int[] M = new int[x.length];~~
−
−	~~for (int i = 0; i < x.length; i++) {~~
−	~~M[i] = product(x, M, i + 1, x.length);~~
−	}
−
−	~~return M;~~
−	}
−
−	~~private static int product(int[] x, int[] y, int i, int length) {~~
−	~~if (i == length)~~
−	~~return productLeft(x, i - 2, length);~~
−
−	~~return x[i] * productLeft(x, i - 2, length) * productRight(x, i + 1, length);~~
−	}
−
−	~~private static int productLeft(int[] x, int i, int length) {~~
−	~~if (i < 0)~~
−	~~return 1;~~
−
−	~~return x[i] * productLeft(x, i - 1, length);~~
−	}
−
−	~~private static int productRight(int[] x, int i, int length) {~~
−	~~if (i >= length)~~
−	~~return 1;~~
−
−	~~return x[i] * productRight(x, i + 1, length);~~
−	}
−	}
−	~~</source>~~
−
−	~~--[[User:Tnoumessi\|Tnoumessi]] ([[User talk:Tnoumessi\|talk]]) 00:21, 8 April 2015 (EDT)~~

@@ Line 2: / Line 2: @@
 . Calculate cumulative production P and Q:<br>
-<math>P_0 = 3
+<math>P_0 = 1, P_k=X_k P_{k-1}=\prod_{i=1}^kx_i</math><br>
 <math>Q_n = 1, Q_k=X_k Q_{k+1}=\prod_{i=k}^nx_i</math>

@@ Line 2: / Line 2: @@
 . Calculate cumulative production P and Q:<br>
-<math>P_0 = 1, P_k=X_k P_{k-1}=\prod_{i=1}^kx_i</math><br>
+<math>P_0 = 3
 <math>Q_n = 1, Q_k=X_k Q_{k+1}=\prod_{i=k}^nx_i</math>

← Older revision		Revision as of 14:40, 23 July 2020
Line 1:		Line 1:
−	We need ~~fast wifi~~	+	We need two passes over X:
		+
		+	1. Calculate cumulative production P and Q:<br>
		+	<math>P_0 = 1, P_k=X_k P_{k-1}=\prod_{i=1}^kx_i</math><br>
		+	<math>Q_n = 1, Q_k=X_k Q_{k+1}=\prod_{i=k}^nx_i</math>
		+
		+	2. Calculate M:<br>
		+	<math>M_k=P_{k-1}Q_{k+1}, k\in[1,n]</math>
		+	-------------------------------------------------------------------------------------
		+	Using Iteration:
		+
		+	Java example:
		+	<source lang="java">
		+	public class Multiplication {
		+	public static int[] product(int[] x) {
		+	int[] M = new int[x.length];
		+
		+	for (int i = 0; i < x.length; i++) {
		+	M[i] = product(x, M, i + 1, x.length);
		+	}
		+
		+	return M;
		+	}
		+
		+	private static int product(int[] x, int[] y, int i, int length) {
		+	if (i == length)
		+	return productLeft(x, i - 2, length);
		+
		+	return x[i] * productLeft(x, i - 2, length) * productRight(x, i + 1, length);
		+	}
		+
		+	private static int productLeft(int[] x, int i, int length) {
		+	if (i < 0)
		+	return 1;
		+
		+	return x[i] * productLeft(x, i - 1, length);
		+	}
		+
		+	private static int productRight(int[] x, int i, int length) {
		+	if (i >= length)
		+	return 1;
		+
		+	return x[i] * productRight(x, i + 1, length);
		+	}
		+	}
		+	</source>
		+
		+	--[[User:Tnoumessi\|Tnoumessi]] ([[User talk:Tnoumessi\|talk]]) 00:21, 8 April 2015 (EDT)

← Older revision		Revision as of 01:41, 14 July 2020
Line 1:		Line 1:
−	We need ~~two passes over X:~~	+	We need fast wifi
−
−	~~1. Calculate cumulative production P and Q:<br>~~
−	~~<math>P_0 = 1, P_k=X_k P_{k-1}=\prod_{i=1}^kx_i</math><br>~~
−	~~<math>Q_n = 1, Q_k=X_k Q_{k+1}=\prod_{i=k}^nx_i</math>~~
−
−	~~2. Calculate M:<br>~~
−	~~<math>M_k=P_{k-1}Q_{k+1}, k\in[1,n]</math>~~
−	~~-------------------------------------------------------------------------------------~~
−	~~Using Iteration:~~
−
−	~~Java example:~~
−	~~<source lang="java">~~
−	~~public class Multiplication {~~
−	~~public static int[] product(int[] x) {~~
−	~~int[] M = new int[x.length];~~
−
−	~~for (int i = 0; i < x.length; i++) {~~
−	~~M[i] = product(x, M, i + 1, x.length);~~
−	}
−
−	~~return M;~~
−	}
−
−	~~private static int product(int[] x, int[] y, int i, int length) {~~
−	~~if (i == length)~~
−	~~return productLeft(x, i - 2, length);~~
−
−	~~return x[i] * productLeft(x, i - 2, length) * productRight(x, i + 1, length);~~
−	}
−
−	~~private static int productLeft(int[] x, int i, int length) {~~
−	~~if (i < 0)~~
−	~~return 1;~~
−
−	~~return x[i] * productLeft(x, i - 1, length);~~
−	}
−
−	~~private static int productRight(int[] x, int i, int length) {~~
−	~~if (i >= length)~~
−	~~return 1;~~
−
−	~~return x[i] * productRight(x, i + 1, length);~~
−	}
−	}
−	~~</source>~~
−
−	~~--[[User:Tnoumessi\|Tnoumessi]] ([[User talk:Tnoumessi\|talk]]) 00:21, 8 April 2015 (EDT)~~

@@ Line 11: / Line 11: @@
 Java example:
-<pre>
+<source lang="java">
 public class Multiplication {
    public static int[] product(int[] x) {
@@ Line 44: / Line 44: @@
+   }
+}
-</pre>
+</source>
 --[[User:Tnoumessi|Tnoumessi]] ([[User talk:Tnoumessi|talk]]) 00:21, 8 April 2015 (EDT)

@@ Line 23: / Line 23: @@
+   }
-   private static int product(int[] x, int[] y, int i, int j) {
+   private static int product(int[] x, int[] y, int i, int length) {
-     if(i == j)
+     if (i == length)
-       return productLeft(x, i - 2, j);
+       return productLeft(x, i - 2, length);
-     return x[i] * productLeft(x, i - 2, j) * productRight(x, i + 1, j);
+     return x[i] * productLeft(x, i - 2, length) * productRight(x, i + 1, length);
+   }
-   private static int productLeft(int[] x, int i, int j) {
+   private static int productLeft(int[] x, int i, int length) {
      if (i < 0)
        return 1;
-     return x[i] * productLeft(x, i - 1, j);
+     return x[i] * productLeft(x, i - 1, length);
+   }
-   private static int productRight(int[] x, int i, int j) {
+   private static int productRight(int[] x, int i, int length) {
-     if (i >= j)
+     if (i >= length)
        return 1;
-     return x[i] * productRight(x, i + 1, j);
+     return x[i] * productRight(x, i + 1, length);
+   }
+}

@@ Line 13: / Line 13: @@
 <pre>
 public class Multiplication {
    public static int[] product(int[] x) {
      int[] M = new int[x.length];
      for (int i = 0; i < x.length; i++) {
-		  M[i] = product(x, M, i + 1, x.length);
+      M[i] = product(x, M, i + 1, x.length);
+     }
      return M;
+   }
@@ Line 35: / Line 42: @@
      return x[i] * productRight(x, i + 1, j);
+   }
+}