1function gcd(a, b) {
2  a = Math.abs(a);
3  b = Math.abs(b);
4  
5  while (b !== 0) {
6    const temp = b;
7    b = a % b;
8    a = temp;
9  }
10  
11  return a;
12}
13
14function gcdMultiple(numbers) {
15  return numbers.reduce((result, num) => gcd(result, num), numbers[0]);
16}
17
18function calculateMillerIndices(intercepts) {
19  // Handle infinity intercepts
20  const reciprocals = intercepts.map(intercept => {
21    if (intercept === 0 || !isFinite(intercept)) {
22      return 0;
23    }
24    return 1 / intercept;
25  });
26  
27  // Find non-zero values for GCD calculation
28  const nonZeroReciprocals = reciprocals.filter(val => val !== 0);
29  
30  if (nonZeroReciprocals.length === 0) {
31    return [0, 0, 0];
32  }
33  
34  // Scale to integers to avoid floating point issues
35  const scale = 1000;
36  const scaled = nonZeroReciprocals.map(val => Math.round(val * scale));
37  
38  // Find GCD
39  const divisor = gcdMultiple(scaled);
40  
41  // Convert to smallest integers
42  const millerIndices = reciprocals.map(val => 
43    val === 0 ? 0 : Math.round((val * scale) / divisor)
44  );
45  
46  return millerIndices;
47}
48
49// Example
50const intercepts = [2, 3, 6];
51const indices = calculateMillerIndices(intercepts);
52console.log(`Miller indices for intercepts ${intercepts}: (${indices.join(',')})`);
53// Output: Miller indices for intercepts 2,3,6: (3,2,1)
54

1import java.util.Arrays;
2
3public class MillerIndicesCalculator {
4    
5    public static int gcd(int a, int b) {
6        a = Math.abs(a);
7        b = Math.abs(b);
8        
9        while (b != 0) {
10            int temp = b;
11            b = a % b;
12            a = temp;
13        }
14        
15        return a;
16    }
17    
18    public static int gcdMultiple(int[] numbers) {
19        int result = numbers[0];
20        for (int i = 1; i < numbers.length; i++) {
21            result = gcd(result, numbers[i]);
22        }
23        return result;
24    }
25    
26    public static int[] calculateMillerIndices(double[] intercepts) {
27        double[] reciprocals = new double[intercepts.length];
28        
29        // Calculate reciprocals
30        for (int i = 0; i < intercepts.length; i++) {
31            if (intercepts[i] == 0 || Double.isInfinite(intercepts[i])) {
32                reciprocals[i] = 0;
33            } else {
34                reciprocals[i] = 1 / intercepts[i];
35            }
36        }
37        
38        // Count non-zero values
39        int nonZeroCount = 0;
40        for (double r : reciprocals) {
41            if (r != 0) nonZeroCount++;
42        }
43        
44        if (nonZeroCount == 0) {
45            return new int[]{0, 0, 0};
46        }
47        
48        // Scale to integers
49        int scale = 1000;
50        int[] scaled = new int[nonZeroCount];
51        int index = 0;
52        
53        for (double r : reciprocals) {
54            if (r != 0) {
55                scaled[index++] = (int) Math.round(r * scale);
56            }
57        }
58        
59        // Find GCD
60        int divisor = gcdMultiple(scaled);
61        
62        // Convert to smallest integers
63        int[] millerIndices = new int[reciprocals.length];
64        for (int i = 0; i < reciprocals.length; i++) {
65            if (reciprocals[i] == 0) {
66                millerIndices[i] = 0;
67            } else {
68                millerIndices[i] = (int) Math.round((reciprocals[i] * scale) / divisor);
69            }
70        }
71        
72        return millerIndices;
73    }
74    
75    public static void main(String[] args) {
76        double[] intercepts = {2, 3, 6};
77        int[] indices = calculateMillerIndices(intercepts);
78        
79        System.out.println("Miller indices for intercepts " + 
80                           Arrays.toString(intercepts) + ": " + 
81                           Arrays.toString(indices));
82        // Output: Miller indices for intercepts [2.0, 3.0, 6.0]: [3, 2, 1]
83    }
84}
85

