java二维数组矩阵相乘

时间: 2023-10-02 14:14:17 浏览: 139
矩阵相乘可以使用二维数组来实现,以下是Java代码示例: ```java public class MatrixMultiplication { public static void main(String[] args) { int[][] matrix1 = {{1, 2, 3}, {4, 5, 6}}; // 定义一个2x3的矩阵 int[][] matrix2 = {{7, 8}, {9, 10}, {11, 12}}; // 定义一个3x2的矩阵 int[][] result = multiply(matrix1, matrix2); // 矩阵相乘 // 输出结果 for (int i = 0; i < result.length; i++) { for (int j = 0; j < result[i].length; j++) { System.out.print(result[i][j] + " "); } System.out.println(); } } // 矩阵相乘函数 public static int[][] multiply(int[][] matrix1, int[][] matrix2) { int row1 = matrix1.length; // 矩阵1的行数 int col1 = matrix1[0].length; // 矩阵1的列数,也是矩阵2的行数 int col2 = matrix2[0].length; // 矩阵2的列数 int[][] result = new int[row1][col2]; // 结果矩阵 // 矩阵相乘 for (int i = 0; i < row1; i++) { for (int j = 0; j < col2; j++) { int sum = 0; for (int k = 0; k < col1; k++) { sum += matrix1[i][k] * matrix2[k][j]; } result[i][j] = sum; } } return result; } } ``` 输出结果为: ``` 58 64 139 154 ```

相关推荐

