confirming this will blink LED at given frequency
You can check if it is correct by timing it for one minute and check if it is (approximately) ok.
However, I see a few improvements:

First is that you always return 1/7/2*1000 = 71.429, which is rounded down to 71. 71 * 14 = 994 ms so you get a bit faster speed than 7 Hz. if this is a problem you have to compensate for this.
Another small problem is that you delay, but the digitalWrite commands also take some time which is not included for the delays. So you need also to take this into account when using a precise delay.
When using floats I always use float constant numbers, like 1.0 and 7.0 instead of 1 and 7. This can especially be useful when you divide two integers (e.g. 1/7), which results in 0.14 this is rounded down to 0 as it is an int.

The best you can do is using the millis command. You keep a timer and compare it to the current millis value. If it is too high, do a state change. This will take into account every other method you do meanwhile the digitalWrites.
Something like: (code fixed due to EdgarBonet's remarks)
const float FREQ = 7.0; // Hz
const int PIN_NR = 4;

unsigned long _startTime;
unsigned long _counter;

int _currentState = LOW;

void setup() 
{
  _startTime = millis();
  _counter = 0;
  _currentState = LOW;
  digitalWrite(PIN_NR, _currentState);
}

void loop() 
{
  if (_startTime + _counter * 1000.0 / FREQ / 2.0 &gt;= millis())
  {
    _counter++;
    _currentState = ~_currentState;
    digitalWrite(PIN_NR, _currentState);
  }
}

Some small notes:

_currentState is the current state of the LED, with ~ you can flip it (it's called the not operator).
_startTime is the (close to zero) value of the millis value at startup.
Take in mind there is a limit how long this app can run or precise. millis works with ms, meaning you cannot get beyond 500 Hz, and you get 'approximations' with frequencies below in some cases. E.g. when Freq = 80 Hz, you get 1000 * 1 / 80 / 2 = 1000 / 160 = 6.25 =&gt; 6, which is actually 1000/6/2=83.3 Hz.
Also the counter is added once per state change, and because of 1000 * _counter ... an overflow exists when _counter &gt;= 256 * 256 * 256 * 256 / 1000 = about 4 million. With 1000 state changes per second, this happens after 4000 seconds, which is 66 minutes. For 7 Hz it will not occur fast.