能否不调用BFGS库函数，写出BFGS的过程代码

当然可以，BFGS算法的核心在于更新Hessian矩阵近似和步长计算。这里是一个简化的Python版本，不依赖外部库，实现了BFGS的基本步骤：

import numpy as np

class BFGSOptimizer:
    def __init__(self, func, initial_guess, Hessian=None):
        self.func = func
        self.x = initial_guess.copy()
        self.Hessian = Hessian if Hessian is not None else np.identity(2)
        self.y = np.zeros_like(self.x)
        self.s = np.zeros_like(self.x)
        self.delta_x = np.zeros_like(self.x)

    def update_Hessian(self):
        # Hessian approximation using BFGS formula
        Hinv_y = np.linalg.solve(self.Hessian, self.y)
        beta = 1 / (np.dot(Hinv_y, self.y) + 1e-8)
        self.Hessian = (np.eye(len(self.x)) - beta * np.outer(Hinv_y, self.y))
        
        # Update the inverse of Hessian-vector product
        self.Hinv_s = np.linalg.solve(self.Hessian, self.s)

    def line_search(self, alpha):
        trial_x = self.x + alpha * self.s
        f_trial = self.func(trial_x)
        if f_trial < self.func(self.x) + alpha * np.dot(self.Hinv_s, self.grad):
            return alpha
        else:
            return alpha / 2.

    def step(self):
        self.grad = self.func.gradient(self.x)
        self.y = self.grad - self.prev_grad
        self.update_Hessian()
        alpha = self.line_search(2)
        self.x -= alpha * self.s
        self.prev_grad = self.grad

    # Simplified for explanation, in practice you'd iterate until convergence
    def optimize(self, max_iter=100, tolerance=1e-6):
        for _ in range(max_iter):
            self.step()
            if np.linalg.norm(self.grad) < tolerance:
                break
        self.minimizer = self.x
        self.min_val = self.func(self.minimizer)

optimizer = BFGSOptimizer(objective_function, initial_point)
optimizer.optimize()