### 回答1: 以下是Java中表示二维数组相乘的示例代码: java public class MatrixMultiplication { public static void main(String[] args) { int[][] matrix1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; int[][] matrix2 = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}}; // 计算两个矩阵的乘积 int[][] result = multiply(matrix1, matrix2); // 打印结果矩阵 for (int i = 0; i < result.length; i++) { for (int j = 0; j < result[i].length; j++) { System.out.print(result[i][j] + " "); } System.out.println(); } } public static int[][] multiply(int[][] matrix1, int[][] matrix2) { int m1Rows = matrix1.length; int m1Cols = matrix1[0].length; int m2Cols = matrix2[0].length; int[][] result = new int[m1Rows][m2Cols]; for (int i = 0; i < m1Rows; i++) { for (int j = 0; j < m2Cols; j++) { for (int k = 0; k < m1Cols; k++) { result[i][j] += matrix1[i][k] * matrix2[k][j]; } } } return result; } } 该程序定义了一个 MatrixMultiplication 类,其中包含一个名为 multiply 的静态方法,该方法计算两个二维整数数组的乘积并返回一个二维整数数组。程序还包含一个 main 方法,该方法创建两个示例矩阵,并将它们相乘,并输出结果矩阵。 在 multiply 方法中,首先确定输入矩阵的维度,然后创建一个大小为 m1Rows x m2Cols 的结果矩阵。接下来,使用三个嵌套的循环计算结果矩阵中的每个元素。其中,外部两个循环用于遍历结果矩阵中的每个元素,内部的循环用于计算乘积的每个元素。 ### 回答2: 在Java中,我们可以使用嵌套的for循环来表示二维数组相乘。首先,我们需要定义两个二维数组A和B,其中A的行数等于B的列数。然后,我们创建一个新的二维数组C,它的行数等于A的行数,列数等于B的列数。 接下来,我们使用嵌套的for循环来遍历A和B的元素,然后将它们进行相乘,并将结果存储在C中的相应位置。具体过程如下: java int[][] A = // 定义二维数组A int[][] B = // 定义二维数组B int[][] C = new int[A.length][B[0].length]; // 创建二维数组C for (int i = 0; i < A.length; i++) { for (int j = 0; j < B[0].length; j++) { for (int k = 0; k < A[0].length; k++) { C[i][j] += A[i][k] * B[k][j]; // 计算A和B对应位置的元素相乘并累加到C中 } } } 最后,C即为A和B的相乘结果。请注意,上述代码中的A.length表示A的行数,B[0].length表示B的列数,A[0].length表示A的列数。这是因为二维数组的长度由行数和列数双重决定。 使用以上代码示例,我们可以实现两个二维数组的相乘操作,并将结果存储在新的二维数组中。注意保证A的列数等于B的行数,否则会导致数组越界异常。 ### 回答3: 在Java中表示二维数组的相乘,需要使用嵌套循环的方式来实现。下面是一个演示如何进行二维数组相乘的示例代码: java // 定义两个二维数组 int[][] matrix1 = {{1, 2}, {3, 4}}; int[][] matrix2 = {{5, 6}, {7, 8}}; // 创建结果数组,用于存储相乘的结果 int[][] result = new int[matrix1.length][matrix2[0].length]; // 检查两个矩阵是否可以相乘 if(matrix1[0].length != matrix2.length){ System.out.println("无法进行矩阵相乘!"); System.exit(0); } // 通过循环遍历相应元素并相乘 for(int i = 0; i < matrix1.length; i++){ for(int j = 0; j < matrix2[0].length; j++){ for(int k = 0; k < matrix2.length; k++){ result[i][j] += matrix1[i][k] * matrix2[k][j]; } } } // 输出结果数组的内容 System.out.println("结果矩阵:"); for(int i = 0; i < result.length; i++){ for(int j = 0; j < result[0].length; j++){ System.out.print(result[i][j] + " "); } System.out.println(); } 以上代码首先定义了两个二维数组matrix1和matrix2,然后创建一个结果数组result来存储相乘的结果。接下来,通过嵌套的三个循环遍历相应元素,并利用结果数组来计算矩阵相乘的每个元素。最后,输出结果数组的内容。 需要注意的是,在进行矩阵相乘之前,需要检查两个矩阵是否符合矩阵相乘的规则,即第一个矩阵的列数必须等于第二个矩阵的行数。 以上就是用Java表示二维数组相乘的方法。
好的,请稍等... 以下是使用 Java 编写的二维数组实现矩阵相乘与矩阵转置的源代码: 矩阵相乘: public class MatrixMultiplication { public static void main(String[] args) { int[][] matrixA = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; int[][] matrixB = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}}; int[][] result = multiply(matrixA, matrixB); printMatrix(result); } public static int[][] multiply(int[][] matrixA, int[][] matrixB) { int aRows = matrixA.length; int aCols = matrixA[0].length; int bRows = matrixB.length; int bCols = matrixB[0].length; if (aCols != bRows) { throw new IllegalArgumentException("The number of columns in matrix A must equal the number of rows in matrix B!"); } int[][] result = new int[aRows][bCols]; for (int i = 0; i < aRows; i++) { for (int j = 0; j < bCols; j++) { for (int k = 0; k < aCols; k++) { result[i][j] += matrixA[i][k] * matrixB[k][j]; } } } return result; } public static void printMatrix(int[][] matrix) { for (int i = 0; i < matrix.length; i++) { for (int j = 0; j < matrix[i].length; j++) { System.out.print(matrix[i][j] + " "); } System.out.println(); } } } 矩阵转置: public class MatrixTranspose { public static void main(String[] args) { int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; int[][] result = transpose(matrix); printMatrix(result); } public static int[][] transpose(int[][] matrix) { int rows = matrix.length; int cols = matrix[0].length; int[][] result = new int[cols][rows]; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { result[j][i] = matrix[i][j]; } } return result; } public static void printMatrix(int[][] matrix) { for (int i = 0; i < matrix.length; i++) { for (int j = 0; j < matrix[i].length; j++) { System.out.print(matrix[i][j] + " "); } System.out.println(); } } } 希望能帮到你!
矩阵连乘问题可以使用动态规划来解决。具体来说,假设有 n 个矩阵需要相乘,它们的维度分别为 d0×d1,d1×d2,...,dn-1×dn。定义 m[i][j] 表示从第 i 个矩阵到第 j 个矩阵相乘的最小代价,s[i][j] 表示从第 i 个矩阵到第 j 个矩阵中最后一次相乘的位置,则有以下递推式: m[i][j] = 0, (i = j) m[i][j] = min{m[i][k] + m[k+1][j] + di-1×dk×dj}, (i <= k < j) s[i][j] = k, (i <= k < j) 其中,i <= j,d[-1] = d[n] = 0。 根据递推式,可以使用二维数组 m 和 s 来保存中间结果,从而避免重复计算。最终,可以通过 s 数组来构造出最终的乘法顺序。 下面是 Java 代码实现: public static void matrixChainOrder(int[] p) { int n = p.length - 1; int[][] m = new int[n][n]; int[][] s = new int[n][n]; for (int i = 0; i < n; i++) { m[i][i] = 0; } for (int l = 2; l <= n; l++) { for (int i = 0; i < n - l + 1; i++) { int j = i + l - 1; m[i][j] = Integer.MAX_VALUE; for (int k = i; k < j; k++) { int q = m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1]; if (q < m[i][j]) { m[i][j] = q; s[i][j] = k; } } } } System.out.println("Minimum number of multiplications: " + m[0][n-1]); printOptimalParenthesis(s, 0, n-1); } public static void printOptimalParenthesis(int[][] s, int i, int j) { if (i == j) { System.out.print("A" + (i+1)); } else { System.out.print("("); printOptimalParenthesis(s, i, s[i][j]); printOptimalParenthesis(s, s[i][j]+1, j); System.out.print(")"); } } 其中,数组 p 表示矩阵的维度,n 表示矩阵的个数。函数 matrixChainOrder 用来计算最小代价并输出乘法顺序,函数 printOptimalParenthesis 用来输出乘法顺序。
### 回答1: 矩阵幂运算可以通过分治法和矩阵快速幂算法实现。以下是矩阵快速幂算法的java实现: java public class MatrixPow { public static int[][] matrixPow(int[][] a, int n) { int[][] res = new int[a.length][a[0].length]; // 初始化为单位矩阵 for (int i = 0; i < a.length; i++) { res[i][i] = 1; } while (n > 0) { if ((n & 1) == 1) { res = matrixMultiply(res, a); } a = matrixMultiply(a, a); n >>= 1; } return res; } public static int[][] matrixMultiply(int[][] a, int[][] b) { int[][] res = new int[a.length][b[0].length]; for (int i = 0; i < a.length; i++) { for (int j = 0; j < b[0].length; j++) { for (int k = 0; k < b.length; k++) { res[i][j] += a[i][k] * b[k][j]; } } } return res; } } 其中,matrixPow方法接收一个矩阵和一个正整数n,返回该矩阵的n次幂。matrixMultiply方法接收两个矩阵,返回它们的乘积。 ### 回答2: 幂运算的矩阵求法可以通过矩阵的乘法来实现。假设要计算一个矩阵A的n次幂,我们可以通过将矩阵A连续乘n次来实现。 具体的步骤如下: 1. 首先,我们需要定义一个矩阵乘法的方法。矩阵乘法的规则是:两个矩阵A和B相乘,结果矩阵的第i行第j列的元素等于矩阵A的第i行的元素与矩阵B的第j列的元素对应位置相乘后的和。我们可以使用一个双层循环来实现这个计算过程。 2. 然后,我们需要定义一个幂运算的方法,接收一个矩阵A和一个整数n作为参数。在方法中,我们可以先创建一个单位矩阵E,作为幂运算的初始结果。 3. 接下来,我们通过一个循环,将矩阵A连续乘n次。在每一次循环中,我们使用之前定义的矩阵乘法方法,将当前结果矩阵E与矩阵A相乘。 4. 最后,当循环结束后,我们可以得到矩阵A的n次幂。 这样,我们就实现了通过矩阵乘法来求解幂运算的矩阵求法。 需要注意的是,矩阵乘法和幂运算的复杂度较高,特别是当矩阵的大小较大时。因此,在实际应用中,需要对矩阵乘法的算法进行优化,以提高效率。 ### 回答3: 幂运算的矩阵求法是指对一个矩阵进行指数次幂运算,即将矩阵自乘多次。在Java中,可以通过以下步骤实现矩阵的幂运算。 1. 首先,定义一个表示矩阵的二维数组,假设矩阵的维度为n * n。 2. 创建一个与原始矩阵相同维度的单位矩阵,作为结果矩阵的初始值。单位矩阵的对角线元素都为1,其余元素为0。 3. 根据幂运算的次数,循环多次进行矩阵自乘。可以使用两个嵌套的for循环遍历矩阵的每一个元素,将每个元素根据矩阵乘法规则计算,并将结果放入结果矩阵中。 4. 将结果矩阵作为下一次迭代的矩阵,继续进行矩阵自乘。 5. 循环结束后,结果矩阵的值即为原始矩阵的指数次幂。 以下是一个简单的示例代码: java public class MatrixPower { public static int[][] matrixPower(int[][] matrix, int power) { int n = matrix.length; int[][] result = new int[n][n]; // 初始化结果矩阵为单位矩阵 for (int i = 0; i < n; i++) { result[i][i] = 1; } // 进行矩阵幂运算 for (int p = 0; p < power; p++) { int[][] temp = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < n; k++) { temp[i][j] += matrix[i][k] * result[k][j]; } } } result = temp; } return result; } public static void main(String[] args) { int[][] matrix = {{1, 2}, {3, 4}}; int power = 2; int[][] result = matrixPower(matrix, power); // 打印结果矩阵 for (int i = 0; i < result.length; i++) { for (int j = 0; j < result[0].length; j++) { System.out.print(result[i][j] + " "); } System.out.println(); } } } 以上代码演示了如何通过循环进行矩阵的幂运算,并打印了结果矩阵。对于给定的矩阵和幂次,可以根据实际情况进行更改。
下面是一个简单的矩阵类的实现,它包含了加法、减法和乘法运算以及生成特定形式矩阵的方法。 java public class Matrix { private int rows; private int cols; private double[][] data; public Matrix(int rows, int cols) { this.rows = rows; this.cols = cols; this.data = new double[rows][cols]; } public Matrix(double[][] data) { this.rows = data.length; this.cols = data[0].length; this.data = data; } public Matrix add(Matrix other) { if (this.rows != other.rows || this.cols != other.cols) { throw new IllegalArgumentException("Matrices must have the same dimensions."); } Matrix result = new Matrix(rows, cols); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { result.data[i][j] = this.data[i][j] + other.data[i][j]; } } return result; } public Matrix subtract(Matrix other) { if (this.rows != other.rows || this.cols != other.cols) { throw new IllegalArgumentException("Matrices must have the same dimensions."); } Matrix result = new Matrix(rows, cols); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { result.data[i][j] = this.data[i][j] - other.data[i][j]; } } return result; } public Matrix multiply(Matrix other) { if (this.cols != other.rows) { throw new IllegalArgumentException("Number of columns in first matrix must match number of rows in second matrix."); } Matrix result = new Matrix(this.rows, other.cols); for (int i = 0; i < result.rows; i++) { for (int j = 0; j < result.cols; j++) { double sum = 0; for (int k = 0; k < this.cols; k++) { sum += this.data[i][k] * other.data[k][j]; } result.data[i][j] = sum; } } return result; } public static Matrix generateDiagonalMatrix(int size, double value) { Matrix result = new Matrix(size, size); for (int i = 0; i < size; i++) { result.data[i][i] = value; } return result; } public static Matrix generateIdentityMatrix(int size) { return generateDiagonalMatrix(size, 1); } public void print() { for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { System.out.print(data[i][j] + " "); } System.out.println(); } } } 这个类包含了一个构造函数,两个变量(rows和cols)和一个二维数组(data),以及下面几个方法: - add方法:用于将两个矩阵相加。 - subtract方法:用于将两个矩阵相减。 - multiply方法:用于将两个矩阵相乘。 - generateDiagonalMatrix方法:用于生成一个对角线为指定值的矩阵。 - generateIdentityMatrix方法:用于生成一个单位矩阵。 - print方法:用于打印矩阵。 例如,我们可以使用以下代码创建两个矩阵并将它们相加: java Matrix m1 = new Matrix(new double[][]{{1, 2}, {3, 4}}); Matrix m2 = new Matrix(new double[][]{{5, 6}, {7, 8}}); Matrix result = m1.add(m2); result.print(); 这会输出以下内容: 6.0 8.0 10.0 12.0 我们还可以使用以下代码创建一个单位矩阵: java Matrix identity = Matrix.generateIdentityMatrix(3); identity.print(); 这会输出以下内容: 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 1.0 我们还可以使用以下代码创建一个具有特定形式的矩阵: java Matrix diagonal = Matrix.generateDiagonalMatrix(4, 2); diagonal.print(); 这会输出以下内容: 2.0 0.0 0.0 0.0 0.0 2.0 0.0 0.0 0.0 0.0 2.0 0.0 0.0 0.0 0.0 2.0
首先,需要明确一点,Java中的二维数组是通过数组嵌套实现的。因此,在本题中,输入的两个方阵需要用二维数组来表示。 下面是一个可能的解决方案: java public static double[][] multiplyMatrix(double[][] a, double[][] b) { int n = a.length; int m = b[0].length; double[][] c = new double[n][m]; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { for (int k = 0; k < a[0].length; k++) { c[i][j] += a[i][k] * b[k][j]; } } } return c; } 这个方法输入两个二维数组 a 和 b,表示两个 $3 \times 3$ 的方阵。输出一个二维数组 c,表示它们的乘积。 具体实现中,首先定义了两个变量 n 和 m 分别表示两个方阵的行数和列数。然后定义了一个二维数组 c 用于存放结果,其行数为 n,列数为 m。 接下来,使用三重循环计算矩阵乘积。外层两重循环分别遍历结果矩阵 c 的每一个元素,内层循环用于计算当前位置的值。具体地,对于结果矩阵中的某个位置 $(i,j)$,需要计算第一个矩阵中第 $i$ 行和第二个矩阵中第 $j$ 列对应元素的乘积之和,即: $$c_{i,j} = \sum_{k=0}^{2}a_{i,k}b_{k,j}$$ 其中 $k$ 是内层循环的循环变量。 最后,返回结果矩阵 c。 下面是一个测试方法的示例: java public static void main(String[] args) { double[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; double[][] b = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}}; double[][] c = multiplyMatrix(a, b); for (int i = 0; i < c.length; i++) { for (int j = 0; j < c[0].length; j++) { System.out.print(c[i][j] + " "); } System.out.println(); } } 在这个测试方法中,我们定义了两个 $3 \times 3$ 的方阵 a 和 b,并调用了 multiplyMatrix 方法来计算它们的乘积。最后,使用两重循环遍历结果矩阵 c 并输出其中的每一个元素。
好的,我明白了。对于题目中给出的四个矩阵A、B、C、D,使用穷举法和动态规划法求其最优加括号方法。 首先,让我们来了解一下这两种方法的基本思路。 穷举法:对于任意的两个矩阵相乘,总共有两种括号方式,即左右括号和上下括号。因此,可以通过穷举所有可能的括号方式,比较它们的计算代价(乘法次数),来确定最优的括号方式。 动态规划法:基于矩阵链乘法的子问题特性,通过先求解子问题的最优解,最终得到原问题的最优解。具体来说,可以定义一个二维数组dp[i][j],表示从第i个矩阵到第j个矩阵的最优计算代价。然后通过填充这个数组,求出原问题的最优解。 接下来,我们逐个介绍如何使用穷举法和动态规划法求解。 使用穷举法求解: 穷举法的基本思路就是对于所有的可能性穷举,然后比较它们的计算代价。对于四个矩阵A、B、C、D,总共存在三种可能的加括号方式: ((AB)(CD)),代价为5×10×20 + 20×15×5 + 5×20×5 = 2250 (A((BC)D)),代价为5×10×20 + 10×20×15 + 5×15×5 = 1750 ((A(B(CD)))),代价为5×10×15 + 5×15×5 + 5×10×5 = 750 因此,最优的加括号方式是第三种方式。 使用动态规划法求解: 具体来说,可以定义一个二维数组dp[i][j],表示从第i个矩阵到第j个矩阵的最优计算代价。然后通过填充这个数组,求出原问题的最优解。 首先,对于任意一个矩阵i,它自己相乘的代价为0,即dp[i][i] = 0。 然后,对于任意的两个相邻矩阵i和i+1,它们相乘的代价为它们的乘积,即dp[i][i+1] = p[i-1]×p[i]×p[i+1](其中p[i]表示矩阵Ai的行数,也就是第i个矩阵的行数和第i+1个矩阵的列数)。 接着,对于任意的长度为len的子问题,可以遍历所有可能的分割点k,将原问题分割为两个子问题,分别求解它们的最优解,然后加上分割点k的代价,得到新的代价。具体来说,对于任意的k∈[i, j-1],有: dp[i][j] = min{dp[i][k] + dp[k+1][j] + p[i-1]×p[k]×p[j]} 最后,dp[1][4]就是原问题的最优解,即750。 综上所述,使用动态规划法求解的过程,可以写成如下的JAVA代码: public int minCost(int[] p) { int n = p.length - 1; int[][] dp = new int[n+1][n+1]; for (int i = 1; i <= n; i++) { dp[i][i] = 0; } for (int len = 2; len <= n; len++) { for (int i = 1; i <= n-len+1; i++) { int j = i + len - 1; dp[i][j] = Integer.MAX_VALUE; for (int k = i; k < j; k++) { dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k+1][j] + p[i-1]*p[k]*p[j]); } } } return dp[1][n]; } 其中,p数组存储矩阵的维数信息,例如对于矩阵Ai,它的行数为p[i-1],列数为p[i]。返回值就是最优的计算代价。 好了,到此为止,你的第一个问题已经解决了,下一个问题是什么?

