Related
I need to create an inverse function that would flip double values: x/y = y/x
inverseDouble(1.2) // 0.83
inverseDouble(0.2) // 5
inverseDouble(6.0) // 0.17
I didn't find any solutions (maybe because I'm not an English speaker and don't know how to google this). By the way, are there any easy solutions to do this? I'm using Dart. Solutions using any programming language would be acceptable. I'd also appreciate even any tips or ideas about where and what to look for. Thank you.
This is about a mathematcal solution. The inverse of a number is always one divided by that number.
Look this execution in python:
>>> 1/1.2
0.8333333333333334
>>> 1/5.0
0.2
>>> 1/6.0
0.16666666666666666
In dart you can implement this function that way:
void main() {
print(inverseDouble(1.2));
print(inverseDouble(0.2));
print(inverseDouble(6.0));
}
double inverseDouble(double number)=>1/number;
And the result is:
0.8333333333333334
5
0.16666666666666666
I'm not a pro in math, but isn't an inverse of a fraction 1/fraction?
So the function would look something like that :
double inverseDouble(double nb){
return 1/nb;
}
If you want to use dart:math for that, note that 1/x is x⁻¹, or pow(x, -1):
import 'dart:math' show pow;
void main() {
print(pow(1.2, -1)); // 0.8333333333333334
print(pow(0.2, -1)); // 5
print(pow(6.0, -1)); // 0.16666666666666666
}
Why make it simple when we can make it complicated 😂
I translated a DTW matlab function to Swift. The code looks as follows:
private func dtw(x1 : [Double], x2 : [Double]) -> Double {
let n1 = x1.count;
let n2 = x2.count;
var table = [[Double]](repeating: [Double](repeating: 0, count: n2 + 1), count: 2);
table[0][0] = 0;
for i in 1...n2 { table[0][i] = Double.infinity }
for i in 1 ... n1 {
table[1][0] = Double.infinity;
for j in 1 ... n2 {
let cost = abs(x1[i - 1] - x2[j - 1]);
var min = table[0][j - 1];
if (min > table[0][j]) {
min = table[0][j];
}
if (min > table[1][j - 1]) { min = table[1][j - 1]; }
table[1][j] = cost + min;
}
let swap = table[0];
table[0] = table[1];
table[1] = swap;
}
return table[0][n2];
}
This function takes an average of 16 ms to complete on an iPhone 11. For my use case, this is very slow. I want to investigate ways to improve speed. I recently read these two articles : DTW in Swift Orailly and Parallel programming with Swift. In the first article, there is a good quote:
Our implementation of DTW is naïve, and can be accelerated using parallel computing. To calculate the new row/column in a distance matrix, you don't need to wait until the previous one is finished; you only need it to be filled one cell ahead of your row/column
This would make the for j in 1 ... n2 { for loop an ideal candidate. ( I think ) Looking at the code, only these two operations should be thread-safe due to the read / write:
table[1][j - 1]
table[1][j]
The problem I am currently experiencing in introducing parallel computing ( from article 2 ) is that I cannot figure out how to tell swift run everything in parallel, except when I come to the two below lines, as they depend on their predocessor:
if (min > table[1][j - 1]) { min = table[1][j - 1]; }
table[1][j] = cost + min;
I suspect I could solve this issue with DispatchQueue.concurrentPerform and an NSLock(), if I implemented it correctly. ( I have not ) It could also be the wrong tool of choice, yielding me back to my question:
What can I do, to improve the speed of my DTW function where the only constraint in performing a task is that the previous execution in an array had to have completed ( parallelization, concurrency, etc. ) A code example would go a long way.
Your first problem is that you're creating an array of arrays. This is not an efficient data structure, and is not a "2 dimensional array" in the way most people mean (i.e a matrix). It is an array made up of other arrays, all of which can have arbitrary sizes, and this can be very expensive to mutate. As a rule, if you want a matrix, you should back it with a flat array and use multiplication to find its offsets, particularly if you're mutating it. Instead of table[i][j] you would use table[i * width + j].
But in your case it's even easier, since there are exactly two rows. So you don't a multi-dimensional array at all. You can just use two variables, and it'll be much more efficient. (In my tests, just making this change is about 30% faster than the original code.)
The major thing that slows you down is contention. You read and write to the same array in the loop. That gets in the way of various reordering and caching optimizations. In particular, it happens here:
if (min > table[1][j - 1]) { min = table[1][j - 1]; }
table[1][j] = cost + min;
If you rewrite that using two row variables rather than an array, it still looks like this:
if (min > row1[j - 1]) { min = row1[j - 1] }
row1[j] = cost + min
This forces the previous write to row1 to be fully completed before the next minimum can be computed, and then requires an array lookup to get the value back. But that's not really necessary. You can just cache the previous value between loops. Doing that means the loop only performs reads on row0 and only performs writes on row1. That's good for memory contention.
Putting those together, I wrote it this way. I changed the offsets to run from 0 rather than 1; it just made the code a little simpler to understand IMO. In my tests, this is about 3x faster than the original code for two arrays of 10k elements each.
func dtw(x1 : [Double], x2 : [Double]) -> Double {
let n1 = x1.count
let n2 = x2.count
var row0 = Array(repeating: Double.infinity, count: n2 + 1)
row0[0] = 0
var row1 = Array(repeating: 0.0, count: n2 + 1)
for i in 0 ..< n1 {
row1[0] = .infinity
// Keep track of the last value so we never have to read from row1.
var lastValue = Double.infinity
for j in 0 ..< n2 {
let cost = abs(x1[i] - x2[j])
// Don't be tempted to use the 3-value version of `min` here. It's much slower.
var minimum = min(row0[j], row0[j + 1])
minimum = min(minimum, lastValue)
lastValue = cost + minimum
row1[j + 1] = lastValue
}
swap(&row0, &row1)
}
return row0[n2];
}
This code is somewhat hard to make parallel, because the operations are not independent. Each row depends on the other rows. The key to good queue-based parallelism is the ability to split up fairly large chunks of independent work, and then efficiently combine them at the end. The cost of coordination will eat your benefits if the work units are too small. In many cases, vectorization (SIMD) is much more efficient than dispatching to multiple queues.
The cost function is independent, and I explored computing it with Accelerate (the main vectorization framework), but this generally made things slower. The compiler is very good at optimizing simple math in loops, and will do quite a lot of vectorizing for you if you let it. Accelerate is best when you need to do an expensive, consistent, and independent computation on a lot of values. And this loop isn't expensive or independent.
I’m trying to make a basic simulation of a 16 bit computer with Swift. The computer will feature
An ALU
2 registers
That’s all. I have enough knowledge to create these parts visually and understand how they work, but it has become increasingly difficult to make larger components with more inputs while using my current approach.
My current approach has been to wrap each component in a struct. This worked early on, but is becoming increasingly difficult to manage multiple inputs while staying true to the principles of computer science.
The primary issue is that the components aren’t updating with the clock signal. I have the output of the component updating when get is called on the output variable, c. This, however, neglects the idea of a clock signal and will likely cause further problems later on.
It’s also difficult to make getters and setters for each variable without getting errors about mutability. Although I have worked through these errors, they are annoying and slow down the development process.
The last big issue is updating the output. The output doesn’t update when the inputs change; it updates when told to do so. This isn’t accurate to the qualities of real computers and is a fundamental error.
This is an example. It is the ALU I mentioned earlier. It takes two 16 bit inputs and outputs 16 bits. It has two unary ALUs, which can make a 16 bit number zero, negate it, or both. Lastly, it either adds or does a bit wise and comparison based on the f flag and inverts the output if the no flag is selected.
struct ALU {
//Operations are done in the order listed. For example, if zx and nx are 1, it first makes input 1 zero and then inverts it.
var x : [Int] //Input 1
var y : [Int] //Input 2
var zx : Int //Make input 1 zero
var zy : Int //Make input 2 zero
var nx : Int //Invert input 1
var ny : Int //Invert input 2
var f : Int //If 0, do a bitwise AND operation. If 1, add the inputs
var no : Int //Invert the output
public var c : [Int] { //Output
get {
//Numbers first go through unary ALUs. These can negate the input (and output the value), return 0, or return the inverse of 0. They then undergo the operation specified by f, either addition or a bitwise and operation, and are negated if n is 1.
var ux = UnaryALU(z: zx, n: nx, x: x).c //Unary ALU. See comments for more
var uy = UnaryALU(z: zy, n: ny, x: y).c
var fd = select16(s: f, d1: Add16(a: ux, b: uy).c, d0: and16(a: ux, b: uy).c).c //Adds a 16 bit number or does a bitwise and operation. For more on select16, see the line below.
var out = select16(s: no, d1: not16(a: fd).c, d0: fd).c //Selects a number. If s is 1, it returns d1. If s is 0, it returns d0. d0 is the value returned by fd, while d1 is the inverse.
return out
}
}
public init(x:[Int],y:[Int],zx:Int,zy:Int,nx:Int,ny:Int,f:Int,no:Int) {
self.x = x
self.y = y
self.zx = zx
self.zy = zy
self.nx = nx
self.ny = ny
self.f = f
self.no = no
}
}
I use c for the output variable, store values with multiple bits in Int arrays, and store single bits in Int values.
I’m doing this on Swift Playgrounds 3.0 with Swift 5.0 on a 6th generation iPad. I’m storing each component or set of components in a separate file in a module, which is why some variables and all structs are marked public. I would greatly appreciate any help. Thanks in advance.
So, I’ve completely redone my approach and have found a way to bypass the issues I was facing. What I’ve done is make what I call “tracker variables” for each input. When get is called for each variable, it returns that value of the tracker assigned to it. When set is called it calls an update() function that updates the output of the circuit. It also updates the value of the tracker. This essentially creates a ‘copy’ of each variable. I did this to prevent any infinite loops.
Trackers are unfortunately necessary here. I’ll demonstrate why
var variable : Type {
get {
return variable //Calls the getter again, resulting in an infinite loop
}
set {
//Do something
}
}
In order to make a setter, Swift requires a getter to be made as well. In this example, calling variable simply calls get again, resulting in a never-ending cascade of calls to get. Tracker variables are a workaround that use minimal extra code.
Using an update method makes sure the output responds to a change in any input. This also works with a clock signal, due to the architecture of the components themselves. Although it appears to act as the clock, it does not.
For example, in data flip-flops, the clock signal is passed into gates. All a clock signal does is deactivate a component when the signal is off. So, I can implement that within update() while remaining faithful to reality.
Here’s an example of a half adder. Note that the tracker variables I mentioned are marked by an underscore in front of their name. It has two inputs, x and y, which are 1 bit each. It also has two outputs, high and low, also known as carry and sum. The outputs are also one bit.
struct halfAdder {
private var _x : Bool //Tracker for x
public var x: Bool { //Input 1
get {
return _x //Return the tracker’s value
}
set {
_x = x //Set the tracker to x
update() //Update the output
}
}
private var _y : Bool //Tracker for y
public var y: Bool { //Input 2
get {
return _y
}
set {
_y = y
update()
}
}
public var high : Bool //High output, or ‘carry’
public var low : Bool //Low output, or ‘sum’
internal mutating func update(){ //Updates the output
high = x && y //AND gate, sets the high output
low = (x || y) && !(x && y) //XOR gate, sets the low output
}
public init(x:Bool, y:Bool){ //Initializer
self.high = false //This will change when the variables are set, ensuring a correct output.
self.low = false //See above
self._x = x //Setting trackers and variables
self._y = y
self.x = x
self.y = y
}
}
This is a very clean way, save for the trackers, do accomplish this task. It can trivially be expanded to fit any number of bits by using arrays of Bool instead of a single value. It respects the clock signal, updates the output when the inputs change, and is very similar to real computers.
New to Kotlin, working on a simple chain of circles. I have been able to get two circles to connect the way I want but can seem to grow the chain further. Seems like the width (w2) doesn't get updated after the first iteration. Let me know why my code isn't working and how I can improve it.
Thank you in advance :) Stay woke!
val iterator = (0..12).iterator()
if (iterator.hasNext()) {
canvas.drawCircle(w.toFloat(), h.toFloat(), (100).toFloat(),brush1)
iterator.next()
}
iterator.forEach {
val w2 = w-100
canvas.drawCircle((w2).toFloat(), h.toFloat(), (100).toFloat(),brush1)
}
here is the kind of effect I'm looking to create
w2 will never change because it's based on w which is never modified.
You can use parameter provided to lambda (it) which tells you what iteration you're on, and not use weird iterator:
val x = 100 // starting x
val inc = 100 // offset for following circles
repeat(12){
val targetX = x + inc * it
canvas.drawCircle(targetX.toFloat(), y.toFloat(), 100.toFloat(), brush)
}
The problem is Get Under 1,000,000,000,000,000,000th fibonacci number%1,000,000
#include <iostream>
#define fibo(a,b) {long long c=b;b=a;a=(b+c)%1000000;}
using namespace std;
int main(){
long long a=1,b=0; //two num
long long pa,pb,n,k,arr[2][1000]; //last two num,input,input<=2^k
cin>>n;
arr[0][0]=n/2;arr[1][0]=n%2;
for(unsigned long long i=1;n>3;i++){
arr[0][i]=arr[0][i-1]/2;
arr[1][i]=arr[0][i-1]%2;
if(arr[0][i]==1){
k=i;
break;
}
}
if(n<=3){ //special occasions
switch(n){
case 0:cout<<"0"<<endl;break;
case 3:cout<<"2"<<endl;break;
default:cout<<"1"<<endl;
}
return 0;
}
while(k>=0){ //calc
pa=a;pb=b;
a=((pa+pb*2)*pa)%1000000; //F(2n)=(F(n)+F(n-1)*2)*F(n)
b=(pa*pa+pb*pb)%1000000; //F(2n-1)=F(n)^2+F(n-1)^2
if(arr[1][k--]==1){fibo(a,b);} //F(n+1)=F(n)+F(n-1)
}
cout<<a<<endl;
return 0;
}
when is it wrong?
And why is it wrong?
I can't find different occasion.
An alternative approach you could consider using here is the fact that there are only 1,000,000 possible remainders for Fibonacci numbers, so if you were to compute the first 1,000,001 Fibonacci numbers, at some point you would find that the numbers would start to go in a cycle. So consider the following approach:
Compute the first 1,000,001 Fibonacci numbers.
The numbers will eventually enter a cycle. Determine how many steps k are needed to enter the cycle and how long l the cycle is.
The 1,000,000,000,000,000,000th Fibonacci number, mod 1,000,000, can be found by determining what position the 1,000,000,000,000,000,000th Fibonacci number would end up in the cycle, which is the ((1,000,000,000,000,000,000 - k) % l)th position. So look at that position and output the entry there.