1' Funcție Excel VBA pentru calcularea indicilor Miller
2Function CalculateMillerIndices(x As Double, y As Double, z As Double) As String
3    Dim recipX As Double, recipY As Double, recipZ As Double
4    Dim nonZeroCount As Integer, i As Integer
5    Dim scale As Long, gcdVal As Long
6    Dim scaledVals() As Long
7    Dim millerH As Long, millerK As Long, millerL As Long
8    
9    ' Calculați reciprocalele
10    If x = 0 Then
11        recipX = 0
12    Else
13        recipX = 1 / x
14    End If
15    
16    If y = 0 Then
17        recipY = 0
18    Else
19        recipY = 1 / y
20    End If
21    
22    If z = 0 Then
23        recipZ = 0
24    Else
25        recipZ = 1 / z
26    End If
27    
28    ' Numărați valorile non-zero
29    nonZeroCount = 0
30    If recipX <> 0 Then nonZeroCount = nonZeroCount + 1
31    If recipY <> 0 Then nonZeroCount = nonZeroCount + 1
32    If recipZ <> 0 Then nonZeroCount = nonZeroCount + 1
33    
34    If nonZeroCount = 0 Then
35        CalculateMillerIndices = "(0,0,0)"
36        Exit Function
37    End If
38    
39    ' Scalați la întregi
40    scale = 1000
41    ReDim scaledVals(1 To nonZeroCount)
42    i = 1
43    
44    If recipX <> 0 Then
45        scaledVals(i) = Round(recipX * scale)
46        i = i + 1
47    End If
48    
49    If recipY <> 0 Then
50        scaledVals(i) = Round(recipY * scale)
51        i = i + 1
52    End If
53    
54    If recipZ <> 0 Then
55        scaledVals(i) = Round(recipZ * scale)
56    End If
57    
58    ' Găsiți GCD
59    gcdVal = scaledVals(1)
60    For i = 2 To nonZeroCount
61        gcdVal = GCD(gcdVal, scaledVals(i))
62    Next i
63    
64    ' Calculați indicii Miller
65    If recipX = 0 Then
66        millerH = 0
67    Else
68        millerH = Round((recipX * scale) / gcdVal)
69    End If
70    
71    If recipY = 0 Then
72        millerK = 0
73    Else
74        millerK = Round((recipY * scale) / gcdVal)
75    End If
76    
77    If recipZ = 0 Then
78        millerL = 0
79    Else
80        millerL = Round((recipZ * scale) / gcdVal)
81    End If
82    
83    CalculateMillerIndices = "(" & millerH & "," & millerK & "," & millerL & ")"
84End Function
85
86Function GCD(a As Long, b As Long) As Long
87    Dim temp As Long
88    
89    a = Abs(a)
90    b = Abs(b)
91    
92    Do While b <> 0
93        temp = b
94        b = a Mod b
95        a = temp
96    Loop
97    
98    GCD = a
99End Function
100
101' Utilizare în Excel:
102' =CalculateMillerIndices(2, 3, 6)
103' Rezultat: (3,2,1)
104

1#include <iostream>
2#include <vector>
3#include <cmath>
4#include <numeric>
5#include <algorithm>
6
7// Calculați GCD al două numere
8int gcd(int a, int b) {
9    a = std::abs(a);
10    b = std::abs(b);
11    
12    while (b != 0) {
13        int temp = b;
14        b = a % b;
15        a = temp;
16    }
17    
18    return a;
19}
20
21// Calculați GCD al mai multor numere
22int gcdMultiple(const std::vector<int>& numbers) {
23    int result = numbers[0];
24    for (size_t i = 1; i < numbers.size(); ++i) {
25        result = gcd(result, numbers[i]);
26    }
27    return result;
28}
29
30// Calculați indicii Miller din interceptări
31std::vector<int> calculateMillerIndices(const std::vector<double>& intercepts) {
32    std::vector<double> reciprocals;
33    
34    // Calculați reciprocalele
35    for (double intercept : intercepts) {
36        if (intercept == 0 || std::isinf(intercept)) {
37            reciprocals.push_back(0);
38        } else {
39            reciprocals.push_back(1.0 / intercept);
40        }
41    }
42    
43    // Găsiți valorile non-zero
44    std::vector<double> nonZeroReciprocals;
45    for (double r : reciprocals) {
46        if (r != 0) {
47            nonZeroReciprocals.push_back(r);
48        }
49    }
50    
51    if (nonZeroReciprocals.empty()) {
52        return {0, 0, 0};
53    }
54    
55    // Scalați la întregi
56    const int scale = 1000;
57    std::vector<int> scaled;
58    for (double r : nonZeroReciprocals) {
59        scaled.push_back(std::round(r * scale));
60    }
61    
62    // Găsiți GCD
63    int divisor = gcdMultiple(scaled);
64    
65    // Convertiți la cei mai mici întregi
66    std::vector<int> millerIndices;
67    for (double r : reciprocals) {
68        if (r == 0) {
69            millerIndices.push_back(0);
70        } else {
71            millerIndices.push_back(std::round((r * scale) / divisor));
72        }
73    }
74    
75    return millerIndices;
76}
77
78int main() {
79    std::vector<double> intercepts = {2, 3, 6};
80    std::vector<int> indices = calculateMillerIndices(intercepts);
81    
82    std::cout << "Miller indices for intercepts [";
83    for (size_t i = 0; i < intercepts.size(); ++i) {
84        std::cout << intercepts[i];
85        if (i < intercepts.size() - 1) std::cout << ", ";
86    }
87    std::cout << "]: (";
88    
89    for (size_t i = 0; i < indices.size(); ++i) {
90        std::cout << indices[i];
91        if (i < indices.size() - 1) std::cout << ",";
92    }
93    std::cout << ")" << std::endl;
94    
95    // Output: Miller indices for intercepts [2, 3, 6]: (3,2,1)
96    
97    return 0;
98}
99