最新推荐

全球汽车行业高管调研.pdf

全球汽车行业高管调研.pdf

金融平台项目微服务架构设计经验及重要技术栈.docx

金融平台项目微服务架构设计经验及重要技术栈

MATLAB噪声滤波.m

MATLAB:噪声滤波 产生白并滤波噪声

量子力学技术前沿:探索、挑战与未来.docx

量子力学技术前沿:探索、挑战与未来.docx

鼠标选取随意选取多个控制点点,每四个控制点绘制一条3次的Bezier曲线

鼠标选取随意选取多个控制点点,每四个控制点绘制一条3次的Bezier曲线

基于单片机温度控制系统设计--大学毕业论文.doc

基于单片机温度控制系统设计--大学毕业论文.doc

"REGISTOR:SSD内部非结构化数据处理平台"

REGISTOR:SSD存储裴舒怡,杨静,杨青,罗德岛大学,深圳市大普微电子有限公司。公司本文介绍了一个用于在存储器内部进行规则表达的平台REGISTOR。Registor的主要思想是在存储大型数据集的存储中加速正则表达式(regex)搜索,消除I/O瓶颈问题。在闪存SSD内部设计并增强了一个用于regex搜索的特殊硬件引擎,该引擎在从NAND闪存到主机的数据传输期间动态处理数据为了使regex搜索的速度与现代SSD的内部总线速度相匹配,在Registor硬件中设计了一种深度流水线结构,该结构由文件语义提取器、匹配候选查找器、regex匹配单元(REMU)和结果组织器组成。此外,流水线的每个阶段使得可能使用最大等位性。为了使Registor易于被高级应用程序使用,我们在Linux中开发了一组API和库,允许Registor通过有效地将单独的数据块重组为文件来处理SSD中的文件Registor的工作原

