[jira] [Updated] (MATH-725) use initialized static final arrays, instead of initializing it in constructors
[
https://issues.apache.org/jira/browse/MATH-725?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Gilles updated MATH-725:
Fix Version/s: 3.0
use initialized static final arrays, instead of initializing it in
constructors
---
Key: MATH-725
URL: https://issues.apache.org/jira/browse/MATH-725
Project: Commons Math
Issue Type: Improvement
Affects Versions: 2.2
Reporter: Eldar Agalarov
Priority: Minor
Fix For: 3.0
Original Estimate: 1h
Remaining Estimate: 1h
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
Another solution: leave as is, but make all these arrays static.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (MATH-725) use initialized static final arrays, instead of initializing it in constructors
[
https://issues.apache.org/jira/browse/MATH-725?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Eldar Agalarov updated MATH-725:
Description:
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much faster implementation, freed from unnecessary costly calculations
(such as %).
was:
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
use initialized static final arrays, instead of initializing it in
constructors
---
Key: MATH-725
URL: https://issues.apache.org/jira/browse/MATH-725
Project: Commons Math
Issue Type: Improvement
Affects Versions: 2.2
Reporter: Eldar Agalarov
Priority: Minor
Original Estimate: 1h
Remaining Estimate: 1h
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much faster implementation, freed from unnecessary costly
calculations (such as %).
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (MATH-725) use initialized static final arrays, instead of initializing it in constructors
[
https://issues.apache.org/jira/browse/MATH-725?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Eldar Agalarov updated MATH-725:
Description:
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
was:
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much faster implementation, freed from unnecessary costly calculations
(such as %).
use initialized static final arrays, instead of initializing it in
constructors
---
Key: MATH-725
URL: https://issues.apache.org/jira/browse/MATH-725
Project: Commons Math
Issue Type: Improvement
Affects Versions: 2.2
Reporter: Eldar Agalarov
Priority: Minor
Original Estimate: 1h
Remaining Estimate: 1h
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (MATH-725) use initialized static final arrays, instead of initializing it in constructors
[
https://issues.apache.org/jira/browse/MATH-725?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Eldar Agalarov updated MATH-725:
Description:
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
If you agreed with my proposal, i can make a patch for this issue.
was:
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
use initialized static final arrays, instead of initializing it in
constructors
---
Key: MATH-725
URL: https://issues.apache.org/jira/browse/MATH-725
Project: Commons Math
Issue Type: Improvement
Affects Versions: 2.2
Reporter: Eldar Agalarov
Priority: Minor
Original Estimate: 1h
Remaining Estimate: 1h
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
If you agreed with my proposal, i can make a patch for this issue.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (MATH-725) use initialized static final arrays, instead of initializing it in constructors
[
https://issues.apache.org/jira/browse/MATH-725?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Eldar Agalarov updated MATH-725:
Description:
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
Another solution: leave as is, but make all these arrays static.
was:
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
If you agreed with my proposal, i can make a patch for this issue.
use initialized static final arrays, instead of initializing it in
constructors
---
Key: MATH-725
URL: https://issues.apache.org/jira/browse/MATH-725
Project: Commons Math
Issue Type: Improvement
Affects Versions: 2.2
Reporter: Eldar Agalarov
Priority: Minor
Original Estimate: 1h
Remaining Estimate: 1h
The Well PRNG's implementations have arrays iRm1, iRm2, iRm3, i1, i2, i3. All
these arrays are unmodifiable, so we can replace this arrays initialization
block
final int w = 32;
final int r = (k + w - 1) / w;
this.v = new int[r];
this.index = 0;
// precompute indirection index tables. These tables are used for
optimizing access
// they allow saving computations like (j + r - 2) % r with costly
modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
with inline initialized static final arrays.
This is much better and faster implementation, freed from unnecessary costly
calculations (such as %).
Another solution: leave as is, but make all these arrays static.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
