Related
Hi I am almost new for fortran and struggling with it at the moment.
My question is,
I open a text file and wanna read muliple lines which have different colums.
(My goal is to read the element into an 1D array)
The last line in my code will print the start to end location.
I hope someone could help me.
IMPLICIT NONE
CHARACTER(500) :: MODELLINE
INTEGER(4) :: STARTPOINT, POINT, N, CNT, NROW
INTEGER(4) :: I, NNOD, J, K
INTEGER(4), ALLOCATABLE :: STARLIST(:), FINDCOL(:,:)
OPEN(UNIT=400, FILE='inputfile.txt', STATUS ='OLD')
CNT = 0
STARTPOINT =0
DO I = 1, 4000
READ(400,'(A)',END = 10001, ERR= 10001) MODELLINE
CNT = CNT + 1
IF (MODELLINE(1:7) == '*ELSET,') STARTPOINT = STARTPOINT+1
ENDDO
10001 REWIND(400)
ALLOCATE(STARLIST(STARTPOINT))
NROW = CNT
K = 0
POINT =0
DO I = 1, NROW
READ(400,'(A)') MODELLINE
IF (MODELLINE(1:7) == '*ELSET,') K = K+1
STARLIST(K) = I ! Location for *ELSET
IF (MODELLINE(1:19) == '*ELSET, ELSET=PART4') POINT = I
ENDDO
!WRITE(*,*) STARTPOINT, STARLIST, POINT
DO I = 1, STARTPOINT
IF (STARLIST(I) == POINT-1) THEN
K = STARLIST(I)-STARLIST(I+1)
ENDIF
ENDDO
WRITE(*,*) POINT, POINT-(K)-1
REWIND(400)
END
inputfile is like this
*ELSET, ELSET=PART1
203, 204, 205, 206, 207, 208, 209, 210, 211, 212
213, 214, 215, 216, 217, 218, 219, 220, 221, 222
223, 224, 225, 255, 256, 257, 258, 259, 260, 261
262, 263, 264, 265, 266, 267, 268, 269, 270, 271
272, 273, 274, 275, 276, 277, 278, 279, 308, 309
310, 311, 312, 313, 314, 315, 316, 317, 318, 319
320, 321, 322, 323, 324, 325, 326, 327, 328, 329
330, 331, 332, 333, 334, 335, 336, 347, 348, 349
350, 351, 352, 353, 354, 355, 356
2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212
2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222
2223, 2224, 2225, 2255, 2256, 2257, 2258, 2259, 2260, 2261
2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271
2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2308, 2309
2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317, 2318, 2319
2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329
2330, 2331, 2332, 2333, 2334, 2335, 2336, 2347, 2348, 2349
2350, 2351, 2352, 2353, 2354, 2355, 2356
*ELSET, ELSET=PART2
226, 227, 228, 229, 337, 359, 465, 466, 467, 468
469, 470, 471, 472, 473, 474, 475, 476, 477, 478
479, 480, 481, 482, 483, 484, 485, 486, 487, 488
2226, 2227, 2228, 2229, 2337, 2359, 2465, 2466, 2467, 2468
2469, 2470, 2471, 2472, 2473, 2474, 2475, 2476, 2477, 2478
2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488
*ELSET, ELSET=PART3
230, 231, 232, 233, 234, 235, 236, 237, 238, 239
240, 241, 242, 243, 244, 245, 246, 247, 248, 249
250, 251, 252, 253, 254
2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239
2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249
2250, 2251, 2252, 2253, 2254
*ELSET, ELSET=PART4
255, 256, 257, 258, 259, 260, 261, 262, 263, 264
265, 266, 267, 268, 269, 270, 271, 272, 273, 274
275, 276, 277, 278, 279
2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264
2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274
2275, 2276, 2277, 2278, 2279
*ELSET, ELSET=PART5
280, 281, 282, 283, 284, 285, 286, 287, 288, 289
290, 291, 292, 293, 294, 295, 296, 297, 298, 299
300, 301, 302, 303, 304, 305, 306, 307
2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289
2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298, 2299
2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307
*ELSET, ELSET=PART6
338, 339, 340, 341, 342, 343, 344, 345, 346
2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, 2346
*ELSET, ELSET=PART7
357, 358, 360, 361, 362, 363, 364, 365, 366, 367
368, 369, 370, 371, 372, 373, 374, 375, 376, 377
378, 379, 380, 381, 382, 383, 384, 385, 386, 387
388, 389, 390, 393
2357, 2358, 2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367
2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377
2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387
2388, 2389, 2390, 2393
i have a data structure of a flat array of numbers
[145, 46, 200, 3, 178, 206, 73, 228, 165, 65, 6, 141, 73, 90, 181, 100]
i need to make an array of arrays with a max of 3 items per sub array. So i look at some examples, and Enum.chunk(arr, n) seems like a candidate
so .chuck(arr, 3) says its deprecated, use chuck_every(arr, 3) instead, so i did that and it produces a strange result vs chunk
for example: chunk returns
[[145, 46, 200], [3, 178, 206], [73, 228, 165], [65, 6, 141], [73, 90, 181]]
while chunk_every returns
[145, 46, 200],
[3, 178, 206],
[73, 228, 165],
[65, 6, 141],
[73, 90, 181],
'p']
the main difference being an extra random element which is a string???
it's almost like it converted the element that chunk cuts off and converts it to a string?
Naturally I am expecting the replacement method would have the same output given the same input. Right?
Look at last element: 100. chunk seems to discard that value while chunk_every add it at last element alone. That is the p character you see. Elixir try to show as chars arrays of numbers in the console, as that is its internal representation.
As you can see in the documentation, you can pass :discard as leftover parameter to behave as deprecated chunk function.
https://hexdocs.pm/elixir/Enum.html#chunk_every/2
Enum.chunk_every/4 was designed by this,
actually its a number if you do like this:
[145, 46, 200, 3, 178, 206, 73, 228, 165, 65, 6, 141, 73, 90, 181, 100]
|> Enum.chunk_every(3, 3, [])
|> Enum.each(fn item ->
IO.inspect item, charlists: false
end)
you can find more detail from official discussion:
https://github.com/elixir-lang/elixir/issues/7260
Sometimes it makes sense to implement basic functionality ourselves, instead of looking up the standard library, for the precisely controlled result.
Here is a recursive implementation, that discards the tail.
input =
[145, 46, 200, 3, 178, 206, 73, 228,
165, 65, 6, 141, 73, 90, 181, 100]
defmodule MyEnum do
def chunk_3(input), do: do_chunk_3(input, [])
defp do_chunk_3([e1, e2, e3 | rest], acc),
do: do_chunk_3(rest, [[e1, e2, e3] | acc])
defp do_chunk_3(_, acc), do: Enum.reverse(acc)
end
MyEnum.chunk_3(input)
#⇒ [[145, 46, 200],
# [3, 178, 206],
# [73, 228, 165],
# [65, 6, 141],
# [73, 90, 181]]
I want to append a row in a python list.
Below is what I am trying,
# Create an empty array
arr=[]
values1 = [32, 748, 125, 458, 987, 361]
arr = np.append(arr, values1)
print arr
[ 32. 748. 125. 458. 987. 361.]
I want to append second row in the list, so that I will get an array like
[ [32. 748. 125. 458. 987. 361.], [42. 344. 145. 448. 187.
304.]]
I am getting error when I try to add second row
values2 = [42, 344, 145, 448, 187, 304]
arr = np.append(arr, values2)
How to do that?
Just append directly to your original list:
# Create an empty list
my_list = []
values1 = [32, 748, 125, 458, 987, 361]
my_list.append(values1)
print(my_list)
values2 = [42, 344, 145, 448, 187, 304]
my_list.append(values2)
print(my_list)
And this will be your output:
[[32, 748, 125, 458, 987, 361]]
[[32, 748, 125, 458, 987, 361], [42, 344, 145, 448, 187, 304]]
Hope that helps!
I have a list of the numbers 1,2,3 and 4.
I wish to print them out in the following manner:
1
2
3
4
11
12
13
14
21
22
23
24
31
..and so on.
How is it possible to do?
Thanks
from itertools import product
maximumDigits = 2
digits = '1234'
for l in range(1, maximumDigits + 1):
for n in product(digits, repeat=l):
print(''.join(n))
Gives you:
1
2
3
4
11
12
13
14
21
22
23
24
31
32
33
34
41
42
43
44
Non-itertools solution:
>>> digits = (1, 2, 3, 4)
>>> nums = newNums = list(digits)
# calculate 2-digit numbers
>>> newNums = [n * 10 + m for n in newNums for m in digits]
>>> nums.extend(newNums)
>>> nums
[1, 2, 3, 4, 11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, 44]
# calculate 3-digit numbers
>>> newNums = [n * 10 + m for n in newNums for m in digits]
>>> nums.extend(newNums)
>>> nums
[1, 2, 3, 4, 11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, 44, 111, 112, 113, 114, 121, 122, 123, 124, 131, 132, 133, 134, 141, 142, 143, 144, 211, 212, 213, 214, 221, 222, 223, 224, 231, 232, 233, 234, 241, 242, 243, 244, 311, 312, 313, 314, 321, 322, 323, 324, 331, 332, 333, 334, 341, 342, 343, 344, 411, 412, 413, 414, 421, 422, 423, 424, 431, 432, 433, 434, 441, 442, 443, 444]
# this repeats for each new digit you want
I have read that prime numbers are fixed and it is better to generate them at compile time rather than depending on runtime. So, i thought of using Template Metaprogramming which internally uses compile-time recursion. I am using Sieve of Eratosthenes method for generating prime numbers. Here is the code:
int prime[500]; // prime[i]==0 means i is prime
template<int n> void fillMultiple(int i)
{
prime[n*i]=1; // n is prime, mark all its multiples as non-prime
n*i<500?fillMultiple<n>(i+1):fillMultiple<499>(i);
}
template<> void fillMultiple<499>(int i)
{
// do nothing
// only used as dummy function
}
template<int n> void generatePrime()
{
prime[n]==0?fillMultiple<n>(2):generatePrime<n+1>(); //if n is prime,mark all the multiples of n as non-prime.
generatePrime<n+1>();
}
template<> void generatePrime<499>()
{
// do nothing
// only used as dummy function
}
int main()
{
prime[0]=prime[1]=1; // 0 and 1 is non-prime
generatePrime<2>();
for(int i=0;i<500;i++) // print prime numbers
if(0==prime[i]) // if prime[i]==0, then i is prime
cout<<i<<endl;
return 0;
}
When i run the code, i am getting Runtime error
I am not very much familiar with Template Metaprogramming.Please explain why am i getting runtime-error? If there is any error, it must have been shown at compile-time.
Or:
int p[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069,
1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223,
1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373,
1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657,
1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811,
1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987,
1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129,
2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287,
2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423,
2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617,
2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741,
2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903,
2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079,
3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257,
3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413,
3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571};
I have read that prime numbers are fixed and it is better to generate them at compile time rather than depending on runtime.
Yes that is a good idea.
Since they are fixed means that they only need to be generated once (not every time).
So, i thought of using Template Meta-programming which internally uses compile-time recursion.
No such a good idea.
There is a maxim recursion level set by the compilers (depends on the compiler 8>16 last time I checked (a while ago)). Best to write a one off program generate the values you want then use the code to generate the file you will compile in your real code (or cut/paste the numbers from Wikipedia like I did).
I am using Sieve of Eratosthenes method for generating prime numbers. Here
Unfortunately that is not a template meta-program.
It works at run time.
As already stated you can use an array of prime numbers for the first x prime numbers which is obviously faster than calculating them every time.
Although it's not an answer to your question here are some information on prime numbers which could be helpful depending of what you need:
Calculating first n prime numbers
Sieve of Eratosthenes (which you already know of)
Sieve of Atkin (optimized version of the algorithm from above)
Calculating the amount of prime numbers smaller than n:
Prime-counting function
Offset logarithmic integral
http://en.wikipedia.org/wiki/Prime_counting_function
Testing if prime or looking for a prime larger than a given number:
Rabin Test
Fermat primality test
Solovay-Strassen-Test
Special prime numbers:
Mersenne prime
Twin prime
This is just a very short extract on the topic of prime numbers. Depending on what your program has to do looking into these topics might be interesting.