如何使用Promise.all()方法?

Promise.all()方法可以将多个Promise实例包装成一个新的Promise实例,当所有的Promise实例都成功时,返回的是一个结果数组,当其中一个Promise实例失败时,返回的是该Promise实例的错误信息。使用Promise.all()方法可以方便地处理多个异步操作的结果。 以下是使用Promise.all()方法的示例代码: ```javascript const promise1 = Promise.resolve(1); const promise2 = Promise.resolve(2); const promise3 = Promise.resolve(3)

android studio设置文档

android studio默认设置文档

海量3D模型的自适应传输

为了获得的目的图卢兹大学博士学位发布人:图卢兹国立理工学院(图卢兹INP)学科或专业:计算机与电信提交人和支持人:M. 托马斯·福吉奥尼2019年11月29日星期五标题:海量3D模型的自适应传输博士学校:图卢兹数学、计算机科学、电信(MITT)研究单位:图卢兹计算机科学研究所(IRIT)论文主任:M. 文森特·查维拉特M.阿克塞尔·卡里尔报告员:M. GWendal Simon,大西洋IMTSIDONIE CHRISTOPHE女士,国家地理研究所评审团成员:M. MAARTEN WIJNANTS,哈塞尔大学,校长M. AXEL CARLIER,图卢兹INP,成员M. GILLES GESQUIERE,里昂第二大学,成员Géraldine Morin女士,图卢兹INP,成员M. VINCENT CHARVILLAT,图卢兹INP,成员M. Wei Tsang Ooi,新加坡国立大学,研究员基于HTTP的动态自适应3D流媒体2019年11月29日星期五,图卢兹INP授予图卢兹大学博士学位,由ThomasForgione发表并答辩Gilles Gesquière